]> 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
AliITSUSeed::GetClusterIndex will return cl. index in old format
[u/mrichter/AliRoot.git] / ITS / AliITSv11GeometrySSD.cxx
CommitLineData
d7599219 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
5ef8864c 16/* $Id$ */
d7599219 17
18//*************************************************************************
19// SSD geometry, based on ROOT geometrical modeler
20//
21// Enrico Cattaruzza ecattar@ts.infn.it
22//*************************************************************************
23#include "TMath.h"
24#include "TGeoVolume.h"
d7599219 25#include "TGeoMatrix.h"
26#include <TGeoManager.h>
d7599219 27#include "TVector3.h"
28#include "TGeoArb8.h"
29#include "TList.h"
30#include "TGeoMatrix.h"
31#include "TGeoCompositeShape.h"
851c0ce3 32#include "TGeoBoolNode.h"
d7599219 33#include "TGeoTube.h"
34#include "TGeoBBox.h"
bf210566 35#include "TGeoXtru.h"
9b0c60ab 36#include "TGeoTorus.h"
37#include "TGeoPgon.h"
47f8de53 38#include "TGeoPcon.h"
9b0c60ab 39#include "TRotation.h"
44285dfa 40#include "AliITSv11GeometrySSD.h"
78e34526 41
d7599219 42/////////////////////////////////////////////////////////////////////////////////
bf210566 43// Names of the Sensitive Volumes of Layer 5 and Layer 6
44/////////////////////////////////////////////////////////////////////////////////
f510fd70 45const char* AliITSv11GeometrySSD::fgkSSDsensitiveVolName5 = "ITSssdSensitivL5";
46const char* AliITSv11GeometrySSD::fgkSSDsensitiveVolName6 = "ITSssdSensitivL6";
bf210566 47/////////////////////////////////////////////////////////////////////////////////
d7599219 48//Parameters for SSD Geometry
49/////////////////////////////////////////////////////////////////////////////////
e21cdd03 50// Variable for Vertical Disalignement of Modules
51/////////////////////////////////////////////////////////////////////////////////
ca86fdb4 52const Double_t AliITSv11GeometrySSD::fgkSSDTolerance = 0.0001*fgkmm;
0fb26117 53const Double_t AliITSv11GeometrySSD::fgkSSDModuleVerticalDisalignment = 0.2*fgkmm;
54const Double_t AliITSv11GeometrySSD::fgkSSDModuleSideDisalignment = 0.2*fgkmm;
160835d5 55// For ladders:
cd2243fb 56const Double_t AliITSv11GeometrySSD::fgkSSDLadderVerticalDisalignment = 0.520*fgkmm;
e21cdd03 57/////////////////////////////////////////////////////////////////////////////////
d7599219 58// Layer5 (lengths are in mm and angles in degrees)
59/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 60const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength = 950.7*fgkmm;
d7599219 61const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber = 22;
62const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber = 34;
9acf2ecc 63const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin = 378.0*fgkmm;
64const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax = 384.0*fgkmm;
65const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition = 467.85*fgkmm;
d7599219 66/////////////////////////////////////////////////////////////////////////////////
67// Layer6 (lengths are in mm and angles in degrees)
68/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 69const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength = 1068.0*fgkmm;
d7599219 70const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber = 25;
71const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber = 38;
9acf2ecc 72const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin = 428.0*fgkmm;
73const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax = 434.0*fgkmm;
74const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition = 526.50*fgkmm;
d7599219 75/////////////////////////////////////////////////////////////////////////////////
76// SSD Chips and Hybrid (lengths are in mm and angles in degrees)
77/////////////////////////////////////////////////////////////////////////////////
78const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber = 6;
9acf2ecc 79const Double_t AliITSv11GeometrySSD::fgkSSDChipLength = 11.100*fgkmm;
80const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth = 3.850*fgkmm;
81const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight = 0.180*fgkmm;
82const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength = 1.000*fgkmm;
bf210566 83const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength = fgkSSDChipLength;
84const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth = fgkSSDChipWidth;
9acf2ecc 85const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight = 0.030*fgkmm;
d7599219 86/////////////////////////////////////////////////////////////////////////////////
87// Stiffener (lengths are in mm and angles in degrees)
88/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 89const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength = 73.000*fgkmm;
90const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth = 6.500*fgkmm;
78e34526 91const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 0.295*fgkmm;
9acf2ecc 92const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist = 2.500*fgkmm;
78e34526 93const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603CapLength = 0.900*fgkmm; // Includes solder
bf210566 94const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length = 1.600*fgkmm;
9acf2ecc 95const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width = 0.870*fgkmm;
96const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height = 0.800*fgkmm;
78e34526 97const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812CapLength = 0.215*fgkmm;
9acf2ecc 98const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length = 4.600*fgkmm;
99const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width = 3.400*fgkmm;
78e34526 100const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height = 1.400*fgkmm;
9acf2ecc 101const Double_t AliITSv11GeometrySSD::fgkSSDWireLength = 30.000*fgkmm;
102const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius = 0.185*fgkmm;
78e34526 103const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2] = {44.32*fgkmm, 0.33*fgkmm};
bf210566 104const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation = 0.44*fgkmm;
105const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength = 2.16*fgkmm;
106const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth = 3.60*fgkmm;
78e34526 107const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight = 0.25*fgkSSDStiffenerHeight;
bf210566 108const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight = 0.030*fgkmm;
109const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight = 0.002*fgkmm;
78e34526 110const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSnHeight = 0.15*fgkmm;
d7599219 111/////////////////////////////////////////////////////////////////////////////////
112// Cooling Block (lengths are in mm and angles in degrees)
113/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 114const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength = 3.000*fgkmm;
115const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth = 4.000*fgkmm;
bf210566 116const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
117 {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
d7599219 118const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
78e34526 119 {1.025*fgkmm, 0.120*fgkmm}; // Added 50 micron tolerance for thicker wall cooling pipe (March 2010)
d7599219 120const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
bf210566 121 {1.900*fgkmm, 0.400*fgkmm};
d7599219 122const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter =
9acf2ecc 123 1.500*fgkmm;
d7599219 124const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight =
9acf2ecc 125 0.300*fgkmm;
d7599219 126/////////////////////////////////////////////////////////////////////////////////
127// SSD Sensor (lengths are in mm and angles in degrees)
128/////////////////////////////////////////////////////////////////////////////////
129const char* AliITSv11GeometrySSD::fgkSSDSensitiveVolName =
bf210566 130 "SSDSensorSensitiveVol";
9acf2ecc 131const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength = 42.000*fgkmm;
132const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight = 0.300*fgkmm;
133const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth = 75.000*fgkmm;
d7599219 134const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap =
9acf2ecc 135 fgkSSDSensorLength-39.1*fgkmm;
bf210566 136const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength = 1.*fgkmm;
137const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth = 1.*fgkmm;
d7599219 138/////////////////////////////////////////////////////////////////////////////////
139// Flex (lengths are in mm and angles in degrees)
140/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 141const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength = 106.000*fgkmm;
d7599219 142const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4] =
bf210566 143 {0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
144 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
145 0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
146 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)
147 - 4.000*fgkmm, 9.500*fgkmm, 10.000*fgkmm};
d7599219 148const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2] =
bf210566 149 { 9.340*fgkmm, 5.380*fgkmm};
d7599219 150const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2] =
bf210566 151 { 0.030*fgkmm, 0.020*fgkmm};
d7599219 152const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle = 30.000;
9acf2ecc 153const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength = 1.430*fgkmm;
154const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth = 3.000*fgkmm;
d7599219 155const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
bf210566 156 {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
d7599219 157const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
bf210566 158 {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
d7599219 159/////////////////////////////////////////////////////////////////////////////////
160// SSD Ladder Cable (lengths are in mm and angles in degrees)
161/////////////////////////////////////////////////////////////////////////////////
bf210566 162const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth = 23.5*fgkmm;
78e34526 163const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableHeight[2] = { 0.030*fgkmm*17.5/23.5, 1.25 * 0.030*fgkmm}; // Al covers ~ 17.5/23.5 of surface, Kapton includes glue+foam
d7599219 164/////////////////////////////////////////////////////////////////////////////////
165// SSD Module (lengths are in mm and angles in degrees)
166/////////////////////////////////////////////////////////////////////////////////
167const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2] =
bf210566 168 { 1.000*fgkmm, 3.900*fgkmm};
d7599219 169const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
9acf2ecc 170 45.600*fgkmm;
d7599219 171const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor =
9acf2ecc 172 5.075*fgkmm;
d7599219 173/////////////////////////////////////////////////////////////////////////////////
174// Sensor Support (lengths are in mm and angles in degrees)
175/////////////////////////////////////////////////////////////////////////////////
bf210566 176const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength =
177 5.800*fgkmm;
d7599219 178const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth =
bf210566 179 2.000*fgkmm;
d7599219 180const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
0fb26117 181 { 4.620*fgkmm-fgkSSDModuleVerticalDisalignment,
182 5.220*fgkmm-fgkSSDModuleVerticalDisalignment};
ca86fdb4 183//const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
184// { 4.520*fgkmm, 5.130*fgkmm};
bf210566 185const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] =
186 { 0.450*fgkmm, 0.450*fgkmm};
187const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition
188 = 0.5 * (fgkSSDModuleSensorSupportDistance
189 + fgkSSDSensorSideSupportThickness[0])
190 - fgkSSDSensorSideSupportLength;
d7599219 191const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength =
bf210566 192 5.250*fgkmm;
d7599219 193const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth =
bf210566 194 1.680*fgkmm;
195const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]
196 = {fgkSSDSensorSideSupportHeight[0]
197 + fgkSSDSensorSideSupportThickness[0],
198 fgkSSDSensorSideSupportHeight[1]
199 + fgkSSDSensorSideSupportThickness[1]};
200const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2]
201 = {fgkSSDSensorSideSupportThickness[0],
202 fgkSSDSensorSideSupportThickness[1]};
d7599219 203const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition =
bf210566 204 19.000*fgkmm;
d7599219 205/////////////////////////////////////////////////////////////////////////////////
206// Chip Cables (lengths are in mm and angles in degrees)
207/////////////////////////////////////////////////////////////////////////////////
208const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2] =
bf210566 209 {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
d7599219 210const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4] =
bf210566 211 { 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
212 - (fgkSSDSensorSideSupportHeight[1]
213 - fgkSSDSensorSideSupportHeight[0])
0fb26117 214 - fgkSSDModuleVerticalDisalignment
bf210566 215 - fgkSSDCoolingBlockHoleCenter
216 - fgkSSDStiffenerHeight
217 - fgkSSDChipHeight-fgkSSDSensorHeight,
218 fgkSSDModuleCoolingBlockToSensor
0fb26117 219 - fgkSSDModuleVerticalDisalignment
bf210566 220 - fgkSSDCoolingBlockHoleCenter
221 - fgkSSDStiffenerHeight
222 - fgkSSDChipHeight-fgkSSDSensorHeight};
d7599219 223const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3] =
bf210566 224 { 11.000*fgkmm, 0.800*fgkmm, 0.600*fgkmm};
d7599219 225/////////////////////////////////////////////////////////////////////////////////
226// Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
227/////////////////////////////////////////////////////////////////////////////////
228const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
bf210566 229 3.820*fgkmm;
230//const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
231// 3.780;
d7599219 232const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth =
bf210566 233 fgkSSDSensorLength-fgkSSDSensorOverlap;
d7599219 234const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2] =
bf210566 235 { 0.86*fgkmm, 0.30*fgkmm};
d7599219 236const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2] =
bf210566 237 { 30.00, 90.00};
d7599219 238const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
bf210566 239 1.78*fgkmm;
d7599219 240/////////////////////////////////////////////////////////////////////////////////
241//Carbon Fiber Parameters (lengths are in mm and angles in degrees)
242/////////////////////////////////////////////////////////////////////////////////
bf210566 243const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength
244 = fgkSSDModuleSensorSupportDistance
245 - 2. * fgkCarbonFiberJunctionToSensorSupport;
246const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00;
d7599219 247const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2] =
bf210566 248 { 0.751*fgkmm, 0.482*fgkmm};
249const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength =
250 1.630*fgkmm;
251const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth = 0.950*fgkmm;
252const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength
253 = fgkCarbonFiberTriangleLength
254 - 0.5*fgkCarbonFiberSupportTopEdgeDist[1]
255 / TMath::Cos(fgkCarbonFiberTriangleAngle
256 * TMath::DegToRad());
257const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength
258 = 0.5*(fgkCarbonFiberJunctionWidth
259 - fgkCarbonFiberSupportWidth)
260 - fgkCarbonFiberSupportTopEdgeDist[0]
261 - fgkCarbonFiberSupportWidth;
d7599219 262/////////////////////////////////////////////////////////////////////////////////
263// Carbon Fiber Lower Support Parameters (lengths are in mm)
264/////////////////////////////////////////////////////////////////////////////////
c40ebacc 265const Double_t AliITSv11GeometrySSD::fgkLowerSupportToSensorZ = 11.575*fgkmm;
d7599219 266const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
9acf2ecc 267 = 0.950*fgkmm;
d7599219 268const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
9acf2ecc 269 = 1.600*fgkmm;
d7599219 270const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
9acf2ecc 271 = 0.830*fgkmm;
d7599219 272const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
273 = 0.5*fgkCarbonFiberSupportWidth;
274const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
bf210566 275 = fgkCarbonFiberJunctionWidth
276 - 2. * (fgkCarbonFiberLowerSupportWidth
277 + fgkCarbonFiberLowerSupportVolumeSeparation);
d7599219 278const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
bf210566 279 = {fgkCarbonFiberLowerSupportWidth
280 + fgkCarbonFiberLowerSupportVolumeSeparation,
281 fgkCarbonFiberLowerSupportWidth
282 + fgkCarbonFiberLowerSupportVolumeSeparation
283 + fgkCarbonFiberLowerSupportTransverseWidth};
d7599219 284/////////////////////////////////////////////////////////////////////////////////
285// End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
286/////////////////////////////////////////////////////////////////////////////////
287const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
bf210566 288 {0.5 * (fgkSSDLay5LadderLength
289 - fgkSSDLay5SensorsNumber
290 * fgkCarbonFiberJunctionWidth
291 - fgkCarbonFiberLowerSupportWidth),
292 0.5 * (fgkSSDLay5LadderLength
293 - fgkSSDLay5SensorsNumber
294 * fgkCarbonFiberJunctionWidth
295 + fgkCarbonFiberLowerSupportWidth)};
d7599219 296const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
bf210566 297 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
298 fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
d7599219 299const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
bf210566 300 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
301 fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
9b0c60ab 302const Double_t AliITSv11GeometrySSD::fgkendladdercoolingsupportdistance[3] =
303 {15.0*fgkmm, 13.5*fgkmm, 14.5*fgkmm};
d7599219 304/////////////////////////////////////////////////////////////////////////////////
305// Cooling Tube Support (lengths are in mm and angles in degrees)
306/////////////////////////////////////////////////////////////////////////////////
bf210566 307const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax = 1.45*fgkmm;
d7599219 308const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
309 = fgkSSDCoolingBlockHoleRadius[0];
bf210566 310const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength = 8.55*fgkmm;
311const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight = 0.85*fgkmm;
312const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth = 2.00*fgkmm;
d7599219 313const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation =
bf210566 314 fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
315const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber =
316 11.70*fgkmm;
d7599219 317/////////////////////////////////////////////////////////////////////////////////
318// Cooling Tube (lengths are in mm and angles in degrees)
319/////////////////////////////////////////////////////////////////////////////////
bf210566 320const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
78e34526 321const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 1.915*fgkmm/2; // Nominal + 50 micron tolerance; real pipes are closer to 450 micron wall thickness
bf210566 322const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
d7599219 323 fgkCarbonFiberJunctionWidth;
324const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
bf210566 325 fgkSSDModuleSensorSupportDistance
326 + fgkSSDCoolingBlockLength;
9b0c60ab 327const Double_t AliITSv11GeometrySSD::fgkMountingBlockToSensorSupport = 30.7*fgkmm;
d7599219 328/////////////////////////////////////////////////////////////////////////////////
329// SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
330/////////////////////////////////////////////////////////////////////////////////
331const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3] =
bf210566 332 { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
d7599219 333const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4] =
bf210566 334 { 4.0*fgkmm, 8.0*fgkmm, 5.0*fgkmm, 0.2*fgkmm};
d7599219 335const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth =
bf210566 336 20.0*fgkmm;
d7599219 337const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle =
bf210566 338 40.0;
d7599219 339const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight =
340 0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
341const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
bf210566 342 2.5*fgkmm;
d7599219 343const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2] =
bf210566 344 { 56.0*fgkmm, 12.0*fgkmm};
d7599219 345const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2] =
bf210566 346 { 5.0*fgkmm, 2.9*fgkmm};
d7599219 347const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius =
bf210566 348 1.0*fgkmm;
d7599219 349const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge =
bf210566 350 6.0*fgkmm;
cd2243fb 351const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeight =
bf210566 352 4.0*fgkmm;
d7599219 353const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2] =
bf210566 354 { 1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
d7599219 355/////////////////////////////////////////////////////////////////////////////////
9b0c60ab 356// SSD Mounting Block Clip Parameters (lengths are in mm and angles in degrees)
357/////////////////////////////////////////////////////////////////////////////////
358const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipLength = 15.1*fgkmm;
359const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipThickness = 0.3*fgkmm;
360const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewRadius = 1.6*fgkmm;
361const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewPosition = 4.0*fgkmm;
362const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibWidth = 9.0*fgkmm;
363/////////////////////////////////////////////////////////////////////////////////
364// SSD Mounting Block Support Parameters (lengths are in mm and angles in degrees)
365/////////////////////////////////////////////////////////////////////////////////
366const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportWidth[2] = {9.5*fgkmm,10.0*fgkmm};
367const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportDownHeight = 4.0*fgkmm;
368const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDLay5RadiusMin
369 - fgkSSDMountingBlockHeight[1]
370 + 0.5*fgkCoolingTubeSupportHeight
371 + fgkSSDModuleCoolingBlockToSensor
372 - fgkMountingBlockSupportDownHeight,
373 fgkSSDLay6RadiusMin
374 - fgkSSDMountingBlockHeight[1]
375 + 0.5*fgkCoolingTubeSupportHeight
376 + fgkSSDModuleCoolingBlockToSensor
377 - fgkMountingBlockSupportDownHeight};
378const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax
379 - fgkSSDMountingBlockHeight[1]
380 + 0.5*fgkCoolingTubeSupportHeight
381 + fgkSSDModuleCoolingBlockToSensor
382 - fgkMountingBlockSupportRadius[0],
383 fgkSSDLay6RadiusMax
384 - fgkSSDMountingBlockHeight[1]
385 + 0.5*fgkCoolingTubeSupportHeight
386 + fgkSSDModuleCoolingBlockToSensor
387 - fgkMountingBlockSupportRadius[1]};
cd2243fb 388const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeight = 10.0*fgkmm; // To be verified
9b0c60ab 389const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
390const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
391/////////////////////////////////////////////////////////////////////////////////
392// SSD End Cap Cover Plate Parameters (lengths are in mm and angles in degrees)
393/////////////////////////////////////////////////////////////////////////////////
394const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleRadius = 1.25*fgkmm;
395const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateBigHoleRadius = 2.45*fgkmm;
396const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateThickness = 0.5*fgkmm;
397const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleSeparation[3] =
398 {16.5*fgkmm,22.0*fgkmm,7.*fgkmm};
399const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateLength[6] =
400 {7.*fgkmm,55.*fgkmm,8.0*fgkmm,53.*fgkmm,61.0*fgkmm,25.5*fgkmm};
401const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateWidth[3] =
402 {68.5*fgkmm,75.5*fgkmm,6.5*fgkmm};
403const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMin = 0.750*fgkmm;
404const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMax = 2.*fgkmm;
405const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipLength = 10.4*fgkmm;
406const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipWidth = 6.0*fgkmm;
407const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipLength = 5.7*fgkmm;
408const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipWidth = 5.0*fgkmm;
409/////////////////////////////////////////////////////////////////////////////////
410// SSD End Cap Kapton Foil Parameters (lengths are in mm and angles in degrees)
411/////////////////////////////////////////////////////////////////////////////////
412const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilThickness = 0.4*fgkmm;
413const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilLength = 68.0*fgkmm;
414const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilWidth = 75.0*fgkmm;
415/////////////////////////////////////////////////////////////////////////////////
416// SSD End Cap Cooling Tube Parameters (lengths are in mm and angles in degrees)
417/////////////////////////////////////////////////////////////////////////////////
418const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAxialRadius[2] =
419 {10.5*fgkmm,9.25*fgkmm};
420const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMin = 1.3*fgkmm;
421const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMax = 1.5*fgkmm;
422const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAngle[5] =
423 {182.3,177.9,84.4,70.0,35.0};
424const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeLength[5] =
425 {49.5*fgkmm,41.7*fgkmm,47.6*fgkmm,5.0*fgkmm};
426const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeToCoverSide = 13.0*fgkmm;
427/////////////////////////////////////////////////////////////////////////////////
428// SSD End Cap Cover Side Parameters (lengths are in mm and angles in degrees)
429/////////////////////////////////////////////////////////////////////////////////
430const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverLength[5] = {3.5*fgkmm,
431 6.5*fgkmm,75.0*fgkmm,8.0*fgkmm,2.0*fgkmm};
432const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverWidth[7] = {30.9*fgkmm,
433 47.5*fgkmm,12.6*fgkmm,5.6*fgkmm,
434 20.0*fgkmm,7.0*fgkmm,5.9*fgkmm};
435const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverThickness = 0.4*fgkmm;
436/////////////////////////////////////////////////////////////////////////////////
437// SSD End Cap Cards Parameters (lengths are in mm and angles in degrees)
438/////////////////////////////////////////////////////////////////////////////////
439const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackLength[3] =
440 {62.0*fgkmm,21.87*fgkmm};
441const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackWidth[2] =
7708d5f3 442 {47.0*fgkmm,0.35*fgkmm};
9b0c60ab 443const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackThickness =
444 1.0*fgkmm;
445const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLength = 61.8*fgkmm;
446const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerWidth[2] =
447 {43.5*fgkmm, 0.70*fgkmm};
448const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerThickness =
449 0.15*fgkmm;
450const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorThickness =
451 19.0*fgkmm;
452const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorLength[2] =
453 {4.80*fgkmm,1.1*fgkmm};
454const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorWidth[2] =
455 {3.3*fgkmm,1.10*fgkmm};
456const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorToLayer =
457 2.1*fgkmm;
458const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorLength[3] =
459 {5.2*fgkmm,3.5*fgkmm,1.2*fgkmm};
460const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorWidth[2] =
461 {1.9*fgkmm,0.15*fgkmm};
462const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorThickness =
463 19*fgkmm;
464const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorDistance =
465 1.0*fgkmm;
466const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorToLayer =
467 3.6*fgkmm;
468const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionLength =
469 61.0*fgkmm;
470const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionThickness =
471 5.97*fgkmm;
472const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionWidth = 3.0*fgkmm;
473const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBLength[7] =
474 {3.1*fgkmm,68.0*fgkmm,3.6*fgkmm,
475 1.9*fgkmm,2.5*fgkmm,14.2*fgkmm,1.5*fgkmm};
476const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBWidth[5] =
477 {17.0*fgkmm,10.0*fgkmm,5.9*fgkmm,6.4*fgkmm,3.9*fgkmm};
478const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBThickness =
479 1.0*fgkmm;
480const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceElectBoardCardBThickness
481 = 0.15*fgkmm;
482const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBJMDConnectorSeparation =
483 20.0*fgkmm;
484const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerLength = 68.0*fgkmm;
485const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerWidth = 5.0*fgkmm;
486const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerThickness = 5.0*fgkmm;
487const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMin = 1.25*fgkmm; // To Be Checked
488const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMax = 1.575*fgkmm; // To Be Checked
489/////////////////////////////////////////////////////////////////////////////////
490// SSD End Cap SupportLayer5/6 Side Parameters (lengths are in mm and angles in degrees)
491/////////////////////////////////////////////////////////////////////////////////
492const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLength[2] = {70.424*fgkmm,72.919*fgkmm};
493const Double_t AliITSv11GeometrySSD::fgkEndCapSupportMiddleRadius[2] = {377.0*fgkmm,437.0*fgkmm};
47f8de53 494const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {375.0*fgkmm,435.0*fgkmm};
9b0c60ab 495const Double_t AliITSv11GeometrySSD::fgkEndCapSupportHighWidth = 20.0*fgkmm;
496const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowWidth[2] = {3.0*fgkmm,3.0*fgkmm};
5d9d4033 497const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 624.9*fgkmm;
9b0c60ab 498const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm;
499const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm;
500const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm;
501/////////////////////////////////////////////////////////////////////////////////
47f8de53 502// SSD Cone Parameters (lengths are in mm and angles in degrees)
503/////////////////////////////////////////////////////////////////////////////////
504const Double_t AliITSv11GeometrySSD::fgkSSDLowerPConeRadius = 296.5*fgkmm;
505const Double_t AliITSv11GeometrySSD::fgkSSDPConeAngle = 39.0;
fcfbdd23 506const Double_t AliITSv11GeometrySSD::fgkSSDPConeZLength[2] = {168.0*fgkmm,153.0*fgkmm};
47f8de53 507const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleRadius = 317.5*fgkmm;
508const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleLength = 20.*fgkmm;
509const Double_t AliITSv11GeometrySSD::fgkSSDConeMiddleRadius = 350.*fgkmm;
510const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleLength = 30.*fgkmm;
511const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleWidth = 40.*fgkmm;
512const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpRadius = 400.*fgkmm;
fcfbdd23 513const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMaxRadius = 459.*fgkmm;
47f8de53 514const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMiddleRadius = 472.5*fgkmm;
515const Double_t AliITSv11GeometrySSD::fgkSSDPConeDownRadius = 282.0*fgkmm;
516const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidAngle = 42.0;
517const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidBasis = 200.0*fgkmm;
518const Double_t AliITSv11GeometrySSD::fgkSSDPConeExternalRadius = 492.5*fgkmm;
519const Double_t AliITSv11GeometrySSD::fgkSSDPConeRadiusWidth = 16.75*fgkmm;
fcfbdd23 520const Double_t AliITSv11GeometrySSD::fgkSSDPConeLength = 168.0*fgkmm;
47f8de53 521const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportLength = 1020.*fgkmm;
522const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportRadius = 297.5*fgkmm;
523const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportWidth = 6.28*fgkmm;
524const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportLength = 60.0*fgkmm;
525const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportWidth = 2.5*fgkSSDCentralSupportWidth;
f7cd318e 526
47f8de53 527/////////////////////////////////////////////////////////////////////////////////
44285dfa 528ClassImp(AliITSv11GeometrySSD)
529/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 530AliITSv11GeometrySSD::AliITSv11GeometrySSD():
531 AliITSv11Geometry(),
44285dfa 532 fSSDChipMedium(),
533 fSSDChipGlueMedium(),
534 fSSDStiffenerMedium(),
535 fSSDStiffenerConnectorMedium(),
536 fSSDStiffener0603CapacitorMedium(),
537 fSSDStiffener1812CapacitorMedium(),
78e34526 538 fSSDStiffenerCapacitorCapMedium(),
44285dfa 539 fSSDStiffenerHybridWireMedium(),
540 fSSDKaptonFlexMedium(),
541 fSSDAlTraceFlexMedium(),
542 fSSDAlTraceLadderCableMedium(),
543 fSSDKaptonLadderCableMedium(),
544 fSSDKaptonChipCableMedium(),
545 fSSDAlTraceChipCableMedium(),
546 fSSDAlCoolBlockMedium(),
547 fSSDSensorMedium(),
548 fSSDSensorSupportMedium(),
549 fSSDCarbonFiberMedium(),
550 fSSDTubeHolderMedium(),
551 fSSDCoolingTubeWater(),
552 fSSDCoolingTubePhynox(),
9b0c60ab 553 fSSDSupportRingAl(),
44285dfa 554 fSSDMountingBlockMedium(),
47f8de53 555 fSSDRohaCellCone(),
bf210566 556 fSSDAir(),
47f8de53 557 fSSDCopper(),
78e34526 558 fSSDSn(),
bf210566 559 fCreateMaterials(kFALSE),
560 fTransformationMatrices(kFALSE),
561 fBasicObjects(kFALSE),
562 fcarbonfiberjunction(),
563 fcoolingtubesupport(),
564 fhybridmatrix(),
565 fssdcoolingblocksystem(),
566 fcoolingblocksystematrix(),
567 fssdstiffenerflex(),
568 fssdendflex(),
cd2243fb 569 fcoolingtube(0),
9b0c60ab 570 fendladdercoolingtubesupportmatrix(),
bf210566 571 fendladdermountingblock(),
9b0c60ab 572 fendladdermountingblockclip(),
bf210566 573 fSSDSensor5(),
574 fSSDSensor6(),
575 fSSDLayer5(),
576 fSSDLayer6(),
577 fMotherVol(),
9b0c60ab 578 fLay5LadderSupportRing(),
579 fLay6LadderSupportRing(),
e5bf64ae 580 fgkEndCapSupportSystem(),
47f8de53 581 fSSDCone(),
44285dfa 582 fColorCarbonFiber(4),
583 fColorRyton(5),
bf210566 584 fColorPhynox(14),
44285dfa 585 fColorSilicon(3),
bf210566 586 fColorAl(38),
78e34526 587 fColorNiSn(40),
44285dfa 588 fColorKapton(6),
589 fColorPolyhamide(5),
590 fColorStiffener(9),
bf210566 591 fColorEpoxy(30),
592 fColorWater(7),
593 fColorG10(41)
44285dfa 594{
595 ////////////////////////
596 // Standard constructor
597 ////////////////////////
705f5cb5 598 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++){
599 fendladdermountingblockcombitrans[i] = NULL;
600 }
045be90c 601 for (Int_t i=0; i < fgkcarbonfibersupportnumber; i++) {
602 fcarbonfibersupport[i] = 0;
603 fcarbonfibersupportmatrix[i] = 0;
604 }
605 for (Int_t i=0; i < fgkcarbonfiberjunctionumber; i++) {
606 fcarbonfiberjunctionmatrix[i] = 0;
607 }
608 for (Int_t i=0; i < fgkcarbonfiberlowersupportnumber; i++) {
609 fcarbonfiberlowersupport[i] = 0;
610 fcarbonfiberlowersupportrans[0] = 0;
611 }
612 for (Int_t i=0; i < fgkvolumekind; i++) {
613 fssdsensorsupport[i] = 0;
614 }
615 for (Int_t i=0; i < fgkssdsensorsupportnumber; i++) {
616 fssdsensorsupportmatrix[i] = 0;
617 }
618 for (Int_t i=0; i < fgkcoolingtubesupportnumber; i++) {
619 fcoolingtubesupportmatrix[i] = 0;
620 }
621 for (Int_t i=0; i < fgkhybridcompnumber; i++) {
622 fssdhybridcomponent[i] = 0;
623 }
624 for (Int_t i=0; i < fgkcoolingblocknumber; i++) {
625 fcoolingblockmatrix[i] = 0;
626 }
627 for (Int_t i=0; i < fgkflexnumber; i++) {
628 fstiffenerflexmatrix[i] = 0;
629 fendflexmatrix[i] = 0;
630 }
631 for (Int_t i=0; i < fgkendladdercoolingtubenumber; i++) {
632 fendladdercoolingtube[i] = 0;
633 for (Int_t j = 0; j < 2; j++)
634 fendladdercoolingtubematrix[i][j] = 0;
635 }
636 for (Int_t i=0; i < fgkendlabbercarbonfiberjunctionumber; i++) {
637 fendladdercarbonfiberjunction[i] = 0;
638 }
b28b5356 639 for (Int_t i=0; i < fgkendladdercarbonfiberjunctionmatrixnumber; i++) {
045be90c 640 fendladdercarbonfiberjunctionmatrix[i] = 0;
641 }
642 for (Int_t i=0; i < fgkendladdercarbonfibermatrixnumber; i++) {
643 fendladdercarbonfibermatrix[i] = 0;
644 }
645 for (Int_t i=0; i < fgkendladdermountingblocknumber; i++) {
646 fendladdermountingblockclipmatrix[i] = 0;
647 }
648 for (Int_t i = 0; i < fgkendladderlowersuppnumber+1; i++) {
649 fendladderlowersupptrans[i] = 0;
650 }
651 for (Int_t i = 0; i < fgkladdercablesnumber; i++) {
652 fladdercablematrix[i] = 0;
653 }
654 for (Int_t i = 0; i < fgkladdersegmentnumber; i++) {
655 fladdersegment[i] = 0;
656 }
657 for (Int_t i = 0; i < fgkladdernumber; i++) {
658 fladder[i] = 0;
659 fladdermatrix[i] = 0;
660 fssdsensormatrix[i] = 0;
661 flayermatrix[i] = 0;
662 }
663 for (Int_t i = 0; i < 2; i++) {
664 fLay5LadderSupport[i] = 0;
665 fLay6LadderSupport[i] = 0;
705f5cb5 666 fcoolingtubematrix[i] = NULL;
667 fendladdersegment[i] = NULL;
668 fendladdersegmentmatrix[i] = NULL;
045be90c 669 }
44285dfa 670}
705f5cb5 671
bf210566 672///////////////////////////////////////////////////////////////////////////////
673void AliITSv11GeometrySSD::CreateTransformationMatrices(){
674 ///////////////////////////////////////////////////////////////////////
675 // Method generating the trasformation matrix for the whole SSD Geometry
676 ///////////////////////////////////////////////////////////////////////
677 // Setting some variables for Carbon Fiber Supportmatrix creation
678 //////////////////////////////////////////////////////////////////////
679 Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
680 * CosD(fgkCarbonFiberJunctionAngle[0]);
681 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
682 + fgkCarbonFiberSupportTopEdgeDist[0]
683 + fgkCarbonFiberSupportWidth);
684 Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
685 * TanD(fgkCarbonFiberJunctionAngle[0]);
686 TGeoRotation* carbonfiberot[3];
687 for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
688 carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
689 carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
690 carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
691 Double_t transvector[3] = {fgkCarbonFiberTriangleLength
692 * CosD(fgkCarbonFiberTriangleAngle),0.,
693 - fgkCarbonFiberTriangleLength
694 * SinD(fgkCarbonFiberTriangleAngle)};
695 ///////////////////////////////////////////
696 //Setting Local Translations and Rotations:
697 ///////////////////////////////////////////
698 TGeoCombiTrans* localcarbonfibersupportmatrix[3];
699 localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
700 0.5*carbonfibersupportheight,NULL);
701 localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
702 2.*symmetryplaneposition+transvector[1],
703 transvector[2], carbonfiberot[2]);
704 localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
705 /////////////////////////////////////////////////////////////
706 // Carbon Fiber Support Transformations
707 /////////////////////////////////////////////////////////////
708 const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
709 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
710 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
711 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
712 fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
713 }
714 /////////////////////////////////////////////////////////////
715 // Carbon Fiber Junction Transformation
716 /////////////////////////////////////////////////////////////
717 const Int_t kcarbonfiberjunctionmatrixnumber = 2;
718 TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
719 TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
720 TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
721 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
722 localcarbonfiberjunctionmatrix[i] =
723 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
724 localcarbonfiberjunctionrot[i] =
725 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
726 localcarbonfiberjunctiontrans[i] =
727 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
d7599219 728 }
bf210566 729 ///////////////////////
730 // Setting Translations
731 ///////////////////////
732 localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
733 localcarbonfiberjunctiontrans[1][0] =
734 new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
735 localcarbonfiberjunctiontrans[2][0] =
736 new TGeoTranslation(fgkCarbonFiberTriangleLength
737 * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
738 fgkCarbonFiberTriangleLength
739 * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
740 localcarbonfiberjunctiontrans[0][1] =
741 new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
742 localcarbonfiberjunctiontrans[1][1] =
743 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
744 localcarbonfiberjunctiontrans[2][1] =
745 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
746 ////////////////////
747 // Setting Rotations
748 ////////////////////
749 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
750 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
751 localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
752 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
753 localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
754 localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
755 localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
756 localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
757 ////////////////////////////////////////
758 // Setting Carbon Fiber Junction matrix
759 ////////////////////////////////////////
760 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
761 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
762 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
763 localcarbonfiberjunctionmatrix[i][j] =
764 new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
765 *localcarbonfiberjunctionrot[i][j]);
766 fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
767 }
d7599219 768 }
bf210566 769 /////////////////////////////////////////////////////////////
770 // Carbon Fiber Lower Support Transformations
771 /////////////////////////////////////////////////////////////
772 TGeoTranslation* localcarbonfiberlowersupportrans[2];
773 localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
774 fgkCarbonFiberLowerSupportVolumePosition[1]
775 + fgkCarbonFiberLowerSupportVolumePosition[0],
776 0.0);
777 localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
778 fgkCarbonFiberJunctionWidth
779 - fgkCarbonFiberLowerSupportWidth
780 - fgkCarbonFiberLowerSupportVolumePosition[0]
781 - fgkCarbonFiberLowerSupportVolumePosition[1],
782 - 0.5*fgkCarbonFiberLowerSupportHeight);
783 localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
784 fcarbonfiberlowersupportrans[0] =
785 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
786 fcarbonfiberlowersupportrans[1] =
787 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
788 /////////////////////////////////////////////////////////////
789 // SSD Sensor Support Transformations
790 /////////////////////////////////////////////////////////////
791 const Int_t kssdsensorsupportmatrixnumber = 3;
792 TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
793 TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
794 TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
795 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
796 localssdsensorsupportmatrix[i] =
797 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
798 localssdsensorsupportrot[i] =
799 new TGeoRotation*[kssdsensorsupportmatrixnumber];
800 localssdsensorsupportrans[i] =
801 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
d7599219 802 }
bf210566 803 ///////////////////////
804 // Setting Translations
805 ///////////////////////
806 localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
807 0.5*fgkSSDSensorSideSupportWidth,
808 0.0);
809 localssdsensorsupportrans[1][0] =
810 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
811 localssdsensorsupportrans[2][0] =
812 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
813 localssdsensorsupportrans[0][1] =
814 new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
815 0.5*fgkSSDSensorSideSupportThickness[0],
816 0.0);
817 localssdsensorsupportrans[1][1] =
818 new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
819 - 0.5*fgkSSDSensorSideSupportThickness[0]
820 - fgkSSDModuleSensorSupportDistance,
821 0.0);
822 localssdsensorsupportrans[2][1] =
823 new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
824 - fgkSSDSensorCenterSupportPosition,
825 0.5*fgkSSDSensorCenterSupportWidth
826 - 0.5*fgkSSDModuleSensorSupportDistance,
827 fgkSSDSensorCenterSupportThickness[0]);
828 localssdsensorsupportrans[0][2] =
829 new TGeoTranslation(fgkCarbonFiberTriangleLength
830 + fgkCarbonFiberJunctionToSensorSupport,
831 fgkCarbonFiberJunctionWidth
832 - 0.5*(fgkCarbonFiberLowerSupportWidth
833 + fgkSSDSensorCenterSupportLength
834 - fgkSSDSensorCenterSupportThickness[0])
835 - fgkSSDSensorCenterSupportPosition,
836 0.0);
837 localssdsensorsupportrans[1][2] =
838 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
839 localssdsensorsupportrans[2][2] =
840 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
841 ////////////////////
842 // Setting Rotations
843 ////////////////////
844 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
845 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
846 localssdsensorsupportrot[i][j] = new TGeoRotation();
847 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
848 localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
849 localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
d7599219 850 }
bf210566 851 localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
852 localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
853 localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
854 ////////////////////////////////////////
855 // SSD Sensor Support matrix
856 ////////////////////////////////////////
857 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
858 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
859 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
860 localssdsensorsupportmatrix[i][j] =
861 new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
862 *localssdsensorsupportrot[i][j]);
863 fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
864 }
d7599219 865 }
44285dfa 866 /////////////////////////////////////////////////////////////
bf210566 867 // SSD Cooling Tube Support Transformations
44285dfa 868 /////////////////////////////////////////////////////////////
bf210566 869 const Int_t kcoolingtubesupportmatrixnumber = 2;
870 TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
871 TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
872 TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
44285dfa 873 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
d7599219 874 /fgkCoolingTubeSupportRmax);
bf210566 875 localcoolingtubesupportrans[0] =
876 new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
d7599219 877 + 2.*(fgkCoolingTubeSupportLength
44285dfa 878 - fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
d7599219 879 + fgkCarbonFiberTriangleLength
bf210566 880 - 2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
881 localcoolingtubesupportrans[1] =
882 new TGeoTranslation(fgkCarbonFiberJunctionLength
883 - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
884 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
885 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
886 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
887 - 0.5*(fgkCarbonFiberLowerSupportWidth
888 + fgkSSDSensorCenterSupportLength
889 - fgkSSDSensorCenterSupportThickness[0])
890 + 0.5*fgkSSDSensorLength,
891 - 0.5*fgkCoolingTubeSupportHeight);
892 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
893 localcoolingtubesupportrot[i] = new TGeoRotation();
894 localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
895 localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
896 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
897 localcoolingtubesupportmatrix[i] =
898 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
899 *localcoolingtubesupportrot[i]);
900 fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
901 fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
902 (*localcoolingtubesupportmatrix[0]));
903 /////////////////////////////////////////////////////////////
9b0c60ab 904 // End Ladder SSD Cooling Tube Support Transformations
905 /////////////////////////////////////////////////////////////
906 TGeoTranslation** localendladdercooltubetrans[2];
907 localendladdercooltubetrans[0] = new TGeoTranslation*[4];
908 localendladdercooltubetrans[1] = new TGeoTranslation*[2];
909 for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
910 localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
911 - (fgkCoolingTubeSupportLength
912 - fgkCoolingTubeSupportRmax),
913 fgkEndLadderMountingBlockPosition[0]
914 - fgkendladdercoolingsupportdistance[0]
915 + 0.5*fgkCoolingTubeSupportWidth,
916 - 0.5*fgkCoolingTubeSupportHeight);
917 localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
918 - (fgkCoolingTubeSupportLength
919 - fgkCoolingTubeSupportRmax),
920 fgkEndLadderMountingBlockPosition[0]
921 + fgkendladdercoolingsupportdistance[1]
922 + 0.5*fgkCoolingTubeSupportWidth,
923 - 0.5*fgkCoolingTubeSupportHeight);
924 localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
925 - fgkCoolingTubeSupportRmax)
926 + fgkCarbonFiberTriangleLength
927 - 2.0*fgkCarbonFiberJunctionLength,
928 0.0,
929 0.0);
930 localendladdercooltubetrans[0][3]->SetTranslation(0.0,
931 fgkendladdercoolingsupportdistance[0]
932 + fgkendladdercoolingsupportdistance[1],
933 0.0);
934 for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
935 localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
936 + fgkCarbonFiberJunctionLength
937 - fgkCoolingTubeSupportLength,
938 fgkEndLadderCarbonFiberLowerJunctionLength[1]
939 - 0.5*fgkCoolingTubeSupportWidth
940 -fgkendladdercoolingsupportdistance[2],
941 - 0.5*fgkCoolingTubeSupportHeight);
942 localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
943 + fgkCoolingTubeSupportLength
944 - fgkCoolingTubeSupportRmax
945 - fgkCarbonFiberJunctionLength,
946 fgkEndLadderCarbonFiberLowerJunctionLength[1]
947 - 0.5*fgkCoolingTubeSupportWidth
948 - fgkendladdercoolingsupportdistance[2],
949 - 0.5*fgkCoolingTubeSupportHeight);
950 fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
951 fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
952 fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
953 fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
954 (*localcoolingtubesupportrot[1]));
955 fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
956 (*localcoolingtubesupportrot[1]));
957 fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
958 fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
959 fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
960 fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
961 fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
962
963 fendladdercoolingtubesupportmatrix[1][0] =
964 new TGeoHMatrix((*localendladdercooltubetrans[1][0])
965 *(*localcoolingtubesupportrot[1]));
966 fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
967 fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
968 fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
969 /////////////////////////////////////////////////////////////
bf210566 970 // SSD Cooling Tube Transformations
971 /////////////////////////////////////////////////////////////
972 TGeoRotation* localcoolingtuberot = new TGeoRotation();
973 localcoolingtuberot->SetAngles(0.,90.,0.);
cd2243fb 974 TGeoTranslation* localcoolingtubetrans[2];
975 TVector3* localcoolingtubevect[2];
976
977 localcoolingtubevect[0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
bf210566 978 -fgkCarbonFiberTriangleLength),
cd2243fb 979 fgkCarbonFiberJunctionWidth // Y-coord is local Z, from sensor translation
980 - fgkCarbonFiberLowerSupportWidth
981 - fgkLowerSupportToSensorZ ,
bf210566 982 - 0.5*fgkCoolingTubeSupportHeight);
cd2243fb 983 localcoolingtubevect[1] = new TVector3( -localcoolingtubevect[0]->X()+fgkCarbonFiberTriangleLength,
984 localcoolingtubevect[0]->Y(),
985 localcoolingtubevect[0]->Z());
78e34526 986 for(Int_t j=0; j<2; j++){
987 localcoolingtubetrans[j] =
988 new TGeoTranslation(localcoolingtubevect[j]->X(),
989 localcoolingtubevect[j]->Y(),
990 localcoolingtubevect[j]->Z());
991 fcoolingtubematrix[j] = new TGeoHMatrix((*localcoolingtubetrans[j])
992 *(*localcoolingtuberot));
993 }
bf210566 994 /////////////////////////////////////////////////////////////
9b0c60ab 995 // SSD End Ladder Cooling Tube Transformations
996 /////////////////////////////////////////////////////////////
997 TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
998 localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
999 TGeoTranslation** localendlladdercoolingtubetrans[2];
cd2243fb 1000 localendlladdercoolingtubetrans[0] = new TGeoTranslation*[2];
1001 localendlladdercoolingtubetrans[1] = new TGeoTranslation*[2];
9b0c60ab 1002 for(Int_t i=0; i<2; i++)
cd2243fb 1003 for(Int_t j=0; j<2; j++)
9b0c60ab 1004 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
cd2243fb 1005
1006 Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
9b0c60ab 1007 localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1008 - fgkCoolingTubeSupportRmax)
1009 + fgkCarbonFiberJunctionLength,
cd2243fb 1010 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
9b0c60ab 1011 - 0.5*fgkCoolingTubeSupportHeight);
1012 localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1013 - fgkCoolingTubeSupportRmax)
1014 - fgkCarbonFiberJunctionLength
1015 + fgkCarbonFiberTriangleLength,
cd2243fb 1016 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
9b0c60ab 1017 - 0.5*fgkCoolingTubeSupportHeight);
cd2243fb 1018
9b0c60ab 1019 localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
cd2243fb 1020 - fgkCoolingTubeSupportRmax)
1021 + fgkCarbonFiberJunctionLength,
1022 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
9b0c60ab 1023 - 0.5*fgkCoolingTubeSupportHeight);
1024 localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1025 - fgkCoolingTubeSupportRmax)
1026 - fgkCarbonFiberJunctionLength
1027 + fgkCarbonFiberTriangleLength,
cd2243fb 1028 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
9b0c60ab 1029 - 0.5*fgkCoolingTubeSupportHeight);
9b0c60ab 1030 for(Int_t i=0; i<2; i++)
cd2243fb 1031 for(Int_t j=0; j<2; j++){
9b0c60ab 1032 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1033 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1034 }
1035 /////////////////////////////////////////////////////////////
bf210566 1036 // SSD Hybrid Components Transformations
1037 /////////////////////////////////////////////////////////////
1038 const Int_t khybridmatrixnumber = 3;
1039 TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1040 localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1041 0.5*fgkSSDStiffenerWidth,
1042 0.5*fgkSSDStiffenerHeight);
1043 localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1044 fgkSSDModuleStiffenerPosition[1],0.0);
1045
1046 localhybridtrans[2] = new TGeoTranslation(
1047 - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1048 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1049 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1050 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1051 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1052 - fgkSSDSensorCenterSupportThickness[0]),
1053 - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
ca86fdb4 1054 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight
0fb26117 1055 - fgkSSDModuleVerticalDisalignment));
bf210566 1056 fhybridmatrix = new TGeoHMatrix();
1057 for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1058 /////////////////////////////////////////////////////////////
1059 // SSD Cooling Block Transformations
1060 /////////////////////////////////////////////////////////////
78e34526 1061 TGeoTranslation localcoolingblocktrans (fcoolingtubematrix[0]->GetTranslation()[0]
1062 - 0.5*fgkSSDCoolingBlockLength,
1063 fhybridmatrix->GetTranslation()[1]-0.5*fgkSSDStiffenerWidth,
1064 fhybridmatrix->GetTranslation()[2]+0.5*fgkSSDStiffenerHeight+
1065 0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1066 fcoolingblocksystematrix = new TGeoHMatrix(localcoolingblocktrans);
bf210566 1067 /////////////////////////////////////////////////////////////
1068 // SSD Stiffener Flex Transformations
1069 /////////////////////////////////////////////////////////////
1070 const Int_t klocalflexmatrixnumber = 4;
1071 TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1072 for(Int_t i=0; i<fgkflexnumber; i++)
1073 localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1074 for(Int_t i=0; i<fgkflexnumber; i++)
1075 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1076 localflexmatrix[i][j] = new TGeoCombiTrans();
1077 Double_t ssdstiffenerseparation = fgkSSDSensorLength
1078 - 2.*fgkSSDModuleStiffenerPosition[1]
1079 - fgkSSDStiffenerWidth;
1080 localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1081 +0.5*fgkSSDStiffenerLength,
1082 0.5*fgkSSDStiffenerWidth,
1083 -0.5*fgkSSDStiffenerHeight
1084 -0.5*fgkSSDFlexHeight[0]);
1085 localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1086 +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1087 -0.5*fgkSSDStiffenerWidth,
1088 -0.5*fgkSSDStiffenerHeight
1089 -0.5*fgkSSDFlexHeight[0]);
1090 TGeoRotation* localflexrot = new TGeoRotation();
1091 localflexrot->SetAngles(180.,0.,0.);
1092 localflexmatrix[1][0]->SetRotation(localflexrot);
1093 for(Int_t i=0; i<fgkflexnumber; i++)
1094 for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1095 localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1096 for(Int_t i=0; i<fgkflexnumber; i++){
1097 fstiffenerflexmatrix[i] = new TGeoHMatrix();
1098 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1099 fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
d7599219 1100 }
bf210566 1101 /////////////////////////////////////////////////////////////
1102 // SSD End Flex Transformations
1103 /////////////////////////////////////////////////////////////
1104 TGeoRotation* localendflexrot = new TGeoRotation();
1105 localendflexrot->SetAngles(0.0,90.0,0.0);
1106 TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1107 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1108 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1109 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1110 * TMath::DegToRad()*ssdflexradiusmax
1111 - fgkSSDFlexLength[2]-TMath::Pi()
0fb26117 1112 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1113 - 0.1*fgkSSDFlexFullLength;
bf210566 1114 Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1115 + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1116 + fgkSSDFlexLength[2];
1117 localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1118 0.5*fgkSSDFlexWidth[0],
1119 2.*fgkSSDStiffenerHeight
1120 + 0.5*fgkSSDFlexHeight[0]);
1121 localendflexmatrix->SetRotation(localendflexrot);
1122 for(Int_t i=0; i<fgkflexnumber; i++)
1123 fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1124 /////////////////////////////////////////////////////////////
1125 // End Ladder Carbon Fiber Junction
1126 /////////////////////////////////////////////////////////////
1127 TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1128 TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1129 TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1130 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1131 localendladdercarbonfiberjunctionmatrix[i]
b28b5356 1132 = new TGeoCombiTrans*[fgkendladdercarbonfiberjunctionmatrixnumber];
bf210566 1133 localendladdercarbonfiberjunctionrot[i]
b28b5356 1134 = new TGeoRotation*[fgkendladdercarbonfiberjunctionmatrixnumber];
bf210566 1135 localendladdercarbonfiberjunctiontrans[i]
b28b5356 1136 = new TGeoTranslation*[fgkendladdercarbonfiberjunctionmatrixnumber];
bf210566 1137 fendladdercarbonfiberjunctionmatrix[i]
b28b5356 1138 = new TGeoHMatrix*[fgkendladdercarbonfiberjunctionmatrixnumber];
d7599219 1139 }
bf210566 1140 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
b28b5356 1141 for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++){
bf210566 1142 localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1143 localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1144 }
1145 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
b28b5356 1146 for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++)
bf210566 1147 localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1148 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1149 localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1150 0.0,0.0);
1151 localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1152 * CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1153 * SinD(fgkCarbonFiberTriangleAngle),
1154 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1155 - fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1156 }
1157 TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1158 TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1159 TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1160 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1161 localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1162 localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1163 localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1164 localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1165 0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1166 localendladdercarbonfiberjunctionglobalmatrix[i] =
1167 new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1168 *localendladdercarbonfiberjunctionglobalrot[i]);
1169 }
1170 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
b28b5356 1171 for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++){
bf210566 1172 localendladdercarbonfiberjunctionmatrix[i][j] =
1173 new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1174 *localendladdercarbonfiberjunctionrot[i][j]);
1175 fendladdercarbonfiberjunctionmatrix[i][j] =
1176 new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1177 * (*localendladdercarbonfiberjunctionmatrix[i][j]));
1178 }
1179 /////////////////////////////////////////////////////////////
1180 // End Ladder Carbon Fiber Support
1181 /////////////////////////////////////////////////////////////
1182 TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1183 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1184 localendladdercarbonfibertrans[i] = new TGeoTranslation();
1185 localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1186 i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1187 fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1188 }
1189 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1190 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1191 fendladdercarbonfibermatrix[i][j] =
1192 new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1193 *(*fcarbonfibersupportmatrix[j]));
1194 /////////////////////////////////////////////////////////////
1195 // End Ladder SSD Mounting Block
1196 /////////////////////////////////////////////////////////////
1197 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
9b0c60ab 1198 fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1199 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1200 fendladdermountingblockcombitrans[i]->SetTranslation(- 0.25*(fgkSSDMountingBlockLength[0]
bf210566 1201 + fgkSSDMountingBlockLength[1])
1202 + 0.5*fgkCarbonFiberTriangleLength,
1203 fgkEndLadderMountingBlockPosition[i],
1204 - fgkSSDMountingBlockHeight[1]
1205 + 0.5*fgkSSDMountingBlockHeight[0]);
9b0c60ab 1206 TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1207 endladdermountingblockrot->SetAngles(0.,90.,0.);
1208 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1209 fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1210 /////////////////////////////////////////////////////////////
1211 // End Ladder SSD Mounting Block Clip Matrix
1212 /////////////////////////////////////////////////////////////
1213 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1214 fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1215
1216 TGeoRotation* localendladdercliprot = new TGeoRotation();
1217 TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1218 localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1219 - fgkSSDMountingBlockLength[1])
1220 + fgkSSDMountingBlockLength[0],0.,0.);
1221 localendladdercliprot->SetAngles(90.,180.,-90.);
1222 TGeoCombiTrans* localendladderclipcombitrans =
1223 new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1224 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1225 for(Int_t j=0; j<2; j++){
1226 fendladdermountingblockclipmatrix[i][j] =
1227 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1228 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1229 }
bf210566 1230 /////////////////////////////////////////////////////////////
1231 // End Ladder Carbon Fiber Lower Support
1232 /////////////////////////////////////////////////////////////
1233 for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1234 fendladderlowersupptrans[i] =
1235 new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1236 + 0.5*fgkSSDMountingBlockWidth),
1237 - 0.5*fgkCarbonFiberLowerSupportHeight);
5d9d4033 1238 fendladderlowersupptrans[0]->SetDz(-0.5*fgkCarbonFiberLowerSupportHeight-fgkSSDTolerance);
bf210566 1239 fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1240 fgkCarbonFiberLowerSupportVolumePosition[1]
1241 + fgkCarbonFiberLowerSupportVolumePosition[0],
1242 0.0);
1243 fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1244 /////////////////////////////////////////////////////////////
1245 // Matrix for positioning Ladder into mother volume
1246 /////////////////////////////////////////////////////////////
1247 TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1248 for(Int_t i=0; i<fgkladdernumber; i++)
1249 ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1250 TGeoRotation* localladdermotherrot = new TGeoRotation();
1251 localladdermotherrot->SetAngles(0.,90.,0.);
1252 TGeoTranslation* localladdermothertrans[fgkladdernumber];
1253 TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1254 for(Int_t i=0; i<fgkladdernumber; i++){
1255 localladdermothertrans[i] = new TGeoTranslation(0.,
1256 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1257 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1258 + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1259 * fgkCarbonFiberJunctionWidth,0.);
1260 localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1261 *localladdermotherrot);
1262 ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1263 ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
d7599219 1264 }
44285dfa 1265 /////////////////////////////////////////////////////////////
bf210566 1266 // Ladder Cables Matrices
44285dfa 1267 /////////////////////////////////////////////////////////////
44285dfa 1268 Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
d7599219 1269 + fgkSSDFlexHeight[1];
44285dfa 1270 Double_t ssdladdercabletransx[3];
1271 ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
bf210566 1272 * SinD(2.*fgkSSDFlexAngle)
1273 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1274 ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1275 - ssdladdercabletransx[0]
bf210566 1276 / SinD(2.*fgkSSDFlexAngle))
1277 * CosD(fgkSSDFlexAngle);
44285dfa 1278 ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1279 * TMath::DegToRad()*ssdflexradiusmax
d7599219 1280 - fgkSSDFlexLength[2]-TMath::Pi()
1281 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1282 - fgkSSDLadderCableWidth)
bf210566 1283 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1284 Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
bf210566 1285 * TanD(2.*fgkSSDFlexAngle),
44285dfa 1286 ssdladdercabletransx[1]
bf210566 1287 * TanD(fgkSSDFlexAngle),
44285dfa 1288 ssdladdercabletransx[2]
bf210566 1289 * TanD(2.*fgkSSDFlexAngle)};
44285dfa 1290 TGeoRotation* localladdercablerot[3];
bf210566 1291 for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1292 localladdercablerot[0]->SetAngles(90.,0.,0.);
1293 localladdercablerot[1]->SetAngles(90.,60.,-90.);
44285dfa 1294 localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1295 * (*localladdercablerot[0]));
cd2243fb 1296 //TGeoRotation* localladdercablerot = new TGeoRotation();
1297 //localladdercablerot->SetAngles(90.,0.,0.);
44285dfa 1298 ////////////////////////////////////////////
1299 // LocalLadderCableCombiTransMatrix
1300 ////////////////////////////////////////////
1301 const Int_t klocalladdersidecablesnumber = 2;
1302 const Int_t klocalladdercombitransnumber = 5;
1303 TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1304 for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1305 localladdercablecombitransmatrix[i] =
1306 new TGeoCombiTrans*[klocalladdercombitransnumber];
1307 ///////////////////////////////////////////
1308 // Left Side Ladder Cables Transformations
1309 ///////////////////////////////////////////
1310 localladdercablecombitransmatrix[0][0] =
d7599219 1311 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1312 0.,0.,NULL);
bf210566 1313 localladdercablecombitransmatrix[0][1] =
1314 new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1315 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1316 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1317 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1318 - 0.5*(fgkCarbonFiberLowerSupportWidth
1319 + fgkSSDSensorCenterSupportLength
1320 - fgkSSDSensorCenterSupportThickness[0]),
1321 - (fgkSSDModuleCoolingBlockToSensor
1322 + 0.5*fgkCoolingTubeSupportHeight
1323 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1324 - fgkSSDChipHeight),NULL);
44285dfa 1325 localladdercablecombitransmatrix[0][2] =
d7599219 1326 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1327 fgkSSDModuleStiffenerPosition[1],0.,0);
bf210566 1328 localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1329 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1330 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1331 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1332 - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1333 new TGeoRotation("",180.,0.,0.));
44285dfa 1334 localladdercablecombitransmatrix[0][4] =
1335 new TGeoCombiTrans(-ssdladdercabletransx[0]
1336 - ssdladdercabletransx[1]-ssdladdercabletransx[2]
d7599219 1337 + fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1338 0.,
1339 0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1340 + fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
44285dfa 1341 + ssdladdercabletransz[0]-ssdladdercabletransz[1]
1342 + ssdladdercabletransz[2],localladdercablerot[2]);
1343 ///////////////////////////////////////////
1344 // Rigth Side Ladder Cables Transformations
1345 ///////////////////////////////////////////
bf210566 1346 TGeoCombiTrans* localladdercablessdmodulematrix =
1347 new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1348 - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1349 fgkSSDStiffenerWidth,
1350 - 0.5*fgkSSDFlexHeight[0],NULL);
44285dfa 1351 for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1352 localladdercablecombitransmatrix[1][i] =
bf210566 1353 (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1354 new TGeoCombiTrans(*localladdercablessdmodulematrix));
44285dfa 1355 ///////////////////////////////////////////
bf210566 1356 // Setting LadderCableHMatrix
44285dfa 1357 ///////////////////////////////////////////
bf210566 1358 Int_t beamaxistrans[2][3];
1359 beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1360 beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1361 beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1362 beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1363 beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1364 beamaxistrans[1][2] = beamaxistrans[1][0];
1365 TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1366 TGeoRotation* laddercablerot = new TGeoRotation();
1367 TGeoTranslation* laddercabletrans = new TGeoTranslation();
1368 TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1369 Double_t* laddercabletransvector;
1370 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1371 localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1372 fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1373 }
1374 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1375 for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1376 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1377 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1378 localladdercablehmatrix[i][j]->MultiplyLeft(
1379 localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1380 }
1381 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1382 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1383 laddercabletrans->SetTranslation(laddercabletransvector[0],
44285dfa 1384 laddercabletransvector[1]
bf210566 1385 + (j==0 ? beamaxistrans[i][0] : 0.)
d7599219 1386 * fgkCarbonFiberJunctionWidth,
bf210566 1387 laddercabletransvector[2]);
1388 laddercablecombitrans->SetRotation(*laddercablerot);
1389 laddercablecombitrans->SetTranslation(*laddercabletrans);
1390 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1391 }
1392 fladdercablematrix[i][2] =
1393 AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1394 beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1395 fladdercablematrix[i][3] =
1396 AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1397 beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1398 }
1399 for(Int_t i=0; i<fgkladdercablesnumber; i++)
78e34526 1400 for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1401 fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1402
bf210566 1403 ///////////////////////////////////////////
1404 // Setting Ladder HMatrix
1405 ///////////////////////////////////////////
1406 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1407 fgkSSDLay6SensorsNumber};
1408 for(Int_t i=0; i<fgkladdernumber; i++){
1409 fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1410 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1411 fladdermatrix[i][j] = new TGeoHMatrix();
1412 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1413 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1414 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1415 }
1416 }
1417 ///////////////////////////////////////////
1418 // Setting SSD Sensor Matrix
1419 ///////////////////////////////////////////
1420 TGeoCombiTrans* localssdsensorcombitrans[2];
1421 TGeoRotation* localssdsensorrot = new TGeoRotation();
1422 localssdsensorrot->SetAngles(0.,90.,0.);
1423 TGeoTranslation* localssdsensortrans[2];
1424 for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1425 localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
c40ebacc 1426 fgkCarbonFiberJunctionWidth
1427 - fgkCarbonFiberLowerSupportWidth
1428 - fgkLowerSupportToSensorZ,
bf210566 1429 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
0fb26117 1430 - fgkSSDModuleCoolingBlockToSensor
e21cdd03 1431 + (fgkSSDSensorSideSupportHeight[1]
0fb26117 1432 - fgkSSDSensorSideSupportHeight[0]));
bf210566 1433 localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
c40ebacc 1434 fgkCarbonFiberJunctionWidth
1435 - fgkCarbonFiberLowerSupportWidth
1436 - fgkLowerSupportToSensorZ,
bf210566 1437 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
0fb26117 1438 -fgkSSDModuleCoolingBlockToSensor);
cd2243fb 1439
bf210566 1440 for(Int_t i=0; i<2; i++)
1441 localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1442 *localssdsensorrot);
1443 for(Int_t i=0; i<fgkladdernumber; i++){
1444 fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1445 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1446 switch(i){
1447 case 0: //Ladder of Layer5
1448 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1449 * ((j%2==0 ? *localssdsensorcombitrans[0] :
1450 *localssdsensorcombitrans[1])));
1451 break;
1452 case 1: //Ladder of Layer6
1453 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1454 * ((j%2==0 ? *localssdsensorcombitrans[1] :
1455 *localssdsensorcombitrans[0])));
1456 break;
1457 }
1458 }
1459 }
1460 //////////////////////////
1461 // Setting SSD End Ladder
1462 //////////////////////////
1463 for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1464 for(Int_t i=0; i<2; i++){
1465 fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1466 fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1467 fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1468 fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1469 fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1470 fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1471 fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1472 fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1473 }
1474 /////////////////////////////////////////////////////
1475 // Setting the CombiTransformation to pass ITS center
1476 /////////////////////////////////////////////////////
1477 Double_t itscentertransz[fgklayernumber];
1478 itscentertransz[0] = fgkSSDLay5LadderLength
1479 - fgkLay5CenterITSPosition;
1480 itscentertransz[1] = fgkSSDLay6LadderLength
1481 - fgkLay6CenterITSPosition;
1482 Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1483 + 0.5*fgkCoolingTubeSupportHeight;
1484 TGeoRotation* itscenterrot[3];
1485 for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1486 itscenterrot[0]->SetAngles(90.,180.,-90.);
1487 itscenterrot[1]->SetAngles(0.,90.,0.);
1488 itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1489 TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1490 for(Int_t i=0; i<fgklayernumber; i++)
1491 itscentercombitrans[i] = new TGeoCombiTrans(0.,
1492 itssensortransy,
1493 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1494 - itscentertransz[i],itscenterrot[2]);
1495 TGeoRotation** locallayerrot[fgklayernumber];
1496 TGeoTranslation** locallayertrans[fgklayernumber];
1497 TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1498 TGeoTranslation* localbeamaxistrans[fgklayernumber];
1499 localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1500 - fgkLay5CenterITSPosition);
1501 localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1502 - fgkLay6CenterITSPosition);
1503 const Int_t kssdlayladdernumber[fgklayernumber] =
1504 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1505 for(Int_t i=0; i<fgklayernumber; i++){
1506 locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1507 locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1508 locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1509 flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1510 }
1511 Double_t layerladderangleposition[fgklayernumber] =
1512 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1513 Double_t layerradius = 0.;
1514 for(Int_t i=0; i<fgklayernumber; i++){
1515 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1516 switch(i){
1517 case 0: //Ladder of Layer5
1518 layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1519 break;
1520 case 1: //Ladder of Layer6
1521 layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1522 break;
1523 }
1524 locallayerrot[i][j] = new TGeoRotation();
1525 locallayertrans[i][j] = new TGeoTranslation();
1526 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1527 locallayertrans[i][j]->SetTranslation(layerradius
1528 * CosD(90.0+j*layerladderangleposition[i]),
1529 layerradius
1530 * SinD(90.0+j*layerladderangleposition[i]),0.);
1531 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1532 *locallayerrot[i][j]);
1533 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1534 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1535 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1536 }
1537 }
44285dfa 1538 /////////////////////////////////////////////////////////////
bf210566 1539 // Deallocating memory
44285dfa 1540 /////////////////////////////////////////////////////////////
bf210566 1541 for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1542 delete carbonfiberot[i];
1543 delete localcarbonfibersupportmatrix[i];
1544 }
1545 for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1546 for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1547 delete localcarbonfiberjunctionmatrix[i][j];
1548 delete localcarbonfiberjunctionrot[i][j];
1549 delete localcarbonfiberjunctiontrans[i][j];
1550 }
1551 delete [] localcarbonfiberjunctionmatrix[i];
1552 delete [] localcarbonfiberjunctionrot[i];
1553 delete [] localcarbonfiberjunctiontrans[i];
1554 }
1555 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1556 delete localcarbonfiberlowersupportrans[i];
1557 for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1558 for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1559 delete localssdsensorsupportmatrix[i][j];
1560 delete localssdsensorsupportrot[i][j];
1561 delete localssdsensorsupportrans[i][j];
1562 }
1563 delete [] localssdsensorsupportmatrix[i];
1564 delete [] localssdsensorsupportrot[i];
1565 delete [] localssdsensorsupportrans[i];
1566 }
1567 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1568 delete localcoolingtubesupportmatrix[i];
1569 delete localcoolingtubesupportrot[i];
1570 delete localcoolingtubesupportrans[i];
1571 }
cd2243fb 1572 for(Int_t j=0; j<2; j++){
1573 delete localcoolingtubevect[j];
1574 delete localcoolingtubetrans[j];
bf210566 1575 }
9b0c60ab 1576 delete endladdermountingblockrot;
bf210566 1577 for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
bf210566 1578 for(Int_t i=0; i<fgkflexnumber; i++){
1579 for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1580 delete localflexmatrix[i][j];
1581 delete [] localflexmatrix[i];
1582 }
9b0c60ab 1583 delete localendlladdercoolingtuberot;
1584 for(Int_t i=0; i<2; i++){
cd2243fb 1585 for(Int_t j=0; j<2; j++)
1586 delete localendlladdercoolingtubetrans[i][j];
9b0c60ab 1587 delete [] localendlladdercoolingtubetrans[i];
1588 }
1589
bf210566 1590 delete localflexrot;
1591 delete localendflexrot;
1592 delete localendflexmatrix;
1593 for(Int_t i=0; i<fgkladdernumber; i++){
1594 delete localladdermothertrans[i];
1595 delete localladdermothercombitrans[i];
1596 }
1597 delete localladdermotherrot;
1598 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
b28b5356 1599 for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++){
bf210566 1600 delete localendladdercarbonfiberjunctionmatrix[i][j];
1601 delete localendladdercarbonfiberjunctionrot[i][j];
1602 delete localendladdercarbonfiberjunctiontrans[i][j];
1603 }
1604 delete [] localendladdercarbonfiberjunctionmatrix[i];
1605 delete [] localendladdercarbonfiberjunctionrot[i];
1606 delete [] localendladdercarbonfiberjunctiontrans[i];
1607 delete localendladdercarbonfiberjunctionglobalrot[i];
1608 delete localendladdercarbonfiberjunctionglobaltrans[i];
1609 delete localendladdercarbonfiberjunctionglobalmatrix[i];
1610 }
9b0c60ab 1611 for(Int_t i=0; i<2; i++){
1612 for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1613 delete [] localendladdercooltubetrans[i];
1614 }
1615 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
bf210566 1616 delete localendladdercarbonfibertrans[i];
1617 for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1618 for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1619 for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1620 delete localladdercablecombitransmatrix[i][j];
1621 delete []localladdercablecombitransmatrix[i];
1622 }
9b0c60ab 1623 delete localendladdercliprot;
1624 delete localendladdercliptrans;
bf210566 1625 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1626 for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1627 delete localladdercablehmatrix[i][j];
1628 delete []localladdercablehmatrix[i];
1629 }
1630 delete laddercablerot;
1631 delete laddercabletrans;
1632 delete laddercablecombitrans;
1633 delete localladdercablessdmodulematrix;
1634 delete localssdsensorrot;
1635 for(Int_t i=0; i<2; i++){
1636 delete localssdsensortrans[i];
1637 delete localssdsensorcombitrans[i];
1638 }
1639 for(Int_t i=0; i<fgklayernumber; i++){
1640 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1641 delete locallayerrot[i][j];
1642 delete locallayertrans[i][j];
1643 delete locallayercombitrans[i][j];
1644 }
1645 delete [] locallayerrot[i];
1646 delete [] locallayertrans[i];
1647 delete [] locallayercombitrans[i];
1648 delete localbeamaxistrans[i];
1649 }
1650 for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1651 for(Int_t i=0; i<fgkladdernumber; i++){
1652 for(Int_t j=0; j<fgkladdernumber; j++)
1653 delete ladderglobalmatrix[i][j];
1654 delete [] ladderglobalmatrix[i];
1655 }
1656 /////////////////////////////////////////////////////////////
1657 fTransformationMatrices = kTRUE;
d7599219 1658}
bf210566 1659///////////////////////////////////////////////////////////////////////////////
1660void AliITSv11GeometrySSD::CreateBasicObjects(){
1661 /////////////////////////////////////////////////////////////
1662 // Method generating the Objects of SSD Geometry
1663 /////////////////////////////////////////////////////////////
1664 // SSD Sensor
1665 ///////////////////////////////////
1666 SetSSDSensor();
1667 /////////////////////////////////////////////////////////////
1668 // Carbon Fiber Support
1669 /////////////////////////////////////////////////////////////
1670 TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1671 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1672 fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
44285dfa 1673 /////////////////////////////////////////////////////////////
bf210566 1674 // Carbon Fiber Junction
44285dfa 1675 /////////////////////////////////////////////////////////////
ca86fdb4 1676 fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth-fgkSSDTolerance);
bf210566 1677 /////////////////////////////////////////////////////////////
1678 // Carbon Fiber Lower Support
1679 /////////////////////////////////////////////////////////////
1680 TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1681 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1682 fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1683 /////////////////////////////
1684 // SSD Sensor Support
1685 /////////////////////////////
1686 for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1687 new TGeoVolume*[fgkssdsensorsupportnumber];
44285dfa 1688 Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
bf210566 1689 fgkSSDSensorSideSupportThickness[1]};
1690 for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1691 fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1692 fgkSSDSensorSideSupportHeight[i],
1693 fgkSSDSensorSideSupportWidth,
1694 sidesupporthickness);
1695 fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1696 fgkSSDSensorCenterSupportHeight[i],
1697 fgkSSDSensorCenterSupportWidth,
1698 sidesupporthickness);
1699 }
1700 /////////////////////////////////////////////////////////////
1701 // SSD Cooling Tube Support
1702 /////////////////////////////////////////////////////////////
3c057f23 1703 Int_t edgesnumber = 3;
bf210566 1704 fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1705 /////////////////////////////////////////////////////////////
1706 // SSD Hybrid
1707 /////////////////////////////////////////////////////////////
1708 TList* ssdhybridcomponentslist = GetSSDHybridParts();
1709 for(Int_t i=0; i<fgkhybridcompnumber; i++)
1710 fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1711 /////////////////////////////////////////////////////////////
1712 // SSD Cooling Block System
1713 /////////////////////////////////////////////////////////////
1714 fssdcoolingblocksystem = GetCoolingBlockSystem();
1715 /////////////////////////////////////////////////////////////
1716 // SSD Cooling Tube
1717 /////////////////////////////////////////////////////////////
cd2243fb 1718 CreateCoolingTubes();
bf210566 1719 /////////////////////////////////////////////////////////////
1720 // SSD Flex
1721 /////////////////////////////////////////////////////////////
1722 fssdstiffenerflex = GetSSDStiffenerFlex();
1723 fssdendflex = GetSSDEndFlex();
1724 ///////////////////////////////////
1725 // End Ladder Carbon Fiber Junction
1726 ///////////////////////////////////
1727 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1728 fendladdercarbonfiberjunction[i] =
1729 new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1730 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1731 fendladdercarbonfiberjunction[i][0] =
ca86fdb4 1732 GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]-fgkSSDTolerance);
bf210566 1733 fendladdercarbonfiberjunction[i][1] =
ca86fdb4 1734 GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]-fgkSSDTolerance);
bf210566 1735 }
1736 ///////////////////////////////////
1737 // End Ladder Mounting Block
1738 ///////////////////////////////////
1739 fendladdermountingblock = GetSSDMountingBlock();
9b0c60ab 1740 ///////////////////////////////////
1741 // End Ladder Mounting Block
1742 ///////////////////////////////////
1743 fendladdermountingblockclip = GetMountingBlockClip();
1744 ///////////////////////////////////
1745 // Ladder Support
1746 ///////////////////////////////////
1747 TList* laddersupportlist = GetMountingBlockSupport(20);
1748 fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1749 fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1750 fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1751 fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
bf210566 1752 /////////////////////////////////////////////////////////////
1753 // Deallocating memory
44285dfa 1754 /////////////////////////////////////////////////////////////
bf210566 1755 delete carbonfibersupportlist;
1756 delete carbonfiberlowersupportlist;
1757 delete ssdhybridcomponentslist;
9b0c60ab 1758 delete laddersupportlist;
44285dfa 1759 /////////////////////////////////////////////////////////////
bf210566 1760 fBasicObjects = kTRUE;
1761}
1762/////////////////////////////////////////////////////////////////////////////////
1763void AliITSv11GeometrySSD::SetSSDSensor(){
1764 ////////////////////////////////////////////////////////////////
1765 // Method generating SSD Sensors: it sets the private variables
1766 // fSSDSensor5, fSSDSensor6
1767 ////////////////////////////////////////////////////////////////
44285dfa 1768 Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1769 Double_t ssdsensitivewidth = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1770 TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
44285dfa 1771 0.5*ssdsensitivewidth,
bf210566 1772 0.5*fgkSSDSensorHeight,
1773 0.5*ssdsensitivelength);
1774 TGeoVolume* ssdsensorsensitiveLay5 =
f510fd70 1775 new TGeoVolume(fgkSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1776 TGeoVolume* ssdsensorsensitiveLay6 =
f510fd70 1777 new TGeoVolume(fgkSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1778 ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1779 ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
44285dfa 1780 TGeoBBox* ssdsensorinsensitiveshape[2];
1781 ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
d7599219 1782 0.5*fgkSSDSensorInsensitiveWidth,
bf210566 1783 0.5*fgkSSDSensorHeight,
1784 0.5*fgkSSDSensorLength);
44285dfa 1785 ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
44285dfa 1786 0.5*ssdsensitivewidth,
bf210566 1787 0.5*fgkSSDSensorHeight,
1788 0.5*fgkSSDSensorInsensitiveWidth);
44285dfa 1789 const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
d7599219 1790 "SSDSensorInsensitive2"};
44285dfa 1791 TGeoVolume* ssdsensorinsensitive[2];
1792 for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1793 new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1794 fSSDSensorMedium);
1795 ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
d7599219 1796 }
bf210566 1797 /////////////////////////////////////////////////////////////
1798 // Virtual Volume containing SSD Sensor
1799 /////////////////////////////////////////////////////////////
1800 TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1801 0.5*fgkSSDSensorWidth,
1802 0.5*fgkSSDSensorHeight,
1803 0.5*fgkSSDSensorLength);
ef9451a3 1804 fSSDSensor5 = new TGeoVolume("ITSssdSensor5",virtualSSDSensorShape,
bf210566 1805 fSSDAir);
ef9451a3 1806 fSSDSensor6 = new TGeoVolume("ITSssdSensor6",virtualSSDSensorShape,
bf210566 1807 fSSDAir);
1808 /////////////////////////////////////////////////////////////
1809 for(Int_t i=0; i<4; i++){
1810 fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1811 ssdsensorinsensitive[1],i<2?1:2,
1812 new TGeoTranslation(
1813 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1814 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1815 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1816 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1817 fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
44285dfa 1818 ssdsensorinsensitive[1],i<2?1:2,
bf210566 1819 new TGeoTranslation(
1820 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1821 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1822 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1823 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1824 }
1825 fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1826 fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
d7599219 1827}
bf210566 1828///////////////////////////////////////////////////////////////////////////////
1829TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1830 /////////////////////////////////////////////////////////////
1831 // Method generating the Carbon Fiber Support
1832 /////////////////////////////////////////////////////////////
1833 const Int_t kvertexnumber = 4;
1834 const Int_t kshapesnumber = 2;
1835 TVector3** vertexposition[kshapesnumber];
1836 for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1837 Double_t carbonfibersupportxaxisEdgeproj =
1838 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1839 * TMath::DegToRad());
1840 Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1841 / fgkCarbonFiberSupportXAxisLength);
1842 /////////////////////
1843 //Vertex Positioning
1844 ////////////////////
1845 vertexposition[0][0] = new TVector3();
1846 vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
1847 fgkCarbonFiberSupportYAxisLength);
1848 vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
1849 carbonfibersupportxaxisEdgeproj
1850 * TMath::Tan(theta));
1851 vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
1852 - carbonfibersupportxaxisEdgeproj,
1853 fgkCarbonFiberSupportYAxisLength
1854 - vertexposition[0][2]->Y());
1855 ////////////////////////////////////////////////////
1856 //Setting the parameters for Isometry Transformation
1857 ////////////////////////////////////////////////////
1858 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
1859 + fgkCarbonFiberSupportTopEdgeDist[0]
1860 + fgkCarbonFiberSupportWidth);
1861 Double_t* param = new Double_t[4];
1862 param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
1863 for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
160835d5 1864 new TVector3((GetReflection(vertexposition[0][j],param))->X(),
1865 (GetReflection(vertexposition[0][j],param))->Y());
a6e0ebfe 1866 const char* carbonfibersupportshapename[kshapesnumber] =
bf210566 1867 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
a6e0ebfe 1868 const char* carbonfibersupportname[kshapesnumber] =
bf210566 1869 {"CarbonFiberSupport1","CarbonFiberSupport2"};
1870 TGeoArb8* carbonfibersupportshape[kshapesnumber];
1871 TGeoVolume* carbonfibersupport[kshapesnumber];
1872 TList* carbonfibersupportlist = new TList();
1873 Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
1874 Double_t carbonfibersupportheight =
1875 carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1876 *TMath::DegToRad());
1877 for(Int_t i = 0; i< kshapesnumber; i++){
1878 carbonfibersupportshape[i] =
1879 GetArbShape(vertexposition[i],width,carbonfibersupportheight,
1880 carbonfibersupportshapename[i],i==0 ? 1: -1);
1881 carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
1882 carbonfibersupportshape[i],fSSDCarbonFiberMedium);
1883 carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
1884 carbonfibersupportlist->Add(carbonfibersupport[i]);
1885 }
1886 /////////////////////////////////////////////////////////////
1887 // Deallocating memory
1888 /////////////////////////////////////////////////////////////
1889 for(Int_t i=0; i< kshapesnumber; i++){
1890 for(Int_t j=0; j< kvertexnumber; j++)
1891 delete vertexposition[i][j];
1892 delete [] vertexposition[i];
1893 }
1894 delete [] param;
44285dfa 1895 /////////////////////////////////////////////////////////////
bf210566 1896 return carbonfibersupportlist;
d7599219 1897}
1898/////////////////////////////////////////////////////////////////////////////////
bf210566 1899TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
44285dfa 1900 /////////////////////////////////////////////////////////////
bf210566 1901 // Method generating SSD Carbon Fiber Junction
44285dfa 1902 /////////////////////////////////////////////////////////////
bf210566 1903 const Int_t kvertexnumber = 6;
1904 TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
d4ff3e0a 1905 Double_t reflectionparam[4] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1906 * TMath::DegToRad()),-1.,0.,0.};
bf210566 1907 TVector3* vertex[kvertexnumber];
1908 vertex[0] = new TVector3();
1909 vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
1910 * TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1911 * TMath::DegToRad()),
1912 fgkCarbonFiberJunctionEdge[0]
1913 * TMath::Sin(fgkCarbonFiberJunctionAngle[0]
1914 * TMath::DegToRad()));
5d9d4033 1915 vertex[4] = new TVector3(fgkCarbonFiberJunctionLength-fgkSSDTolerance,
bf210566 1916 fgkCarbonFiberJunctionEdge[1]);
5d9d4033 1917 vertex[5] = new TVector3(fgkCarbonFiberJunctionLength-fgkSSDTolerance);
bf210566 1918 vertex[1] = GetReflection(vertex[5],reflectionparam);
1919 vertex[2] = GetReflection(vertex[4],reflectionparam);
1920 Double_t xvertexpoints[6], yvertexpoints[6];
1921 for(Int_t i=0; i<kvertexnumber; i++)
1922 xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
1923 carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
1924 carbonfiberjunctionshape->DefineSection(0,-0.5*width);
1925 carbonfiberjunctionshape->DefineSection(1,0.5*width);
1926 TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
1927 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
1928 carbonfiberjunction->SetLineColor(fColorCarbonFiber);
1929 /////////////////////////////////////////////////////////////
1930 // Deallocating memory
1931 /////////////////////////////////////////////////////////////
1932 for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
1933 /////////////////////////////////////////////////////////////
1934 return carbonfiberjunction;
1935}
1936////////////////////////////////////////////////////////////////////////////////
1937TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
1938 /////////////////////////////////////////////////////////////
1939 // Method generating the Carbon Fiber Lower Support
1940 /////////////////////////////////////////////////////////////
1941 const Int_t kvertexnumber = 4;
1942 const Int_t kshapesnumber = 2;
1943 Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
1944 fgkCarbonFiberLowerSupportWidth};
1945 TVector3** vertexposition[kshapesnumber];
1946 for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
1947 new TVector3*[kvertexnumber];
1948 //First Shape Vertex Positioning
1949 vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
1950 vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
1951 - fgkCarbonFiberLowerSupportLowerLenght);
1952 vertexposition[0][2] = new TVector3();
1953 vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
1954 //Second Shape Vertex Positioning
1955 Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
1956 - fgkCarbonFiberLowerSupportVolumePosition[0])
1957 / fgkCarbonFiberTriangleLength);
1958 vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
1959 vertexposition[0][0]->X()*TMath::Tan(theta)
1960 + fgkCarbonFiberLowerSupportVolumePosition[0]);
1961 vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
1962 vertexposition[0][1]->X()*TMath::Tan(theta)
1963 + fgkCarbonFiberLowerSupportVolumePosition[0]);
1964 vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
1965 vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
1966 fgkCarbonFiberLowerSupportVolumePosition[1]);
a6e0ebfe 1967 const char* carbonfiberlowersupportshapename[kshapesnumber] =
bf210566 1968 {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
a6e0ebfe 1969 const char* carbonfiberlowersupportname[kshapesnumber] =
bf210566 1970 {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
1971 TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
1972 TGeoVolume* carbonfiberlowersupport[kshapesnumber];
1973 TList* carbonfiberlowersupportlist = new TList();
1974 for(Int_t i = 0; i< kshapesnumber; i++){
1975 carbonfiberlowersupportshape[i] =
1976 GetArbShape(vertexposition[i],width,
1977 fgkCarbonFiberLowerSupportHeight,
1978 carbonfiberlowersupportshapename[i]);
1979 carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
1980 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
1981 carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
1982 carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
1983 }
1984 /////////////////////////////////////////////////////////////
1985 // Deallocating memory
1986 /////////////////////////////////////////////////////////////
1987 for(Int_t i=0; i< kshapesnumber; i++){
1988 for(Int_t j=0; j< kvertexnumber; j++)
1989 delete vertexposition[i][j];
1990 delete [] vertexposition[i];
1991 }
1992 /////////////////////////////////////////////////////////////
1993 return carbonfiberlowersupportlist;
1994}
1995///////////////////////////////////////////////////////////////////////////////
1996TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
5cb5bc3d 1997 Double_t width, const Double_t* thickness)const{
bf210566 1998 /////////////////////////////////////////////////////////////
1999 // Method generating the Sensor Support
2000 /////////////////////////////////////////////////////////////
2001 const Int_t kvertexnumber = 6;
2002 TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2003 TVector3* vertexposition[kvertexnumber];
2004 vertexposition[0] = new TVector3();
2005 vertexposition[1] = new TVector3(0.0,length);
2006 vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y());
2007 vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]);
2008 vertexposition[4] = new TVector3(height,vertexposition[3]->Y());
2009 vertexposition[5] = new TVector3(vertexposition[4]->X());
2010 Double_t xvertexpoints[6], yvertexpoints[6];
2011 for(Int_t i=0; i<kvertexnumber; i++)
2012 xvertexpoints[i] = vertexposition[i]->X(),
2013 yvertexpoints[i] = vertexposition[i]->Y();
2014 ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2015 ssdsensorsupportshape->DefineSection(0,-0.5*width);
2016 ssdsensorsupportshape->DefineSection(1,0.5*width);
2017 TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2018 ssdsensorsupportshape,fSSDSensorSupportMedium);
2019 /////////////////////////////////////////////////////////////
2020 // Deallocating memory
2021 /////////////////////////////////////////////////////////////
2022 for (Int_t i=0; i<kvertexnumber; i++)
2023 delete vertexposition[i];
2024 /////////////////////////////////////////////////////////////
2025 return ssdsensorsupport;
2026}
2027////////////////////////////////////////////////////////////////////////////////
2028TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2029 /////////////////////////////////////////////////////////////
2030 // Method generating the Cooling Tube Support
2031 /////////////////////////////////////////////////////////////
2032 if(nedges%2!=0) nedges--;
2033 const Int_t kvertexnumber = nedges+5;
2034 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2035 / fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2036 Double_t angle = 90.+phi;
2037 Double_t psi = 90.-phi;
2038 ///////////////////////////////////////
2039 // Vertex Positioning for TGeoXTru
2040 ///////////////////////////////////////
2041 TVector3** vertexposition = new TVector3*[kvertexnumber];
cd2243fb 2042
f510fd70 2043 Double_t router = fgkCoolingTubeSupportRmin/CosD(phi/nedges); // Recalc inner radius so that tube fits inside
2044 vertexposition[0] = new TVector3(router*CosD(angle),
2045 router*SinD(angle));
bf210566 2046 vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2047 fgkCoolingTubeSupportRmax*SinD(angle));
2048 vertexposition[2] = new TVector3(vertexposition[1]->X(),
2049 fgkCoolingTubeSupportRmax);
2050 vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2051 fgkCoolingTubeSupportRmax);
2052 vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2053 vertexposition[1]->Y());
cd2243fb 2054
bf210566 2055 for(Int_t i=0; i<nedges; i++)
2056 vertexposition[i+5] =
f510fd70 2057 new TVector3(router*CosD(psi+i*(2.*phi/nedges)),
2058 router*SinD(psi+i*(2.*phi/nedges)));
bf210566 2059 ///////////////////////////////////////////////////////////////////////
2060 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2061 ///////////////////////////////////////////////////////////////////////
2062 TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2063 Double_t* xvertexpoints = new Double_t[kvertexnumber];
2064 Double_t* yvertexpoints = new Double_t[kvertexnumber];
2065 for(Int_t i=0; i<kvertexnumber; i++){
2066 xvertexpoints[i] = vertexposition[i]->X();
2067 yvertexpoints[i] = vertexposition[i]->Y();
2068 }
2069 coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2070 yvertexpoints);
2071 coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2072 coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2073 TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2074 coolingtubesupportarcshape,
2075 fSSDTubeHolderMedium);
2076 coolingtubesupportarc->SetLineColor(fColorG10);
2077 //////////////////////////////////////////////////////////////////////////
2078 // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2079 //////////////////////////////////////////////////////////////////////////
2080 TGeoTubeSeg* coolingtubesupportsegshape =
2081 new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2082 fgkCoolingTubeSupportRmax,
2083 0.5*fgkCoolingTubeSupportWidth,
2084 phi,360-phi);
2085 TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2086 coolingtubesupportsegshape,
2087 fSSDTubeHolderMedium);
2088 coolingtubesupportseg->SetLineColor(fColorG10);
2089 //////////////////////////////////////////////////////////////////////////
2090 // TGeoBBox Volume definition for Cooling Tube Support Box Part
2091 //////////////////////////////////////////////////////////////////////////
2092 Double_t* boxorigin = new Double_t[3];
2093 Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2094 boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2095 TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2096 0.5*fgkCoolingTubeSupportHeight,
2097 0.5*fgkCoolingTubeSupportWidth,boxorigin);
2098 TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2099 coolingtubesupportboxshape,fSSDTubeHolderMedium);
2100 coolingtubesupportbox->SetLineColor(fColorG10);
2101 //////////////////////////////////////////////////////////////////////////
2102 // Cooling Tube for Cooling Tube Support
2103 //////////////////////////////////////////////////////////////////////////
2104 TGeoXtru* coolingtubearcshape[2];
2105 coolingtubearcshape[0] = new TGeoXtru(2);
2106 Double_t* xvert = new Double_t[nedges+2];
2107 Double_t* yvert = new Double_t[nedges+2];
2108 Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2109 ////////////////////////////////////////
2110 // Positioning the vertices for TGeoXTru
2111 ////////////////////////////////////////
2112 xvert[0] = 0., yvert[0] = 0.;
2113 xvert[1] = vertexposition[0]->X()*ratio, yvert[1] = vertexposition[0]->Y()*ratio;
2114 for(Int_t i=0; i< nedges; i++)
2115 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2116 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2117 ////////////////////////////////////////
2118 // Defining TGeoXTru PolyGone
2119 ////////////////////////////////////////
2120 coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2121 coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2122 coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2123 coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2124 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2125 TGeoVolume* coolingtubearc[2];
2126 coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2127 coolingtubearcshape[0],fSSDCoolingTubeWater);
2128 coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2129 coolingtubearcshape[1],fSSDCoolingTubePhynox);
2130 coolingtubearc[0]->SetLineColor(fColorWater);
2131 coolingtubearc[1]->SetLineColor(fColorPhynox);
2132 ////////////////////////////////////////////
2133 // Defining TGeoTubeSeg Part of Cooling Tube
2134 ////////////////////////////////////////////
2135 TGeoTubeSeg* coolingtubesegshape[2];
2136 coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2137 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2138 coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2139 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2140 TGeoVolume* coolingtubeseg[2];
2141 coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2142 coolingtubesegshape[0],fSSDCoolingTubePhynox);
2143 coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2144 coolingtubesegshape[1],fSSDCoolingTubeWater);
2145 coolingtubeseg[0]->SetLineColor(fColorPhynox);
2146 coolingtubeseg[1]->SetLineColor(fColorWater);
2147 /////////////////////////////////////////////////////////////
2148 // Virtual Volume containing Cooling Tube Support
2149 /////////////////////////////////////////////////////////////
2150 TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2151 const Int_t kvirtualvertexnumber = 8;
2152 TVector3* virtualvertex[kvirtualvertexnumber];
2153 ////////////////////////////////////////
2154 // Positioning the vertices for TGeoXTru
2155 ////////////////////////////////////////
2156 virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax);
2157 virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y());
2158 virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y());
2159 virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight);
2160 virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y());
2161 virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y());
2162 virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y());
2163 virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y());
2164 Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2165 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2166 xmothervertex[i] = virtualvertex[i]->X(),
2167 ymothervertex[i] = virtualvertex[i]->Y();
2168 ////////////////////////////////////////
2169 // Defining TGeoXTru PolyGone
2170 ////////////////////////////////////////
2171 virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2172 ymothervertex);
2173 virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2174 virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
cd2243fb 2175 /*TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2176 virtualCoolingTubeSupportShape,fSSDAir); */
2177 TGeoVolume* virtualcoolingtubesupport = new TGeoVolumeAssembly("CoolingTubeSupport");
2178
bf210566 2179 ////////////////////////////////////////
2180 // Positioning Volumes in Virtual Volume
2181 ////////////////////////////////////////
2182 TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2183 coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2184 virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2185 virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2186 virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
cd2243fb 2187 //virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2188 //virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2189 //virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2190 //virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
bf210566 2191 /////////////////////////////////////////////////////////////
2192 // Deallocating memory
2193 /////////////////////////////////////////////////////////////
2194 delete [] vertexposition;
3e008bd7 2195 delete [] xvertexpoints;
2196 delete [] yvertexpoints;
2197 delete [] xvert;
2198 delete [] yvert;
bf210566 2199 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2200 delete virtualvertex[i];
2201 /////////////////////////////////////////////////////////////
2202 return virtualcoolingtubesupport;
2203}
2204/////////////////////////////////////////////////////////////////////////////////
2205TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2206 /////////////////////////////////////////////////////////////
2207 // Method generating List containing SSD Hybrid Components
2208 /////////////////////////////////////////////////////////////
2209 TList* ssdhybridlist = new TList();
2210 const Int_t kssdstiffenernumber = 2;
2211 Double_t ssdstiffenerseparation = fgkSSDSensorLength
2212 - 2.*fgkSSDModuleStiffenerPosition[1]
2213 - fgkSSDStiffenerWidth;
2214 Double_t ssdchipcablesradius[kssdstiffenernumber];
2215 for(Int_t i=0; i<kssdstiffenernumber; i++)
2216 ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2217 - fgkSSDChipCablesHeight[0]
2218 - fgkSSDChipCablesHeight[1]);
2219 /////////////////////////////////////////////////////////////
2220 // Mother Volumes Containers
2221 /////////////////////////////////////////////////////////////
2222 const Int_t kmothernumber = 2;
3cf6a656 2223 const Int_t kmothervertexnumber = 8;
bf210566 2224 Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2225 Double_t ymothervertex[kmothernumber][kmothervertexnumber];
3cf6a656 2226
2227 TGeoVolumeAssembly* ssdhybridassembly[kmothernumber];
2228 TGeoVolume* ssdhybridmother[kmothernumber][2];
2229
2230 TGeoRotation hybridmotherrotR(TGeoRotation("",-90.0,0.0,0.0)*TGeoRotation("",0.0,90.0,0.0)*TGeoRotation("",90.,180.,-90));
2231 TGeoRotation hybridmotherrotL(TGeoRotation("",180.,0.0,0.0)*hybridmotherrotR);
2232 TGeoRotation *hybridmotherrotInv = new TGeoRotation(hybridmotherrotR.Inverse());
2233
bf210566 2234 const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2235 for(Int_t i=0; i<kmothernumber; i++){
3cf6a656 2236 xmothervertex[i][0] = -0.5*fgkSSDStiffenerWidth;
2237 ymothervertex[i][0] = 0.5*fgkSSDStiffenerHeight;
2238 xmothervertex[i][1] = -0.5*fgkSSDStiffenerWidth;
2239 ymothervertex[i][1] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2240 -fgkSSDChipCablesHeight[i+2];
2241
2242 xmothervertex[i][2] = 0.5*(fgkSSDSensorLength-ssdstiffenerseparation); //0.5*fgkSSDStiffenerWidth;
2243 ymothervertex[i][2] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight -fgkSSDChipCablesHeight[i+2];
2244 xmothervertex[i][3] = xmothervertex[i][2];
5d9d4033 2245 ymothervertex[i][3] = ymothervertex[i][2]+fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1]+fgkSSDTolerance;
3cf6a656 2246
2247 xmothervertex[i][4] = xmothervertex[i][2]-0.4;
2248 ymothervertex[i][4] = ymothervertex[i][3];
2249 xmothervertex[i][5] = xmothervertex[i][4];
5d9d4033 2250 ymothervertex[i][5] = ymothervertex[i][4]+2*ssdchipcablesradius[i]-fgkSSDTolerance;
3cf6a656 2251
2252 xmothervertex[i][6] = 0.5*fgkSSDStiffenerWidth+ssdchipcablesradius[i]+0.3*fgkmm;
2253 ymothervertex[i][6] = ymothervertex[i][5];
2254
2255 xmothervertex[i][7] = xmothervertex[i][6];
2256 ymothervertex[i][7] = 0.5*fgkSSDStiffenerHeight;
3cf6a656 2257 TGeoXtru *shape = new TGeoXtru(2);
2258 shape->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
2259 shape->DefineSection(0,-0.5*fgkSSDStiffenerLength);
2260 shape->DefineSection(1,0.5*fgkSSDStiffenerLength);
2261 ssdhybridmother[i][0] = new TGeoVolume(TString(ssdhybridmothername[i])+"L",shape,fSSDAir);
2262 ssdhybridmother[i][1] = new TGeoVolume(TString(ssdhybridmothername[i])+"R",shape,fSSDAir);
2263 ssdhybridassembly[i] = new TGeoVolumeAssembly(ssdhybridmothername[i]);
bf210566 2264 }
2265 /////////////////////////////////////////////////////////////
2266 // SSD Stiffener
2267 /////////////////////////////////////////////////////////////
2268 TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2269 0.5*fgkSSDStiffenerLength,
ca86fdb4 2270 0.5*(fgkSSDStiffenerWidth-fgkSSDTolerance),
bf210566 2271 0.5*fgkSSDStiffenerHeight);
2272 TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2273 fSSDStiffenerMedium);
2274 ssdstiffener->SetLineColor(fColorStiffener);
3cf6a656 2275
bf210566 2276////////////////////////////
2277// Capacitor 0603-2200 nF
2278///////////////////////////
2279 const Int_t knapacitor0603number = 5;
78e34526 2280 TGeoBBox* capacitor0603mothershape = new TGeoBBox("Capacitor0603MotherShape",
2281 0.5*fgkSSDCapacitor0603Length + fgkSSDCapacitor0603CapLength,
2282 0.5*fgkSSDCapacitor0603Width,
2283 0.5*fgkSSDCapacitor0603Height);
2284 TGeoVolume* capacitor0603mother = new TGeoVolume("Capacitor0603Mother",capacitor0603mothershape,
2285 fSSDAir);
2286
bf210566 2287 TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
3cf6a656 2288 0.5*fgkSSDCapacitor0603Length,
78e34526 2289 0.5*fgkSSDCapacitor0603Width,
3cf6a656 2290 0.5*fgkSSDCapacitor0603Height);
bf210566 2291 TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
44285dfa 2292 fSSDStiffener0603CapacitorMedium);
2293 capacitor0603->SetLineColor(fColorAl);
78e34526 2294 TGeoTranslation *cap0603trans = new TGeoTranslation(0.,0.,0.);
2295 capacitor0603mother->AddNode(capacitor0603,1,cap0603trans);
2296
2297 TGeoBBox* capacitor0603capshape = new TGeoBBox("Capacitor0603CapShape",
2298 0.5*fgkSSDCapacitor0603CapLength,
2299 0.5*fgkSSDCapacitor0603Width,
2300 0.5*fgkSSDCapacitor0603Height);
2301 TGeoVolume* capacitor0603cap = new TGeoVolume("Capacitor0603Cap",capacitor0603capshape,
2302 fSSDStiffenerCapacitorCapMedium);
2303 capacitor0603cap->SetLineColor(fColorNiSn);
2304 TGeoTranslation *cap0603captrans1 = new TGeoTranslation(- capacitor0603shape->GetDX() - capacitor0603capshape->GetDX(),0.,0.);
2305 capacitor0603mother->AddNode(capacitor0603cap,1,cap0603captrans1);
2306 TGeoTranslation *cap0603captrans2 = new TGeoTranslation(capacitor0603shape->GetDX() + capacitor0603capshape->GetDX(),0.,0.);
2307 capacitor0603mother->AddNode(capacitor0603cap,2,cap0603captrans2);
2308
3cf6a656 2309
2310 TGeoVolume* ssdchip = GetSSDChip();
2311
2312 const Int_t knedges = 5;
2313 TGeoVolume *ssdchipcables[2];
2314
bf210566 2315 for(Int_t i=0; i<kmothernumber; i++){
3cf6a656 2316 for(Int_t j=0; j<kssdstiffenernumber; j++){
2317 ssdhybridmother[i][j]->AddNode(ssdstiffener,1,hybridmotherrotInv);
2318 for(Int_t k=1; k<knapacitor0603number+1; k++){
78e34526 2319 ssdhybridmother[i][j]->AddNode(capacitor0603mother,k,
3cf6a656 2320 new TGeoCombiTrans("",
2321 -0.5*(fgkSSDStiffenerWidth - fgkSSDCapacitor0603Width),
2322 -0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height),
2323 (k-3.)/6*fgkSSDStiffenerLength,
2324 hybridmotherrotInv));
2325 }
2326 }
2327
2328 GetSSDChipCables(ssdchipcables[0],ssdchipcables[1],fgkSSDChipCablesHeight[i+2],knedges);
2329 for(Int_t k=0; k<fgkSSDChipNumber; k++){
2330 TGeoTranslation *chipcabletrans = new TGeoTranslation("",0.5*fgkSSDStiffenerWidth-fgkSSDChipWidth,
2331 - 0.5*fgkSSDStiffenerHeight - fgkSSDChipHeight
2332 - fgkSSDChipCablesHeight[i+2],
2333 (k+0.5-fgkSSDChipNumber/2)*
2334 (fgkSSDChipLength + fgkSSDChipSeparationLength));
2335 TGeoCombiTrans *chiptrans = new TGeoCombiTrans("",0.5*(fgkSSDStiffenerWidth-fgkSSDChipWidth),
2336 - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight),
2337 (k+0.5-fgkSSDChipNumber/2)*(fgkSSDChipLength + fgkSSDChipSeparationLength),
2338 hybridmotherrotInv);
bf210566 2339 for(Int_t j=0; j<kssdstiffenernumber; j++){
3cf6a656 2340 ssdhybridmother[i][j]->AddNode(ssdchipcables[j],k+1,chipcabletrans);
2341 ssdhybridmother[i][j]->AddNode(ssdchip,k+1,chiptrans);
2342 }
2343 }
2344 // Final placement by assembly
2345 ssdhybridassembly[i]->AddNode(ssdhybridmother[i][0],1,new TGeoCombiTrans(TGeoTranslation("",0,0,0),hybridmotherrotL));
2346 ssdhybridassembly[i]->AddNode(ssdhybridmother[i][1],1,new TGeoCombiTrans(TGeoTranslation("",0,ssdstiffenerseparation,0),hybridmotherrotR));
2347 ssdhybridlist->Add(ssdhybridassembly[i]);
bf210566 2348 }
3cf6a656 2349 /////////////////////////////////////////////////////////////
2350 // Mother Volume Containing Capacitor Part
2351 /////////////////////////////////////////////////////////////
bf210566 2352 const Int_t kcapacitormothernumber = 8;
2353 Double_t xcapacitorvertex[kcapacitormothernumber];
2354 Double_t ycapacitorvertex[kcapacitormothernumber];
2355 ///////////////////////
2356 // Setting the vertices
2357 ///////////////////////
2358 xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2359 xcapacitorvertex[1] = xcapacitorvertex[0];
2360 xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2361 xcapacitorvertex[3] = xcapacitorvertex[2];
2362 xcapacitorvertex[4] = xcapacitorvertex[0];
2363 xcapacitorvertex[5] = xcapacitorvertex[0];
2364 xcapacitorvertex[6] = -xcapacitorvertex[0];
2365 xcapacitorvertex[7] = xcapacitorvertex[6];
2366 ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2367 ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2368 ycapacitorvertex[2] = ycapacitorvertex[1];
2369 ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2370 ycapacitorvertex[4] = ycapacitorvertex[3];
2371 ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2372 ycapacitorvertex[6] = ycapacitorvertex[5];
2373 ycapacitorvertex[7] = ycapacitorvertex[0];
2374 TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2375 ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2376 ycapacitorvertex);
2377 ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2378 ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
ca86fdb4 2379// TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2380// fSSDAir);
2381 TGeoVolumeAssembly* ssdhybridcapacitormother = new TGeoVolumeAssembly("SSDHybridCapacitorMother");
d7599219 2382////////////////////////////
bf210566 2383// Connector
d7599219 2384///////////////////////////
78e34526 2385 const Int_t kssdconnectorlayernumber = 3;
2386 TGeoBBox* ssdconnectorshape[kssdconnectorlayernumber];
2387 Double_t ssdConnectorThickness[kssdconnectorlayernumber]={fgkSSDConnectorAlHeight,fgkSSDConnectorNiHeight,fgkSSDConnectorSnHeight};
2388 /*
bf210566 2389 Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2390 Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2391 + fgkSSDConnectorAlHeight};
78e34526 2392 */
2393 Double_t ssdconnectororigin[3] = {0,0,0.5*fgkSSDStiffenerHeight};
2394 const char* ssdconnectorname[kssdconnectorlayernumber] = {"SSDConnectorAl","SSDConnectorNi","SSDConnectorSn"};
2395 TGeoMedium *ssdConnectorMedium[kssdconnectorlayernumber]={fSSDAlTraceFlexMedium,fSSDStiffenerConnectorMedium,fSSDSn};
2396 TGeoVolume* ssdconnector[kssdconnectorlayernumber];
2397 for(Int_t i=0; i<kssdconnectorlayernumber; i++){
2398 ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
bf210566 2399 ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2400 0.5*fgkSSDConnectorWidth,
78e34526 2401 0.5*ssdConnectorThickness[i],
2402 ssdconnectororigin);
2403 ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
bf210566 2404 ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
78e34526 2405 ssdConnectorMedium[i]);
2406 ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorNiSn);
bf210566 2407 }
78e34526 2408 const Int_t kssdconnectornumber = 4;
2409 TGeoTranslation* ssdconnectortrans[kssdconnectornumber];
bf210566 2410 ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2411 + fgkSSDConnectorPosition[0]
2412 - fgkSSDConnectorSeparation
2413 - 1.5*fgkSSDConnectorLength,
2414 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2415 - fgkSSDConnectorPosition[1]
2416 - ssdconnectorshape[0]->GetDY(),0.0);
2417 ssdconnectortrans[1] = new TGeoTranslation(
2418 - ssdstiffenershape->GetDX()
2419 + fgkSSDConnectorPosition[0]
2420 - 0.5*fgkSSDConnectorLength,
2421 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2422 - fgkSSDConnectorPosition[1]
2423 - ssdconnectorshape[0]->GetDY(),0.0);
2424 ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2425 - fgkSSDConnectorPosition[0]
2426 + fgkSSDConnectorSeparation
2427 + 1.5*fgkSSDConnectorLength,
2428 -(ssdstiffenershape->GetDY()
2429 - fgkSSDConnectorPosition[1]
2430 - ssdconnectorshape[0]->GetDY()),0.0);
2431 ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2432 - fgkSSDConnectorPosition[0]
2433 + 0.5*fgkSSDConnectorLength,
2434 -(ssdstiffenershape->GetDY()
2435 - fgkSSDConnectorPosition[1]
2436 - ssdconnectorshape[0]->GetDY()),0.0);
78e34526 2437 for(Int_t i=0; i<kssdconnectornumber; i++) {
2438 Int_t nlay = kssdconnectorlayernumber - 1;
2439 if (i == 1 || i == 2)
2440 nlay++;
2441 for(Int_t j=0; j<nlay; j++)
2442 ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2443 }
bf210566 2444////////////////////////////
2445// Capacitor 1812-330 nF
2446///////////////////////////
78e34526 2447// Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
44285dfa 2448 TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape",
d7599219 2449 0.5*fgkSSDCapacitor1812Length,
2450 0.5*fgkSSDCapacitor1812Width,
78e34526 2451 0.5*fgkSSDCapacitor1812Height);
2452 // ssdcapacitor1812origin);
44285dfa 2453 TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2454 fSSDStiffener1812CapacitorMedium);
2455 capacitor1812->SetLineColor(fColorAl);
bf210566 2456 TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2457 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
78e34526 2458 - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
bf210566 2459 ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
78e34526 2460
2461 TGeoBBox* capacitor1812capshape = new TGeoBBox("Capacitor1812CapShape",
2462 0.5*fgkSSDCapacitor1812CapLength, 0.5*fgkSSDCapacitor1812Width,
2463 0.5*fgkSSDCapacitor1812Height);
2464 TGeoVolume* capacitor1812cap = new TGeoVolume("Capacitor1812Cap",capacitor1812capshape,
2465 fSSDStiffenerCapacitorCapMedium);
2466 capacitor1812cap->SetLineColor(fColorNiSn);
2467 TGeoTranslation* capacitor1812captrans1 = new TGeoTranslation(
2468 - capacitor1812shape->GetDX() - capacitor1812capshape->GetDX(),
2469 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2470 - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
2471 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2472 ssdhybridcapacitormother->AddNode(capacitor1812cap,1,capacitor1812captrans1);
2473 TGeoTranslation* capacitor1812captrans2 = new TGeoTranslation(
2474 capacitor1812shape->GetDX() + capacitor1812capshape->GetDX(),
2475 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2476 - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
2477 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2478 ssdhybridcapacitormother->AddNode(capacitor1812cap,2,capacitor1812captrans2);
2479
d7599219 2480////////////////////////////
2481//Hybrid Wire
2482////////////////////////////
44285dfa 2483 Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
d7599219 2484 - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2485 - fgkSSDConnectorSeparation;
44285dfa 2486 Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
d7599219 2487 - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
60e55aee 2488 Double_t ssdwireradius = TMath::Sqrt(wirex*wirex+wirey*wirey);
2489
44285dfa 2490 Double_t wireangle = TMath::ATan(wirex/wirey);
2491 TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2492 fgkSSDWireRadius, 0.5*ssdwireradius);
2493 TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2494 fSSDStiffenerHybridWireMedium);
2495 hybridwire->SetLineColor(fColorPhynox);
2496 TGeoCombiTrans* hybridwirecombitrans[2];
2497 hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
d7599219 2498 0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2499 + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
44285dfa 2500 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
d7599219 2501 + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
bf210566 2502 ssdstiffenershape->GetDZ()
78e34526 2503 + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight+fgkSSDConnectorSnHeight,
d7599219 2504 new TGeoRotation("HybridWireRot1",0.,90.,0.));
44285dfa 2505 hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
bf210566 2506 0.0,
2507 - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2508 0.0,
2509 new TGeoRotation("HybridWireRot2",
2510 - wireangle*TMath::RadToDeg(),0.,0.));
44285dfa 2511 TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2512 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2513 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
bf210566 2514 ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2515 ssdhybridlist->Add(ssdhybridcapacitormother);
44285dfa 2516 /////////////////////////////////////////////////////////////
bf210566 2517 // Deallocating memory
44285dfa 2518 /////////////////////////////////////////////////////////////
bf210566 2519 delete hybridwirecombitrans[0];
2520 delete hybridwirecombitrans[1];
bf210566 2521 return ssdhybridlist;
2522 /////////////////////////////////////////////////////////////
2523}
2524///////////////////////////////////////////////////////////////////////////////
2525TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2526 /////////////////////////////////////////////////////////////
2527 // SSD Cooling Block System
2528 /////////////////////////////////////////////////////////////
2529 // SSD Cooling Block and Cooling Tube Transformations
2530 /////////////////////////////////////////////////////////////
2531 TGeoRotation* localcoolingblockrot = new TGeoRotation();
2532 localcoolingblockrot->SetAngles(0.,90.,0.);
535e8862 2533 TGeoCombiTrans localcoolingblockmatrix(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
bf210566 2534 TVector3* coolingblocktransvector;
78e34526 2535 coolingblocktransvector = new TVector3(fgkCoolingTubeSeparation,
bf210566 2536 fgkSSDSensorLength
2537 - 2.*fgkSSDModuleStiffenerPosition[1]
2538 - fgkSSDCoolingBlockWidth);
2539 const Int_t kcoolingblocktransnumber = 2;
2540 const Int_t kcoolingblocknumber = 4;
2541 TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
bf210566 2542 TGeoRotation* localcoolingtuberot = new TGeoRotation();
2543 localcoolingtuberot->SetAngles(0.0,90.0,0.0);
bf210566 2544 for(Int_t i=0; i<kcoolingblocktransnumber; i++){
535e8862 2545 for(Int_t j=0; j<kcoolingblocktransnumber; j++){
78e34526 2546 TGeoTranslation localcoolingblocktrans(i*coolingblocktransvector->X(),//+2*coolingtubedistance,
535e8862 2547 j*coolingblocktransvector->Y(),
2548 - 0.5*(fgkSSDCoolingBlockHoleCenter
2549 + fgkCoolingTubeRmax));
2550 coolingblockmatrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingblockmatrix);
535e8862 2551 }
d7599219 2552 }
ca86fdb4 2553 TGeoVolume* coolingsystemother = new TGeoVolumeAssembly("CoolingBlockSystem");
bf210566 2554 TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2555 /////////////////////////////////////////////////////////////
2556 // Adding Cooling block to mother volume
2557 /////////////////////////////////////////////////////////////
3cf6a656 2558 for(Int_t i=0; i<kcoolingblocknumber; i++){
2559 coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
d7599219 2560 }
bf210566 2561 /////////////////////////////////////////////////////////////
2562 // Deallocating memory
2563 /////////////////////////////////////////////////////////////
3cf6a656 2564 delete coolingblocktransvector;
2565 delete localcoolingblockrot;
2566
2567 return coolingsystemother;
d7599219 2568}
2569/////////////////////////////////////////////////////////////////////////////////
bf210566 2570TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
44285dfa 2571 /////////////////////////////////////////////////////////////
bf210566 2572 // SSD Flex
44285dfa 2573 /////////////////////////////////////////////////////////////
bf210566 2574 const Int_t kssdflexlayernumber = 2;
2575 TGeoXtru* ssdflexshape[kssdflexlayernumber];
2576 for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2577 const Int_t kmothervertexnumber = 17;
2578 Double_t xmothervertex[kmothervertexnumber];
2579 Double_t ymothervertex[kmothervertexnumber];
2580 /////////////////////////////////////////////
2581 // Auxiliary variables for vertex positioning
2582 /////////////////////////////////////////////
2583 const Int_t kssdflexboxnumber = 5;
44285dfa 2584 Double_t ssdflexboxlength[kssdflexboxnumber];
2585 ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
d7599219 2586 * fgkSSDChipLength+(fgkSSDChipNumber-1)
2587 * fgkSSDChipSeparationLength
2588 - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2589 - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
44285dfa 2590 ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2591 ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
d7599219 2592 - fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
44285dfa 2593 ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2594 ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2595 - ssdflexboxlength[1];
44285dfa 2596 Double_t ssdflexboxwidth[kssdflexboxnumber];
2597 ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2598 ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2599 ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2600 ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2601 ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
bf210566 2602 ///////////////////////
2603 // Setting the vertices
2604 ///////////////////////
2605 xmothervertex[0] = 0.0;
2606 xmothervertex[1] = xmothervertex[0];
2607 xmothervertex[2] = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2608 xmothervertex[3] = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2609 + ssdflexboxlength[4];
2610 xmothervertex[4] = xmothervertex[3];
2611 xmothervertex[5] = xmothervertex[4]-ssdflexboxlength[4];
2612 xmothervertex[6] = xmothervertex[5];
2613 xmothervertex[7] = xmothervertex[6]-fgkSSDFlexHoleLength;
2614 xmothervertex[8] = xmothervertex[7];
2615 xmothervertex[9] = xmothervertex[8]-ssdflexboxlength[2];
2616 xmothervertex[10] = xmothervertex[9];
2617 xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2618 xmothervertex[12] = xmothervertex[11];
2619 xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2620 xmothervertex[14] = xmothervertex[13];
2621 xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2622 xmothervertex[16] = xmothervertex[15];
2623 ymothervertex[0] = 0.0;
2624 ymothervertex[1] = fgkSSDFlexWidth[1];
2625 ymothervertex[2] = fgkSSDFlexWidth[0];
2626 ymothervertex[3] = ymothervertex[2];
2627 ymothervertex[4] = ymothervertex[0];
2628 ymothervertex[5] = ymothervertex[4];
2629 ymothervertex[6] = ssdflexboxwidth[2];
2630 ymothervertex[7] = ymothervertex[6];
2631 ymothervertex[8] = ymothervertex[0];
2632 ymothervertex[9] = ymothervertex[8];
2633 ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2634 ymothervertex[11] = ymothervertex[10];
2635 ymothervertex[12] = ymothervertex[0];
2636 ymothervertex[13] = ymothervertex[12];
2637 ymothervertex[14] = ymothervertex[7];
2638 ymothervertex[15] = ymothervertex[14];
2639 ymothervertex[16] = ymothervertex[0];
2640 /////////////////////////////////////////////////////////////
2641 // First Mother Volume containing SSDFlex
2642 /////////////////////////////////////////////////////////////
2643 TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2644 ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2645 ymothervertex);
2646 ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2647 ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
ca86fdb4 2648 TGeoVolumeAssembly* ssdflexmother = new TGeoVolumeAssembly("SSDFlexMother");
2649// TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2650// fSSDAir);
bf210566 2651 /////////////////////////////////////////////////////////////
2652 // SSDFlex Layer Shapes
2653 /////////////////////////////////////////////////////////////
2654 for(Int_t i=0; i<kssdflexlayernumber; i++){
2655 ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2656 ymothervertex);
2657 ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2658 ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2659 }
2660 /////////////////////////////////////
2661 // Setting Layers into Mother Volume
2662 /////////////////////////////////////
2663 Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2664 TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2665 fSSDKaptonFlexMedium};
2666 const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2667 "AlFlexLay2","KaptonFlexLay2"};
2668 TGeoVolume* ssdflex[2*kssdflexlayernumber];
2669 TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2670 for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2671 ssdflex[i] = new TGeoVolume(ssdflexname[i],
2672 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2673 i%2==0 ? ssdflexmed[0] : ssdflexmed[1]);
2674 ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2675 ssdflextrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2676 + fgkSSDFlexHeight[1]));
2677 ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2678 }
bf210566 2679 return ssdflexmother;
d7599219 2680}
2681/////////////////////////////////////////////////////////////////////////////////
bf210566 2682TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
44285dfa 2683 /////////////////////////////////////////////////////////////
2684 // Method generating SSD End Flex
d7599219 2685 /////////////////////////////////////////
bf210566 2686 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2687 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2688 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2689 * TMath::DegToRad()*ssdflexradiusmax
2690 - fgkSSDFlexLength[2]-TMath::Pi()
0fb26117 2691 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
2692 - 0.1*fgkSSDFlexFullLength;
bf210566 2693 const Int_t knedges = 20;
2694 const Int_t karcnumber = 2;
2695 TVector3* vertexposition[karcnumber*(knedges+1)];
2696 Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2697 Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2698 Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2699 Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2700 - 90.0*TMath::DegToRad()};
2701 TVector3* referencetrans[karcnumber];
2702 referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2703 + radius[0]*SinD(2.*fgkSSDFlexAngle),
2704 radius[0]);
2705 referencetrans[1] = new TVector3(referencetrans[0]->X()
2706 + fgkSSDFlexLength[2],
2707 - fgkSSDStiffenerHeight);
2708for(Int_t i=0; i<karcnumber; i++){
2709 for(Int_t j=0; j<knedges+1; j++){
2710 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2711 radius[i]*SinD(angle[i]));
2712 angle[i] += deltangle[i]*(1.0-2.0*i);
2713 }
2714 }
2715 ///////////////////////
2716 // Setting the vertices
2717 ///////////////////////
2718 const Int_t kendflexlayernumber = 4;
2719 const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2720 TVector3** vertex[kendflexlayernumber];
2721 for(Int_t i=0; i<kendflexlayernumber; i++)
2722 vertex[i] = new TVector3*[kendflexvertexnumber];
2723 TVector3* transvector[kendflexlayernumber+1];
2724 TVector3* deltatransvector = new TVector3();
2725 for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2726 transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2727 + radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2728 for(Int_t i=1; i<kendflexlayernumber+1; i++){
2729 deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2730 * CosD(fgkSSDFlexAngle),
2731 (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2732 * SinD(fgkSSDFlexAngle),0.0);
2733 *transvector[i] = *transvector[i-1]+*deltatransvector;
2734 }
2735 Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2736 ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2737 for(Int_t i=0; i<karcnumber; i++){
2738 for(Int_t j=1; j<kendflexlayernumber+1; j++){
2739 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2740 * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2741 /radius[i];
2742 }
2743 }
2744 for(Int_t i=0; i<kendflexlayernumber; i++){
2745 vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y());
2746 vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y());
2747 for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2748 if(j<(knedges+1)){
2749 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2750 vertexposition[j]->Y()*ratioradius[0][i+1]);
2751 vertex[i][j+2]->RotateZ(referenceangle[0]);
2752 *vertex[i][j+2] += *referencetrans[0];
2753 vertex[i][4*(knedges+1)-j+1] =
2754 new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2755 vertexposition[j]->Y()*ratioradius[0][i]);
2756 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2757 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2758 }
2759 else{
2760
2761 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2762 vertexposition[j]->Y()*ratioradius[1][i+1]);
2763 vertex[i][j+2]->RotateZ(referenceangle[1]);
2764 *vertex[i][j+2] += *referencetrans[1];
2765 vertex[i][4*(knedges+1)-j+1] =
2766 new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2767 vertexposition[j]->Y()*ratioradius[1][i]);
2768 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2769 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2770 }
2771 }
2772 }
44285dfa 2773 /////////////////////////////////////////////////////////////
bf210566 2774 // First Mother Volume containing SSDEndFlex
2775 /////////////////////////////////////////////////////////////
2776 TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2777 Double_t xmothervertex[kendflexvertexnumber];
2778 Double_t ymothervertex[kendflexvertexnumber];
2779 xmothervertex[0] = vertex[0][0]->X();
2780 ymothervertex[0] = vertex[0][0]->Y();
2781 for(Int_t i=1; i<kendflexvertexnumber; i++){
2782 if(i<2*(knedges+1)+2){
2783 xmothervertex[i] = vertex[3][i]->X();
2784 ymothervertex[i] = vertex[3][i]->Y();
2785 }
2786 else{
2787 xmothervertex[i] = vertex[0][i]->X();
2788 ymothervertex[i] = vertex[0][i]->Y();
2789 }
2790 }
2791 ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2792 xmothervertex,ymothervertex);
2793 ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2794 ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
0fb26117 2795// TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2796// ssdendflexmothershape,fSSDAir);
2797 TGeoVolumeAssembly* ssdendflexmother = new TGeoVolumeAssembly("SSDEndFlexMother");
bf210566 2798 //////////////////////////////////////
2799 // End Flex TGeoXtru Layer Definition
2800 //////////////////////////////////////
2801 TGeoXtru* ssdendflexshape[kendflexlayernumber];
2802 TGeoVolume* ssdendflex[kendflexlayernumber];
2803 for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2804 Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2805 Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2806 Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2807 TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2808 fSSDKaptonFlexMedium};
2809 const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2810 "AlEndFlexLay2","KaptonEndFlexLay2"};
2811 for(Int_t i=0; i<kendflexlayernumber; i++){
2812 for(Int_t j=0; j<4*(knedges+1)+2; j++){
2813 xvertex[i][j] = vertex[i][j]->X();
2814 yvertex[i][j] = vertex[i][j]->Y();
2815 }
2816 ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2817 ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2818 ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2819 ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2820 i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2821 ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2822 ssdendflexmother->AddNode(ssdendflex[i],1);
2823 }
44285dfa 2824 /////////////////////////////////////////////////////////////
bf210566 2825 // Deallocating memory
44285dfa 2826 /////////////////////////////////////////////////////////////
bf210566 2827 for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2828 for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2829 for(Int_t i=0; i<kendflexlayernumber; i++){
2830 for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2831 delete [] vertex[i];
2832 }
2833 for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2834 delete deltatransvector;
44285dfa 2835 /////////////////////////////////////////////////////////////
6727e2db 2836 //ssdendflexmother->CheckOverlaps(0.01);
bf210566 2837 return ssdendflexmother;
d7599219 2838}
9b0c60ab 2839///////////////////////////////////////////////////////////////////////////////
bf210566 2840TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
44285dfa 2841 /////////////////////////////////////////////////////////////
9b0c60ab 2842 // Method generating the Mounting Block
bf210566 2843 /////////////////////////////////////////////////////////////
9b0c60ab 2844 const Int_t kvertexnumber = 8;
2845 Double_t xvertex[kvertexnumber];
2846 Double_t yvertex[kvertexnumber];
2847 xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
2848 xvertex[1] = xvertex[0];
2849 xvertex[2] = -xvertex[0];
2850 xvertex[3] = xvertex[2];
2851 xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
2852 - fgkSSDMountingBlockLength[2]);
2853 xvertex[5] = xvertex[4];
2854 xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
2855 - 0.5*fgkSSDMountingBlockScrewHoleEdge
2856 - fgkSSDMountingBlockScrewHoleRadius[0];
2857 xvertex[7] = xvertex[6];
2858 yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
0fb26117 2859 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
9b0c60ab 2860 yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
2861 yvertex[2] = yvertex[1];
2862 yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
2863 yvertex[4] = yvertex[3];
2864 yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
2865 - fgkSSDMountingBlockHeight[0];
2866 yvertex[6] = yvertex[5];
2867 yvertex[7] = yvertex[0];
160835d5 2868
9b0c60ab 2869 ///////////////////////////////////////////////////////////////////////
2870 // TGeoXTru Volume definition for Mounting Block Part
2871 ///////////////////////////////////////////////////////////////////////
2872 TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
2873 ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
2874 ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
2875 ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
bf210566 2876 TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
9b0c60ab 2877 ssdmountingblockshape,
2878 fSSDMountingBlockMedium);
2879 ssdmountingblock->SetLineColor(fColorG10);
2880 TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
2881 mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
2882 TGeoRotation* mountingblockrot = new TGeoRotation();
2883 mountingblockrot->SetAngles(90.,180.,-90.);
2884 mountingblockcombitrans->SetRotation(*mountingblockrot);
2885 /////////////////////////////////////////////////////////////
2886 // Generating the Mounting Block Screw Vertices
2887 /////////////////////////////////////////////////////////////
2888 const Int_t kscrewvertexnumber = 15;
2889 Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
2890 - fgkSSDMountingBlockScrewHoleEdge)
2891 / fgkSSDMountingBlockScrewHoleRadius[0])
2892 * TMath::RadToDeg();
2893 Double_t phi0 = 90.+alpha;
2894 Double_t phi = 270.-2*alpha;
2895 Double_t deltaphi = phi/kscrewvertexnumber;
2896 TVector3* screwvertex[kscrewvertexnumber+1];
2897 for(Int_t i=0; i<kscrewvertexnumber+1; i++)
2898 screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
2899 *CosD(phi0+i*deltaphi),
2900 fgkSSDMountingBlockScrewHoleRadius[0]
2901 *SinD(phi0+i*deltaphi));
2902 Double_t xscrewvertex[kscrewvertexnumber+6];
2903 Double_t yscrewvertex[kscrewvertexnumber+6];
2904 xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
2905 yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
2906 - fgkSSDMountingBlockScrewHoleEdge);
2907 xscrewvertex[1] = xscrewvertex[0];
2908 yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2909 xscrewvertex[2] = screwvertex[0]->X();
2910 yscrewvertex[2] = yscrewvertex[1];
2911 for(Int_t i=0; i<kscrewvertexnumber+1; i++){
2912 xscrewvertex[i+3] = screwvertex[i]->X();
2913 yscrewvertex[i+3] = screwvertex[i]->Y();
2914 }
2915 xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2916 yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
2917 xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
2918 yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
2919 TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
2920 ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
2921 ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
2922 ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
2923 + fgkSSDMountingBlockHeight[2]);
2924 TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
2925 ssdmountingblockscrewshape,
2926 fSSDMountingBlockMedium);
2927 ssdmountingblockscrew->SetLineColor(fColorG10);
2928 TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
2929 for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
2930 ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2931 - yscrewvertex[1],
2932 0.5*fgkSSDMountingBlockHeight[0]
2933 - fgkSSDMountingBlockHeight[2]
2934 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2935 + fgkSSDMountingBlockHeight[2]
2936 - yvertex[0]));
2937 ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
2938 -0.5*fgkSSDMountingBlockScrewHoleEdge,
2939 yscrewvertex[1]
2940 -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2941 +fgkSSDMountingBlockHeight[2]
2942 -yvertex[0]));
2943 ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2944 yscrewvertex[1],
2945 - 0.5*fgkSSDMountingBlockHeight[0]
2946 + fgkSSDMountingBlockHeight[2]
2947 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2948 + fgkSSDMountingBlockHeight[2]
2949 - yvertex[0]));
2950 ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
2951 yscrewvertex[1],
2952 - yscrewvertex[1]
2953 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2954 + fgkSSDMountingBlockHeight[2]
2955 - yvertex[0]));
2956 TGeoRotation* ssdmountingblockscrewrot[4];
2957 for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
2958 ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
2959 ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
2960 ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
2961 for(Int_t i=1; i<4; i++)
2962 ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
2963 TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
2964 ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
2965 TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
2966 ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
2967 + xvertex[0],yscrewvertex[1]
2968 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2969 + fgkSSDMountingBlockHeight[2]
2970 - yvertex[0]),0.);
2971 TGeoHMatrix* ssdmountingblockscrewmatrix[4];
2972 for(Int_t i=0; i<4; i++){
2973 ssdmountingblockscrewmatrix[i] =
2974 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
2975 ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
2976 }
2977 ///////////////////////////////////////////////////////////////////////
2978 // TGeoXtru for Mother Volume
2979 ///////////////////////////////////////////////////////////////////////
2980 const Int_t kvertexmothernumber = 12;
2981 Double_t xmothervertex[kvertexmothernumber];
2982 Double_t ymothervertex[kvertexmothernumber];
2983 for(Int_t i=0; i<6; i++){
2984 xmothervertex[i] = xvertex[i];
2985 ymothervertex[i] = yvertex[i];
2986 }
2987 xmothervertex[6] = xvertex[5]+fgkSSDMountingBlockLength[2];
2988 ymothervertex[6] = ymothervertex[5];
2989 xmothervertex[7] = xmothervertex[6];
5d9d4033 2990 ymothervertex[7] = ymothervertex[4] - fgkSSDTolerance;
9b0c60ab 2991 xmothervertex[8] = xmothervertex[7]
2992 + 0.5*(fgkSSDMountingBlockLength[1]
2993 - fgkSSDMountingBlockLength[2]);
5d9d4033 2994 ymothervertex[8] = ymothervertex[7];
9b0c60ab 2995 xmothervertex[9] = xmothervertex[8];
2996 ymothervertex[9] = ymothervertex[2];
2997 xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
2998 ymothervertex[10] = ymothervertex[1];
2999 xmothervertex[11] = xmothervertex[10];
3000 ymothervertex[11] = ymothervertex[0];
3001 TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3002 ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3003 ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3004 ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3005 TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3006 ssdmountingblockmothershape,
3007 fSSDAir);
3008 /////////////////////////////////////////////////////////////
3009 // Placing the Volumes into Mother Volume
3010 /////////////////////////////////////////////////////////////
3011 ssdmountingblockmother->AddNode(ssdmountingblock,1);
3012 ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3013 for(Int_t i=0; i<4; i++)
3014 ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3015 ssdmountingblockscrewmatrix[i]);
3016 /////////////////////////////////////////////////////////////
3017 // Deallocating memory
3018 /////////////////////////////////////////////////////////////
3019 delete mountingblockrot;
3020 for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3021 delete ssdmountingblockglobalrot;
3022 delete ssdmountingblockglobaltrans;
3023 /////////////////////////////////////////////////////////////
3024 return ssdmountingblockmother;
3025}
3026///////////////////////////////////////////////////////////////////////////////
3027 TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3028 /////////////////////////////////////////////////////////////
3029 // Method generating the Mounting Block Clip
3030 /////////////////////////////////////////////////////////////
3031 const Int_t kmothervertexnumber = 10;
3032 Double_t xmothervertex[kmothervertexnumber];
3033 Double_t ymothervertex[kmothervertexnumber];
3034 xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3035 - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3036 xmothervertex[1] = xmothervertex[0];
3037 xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3038 - fgkMountingBlockClibScrewRadius);
3039 xmothervertex[3] = xmothervertex[2];
3040 xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3041 xmothervertex[5] = xmothervertex[4];
3042 xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3043 xmothervertex[7] = xmothervertex[6];
3044 xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3045 xmothervertex[9] = xmothervertex[8];
3046 ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
0fb26117 3047 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
9b0c60ab 3048 ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3049 ymothervertex[2] = ymothervertex[1];
3050 ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3051 - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3052 - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3053 ymothervertex[4] = ymothervertex[3];
3054 ymothervertex[5] = ymothervertex[2];
3055 ymothervertex[6] = ymothervertex[5];
3056 ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3057 ymothervertex[8] = ymothervertex[7];
3058 ymothervertex[9] = ymothervertex[0];
160835d5 3059
9b0c60ab 3060 ///////////////////////////////////////////////////////////////////////
3061 // TGeoXTru Volume definition for Mounting Block Clip Part
3062 ///////////////////////////////////////////////////////////////////////
3063 TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3064 ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3065 ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3066 ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3067 TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3068 ssdmountingblockclipshape,fSSDAir);
3069 ssdmountingblockclip->SetLineColor(4);
3070 ///////////////////////////////////////////////////////////////////////
3071 // TGeoXTru Volume definition for Clip
3072 ///////////////////////////////////////////////////////////////////////
3073 const Int_t kclipvertexnumber = 6;
3074 Double_t xclipvertex[kclipvertexnumber];
3075 Double_t yclipvertex[kclipvertexnumber];
3076 xclipvertex[0] = xmothervertex[0];
3077 xclipvertex[1] = xclipvertex[0];
3078 xclipvertex[2] = xmothervertex[6];
3079 xclipvertex[3] = xclipvertex[2];
3080 xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3081 xclipvertex[5] = xclipvertex[4];
3082 yclipvertex[0] = ymothervertex[0];
3083 yclipvertex[1] = ymothervertex[1];
3084 yclipvertex[2] = yclipvertex[1];
3085 yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3086 yclipvertex[4] = yclipvertex[3];
3087 yclipvertex[5] = yclipvertex[0];
3088 TGeoXtru* clipshape = new TGeoXtru(2);
3089 clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3090 clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3091 clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3092 + fgkMountingBlockClibWidth);
3093 TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3094 clip->SetLineColor(18);
3095 ///////////////////////////////////////////////////////////////////////
3096 // Ladder Support Piece
3097 ///////////////////////////////////////////////////////////////////////
3098 const Int_t ksupportvertexnumber = 4;
3099 Double_t xsupportvertex[ksupportvertexnumber];
3100 Double_t ysupportvertex[ksupportvertexnumber];
3101 xsupportvertex[0] = xclipvertex[5];
3102 xsupportvertex[1] = xsupportvertex[0];
3103 xsupportvertex[2] = xmothervertex[9];
3104 xsupportvertex[3] = xsupportvertex[2];
3105 ysupportvertex[0] = yclipvertex[0];
3106 ysupportvertex[1] = yclipvertex[3];
3107 ysupportvertex[2] = ysupportvertex[1];
3108 ysupportvertex[3] = ysupportvertex[0];
3109 TGeoXtru* supportshape = new TGeoXtru(2);
3110 supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3111 supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3112 supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3113 TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3114 support->SetLineColor(9);
3115 ///////////////////////////////////////////////////////////////////////
3116 // TGeoXTru Volume definition for Screw
3117 ///////////////////////////////////////////////////////////////////////
3118 Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3119 0.5*fgkMountingBlockClibScrewRadius};
3120 Int_t edgesnumber[2] = {50,6};
3121 Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3122 +0.5*(ymothervertex[3]-ymothervertex[2])};
851c0ce3 3123 TGeoShape* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
9b0c60ab 3124 TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3125 clipscrew->SetLineColor(12);
3126 TGeoRotation* screwrot = new TGeoRotation();
3127 screwrot->SetAngles(0.,90.,0.);
3128 TGeoTranslation* screwtrans = new TGeoTranslation();
3129 screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3130 0.5*(ymothervertex[3]+ymothervertex[2]),
3131 0.5*fgkSSDMountingBlockWidth+
3132 -0.5*fgkMountingBlockSupportWidth[0]);
3133 TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3134 ///////////////////////////////////////////////////////////////////////
3135 // Placing the Volumes
3136 ///////////////////////////////////////////////////////////////////////
3137 ssdmountingblockclip->AddNode(clip,1);
3138 ssdmountingblockclip->AddNode(support,1);
3139 ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3140 /////////////////////////////////////////////////////////////
3141 // Deallocating memory
3142 /////////////////////////////////////////////////////////////
3143 delete screwtrans;
3144 delete screwrot;
3145 /////////////////////////////////////////////////////////////
3146 return ssdmountingblockclip;
d7599219 3147}
bf210566 3148///////////////////////////////////////////////////////////////////////////////
cd2243fb 3149void AliITSv11GeometrySSD::CreateCoolingTubes() {
44285dfa 3150 /////////////////////////////////////////////////////////////
bf210566 3151 // Method generating the Cooling Tube
cd2243fb 3152 // sets fcoolingtube and returns list for endladdercoolingtube
44285dfa 3153 /////////////////////////////////////////////////////////////
cd2243fb 3154 TGeoTube *coolingtubeshape[2];
3155 // Ladder Cooling Tubes
3156
3157 // MvL: Simplified cooling tubes
3158 coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,0.5*fgkCoolingTubeLength);
3159 coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,coolingtubeshape[0]->GetDz());
3160
3161 // End Ladder Cooling Tubes
3162 TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3163 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3164 endladdercoolingtubeshape[i] = new TGeoTube*[2];
3165
3166 Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
3167 endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3168 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0] - sensZshift));
3169 endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3170 endladdercoolingtubeshape[0][0]->GetDz());
3171 endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3172 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1] + sensZshift));
3173 endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3174 endladdercoolingtubeshape[1][0]->GetDz()-0.5*fgkSSDTolerance);
3175 // Ladder Cooling Tubes
3176 TGeoVolume* coolingtube[2];
3177 coolingtube[0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0], fSSDCoolingTubePhynox);
3178 coolingtube[1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[1], fSSDCoolingTubeWater);
3179 coolingtube[0]->SetLineColor(fColorPhynox);
3180 coolingtube[1]->SetLineColor(fColorWater);
3181
3182 // End Ladder Cooling Tubes
3183 TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3184 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3185 endladdercoolingtube[i] = new TGeoVolume*[2];
3186 endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3187 endladdercoolingtubeshape[0][0],
3188 fSSDCoolingTubePhynox);
3189 endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3190 endladdercoolingtubeshape[0][1],
3191 fSSDCoolingTubeWater);
3192 endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3193 endladdercoolingtubeshape[1][0],
3194 fSSDCoolingTubePhynox);
3195 endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3196 endladdercoolingtubeshape[1][1],
3197 fSSDCoolingTubeWater);
3198 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3199 endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3200 endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3201 }
0fb26117 3202
bf210566 3203 /////////////////////////////////////////////////////////////
3204 // Virtual Volume containing Cooling Tubes
3205 /////////////////////////////////////////////////////////////
9b0c60ab 3206 // Ladder Cooling Tubes
cd2243fb 3207 TGeoTube* virtualcoolingtubeshape = new TGeoTube(coolingtubeshape[1]->GetRmin(),
3208 coolingtubeshape[0]->GetRmax(),
3209 coolingtubeshape[0]->GetDz());
3210 fcoolingtube = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape, fSSDAir);
3211 fcoolingtube->AddNode(coolingtube[0],1);
3212 fcoolingtube->AddNode(coolingtube[1],1);
3213
9b0c60ab 3214 // End Ladder Cooling Tubes
3215 TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3216 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
cd2243fb 3217 endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3218 endladdercoolingtubeshape[i][0]->GetRmax(),
3219 endladdercoolingtubeshape[i][0]->GetDz());
3220 fendladdercoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3221 endladdervirtualcoolingtubeshape[0],
3222 fSSDAir);
3223 fendladdercoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3224 endladdervirtualcoolingtubeshape[1],
3225 fSSDAir);
3226 fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3227 fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3228 fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3229 fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
d7599219 3230}
bf210566 3231///////////////////////////////////////////////////////////////////////////////
3232TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
44285dfa 3233 /////////////////////////////////////////////////////////////
bf210566 3234 // Method generating SSD Cooling Block
44285dfa 3235 /////////////////////////////////////////////////////////////
bf210566 3236 const Int_t kvertexnumber = 8;
3237 ///////////////////////////////////////
3238 // Vertex Positioning for TGeoXTru
3239 ///////////////////////////////////////
3240 TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3241 vertexposition[0] = new TVector3(0.0,0.0);
3242 vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1]);
3243 vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3244 vertexposition[1]->Y());
3245 vertexposition[3] = new TVector3(vertexposition[2]->X(),
3246 vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2]);
3247 vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y());
3248 vertexposition[5] = new TVector3(vertexposition[4]->X(),
3249 + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1]);
3250 vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3251 vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3252 - fgkSSDCoolingBlockHoleLength[0]
3253 - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3254 fgkSSDCoolingBlockHeight[0]
3255 - fgkSSDCoolingBlockHoleRadius[1],
3256 fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0]);
3257 vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3258 - fgkSSDCoolingBlockHoleLength[0]),
3259 vertexposition[6]->Y());
3260 Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3261 / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3262 Double_t phi = 180.-alpha;
3263 Double_t psi = 180.+2.*alpha;
3264 Double_t deltapsi = psi/nedges;
3265 Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3266 TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3267 fgkSSDCoolingBlockHoleCenter);
3268 for(Int_t i=0; i<nedges+1; i++){
3269 vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3270 radius*SinD(phi+i*deltapsi));
3271 *vertexposition[kvertexnumber+i] += (*transvector);
3272 }
3273 Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3274 for(Int_t i=0; i<kvertexnumber; i++)
3275 vertexposition[kvertexnumber+nedges+1+i] =
3276 GetReflection(vertexposition[kvertexnumber-1-i],param);
3277 ///////////////////////////////////////////////////////////////////////
3278 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3279 ///////////////////////////////////////////////////////////////////////
3280 TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3281 Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3282 Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3283 for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3284 xvertexpoints[i] = vertexposition[i]->X();
3285 yvertexpoints[i] = vertexposition[i]->Y();
3286 }
3287 ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3288 yvertexpoints);
3289 ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3290 ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3291 TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3292 ssdcoolingblockshape,
3293 fSSDAlCoolBlockMedium);
3294 ssdcoolingblock->SetLineColor(fColorAl);
3295 /////////////////////////////////////////////////////////////
3296 // Deallocating memory
3297 /////////////////////////////////////////////////////////////
3298 delete [] vertexposition;
7b208ef4 3299 delete [] xvertexpoints;
3300 delete [] yvertexpoints;
bf210566 3301 /////////////////////////////////////////////////////////////
3302 return ssdcoolingblock;
3303}
3304/////////////////////////////////////////////////////////////////////////////////
3cf6a656 3305void AliITSv11GeometrySSD::GetSSDChipCables(TGeoVolume *&cableL, TGeoVolume *&cableR, Double_t SSDChipCablesHeight, Int_t nedges){
d7599219 3306 ///////////////////////////////////////////////////////
cd2243fb 3307 static const Int_t kssdchipcablesnumber = 2; // Number of cables: left and right
3308 static const Int_t kssdchipcableslaynumber = 2; // Number of layers: Al and Kapton
3309 static const Int_t kvertexnumber = 4*(nedges+1)+4;
bf210566 3310 Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3311 Double_t ssdchipcablesradius[kssdchipcableslaynumber];
cd2243fb 3312 ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeight
bf210566 3313 - fgkSSDChipCablesHeight[0]
3314 - fgkSSDChipCablesHeight[1]);
3315 ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3316 Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3317 ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3318 - 2.*TMath::Pi()*ssdchipcablesradius[0]
3319 - ssdchipcablesradius[0]
3320 - fgkSSDChipCablesWidth[1]
3321 - fgkSSDChipCablesWidth[2]);
3322 ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3323 - 0.5*(fgkSSDModuleStiffenerPosition[1]
3324 + fgkSSDChipCablesHeight[1]
3325 + fgkSSDSensorHeight);
d7599219 3326 ///////////////////////////////////////////////////////
bf210566 3327 // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3328 ///////////////////////////////////////////////////////
3329 TVector3** vertexposition[kssdchipcableslaynumber];
3330 for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3331 new TVector3*[4*(nedges+1)+4];
3332 Double_t ratio[4];
3333 ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3334 ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3335 / ssdchipcablesradius[0];
3336 ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3337 / ssdchipcablesradius[0];
3338 ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3339 + fgkSSDChipCablesHeight[1])
3340 / ssdchipcablesradius[0];
3341 Double_t phi = 180.;
3342 Double_t deltaphi = 180./nedges;
3343 Double_t angle = 0.0;
045be90c 3344
3345 Double_t xvertexpoints[kssdchipcableslaynumber][kvertexnumber];
3346 Double_t yvertexpoints[kssdchipcableslaynumber][kvertexnumber];
3347
bf210566 3348 TVector3* vertex = new TVector3();
3349 TVector3* transvector[kssdchipcableslaynumber];
3350 transvector[0] = new TVector3(fgkSSDChipWidth,
cd2243fb 3351 SSDChipCablesHeight-ssdchipcablesradius[0]);
bf210566 3352 transvector[1] = new TVector3();
cd2243fb 3353 TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcablesnumber];
3354 TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcablesnumber];
3355 const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcablesnumber] =
bf210566 3356 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3357 "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3358 for(Int_t k=0; k<kssdchipcablesnumber; k++){
3359 transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3360 transvector[1]->SetY(ssdchipcablesradius[0]
3361 + fgkSSDChipCablesHeight[0]
3362 + fgkSSDChipCablesHeight[1]);
3363 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
cd2243fb 3364 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeight
bf210566 3365 - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
cd2243fb 3366 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeight
bf210566 3367 - i*fgkSSDChipCablesHeight[0]);
3368 vertexposition[i][2*(nedges+1)+2] =
3369 new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3370 + fgkSSDChipCablesWidth[1]
3371 + fgkSSDChipCablesWidth[2],
3372 ((1.-i)*fgkSSDChipCablesHeight[i]
3373 + fgkSSDChipCablesHeight[1]));
3374 vertexposition[i][2*(nedges+1)+3] =
3375 new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3376 vertexposition[i][2*(nedges+1)+2]->Y()
3377 - fgkSSDChipCablesHeight[i]);
3378 for(Int_t j=0; j<nedges+1; j++){
3379 angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3380 vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3381 vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3382 vertexposition[0][(nedges+1)*i+j+2] =
3383 new TVector3(*vertex+*transvector[i]);
3384 vertexposition[1][(nedges+1)*i+j+2] =
3385 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3386 vertex->Y()*ratio[2*i]+transvector[i]->Y());
3387 vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3388 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3389 vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3390 new TVector3(vertex->X()*ratio[2*i+1]
3391 + transvector[i]->X(),
3392 vertex->Y()*ratio[2*i+1]
3393 + transvector[i]->Y());
3394 }
3395 }
3396 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3397 for(Int_t j=0; j<kvertexnumber; j++){
3398 xvertexpoints[i][j] = vertexposition[i][j]->X();
3399 yvertexpoints[i][j] = vertexposition[i][j]->Y();
3400 }
3401 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3402 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3403 xvertexpoints[i],yvertexpoints[i]);
3404 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3405 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3406 ssdchipcable[kssdchipcablesnumber*k+i] =
3407 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3408 ssdchipcableshape[kssdchipcablesnumber*k+i],
3409 (kssdchipcablesnumber*k+i)%2==0?
3410 fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3411 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3412 }
3413 for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3414 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3415 }
44285dfa 3416 /////////////////////////////////////////////////////////////
bf210566 3417 // Mother Volume definition
3418 /////////////////////////////////////////////////////////////
cd2243fb 3419 static const Int_t kmothervertexnumber = 8;
3420 Double_t xmothervertex[kmothervertexnumber];
3421 Double_t ymothervertex[kmothervertexnumber];
3422 xmothervertex[0] = xvertexpoints[0][1];
3423 ymothervertex[0] = yvertexpoints[0][1];
3424 xmothervertex[1] = xvertexpoints[0][2+nedges/2];
3425 ymothervertex[1] = yvertexpoints[0][1];
3426 xmothervertex[2] = xvertexpoints[0][2+nedges/2];
3427 ymothervertex[2] = yvertexpoints[0][2+nedges];
3428 xmothervertex[3] = xvertexpoints[0][3+nedges];
3429 ymothervertex[3] = yvertexpoints[0][3+nedges];
3430 xmothervertex[4] = xvertexpoints[0][3+2*nedges];
5d9d4033 3431 ymothervertex[4] = yvertexpoints[0][3+2*nedges]+fgkSSDTolerance;
cd2243fb 3432 xmothervertex[5] = xvertexpoints[0][4+2*nedges];
5d9d4033 3433 ymothervertex[5] = yvertexpoints[0][4+2*nedges]+fgkSSDTolerance;
cd2243fb 3434 xmothervertex[6] = xvertexpoints[1][5+2*nedges];
3435 ymothervertex[6] = yvertexpoints[1][5+2*nedges];
3436 xmothervertex[7] = xvertexpoints[0][1];
3437 ymothervertex[7] = yvertexpoints[1][5+2*nedges];
3438 TGeoXtru *ssdchipcablemothershape = new TGeoXtru(2);
3439 ssdchipcablemothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3440 ssdchipcablemothershape->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3441 ssdchipcablemothershape->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3442
3cf6a656 3443 cableL = new TGeoVolume("SSDChipCableMotherLeft",ssdchipcablemothershape,fSSDAir);
3444 cableR = new TGeoVolume("SSDChipCableMotherRight",ssdchipcablemothershape,fSSDAir);
cd2243fb 3445
3cf6a656 3446 cableL->AddNode(ssdchipcable[0],1);
3447 cableL->AddNode(ssdchipcable[1],1);
3448 cableR->AddNode(ssdchipcable[2],1);
3449 cableR->AddNode(ssdchipcable[3],1);
cd2243fb 3450
bf210566 3451 /////////////////////////////////////////////////////////////
3452 // Deallocating memory
3453 /////////////////////////////////////////////////////////////
bf210566 3454 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3455 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3456 delete vertex;
bf210566 3457 /////////////////////////////////////////////////////////////
d7599219 3458}
5bf92139 3459//_____________________________________________________________________________
3cf6a656 3460TGeoVolume* AliITSv11GeometrySSD::GetSSDChip() const{
44285dfa 3461 /////////////////////////////////////////////////////////////
bf210566 3462 // SSD Chip Assembly Generation
3463 /////////////////////////////////////////////////////////////
bf210566 3464 TGeoBBox* ssdchipcompshape[2];
3465 ssdchipcompshape[0] = new TGeoBBox("SSDChipCompShape",
3466 0.5*fgkSSDChipLength,
3467 0.5*fgkSSDChipWidth,
3468 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3469 ssdchipcompshape[1] = new TGeoBBox("SSDChipGlueCompShape",
3470 0.5*fgkSSDChipLength,
3471 0.5*fgkSSDChipWidth,
3472 0.5*fgkSSDChipGlueHeight);
3473 TGeoVolume* ssdchipcomp[2];
3474 ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3475 ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3476 fSSDChipGlueMedium);
3477 ssdchipcomp[0]->SetLineColor(fColorSilicon);
3478 ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3479 TGeoTranslation* ssdchipcomptrans[2];
3480 ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3481 ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3482 /////////////////////////////////////////////////////////////
3483 // Virtual Volume containing SSDChip
3484 /////////////////////////////////////////////////////////////
3485 TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3486 0.5*fgkSSDChipWidth,
3487 0.5*fgkSSDChipHeight);
e21cdd03 3488 TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
bf210566 3489 /////////////////////////////////////////////////////////////
3490 for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3cf6a656 3491 return ssdchip;
d7599219 3492}
bf210566 3493/////////////////////////////////////////////////////////////////////////////////
3494TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
44285dfa 3495 /////////////////////////////////////////////////////////////
bf210566 3496 // Method returning a List containing pointers to Ladder Cable Volumes
cd2243fb 3497 //
3498 // Return list contains 3 assemblies: cable box, cable arb shape and the end part of the cable
3499 // each contains 2 volumes, one for polyamide and one for aluminium
44285dfa 3500 /////////////////////////////////////////////////////////////
bf210566 3501 const Int_t kladdercablesegmentnumber = 2;
3502 /////////////////////////////////////////
3503 // LadderSegmentBBox Volume
3504 /////////////////////////////////////////
160835d5 3505 static TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber] = {0,0};
bf210566 3506 const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3507 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
160835d5 3508
3509
3510 const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3511 {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3512 static TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3513
3514 static TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber] = {
3515 new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3516 0.5*fgkSSDFlexWidth[0],
3517 0.5*fgkSSDLadderCableWidth,
78e34526 3518 0.5*fgkSSDLadderCableHeight[0]),
160835d5 3519 new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3520 0.5*fgkSSDFlexWidth[0],
3521 0.5*fgkSSDLadderCableWidth,
78e34526 3522 fgkSSDLadderCableHeight[0]
3523 +0.5*fgkSSDLadderCableHeight[1])
160835d5 3524 };
3525 static TGeoVolume* laddercablesegmentbboxassembly = new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly") ;
3526 static TGeoVolume* laddercablesegmentarbassembly =
3527 new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3528
3529 static TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3530 static TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3531
3532 if (laddercablesegmentbboxshape[0] == 0) {
3533 // Initialise static shapes and volumes
bf210566 3534 for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3535 new TGeoBBox(laddercablesegmentbboxshapename[i],
3536 0.5*fgkSSDFlexWidth[0],
3537 0.5*fgkSSDLadderCableWidth,
78e34526 3538 0.5*fgkSSDLadderCableHeight[i]);
160835d5 3539
bf210566 3540 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3541 laddercablesegmentbbox[i] =
3542 new TGeoVolume(laddercablesegmentbboxname[i],
3543 laddercablesegmentbboxshape[i],
3544 (i==0?fSSDAlTraceLadderCableMedium:
3545 fSSDKaptonLadderCableMedium));
3546 laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3547 fColorPolyhamide);
3548 }
160835d5 3549
bf210566 3550 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3551 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3552 laddercablesegmentbboxtrans[i]);
3553/////////////////////////////////////////
3554// LadderSegmentArb8 Volume
3555/////////////////////////////////////////
3556 const Int_t kvertexnumber = 4;
3557 TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3558 for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3559 new TVector3*[kvertexnumber];
3560//Shape Vertex Positioning
3561 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3562 laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
3563 laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3564 i*fgkSSDFlexHeight[0]);
3565 laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3566 + fgkSSDFlexHeight[1]
3567 + i*fgkSSDFlexHeight[0]);
3568 laddercablesegmentvertexposition[i][3] =
3569 new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3570 laddercablesegmentvertexposition[i][2]->Y());
3571 }
3572 Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3573 {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
a6e0ebfe 3574 const char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
bf210566 3575 {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
160835d5 3576
bf210566 3577 for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3578 GetArbShape(laddercablesegmentvertexposition[i],
3579 laddercablesegmentwidth[i],
3580 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3581 laddercablesegmentarbshapename[i]);
3582 const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3583 {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
160835d5 3584
bf210566 3585 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3586 laddercablesegmentarb[i] =
3587 new TGeoVolume(laddercablesegmentarbname[i],
3588 laddercablesegmentarbshape[i],
3589 (i==0?fSSDAlTraceLadderCableMedium:
3590 fSSDKaptonLadderCableMedium));
3591 laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3592 fColorPolyhamide);
d7599219 3593}
bf210566 3594 TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3595 laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3596 90.,90,-90.);
3597 laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3598 0.,90.,0.);
3599 TGeoCombiTrans* laddercablesegmentarbcombitrans =
3600 new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3601 0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3602 + fgkSSDFlexWidth[0],0.,0.,
3603 new TGeoRotation((*laddercablesegmentarbrot[1])
3604 *(*laddercablesegmentarbrot[0])));
bf210566 3605 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3606 laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3607 laddercablesegmentarbcombitrans);
160835d5 3608 } // End of static initialisations
bf210566 3609/////////////////////////////////////////
3610// End Ladder Cable Volume
160835d5 3611// Note: this part depends explicitly on the length passed as an argument to the function
bf210566 3612/////////////////////////////////////////
3613 TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3614 const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3615 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3616 for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3617 new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3618 0.5*ssdendladdercablelength,
3619 0.5*fgkSSDLadderCableWidth,
78e34526 3620 0.5*fgkSSDLadderCableHeight[i]);
bf210566 3621 const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3622 {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
3623 TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
3624 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3625 ladderendcablesegmentbbox[i] =
3626 new TGeoVolume(ladderendcablesegmentbboxname[i],
3627 ladderendcablesegmentbboxshape[i],
3628 (i==0?fSSDAlTraceLadderCableMedium:
3629 fSSDKaptonLadderCableMedium));
3630 ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3631 fColorPolyhamide);
3632 }
3633 TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
3634 ladderendcablesegmentbboxtrans[0] =
3635 new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
3636 0.5*ssdendladdercablelength,
3637 0.5*fgkSSDLadderCableWidth,
78e34526 3638 0.5*fgkSSDLadderCableHeight[0]);
bf210566 3639 ladderendcablesegmentbboxtrans[1] =
3640 new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
3641 0.5*ssdendladdercablelength,
3642 0.5*fgkSSDLadderCableWidth,
78e34526 3643 fgkSSDLadderCableHeight[0]
3644 +0.5*fgkSSDLadderCableHeight[1]);
bf210566 3645 TGeoVolume* ladderendcablesegmentbboxassembly =
3646 new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
3647 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3648 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
3649 ladderendcablesegmentbboxtrans[i]);
3650/////////////////////////////////////////
3651 TList* laddercablesegmentlist = new TList();
3652 laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
3653 laddercablesegmentlist->Add(laddercablesegmentarbassembly);
3654 laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
3655 return laddercablesegmentlist;
160835d5 3656}
3657
bf210566 3658/////////////////////////////////////////////////////////////////////////////////
3659TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
44285dfa 3660 /////////////////////////////////////////////////////////////
cd2243fb 3661 // Method generating Ladder Cable of given length (n modules + end)
3662 // Called by GetLadderCableAssembly
44285dfa 3663 /////////////////////////////////////////////////////////////
bf210566 3664 TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
3665 TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
3666 for(Int_t i=0; i<n; i++){
3667 TGeoTranslation* laddercabletrans = new TGeoTranslation(
3668 i*(fgkCarbonFiberJunctionWidth),
3669 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
78e34526 3670 i*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
bf210566 3671 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
cd2243fb 3672 if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
3673
d7599219 3674 }
bf210566 3675 TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
3676 (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
cd2243fb 3677 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
78e34526 3678 (n-1)*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
bf210566 3679 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
3680 return laddercable;
3681}
3682/////////////////////////////////////////////////////////////////////////////////
3683TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
cd2243fb 3684 ///////////////////////////////////////////////////////////////////
3685 // Main method generating Ladder Cable bundles containing n cables
3686 ///////////////////////////////////////////////////////////////////
3687 Double_t totalLength = ssdendladdercablelength+(n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0];
78e34526 3688 Double_t cableOrig[3] = {0.5*totalLength,1.5*fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1])};
3689 TGeoBBox *laddercableshape = new TGeoBBox(0.5*totalLength,0.5*fgkSSDLadderCableWidth,0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]),cableOrig);
cd2243fb 3690 TGeoVolume* laddercable = new TGeoVolume("LadderCableMother", laddercableshape, fSSDAir);
a3f8715e 3691 char laddercabletransname[100];
bf210566 3692 for(Int_t i=0; i<n; i++){
045be90c 3693 snprintf(laddercabletransname,100,"LadderCableTrans%i",i+1);
3694 laddercable->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
3695 new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0,0));
d7599219 3696 }
cd2243fb 3697 return laddercable;
bf210566 3698}
3699/////////////////////////////////////////////////////////////////////////////////
3700TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
3701 /////////////////////////////////////////////////////////////
3702 // Method generating Ladder Cable List Assemblies
cd2243fb 3703 // containing two cables bundles, i.e. P+N readout for one endcap
bf210566 3704 /////////////////////////////////////////////////////////////
cd2243fb 3705 const Int_t kladdercableassemblynumber = 2;
bf210566 3706 TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
3707 TGeoVolume* ladderCable[kladdercableassemblynumber];
a3f8715e 3708 char laddercableassemblyname[100];
bf210566 3709 TList* laddercableassemblylist = new TList();
3710 for(Int_t i=0; i<kladdercableassemblynumber; i++){
045be90c 3711 snprintf(laddercableassemblyname,100,"LadderCableAssembly%i",i+1);
bf210566 3712 ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
3713 ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
3714 new TGeoCombiTrans((n-1)
3715 * fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
3716 2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
3717 0.,new TGeoRotation("",180,0.,0.)));
3718 laddercableassemblylist->Add(ladderCable[i]);
3719}
3720 return laddercableassemblylist;
3721}
3722///////////////////////////////////////////////////////////////////////////////
3723void AliITSv11GeometrySSD::SetLadderSegment(){
3724 /////////////////////////////////////////////////////////////
3725 // Method Generating Ladder Segment Array
3726 /////////////////////////////////////////////////////////////
3727 fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
3728 fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
cd2243fb 3729
3730 /* MvL: tried to create mother volume. Requires changes in all rotations, bc xtru is always along z-axis
3731 TGeoXtru *laddersegmentshape = new TGeoXtru(2);
3732 static const Int_t ntrianglevtx = 3;
3733 Double_t xtrianglevtx[ntrianglevtx]={-0.5*fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength, 0};
3734 Double_t ytrianglevtx[ntrianglevtx]={0, 0, fgkCarbonFiberTriangleLength * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
3735 laddersegmentshape->DefinePolygon(ntrianglevtx,xtrianglevtx,ytrianglevtx);
3736 laddersegmentshape->DefineSection(0,0);
3737 laddersegmentshape->DefineSection(1,fgkCarbonFiberJunctionWidth); // MVL
3738 fladdersegment[0] = new TGeoVolume("LadderSegment1",laddersegmentshape,fSSDAir);
3739 fladdersegment[1] = new TGeoVolume("LadderSegment2",laddersegmentshape,fSSDAir);
3740 */
3741
bf210566 3742 if(!fCreateMaterials) CreateMaterials();
3743 if(!fTransformationMatrices) CreateTransformationMatrices();
3744 if(!fBasicObjects) CreateBasicObjects();
3745 for(Int_t i=0; i<fgkladdersegmentnumber; i++){
3746 // Placing Carbon Fiber Support
3747 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
3748 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3749 fcarbonfibersupportmatrix[j]);
3750 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3751 fcarbonfibersupportmatrix[j]);
d7599219 3752 }
bf210566 3753 // Placing Carbon Fiber Junction
cd2243fb 3754 for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++) {
bf210566 3755 fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
3756 fcarbonfiberjunctionmatrix[j]);
cd2243fb 3757 }
bf210566 3758 // Placing Carbon Fiber Lower Support
cd2243fb 3759 for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++) {
bf210566 3760 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
3761 fcarbonfiberlowersupportrans[j]);
cd2243fb 3762 }
bf210566 3763 // Placing SSD Sensor Support
3764 for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
cd2243fb 3765 fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
bf210566 3766 fssdsensorsupport[1][i],
3767 j+1,fssdsensorsupportmatrix[j]);
3768 // Placing SSD Cooling Tube Support
3769 for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
3770 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3771 fcoolingtubesupportmatrix[j]);
3772 // Placing SSD Cooling Tube
cd2243fb 3773 fladdersegment[i]->AddNode(fcoolingtube,1,fcoolingtubematrix[0]);
3774 fladdersegment[i]->AddNode(fcoolingtube,2,fcoolingtubematrix[1]);
bf210566 3775 // Placing SSD Hybrid
3776 switch(i){
3777 case 0:
3778 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
3779 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3780 break;
3781 case 1:
3782 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
3783 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3784 break;
3785 }
3786 // Placing Cooling Block System
cd2243fb 3787 fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
bf210566 3788 // Placing SSD Flex
cd2243fb 3789 for(Int_t j=0; j<fgkflexnumber; j++){
3790 fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
3791 fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
3792 }
bf210566 3793 }
d7599219 3794}
bf210566 3795///////////////////////////////////////////////////////////////////////////////
3796void AliITSv11GeometrySSD::SetEndLadderSegment(){
3797 /////////////////////////////////////////////////////////////
3798 // Method Generating End Ladder
3799 /////////////////////////////////////////////////////////////
3800 // End Ladder Carbon Fiber Junction
3801 /////////////////////////////////////////////////////////////
3802 fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
3803 fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
3804 if(!fCreateMaterials) CreateMaterials();
3805 if(!fTransformationMatrices) CreateTransformationMatrices();
3806 if(!fBasicObjects) CreateBasicObjects();
3807 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
b28b5356 3808 for(Int_t j=0; j<fgkendladdercarbonfiberjunctionmatrixnumber; j++)
bf210566 3809 fendladdersegment[i]->AddNode(j==2 ?
3810 fendladdercarbonfiberjunction[i][1] :
3811 fendladdercarbonfiberjunction[i][0],
3812 j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
3813 }
3814 /////////////////////////////////////////////////////////////
3815 // End Ladder Carbon Fiber Support
3816 /////////////////////////////////////////////////////////////
3817 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
3818 for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
3819 fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3820 fendladdercarbonfibermatrix[i][j]);
3821 fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3822 fendladdercarbonfibermatrix[i][j]);
3823 }
3824 /////////////////////////////////////////////////////////////
3825 // End Ladder Mounting Block
3826 /////////////////////////////////////////////////////////////
9b0c60ab 3827 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3828 fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
e21cdd03 3829 fendladdermountingblockcombitrans[i]);
9b0c60ab 3830 /////////////////////////////////////////////////////////////
e5bf64ae 3831 // End Ladder Mounting Block Clip
9b0c60ab 3832 /////////////////////////////////////////////////////////////
3833 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3834 for(Int_t j=0; j<2; j++)
e21cdd03 3835 fendladdersegment[i]->AddNode(fendladdermountingblockclip,j+1,
3836 fendladdermountingblockclipmatrix[i][j]);
bf210566 3837 /////////////////////////////////////////////////////////////
3838 // End Ladder Lower Supports
44285dfa 3839 /////////////////////////////////////////////////////////////
bf210566 3840 fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
e21cdd03 3841 fendladderlowersupptrans[0]);
bf210566 3842 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
e21cdd03 3843 fendladderlowersupptrans[1]);
bf210566 3844 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
e21cdd03 3845 fendladderlowersupptrans[2]);
9b0c60ab 3846 /////////////////////////////////////////////////////////////
3847 // End Ladder Cooling Tube Support
3848 /////////////////////////////////////////////////////////////
3849 for(Int_t i=0; i<2; i++)
3850 for(Int_t j=0; j<(i==0?4:2); j++)
e21cdd03 3851 fendladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3852 fendladdercoolingtubesupportmatrix[i][j]);
9b0c60ab 3853 /////////////////////////////////////////////////////////////
3854 // End Ladder Cooling Tube Support
3855 /////////////////////////////////////////////////////////////
cd2243fb 3856 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
3857 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
3858 fendladdersegment[1]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[1][0]);
3859 fendladdersegment[1]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[1][1]);
bf210566 3860}
3861///////////////////////////////////////////////////////////////////////////////
3862void AliITSv11GeometrySSD::SetLadder(){
3863 /////////////////////////////////////////////////////////////
3864 // Method Generating Ladder of Layer 5 and 6
44285dfa 3865 /////////////////////////////////////////////////////////////
bf210566 3866 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
3867 fgkSSDLay6SensorsNumber};
3868 /////////////////////////////////////////////////////////////////////////////
3869 /// Generating Ladder Mother Volume Containing Ladder
3870 /////////////////////////////////////////////////////////////////////////////
3871 TGeoXtru* laddershape[fgkladdernumber];
3872 for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
3873 const Int_t kmothervertexnumber = 8;
3874 Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
3875 Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
3876 ///////////////////////
3877 // Setting the vertices
3878 ///////////////////////
3879 Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
78e34526 3880 * (fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]);
bf210566 3881 xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
0fb26117 3882 ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor;
bf210566 3883 xmothervertex[0][1] = xmothervertex[0][0];
78e34526 3884 ymothervertex[0][1] = -0.5*fgkCoolingTubeSupportHeight; // 0.0; MvL 20-apr-2010
bf210566 3885 xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
3886 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
3887 ymothervertex[0][2] = ymothervertex[0][1];
3888 ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
3889 xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
3890 xmothervertex[0][4] = -xmothervertex[0][3];
3891 ymothervertex[0][4] = ymothervertex[0][3];
3892 xmothervertex[0][5] = -xmothervertex[0][2];
3893 ymothervertex[0][5] = ymothervertex[0][2];
3894 xmothervertex[0][6] = -xmothervertex[0][1];
3895 ymothervertex[0][6] = ymothervertex[0][1];
3896 xmothervertex[0][7] = -xmothervertex[0][0];
3897 ymothervertex[0][7] = ymothervertex[0][0];
3898 for(Int_t i=0; i<kmothervertexnumber; i++){
3899 xmothervertex[1][i] = xmothervertex[0][i];
3900 ymothervertex[1][i] = ymothervertex[0][i];
3901 }
0fb26117 3902///////////////////////////////////////////////////////////////////////////
3903// Disalignement Mother Volume corrections 25/08/08
3904///////////////////////////////////////////////////////////////////////////
160835d5 3905 TGeoXtru* leftladdershape1[fgkladdernumber];
3906 TGeoXtru* leftladdershape2[fgkladdernumber];
0fb26117 3907 TGeoXtru* centersensorladdershape[fgkladdernumber];
160835d5 3908 TGeoXtru* rightladdershape1[fgkladdernumber];
3909 TGeoXtru* rightladdershape2[fgkladdernumber];
bf210566 3910 for(Int_t i=0; i<fgkladdernumber; i++){
160835d5 3911 leftladdershape1[i] = new TGeoXtru(2);
3912 leftladdershape2[i] = new TGeoXtru(2);
3913 centersensorladdershape[i] = new TGeoXtru(2);
3914 rightladdershape1[i] = new TGeoXtru(2);
3915 rightladdershape2[i] = new TGeoXtru(2);
3916 }
0fb26117 3917 //////////////////////////////////////
160835d5 3918 // Setting the names for shapes
0fb26117 3919 //////////////////////////////////////
160835d5 3920 leftladdershape1[0]->SetName("Lay5Left1LadderSegmentContainer");
3921 leftladdershape2[0]->SetName("Lay5Left2LadderSegmentContainer");
3922 leftladdershape1[1]->SetName("Lay6Left1LadderSegmentContainer");
3923 leftladdershape2[1]->SetName("Lay6Left2LadderSegmentContainer");
0fb26117 3924 centersensorladdershape[0]->SetName("Lay5CenterSensorContainer");
3925 centersensorladdershape[1]->SetName("Lay6CenterSensorContainer");
160835d5 3926 rightladdershape1[0]->SetName("Lay5Right1LadderSegmentContainer");
3927 rightladdershape2[0]->SetName("Lay5Right2LadderSegmentContainer");
3928 rightladdershape1[1]->SetName("Lay6Right1LadderSegmentContainer");
3929 rightladdershape2[1]->SetName("Lay6Right2LadderSegmentContainer");
0fb26117 3930 //////////////////////////////////////
160835d5 3931 Double_t xend1laddervertex[fgkladdernumber][kmothervertexnumber];
3932 Double_t yend1laddervertex[fgkladdernumber][kmothervertexnumber];
0fb26117 3933 Double_t xcentersensorvertex[fgkladdernumber][kmothervertexnumber];
3934 Double_t ycentersensorvertex[fgkladdernumber][kmothervertexnumber];
160835d5 3935 Double_t xend2laddervertex[fgkladdernumber][kmothervertexnumber];
3936 Double_t yend2laddervertex[fgkladdernumber][kmothervertexnumber];
3937 for(Int_t i=0; i<fgkladdernumber; i++) {
3938 for(Int_t j=0; j<kmothervertexnumber; j++){
3939 xcentersensorvertex[i][j] = xmothervertex[i][j];
3940 ycentersensorvertex[i][j] = ymothervertex[i][j];
3941 xend1laddervertex[i][j] = xmothervertex[i][j];
3942 yend1laddervertex[i][j] = ymothervertex[i][j];
3943 xend2laddervertex[i][j] = xmothervertex[i][j];
3944 yend2laddervertex[i][j] = ymothervertex[i][j];
3945 }
3946 // Add some space around sensors to accommodate misalignments
3947 xcentersensorvertex[i][0] -= fgkSSDModuleSideDisalignment;
3948 xcentersensorvertex[i][1] = xcentersensorvertex[0][0];
3949 xcentersensorvertex[i][6] = -xcentersensorvertex[0][1];
3950 xcentersensorvertex[i][7] = -xcentersensorvertex[0][0];
3951
3952 ycentersensorvertex[i][0] -= fgkSSDModuleVerticalDisalignment;
3953 ycentersensorvertex[i][7] = ycentersensorvertex[0][0];
3954
3955 // Center Ladder Piece
3956 centersensorladdershape[i]->DefinePolygon(kmothervertexnumber,xcentersensorvertex[i],
3957 ycentersensorvertex[i]);
3958 centersensorladdershape[i]->DefineSection(0, - fgkEndLadderCarbonFiberLowerJunctionLength[1]
3959 + 1.45*fgkSSDMountingBlockWidth);
3960 centersensorladdershape[i]->DefineSection(1, ssdlaysensorsnumber[i] * fgkCarbonFiberJunctionWidth
3961 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
3962 - 2.4*fgkSSDMountingBlockWidth);
0fb26117 3963
160835d5 3964 // Left and Right Ladder Pieces: Mother volumes around ladder mounting areas
0fb26117 3965
160835d5 3966 // Cuts off first corner (neg x)
3967 xend1laddervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
3968 xend1laddervertex[i][1] = -0.5*fgkSSDMountingBlockLength[0];
3969 // Cuts off last part (pos x)
3970 xend2laddervertex[i][6] = 0.5*fgkSSDMountingBlockLength[0];
3971 xend2laddervertex[i][7] = 0.5*fgkSSDMountingBlockLength[0];
0fb26117 3972
160835d5 3973 leftladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
3974 yend1laddervertex[i]);
3975 leftladdershape1[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
3976 leftladdershape1[i]->DefineSection(1, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
3977 - fgkEndLadderMountingBlockPosition[0]);
3978
3979 leftladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
3980 yend2laddervertex[i]);
3981 leftladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
3982 - fgkEndLadderMountingBlockPosition[0]);
3983 leftladdershape2[i]->DefineSection(1,- fgkEndLadderCarbonFiberLowerJunctionLength[1]
3984 + 1.45*fgkSSDMountingBlockWidth); // connect to main volume at -1.6725 cm
3985
3986 rightladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
3987 yend1laddervertex[i]);
3988 rightladdershape1[i]->DefineSection(0,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
3989 +fgkEndLadderCarbonFiberLowerJunctionLength[0]
3990 -2.4*fgkSSDMountingBlockWidth);
3991 rightladdershape1[i]->DefineSection(1,fendladdersegmentmatrix[1][i]->GetTranslation()[2]
3992 + fgkEndLadderMountingBlockPosition[1]);
3993
3994 rightladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
3995 yend2laddervertex[i]);
3996 rightladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[1][i]->GetTranslation()[2]
3997 + fgkEndLadderMountingBlockPosition[1]);
3998 rightladdershape2[i]->DefineSection(1, ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
3999 + fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4000 }
4001 TGeoCompositeShape* laddershapecontainer[2];
4002 laddershapecontainer[0] = new TGeoCompositeShape("Lay5LadderCompositeShape",
4003 "Lay5Left1LadderSegmentContainer+Lay5Left2LadderSegmentContainer"
4004 "+Lay5CenterSensorContainer"
4005 "+Lay5Right1LadderSegmentContainer+Lay5Right2LadderSegmentContainer");
4006 laddershapecontainer[1] = new TGeoCompositeShape("Lay6LadderCompositeShape",
4007 "Lay6Left1LadderSegmentContainer+Lay6Left2LadderSegmentContainer"
4008 "+Lay6CenterSensorContainer"
4009 "+Lay6Right1LadderSegmentContainer+Lay6Right2LadderSegmentContainer");
4010 const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4011 for(Int_t i=0; i<fgkladdernumber; i++){
4012 fladder[i] = new TGeoVolume(laddername[i],laddershapecontainer[i],fSSDAir);
4013 fladder[i]->SetLineColor(4);
4014 }
bf210566 4015///////////////////////////////////////////////////////////////////////////
4016 if(!fCreateMaterials) CreateMaterials();
4017 if(!fTransformationMatrices) CreateTransformationMatrices();
4018 if(!fBasicObjects) CreateBasicObjects();
4019 SetLadderSegment();
4020 SetEndLadderSegment();
4021 for(Int_t i=0; i<fgkladdernumber; i++){
4022 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4023 //////////////////////////
4024 /// Placing Ladder Segment
4025 //////////////////////////
4026 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4027 fladdersegment[i==0 ? 1 : 0],
4028 ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4029 //////////////////////////
4030 /// Placing SSD Sensor
4031 //////////////////////////
ca86fdb4 4032 if(i==0&&ssdlaysensorsnumber[i]-j-1==13) fSSDSensor5->SetLineColor(kRed);
bf210566 4033 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4034 fssdsensormatrix[i][j]);
4035 }
4036 ///////////////////////////////
4037 /// Placing End Ladder Segment
4038 ///////////////////////////////
160835d5 4039 fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
bf210566 4040 fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4041 }
d7599219 4042/////////////////////////////////////////////////////////////////////////////
4043/// Placing Ladder Cables
4044/////////////////////////////////////////////////////////////////////////////
bf210566 4045 Int_t sidecablenumber[2][2];
4046 sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4047 sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4048 sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4049 sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4050 Double_t carbonfibertomoduleposition[3];
4051 carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4052 carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4053 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4054 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4055 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4056 - fgkSSDSensorCenterSupportThickness[0]);
4057 carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4058 + 0.5*fgkCoolingTubeSupportHeight
4059 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4060 const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
44285dfa 4061 Double_t ssdendladdercablelength[4];
4062 ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
d7599219 4063 + fgkSSDSensorLength
4064 - fgkSSDModuleStiffenerPosition[1]
4065 - fgkSSDStiffenerWidth
4066 - fgkSSDFlexWidth[0]
bf210566 4067 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4068 ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
d7599219 4069 + fgkSSDModuleStiffenerPosition[1]
4070 + fgkSSDStiffenerWidth
bf210566 4071 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4072 ssdendladdercablelength[2] = ssdendladdercablelength[1]
d7599219 4073 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
bf210566 4074 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4075 - kendladdercablecorrection;
44285dfa 4076 ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4077 + carbonfibertomoduleposition[1]
d7599219 4078 - fgkSSDModuleStiffenerPosition[1]
4079 - fgkSSDStiffenerWidth)
bf210566 4080 + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
78e34526 4081
44285dfa 4082 TList* laddercableassemblylist[4];
4083 const Int_t kendladdercablesnumber = 4;
cd2243fb 4084 TGeoRotation *laddercablerot = new TGeoRotation();
4085 laddercablerot->SetAngles(90.,60.,-90.);
bf210566 4086 for(Int_t i=0; i<fgkladdercablesnumber; i++)
4087 for(Int_t j=0; j<kendladdercablesnumber; j++){
4088 laddercableassemblylist[j] =
4089 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4090 ssdendladdercablelength[j]);
0fb26117 4091 fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4092 j<2?1:2,fladdercablematrix[i][j]);
bf210566 4093 }
bf210566 4094}
4095////////////////////////////////////////////////////////////////////////////////
4096void AliITSv11GeometrySSD::SetLayer(){
d7599219 4097////////////////////////////////////////////////////////////////////////////////
bf210566 4098 // Creating Ladder of Layer 5 and Layer 6
4099 /////////////////////////////////////////////////////////////
4100 if(!fCreateMaterials) CreateMaterials();
4101 if(!fTransformationMatrices) CreateTransformationMatrices();
4102 if(!fBasicObjects) CreateBasicObjects();
4103 SetLadder(); // Generating the ladder of Layer5 and Layer6
4104 const Int_t kssdlayladdernumber[fgklayernumber] =
4105 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4106 /////////////////////////////////////////////////////////////
4107 // Generating mother volumes for Layer5 and Layer6
4108 /////////////////////////////////////////////////////////////
e5bf64ae 4109 fSSDLayer5 = new TGeoVolumeAssembly("ITSssdLayer5");
4110 fSSDLayer6 = new TGeoVolumeAssembly("ITSssdLayer6");
bf210566 4111 Int_t *ladderindex[fgklayernumber];
4112 Int_t index[fgklayernumber] = {8,9};
4113 for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4114 for(Int_t i=0; i<fgklayernumber; i++)
4115 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4116 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4117 j+index[i] : j+index[i]-kssdlayladdernumber[i];
4118 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4119 fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4120 }
44285dfa 4121 /////////////////////////////////////////////////////////////
bf210566 4122 // Deallocating memory
4123 /////////////////////////////////////////////////////////////
7b208ef4 4124 for(Int_t i=0; i<fgklayernumber; i++) delete [] ladderindex[i];
d7599219 4125}
4126////////////////////////////////////////////////////////////////////////////////
4127void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
44285dfa 4128 /////////////////////////////////////////////////////////////
4129 // Insert the layer 5 in the mother volume.
4130 /////////////////////////////////////////////////////////////
4131 if (! moth) {
160835d5 4132 AliError("Can't insert layer5, mother is null!\n");
44285dfa 4133 return;
4134 };
bf210566 4135 if(!fSSDLayer5) SetLayer();
4136 fMotherVol = moth;
4137 TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4138 + fgkLay5CenterITSPosition);
4139 moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
44285dfa 4140 }
d7599219 4141////////////////////////////////////////////////////////////////////////////////
4142void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
44285dfa 4143 /////////////////////////////////////////////////////////////
4144 // Insert the layer 6 in the mother volume.
4145 /////////////////////////////////////////////////////////////
4146 if (! moth) {
160835d5 4147 AliError("AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
44285dfa 4148 return;
4149 };
bf210566 4150 if(!fSSDLayer6) SetLayer();
4151 fMotherVol = moth;
4152 TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4153 + fgkLay6CenterITSPosition);
4154 moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
44285dfa 4155 }
bf210566 4156 ////////////////////////////////////////////////////////////////////////////////
9b0c60ab 4157 TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4158 /////////////////////////////////////////////////////////////
4159 // Method generating the Arc structure of Ladder Support
4160 /////////////////////////////////////////////////////////////
4161 const Int_t kssdlayladdernumber[fgklayernumber] =
4162 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4163 Double_t mountingsupportedge[fgklayernumber];
4164 Double_t mountingblockratio[fgklayernumber];
4165 Double_t theta[fgklayernumber];
4166 Double_t phi[fgklayernumber];
4167 Double_t psi0[fgklayernumber];
4168 Double_t deltapsi[fgklayernumber];
4169 TVector3* mountingsupportedgevector[fgklayernumber];
4170 for(Int_t i=0; i<fgklayernumber; i++){
4171 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4172 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
60e55aee 4173 * (TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
9b0c60ab 4174 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4175 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4176 / kssdlayladdernumber[i])));
4177 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4178 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4179 mountingsupportedgevector[i] = new TVector3();
60e55aee 4180 mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4181 mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(
4182 (1.-mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])*
4183 (1.+mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])));
9b0c60ab 4184 psi0[i] = 0.5*TMath::Pi()-phi[i];
4185 deltapsi[i] = (theta[i]+phi[i])/nedges;
4186 }
4187 TVector3** vertex[fgklayernumber];
4188 TList* vertexlist[fgklayernumber];
4189 Int_t indexedge[fgklayernumber] = {0,0};
4190 for(Int_t i=0; i<fgklayernumber; i++){
4191 vertex[i] = new TVector3*[nedges+1];
4192 vertexlist[i] = new TList();
4193 }
4194 for(Int_t i=0; i<fgklayernumber; i++){
4195 for(Int_t j=0; j<nedges+1; j++){
4196 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
4197 fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]));
4198 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4199 vertexlist[i]->Add(vertex[i][j]);
4200 }
4201 vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4202 }
4203 Double_t** xsidevertex = new Double_t*[fgklayernumber];
4204 Double_t** ysidevertex = new Double_t*[fgklayernumber];
4205 Double_t** xcentervertex = new Double_t*[fgklayernumber];
4206 Double_t** ycentervertex = new Double_t*[fgklayernumber];
4207 Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4208 Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4209 Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4210 Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4211 for(Int_t i=0; i<fgklayernumber; i++){
4212 xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4213 ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4214 xcentervertex[i] = new Double_t[indexedge[i]+3];
4215 ycentervertex[i] = new Double_t[indexedge[i]+3];
4216 xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4217 ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4218 xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4219 ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4220 for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4221 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4222 ((TVector3*)vertexlist[i]->At(j))->X();
4223 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4224 ((TVector3*)vertexlist[i]->At(j))->Y();
4225 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4226 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4227 if(j<indexedge[i]+1){
4228 xcentervertex[i][j!=indexedge[i]?j+3:0] =
4229 ((TVector3*)vertexlist[i]->At(j))->X();
4230 ycentervertex[i][j!=indexedge[i]?j+3:0] =
4231 ((TVector3*)vertexlist[i]->At(j))->Y();
4232 xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4233 ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4234 }
4235 }
4236 xsidevertex[i][1] = xsidevertex[i][0];
4237 ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4238 xsidevertex[i][2] = xsidevertex[i][3];
4239 ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4240 xcentervertex[i][1] = xcentervertex[i][0];
4241 ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4242 xcentervertex[i][2] = xcentervertex[i][3];
4243 ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4244 xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4245 ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4246 xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4247 ycenterlowervertex[i][0] = ysidevertex[i][0];
4248 xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4249 ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4250 }
4251 /////////////////////////////////////////////////////////////
4252 // Building the Arc Structure of Ladder Supports
4253 /////////////////////////////////////////////////////////////
4254 TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4255 TGeoXtru* centermountingsupportshape[fgklayernumber];
4256 TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4257 TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4258 TGeoVolume* sidemountingblocksupport[fgklayernumber];
4259 TGeoVolume* centermountingblocksupport[fgklayernumber];
4260 TGeoVolume* sideladdersupportpiece[fgklayernumber];
4261 TGeoVolume* centerladdersupportpiece[fgklayernumber];
a3f8715e 4262 char sidemountingblockname[100];
4263 char centermountingblockname[100];
4264 char sideladdersupportpiecename[100];
4265 char centerladdersupportpiecename[100];
9b0c60ab 4266 for(Int_t i=0; i<fgklayernumber; i++){
045be90c 4267 snprintf(sidemountingblockname,100,"MountingBlockSupportSideLay%dArc",i+5);
4268 snprintf(centermountingblockname,100,"MountingBlockSupportCenterLay%dArc",i+5);
4269 snprintf(sideladdersupportpiecename,100,"SideLadderSupportPieceLay%d",i+5);
4270 snprintf(centerladdersupportpiecename,100,"CenterLadderSupportPieceLay%d",i+5);
4271 sidemountingblocksupportshape[i] = new TGeoXtru(2);
9b0c60ab 4272 sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4273 xsidevertex[i],ysidevertex[i]);
4274 sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4275 -fgkMountingBlockSupportWidth[0]);
4276 sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4277 sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4278 sidemountingblocksupportshape[i],
4279 fSSDAlCoolBlockMedium);
4280 sidemountingblocksupport[i]->SetLineColor(9);
4281 centermountingsupportshape[i] = new TGeoXtru(2);
4282 centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4283 xcentervertex[i],ycentervertex[i]);
4284 centermountingsupportshape[i]->DefineSection(0,0.);
4285 centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4286 -fgkMountingBlockSupportWidth[0]);
160835d5 4287
9b0c60ab 4288 centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4289 centermountingsupportshape[i],
4290 fSSDAlCoolBlockMedium);
4291 centermountingblocksupport[i]->SetLineColor(9);
4292 sideladdersupportpieceshape[i] = new TGeoXtru(2);
4293 sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4294 xsidelowervertex[i],ysidelowervertex[i]);
4295 sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4296 -fgkMountingBlockSupportWidth[0]);
4297 sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4298 sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4299 sideladdersupportpieceshape[i],
e21cdd03 4300 fSSDCarbonFiberMedium);
9b0c60ab 4301 sideladdersupportpiece[i]->SetLineColor(fColorAl);
4302 centerladdersupportpieceshape[i] = new TGeoXtru(2);
4303 centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4304 xcenterlowervertex[i],ycenterlowervertex[i]);
4305 centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4306 centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4307 -fgkMountingBlockSupportWidth[0]);
4308 centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4309 centerladdersupportpieceshape[i],
e21cdd03 4310 fSSDCarbonFiberMedium);
9b0c60ab 4311 centerladdersupportpiece[i]->SetLineColor(fColorAl);
4312 }
4313 /////////////////////////////////////////////////////////////
4314 // Building the Up Structure of Ladder Supports
4315 /////////////////////////////////////////////////////////////
4316 TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4317 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4318 TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4319 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4320 TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4321 //////////////////////////////////////////////////////////
4322 // Setting the volume for TGeoXtru Mounting Block Piece
4323 //////////////////////////////////////////////////////////
4324 TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4325 TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4326 TGeoVolume* mountingblockpiecedown[fgklayernumber];
4327 TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4328 TGeoVolume* mountingblockpieceup[fgklayernumber];
4329 Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4330 Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4331 Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4332 Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
a3f8715e 4333 char mountingblockpiecedownname[100];
4334 char mountingblockpieceupname[100];
9b0c60ab 4335 for(Int_t i=0; i<fgklayernumber; i++){
4336 ///////////////////////////
4337 // Mounting Block Down Vertex
4338 ///////////////////////////
4339 mountingblockpiecedownshape[i] = new TGeoXtru(2);
045be90c 4340 snprintf(mountingblockpiecedownname,100,"MountingBlockPieceDownLay%d",i+5);
9b0c60ab 4341 mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4342 mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
160835d5 4343 + fgkMountingBlockSupportDownHeight
4344 - fgkSSDLadderVerticalDisalignment;
9b0c60ab 4345 mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4346 mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4347 + fgkSSDMountingBlockHeight[1]
4348 - 0.5*fgkCoolingTubeSupportHeight
0fb26117 4349 - fgkSSDModuleCoolingBlockToSensor;
9b0c60ab 4350 mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4351 mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4352 mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4353 mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4354 mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4355 mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4356 mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4357 mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4358 + fgkSSDMountingBlockHeight[2]
4359 - fgkSSDMountingBlockHeight[0];
4360 mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4361 mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4362 mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4363 mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4364 mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4365 mountingblockpiecedownyvertex[i]);
4366 mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4367 mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4368 mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
e21cdd03 4369 mountingblockpiecedownshape[i],fSSDMountingBlockMedium);
9b0c60ab 4370 mountingblockpiecedown[i]->SetLineColor(fColorG10);
160835d5 4371
9b0c60ab 4372 ///////////////////////////
4373 // Mounting Block Up Vertex
4374 ///////////////////////////
4375 mountingblockpieceupshape[i] = new TGeoXtru(2);
045be90c 4376 snprintf(mountingblockpieceupname,100,"MountingBlockPieceUpLay%d",i+5);
9b0c60ab 4377 mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4378 mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
160835d5 4379 + fgkMountingBlockSupportUpHeight[i]
4380 - fgkSSDLadderVerticalDisalignment;
9b0c60ab 4381 mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4382 mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4383 + fgkSSDMountingBlockHeight[1]
4384 - 0.5*fgkCoolingTubeSupportHeight
0fb26117 4385 - fgkSSDModuleCoolingBlockToSensor;
9b0c60ab 4386 mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4387 mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4388 mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4389 mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4390 mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4391 mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4392 mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4393 mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4394 + fgkSSDMountingBlockHeight[2]
4395 - fgkSSDMountingBlockHeight[0];
4396 mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4397 mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4398 mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4399 mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
160835d5 4400
9b0c60ab 4401 mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4402 mountingblockpieceupyvertex[i]);
4403 mountingblockpieceupshape[i]->DefineSection(0,0.0);
4404 mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4405 mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
e21cdd03 4406 mountingblockpieceupshape[i],fSSDMountingBlockMedium);
9b0c60ab 4407 mountingblockpieceup[i]->SetLineColor(fColorG10);
4408 }
4409 ///////////////////////////////////////////////////////////////////
4410 // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4411 ///////////////////////////////////////////////////////////////////
4412 TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4413 TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4414 TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4415 TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4416 Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4417 Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4418 Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4419 Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
a3f8715e 4420 char mountingblocksupportrapezoidowname[100];
4421 char mountingblocksupportrapezoidupname[100];
9b0c60ab 4422 Double_t scalefactor = 3./4.;
4423 for(Int_t i=0; i<fgklayernumber; i++){
4424 ////////////////////////////////////////////
4425 // Mounting Block Support Down Trapezoid Vertex
4426 ////////////////////////////////////////////
4427 mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4428 mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4429 - mountingsupportedge[i];
4430 mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4431 mountingblocksupportrapezoidownxvertex[i][1] =
4432 mountingblocksupportrapezoidownxvertex[i][0];
4433 mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4434 + scalefactor*(mountingblockpiecedownyvertex[i][1]
4435 - mountingblockpiecedownyvertex[i][0]);
4436 mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4437 mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4438 mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4439 mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4440 mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4441 mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
160835d5 4442
9b0c60ab 4443 mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4444 mountingblocksupportrapezoidownyvertex[i]);
4445 mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4446 -fgkMountingBlockSupportWidth[0]);
4447 mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
045be90c 4448 snprintf(mountingblocksupportrapezoidowname,100,"MountingBlockSuppTrapezoidDownLay%d",i+5);
9b0c60ab 4449 mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
e21cdd03 4450 mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4451 mountingblocksupportrapezoidown[i]->SetLineColor(9);
4452 ////////////////////////////////////////////
4453 // Mounting Block Support Up Trapezoid Vertex
4454 ////////////////////////////////////////////
4455 mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4456 mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4457 - mountingsupportedge[i];
4458 mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4459 mountingblocksupportrapezoidupxvertex[i][1] =
4460 mountingblocksupportrapezoidupxvertex[i][0];
4461 mountingblocksupportrapezoidupyvertex[i][1] =
4462 mountingblockpieceupyvertex[i][0]
4463 + scalefactor*(mountingblockpieceupyvertex[i][1]
4464 - mountingblockpieceupyvertex[i][0]);
4465 mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4466 mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4467 mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4468 mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4469 mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4470 mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
160835d5 4471
9b0c60ab 4472 mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4473 mountingblocksupportrapezoidupyvertex[i]);
4474 mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4475 -fgkMountingBlockSupportWidth[0]);
4476 mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
045be90c 4477 snprintf(mountingblocksupportrapezoidupname,100,"MountingBlockSuppTrapezoidUpLay%d",i+5);
9b0c60ab 4478 mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
e21cdd03 4479 mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4480 mountingblocksupportrapezoidup[i]->SetLineColor(9);
4481 }
4482 ///////////////////////////////////////////////////////////////////
4483 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4484 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4485 Double_t boxoriginup[fgklayernumber][2][3];
4486 Double_t boxorigindown[fgklayernumber][2][3];
a3f8715e 4487 char mountingblocksupportboxdownname[100];
4488 char mountingblocksupportboxupname[100];
9b0c60ab 4489 TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4490 mountingblocksupportrot->SetAngles(90.,180.,-90);
4491 TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4492 globalrefladdersupportrot->SetAngles(0.,90.,0.);
4493 TGeoHMatrix* laddersupportmatrix[2];
4494 laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4495 laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4496 /////////////////////////////////////////////////////////////
4497 // Creating Mother Volume for Containment
4498 /////////////////////////////////////////////////////////////
4499 Double_t *xmothervertex[fgklayernumber];
4500 Double_t *ymothervertex[fgklayernumber];
4501 for(Int_t i=0; i<fgklayernumber; i++){
4502 xmothervertex[i] = new Double_t[8];
4503 ymothervertex[i] = new Double_t[8];
4504 }
4505 TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4506 TGeoVolume* downmotherladdersupport[fgklayernumber];
4507 TGeoXtru* upmotherladdersupportshape[fgklayernumber];
160835d5 4508 TGeoVolume* upmotherladdersupport[fgklayernumber];
a3f8715e 4509 char upmotheladdersupportname[100];
4510 char downmotheladdersupportname[100];
9b0c60ab 4511 for(Int_t i=0; i<fgklayernumber; i++){
4512 xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4513 - mountingsupportedge[i];
4514 ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4515 xmothervertex[i][1] = xmothervertex[i][0];
4516 ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4517 + fgkMountingBlockSupportWidth[0];
4518 xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4519 ymothervertex[i][2] = ymothervertex[i][1];
4520 xmothervertex[i][3] = xmothervertex[i][2];
4521 ymothervertex[i][3] = -ymothervertex[i][0];
4522 xmothervertex[i][4] = -xmothervertex[i][0];
4523 ymothervertex[i][4] = ymothervertex[i][3];
4524 xmothervertex[i][5] = xmothervertex[i][4];
4525 ymothervertex[i][5] = -ymothervertex[i][1];
4526 xmothervertex[i][6] = -xmothervertex[i][2];
4527 ymothervertex[i][6] = ymothervertex[i][5];
4528 xmothervertex[i][7] = xmothervertex[i][6];
4529 ymothervertex[i][7] = ymothervertex[i][0];
160835d5 4530
045be90c 4531 snprintf(downmotheladdersupportname,100,"LadderSupportDownLay%d",i+5);
4532 snprintf(upmotheladdersupportname,100,"LadderSupportUpLay%d",i+5);
160835d5 4533
4534 downmotherladdersupportshape[i] = new TGeoXtru(2);
9b0c60ab 4535 downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4536 downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
160835d5 4537 downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
9b0c60ab 4538 + fgkMountingBlockSupportDownHeight
4539 + fgkSSDMountingBlockHeight[1]
4540 - 0.5*fgkCoolingTubeSupportHeight
160835d5 4541 - fgkSSDModuleCoolingBlockToSensor
4542 - fgkSSDLadderVerticalDisalignment);
4543
4544// - fgkSSDModuleVerticalDisalignment);
4545 //downmotherladdersupport[i] = new TGeoVolumeAssembly(downmotheladdersupportname);
4546
4547 downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4548 downmotherladdersupportshape[i],fSSDAir);
9b0c60ab 4549 upmotherladdersupportshape[i] = new TGeoXtru(2);
4550 upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4551 upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4552 upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4553 + fgkMountingBlockSupportUpHeight[i]
4554 + fgkSSDMountingBlockHeight[1]
4555 - 0.5*fgkCoolingTubeSupportHeight
160835d5 4556 - fgkSSDModuleCoolingBlockToSensor
4557 - fgkSSDLadderVerticalDisalignment);
4558
4559 upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4560 upmotherladdersupportshape[i],fSSDAir);
9b0c60ab 4561 }
4562 for(Int_t i=0; i<fgklayernumber; i++){
4563 /////////////////////////
4564 // Setting the box origin
4565 /////////////////////////
4566 boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4567 boxorigindown[i][0][1] = fgkMountingBlockSupportRadius[i]
160835d5 4568 + 0.5*fgkMountingBlockSupportDownHeight
4569 - 0.5*fgkSSDLadderVerticalDisalignment;
9b0c60ab 4570 boxorigindown[i][0][2] = fgkMountingBlockSupportWidth[1]
4571 - 0.5*fgkMountingBlockSupportWidth[0];
4572
4573 boxorigindown[i][1][0] = 0.0;
4574 boxorigindown[i][1][1] = boxorigindown[i][0][1];
4575 boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4576 - fgkMountingBlockSupportWidth[0]);
4577
4578 boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4579 boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
160835d5 4580 + 0.5*fgkMountingBlockSupportUpHeight[i]
4581 - 0.5*fgkSSDLadderVerticalDisalignment;
9b0c60ab 4582 boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4583 - 0.5*fgkMountingBlockSupportWidth[0];
4584
4585 boxoriginup[i][1][0] = 0.0;
160835d5 4586 boxoriginup[i][1][1] = boxoriginup[i][0][1];
9b0c60ab 4587 boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4588 - fgkMountingBlockSupportWidth[0]);
4589
4590 /////////////////////////
4591 // Setting the boxes
4592 /////////////////////////
4593 mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4594 + fgkSSDMountingBlockLength[0]),
160835d5 4595 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4596 0.5*fgkMountingBlockSupportWidth[0],
4597 boxorigindown[i][0]);
160835d5 4598 mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4599 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4600 0.5*(fgkMountingBlockSupportWidth[1]
4601 - fgkMountingBlockSupportWidth[0]),
4602 boxorigindown[i][1]);
4603
4604 mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4605 + fgkSSDMountingBlockLength[0]),
160835d5 4606 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4607 0.5*fgkMountingBlockSupportWidth[0],
4608 boxoriginup[i][0]);
160835d5 4609
9b0c60ab 4610 mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
160835d5 4611 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4612 0.5*(fgkMountingBlockSupportWidth[1]
4613 - fgkMountingBlockSupportWidth[0]),
4614 boxoriginup[i][1]);
4615 ///////////////////////////////////////
160835d5 4616 // Adding the Volumes to Mother Volume
9b0c60ab 4617 ///////////////////////////////////////
4618 for(Int_t j=0; j<2; j++){
045be90c 4619 snprintf(mountingblocksupportboxdownname,100,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4620 snprintf(mountingblocksupportboxupname,100,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4621 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4622 mountingblocksupportboxdownshape[i][j],
4623 fSSDCarbonFiberMedium);
4624 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4625 mountingblocksupportboxupshape[i][j],
4626 fSSDCarbonFiberMedium);
9b0c60ab 4627 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4628 mountingblocksupportboxup[i][j]->SetLineColor(9);
4629 for(Int_t k=0; k<2; k++){
4630 downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
160835d5 4631 upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
9b0c60ab 4632 }
4633 }
4634 for(Int_t k=0; k<2; k++){
4635 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4636 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4637 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4638 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
160835d5 4639 downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
9b0c60ab 4640 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4641 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
160835d5 4642 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4643 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4644 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4645 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4646 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
9b0c60ab 4647 }
4648 }
4649 TList* laddersupportlist = new TList();
4650 laddersupportlist->Add(downmotherladdersupport[0]);
4651 laddersupportlist->Add(upmotherladdersupport[0]);
4652 laddersupportlist->Add(downmotherladdersupport[1]);
4653 laddersupportlist->Add(upmotherladdersupport[1]);
4654 /////////////////////////////////////////////////////////////
4655 // Deallocating memory
4656 /////////////////////////////////////////////////////////////
4657 for(Int_t i=0; i<fgklayernumber; i++){
4658 for(Int_t j=0; j<nedges+1; j++)
4659 delete vertex[i][j];
4660 delete mountingsupportedgevector[i];
4661 delete [] vertex[i];
4662 delete vertexlist[i];
4663 delete [] xsidevertex[i];
4664 delete [] ysidevertex[i];
4665 delete [] xcentervertex[i];
4666 delete [] ycentervertex[i];
4667 delete [] xsidelowervertex[i];
4668 delete [] ysidelowervertex[i];
4669 delete [] xcenterlowervertex[i];
4670 delete [] ycenterlowervertex[i];
7b208ef4 4671 delete [] xmothervertex[i];
4672 delete [] ymothervertex[i];
9b0c60ab 4673 }
3e008bd7 4674 delete [] xsidevertex;
4675 delete [] ysidevertex;
4676 delete [] xcentervertex;
4677 delete [] ycentervertex;
4678 delete [] xsidelowervertex;
4679 delete [] ysidelowervertex;
4680 delete [] xcenterlowervertex;
4681 delete [] ycenterlowervertex;
9b0c60ab 4682 delete globalrefladdersupportrot;
4683 delete mountingblocksupportrot;
4684 /////////////////////
4685 return laddersupportlist;
4686}
4687 ////////////////////////////////////////////////////////////////////////////////
4688void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
4689//////////////////////////////////////////
4690// Method Generating Ladder Support Ring
4691//////////////////////////////////////////
4692 if(!fCreateMaterials) CreateMaterials();
4693 if(!fTransformationMatrices) CreateTransformationMatrices();
4694 if(!fBasicObjects) CreateBasicObjects();
4695 fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
4696 fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
4697 const Int_t kssdlayladdernumber[fgklayernumber] =
4698 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4699 Double_t mountingsupportedge[fgklayernumber];
4700 Double_t mountingblockratio[fgklayernumber];
4701 Double_t theta[fgklayernumber];
4702 Double_t phi[fgklayernumber];
4703 for(Int_t i=0; i<fgklayernumber; i++){
4704 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4705 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
60e55aee 4706 *(TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
9b0c60ab 4707 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4708 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4709 / kssdlayladdernumber[i])));
4710 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
4711 / fgkMountingBlockSupportRadius[i]);
4712 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4713 }
4714 TGeoRotation* globalrot = new TGeoRotation();
4715 globalrot->SetAngles(0.,-90.,0.);
4716 TGeoRotation** laddersupportrot[fgklayernumber];
4717 TGeoHMatrix** laddersupportmatrix[fgklayernumber];
4718 for(Int_t i=0; i<fgklayernumber; i++){
4719 laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
4720 laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
4721 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4722 laddersupportrot[i][j] = new TGeoRotation();
4723 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
4724 switch(i){
4725 case 0: //Ladder of Layer5
4726 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4727 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
4728 laddersupportmatrix[i][j]);
4729 break;
4730 case 1: //Ladder of Layer6
4731 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4732 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
4733 laddersupportmatrix[i][j]);
4734 break;
4735 }
4736 }
4737 }
4738 /////////////////////////////////////////////////////////////
4739 // Creating Lower Ladder Support
4740 /////////////////////////////////////////////////////////////
4741 TVector3** ringsupportvertex[fgklayernumber];
4742 Double_t angle = 360./nedges;
4743 for(Int_t i=0; i<fgklayernumber; i++){
4744 ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
4745 ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
4746 * TMath::Cos(theta[i]));
4747 ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
4748 - mountingsupportedge[i],
4749 ringsupportvertex[i][0]->Y());
4750 ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
4751 ringsupportvertex[i][1]->Y());
4752 ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
4753 for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4754 ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
4755 ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
4756 ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
4757 ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
4758 }
4759 ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
4760 for(Int_t j=0; j<nedges+1; j++){
4761 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
cd2243fb 4762 new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*CosD(90.0-j*angle),
4763 (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*SinD(90.0-j*angle));
9b0c60ab 4764 }
4765 }
4766 Double_t **xmothervertex = new Double_t*[fgklayernumber];
4767 Double_t **ymothervertex = new Double_t*[fgklayernumber];
4768 for(Int_t i=0; i<fgklayernumber; i++){
4769 xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4770 ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4771 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
4772 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
4773 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
4774 }
4775 }
0e8760e5 4776////////////////////////////////////////////////////////////////////////////////
4777// Start Corrections 13/06/08
4778////////////////////////////////////////////////////////////////////////////////
a3f8715e 4779 char lowerladderpconsupportname[100];
0e8760e5 4780 TGeoPcon* lowerladderpconsupportshape[fgklayernumber];
4781 TGeoVolume* lowerladderpconsupport[fgklayernumber];
4782 Double_t lowerladderpconezsection[2] = {0.,fgkMountingBlockSupportWidth[1]};
4783 Double_t lowerladderpconradiusmax[fgklayernumber];
4784 Double_t lowerladderpconradiusmin[fgklayernumber];
4785 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4786 lowerladdersupportrot->SetAngles(90.,180.,-90);
4787 for(Int_t i=0; i<fgklayernumber; i++){
4788 lowerladderpconradiusmax[i] = fgkMountingBlockSupportRadius[i]
4789 * TMath::Cos(theta[i]);
cd2243fb 4790 lowerladderpconradiusmin[i] = lowerladderpconradiusmax[i]-fgkLadderSupportHeight;
0e8760e5 4791 }
4792 for(Int_t i=0; i<fgklayernumber; i++){
4793/////////////////////////// Modified Version ?///////////////////
4794 lowerladderpconsupportshape[i] = new TGeoPcon(0.,360.,2);
4795 for(Int_t j=0; j<2; j++) lowerladderpconsupportshape[i]->DefineSection(j,
4796 lowerladderpconezsection[j],lowerladderpconradiusmin[i],
4797 lowerladderpconradiusmax[i]);
045be90c 4798 snprintf(lowerladderpconsupportname,100,"LowerLadderPConSupportNameLay%d",i+5);
0e8760e5 4799 lowerladderpconsupport[i] = new TGeoVolume(lowerladderpconsupportname,lowerladderpconsupportshape[i],fSSDSupportRingAl);
4800 lowerladderpconsupport[i]->SetLineColor(fColorAl);
4801 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],1);
4802 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],2,lowerladdersupportrot);
4803 }
4804////////////////////////////////////////////////////////////////////////////////
4805// End Corrections 13/06/08
4806////////////////////////////////////////////////////////////////////////////////
4807 /*char lowerladdersupportname[30];
9b0c60ab 4808 TGeoXtru* lowerladdersupportshape[fgklayernumber];
4809 TGeoVolume* lowerladdersupport[fgklayernumber];
4810 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4811 lowerladdersupportrot->SetAngles(90.,180.,-90);
4812 for(Int_t i=0; i<fgklayernumber; i++){
4813 lowerladdersupportshape[i] = new TGeoXtru(2);
4814 lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
4815 xmothervertex[i],ymothervertex[i]);
4816 lowerladdersupportshape[i]->DefineSection(0,0.);
4817 lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4818 sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
4819 lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
4820 lowerladdersupportshape[i],fSSDSupportRingAl);
4821 lowerladdersupport[i]->SetLineColor(fColorAl);
4822 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
4823 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
0e8760e5 4824 }*/
9b0c60ab 4825 /////////////////////////////////////////////////////////////
4826 // Deallocating memory
4827 /////////////////////////////////////////////////////////////
4828 for(Int_t i=0; i<fgklayernumber; i++){
4829 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
4830 delete ringsupportvertex[i][j];
4831 delete [] ringsupportvertex[i];
4832 }
4833 for(Int_t i=0; i<fgklayernumber; i++){
4834 delete [] xmothervertex[i];
4835 delete [] ymothervertex[i];
4836 }
7b208ef4 4837 delete [] xmothervertex;
4838 delete [] ymothervertex;
9b0c60ab 4839 delete globalrot;
4840 for(Int_t i=0; i<fgklayernumber; i++){
4841 for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
4842 delete laddersupportrot[i][j];
4843 delete [] laddersupportrot[i];
4844 }
4845 }
4846 ////////////////////////////////////////////////////////////////////////////////
4847 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
4848 /////////////////////////////////////////////////////////////
4849 // Method generating Endcap CoverPlate
4850 /////////////////////////////////////////////////////////////
4851 // Holes Definition
4852 ///////////////////
4853 Int_t nendcapcoverplateholedges = 30;
4854 const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
4855 Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
4856 0.5*fgkEndCapCoverPlateThickness};
851c0ce3 4857 TGeoShape* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
9b0c60ab 4858 nendcapcoverplateholedges,holesection);
4859 TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
e21cdd03 4860 endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 4861 endcapcoverplatesmallhole->SetLineColor(6);
851c0ce3 4862 TGeoShape* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
9b0c60ab 4863 nendcapcoverplateholedges,holesection);
4864 TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
e21cdd03 4865 endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 4866 endcapcoverplatebighole->SetLineColor(6);
4867 //////////////////////////
4868 // Screw Piece Definition
4869 //////////////////////////
4870 Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
4871 TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
4872 CosD(0.5*smallscrewangle),
4873 0.5*fgkEndCapCoverPlateThickness);
4874 TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
4875 endcapsmallscrewpieceshape,
4876 fSSDCoolingTubePhynox);
4877 endcapsmallscrewpiece->SetLineColor(fColorPhynox);
4878 ///////////////////
4879 // Box Definition
4880 ///////////////////
4881 TGeoBBox* endcapcoverplateboxshape[4];
4882 TGeoVolume* endcapcoverplatebox[4];
4883 Double_t boxorigin[5][3];
4884 boxorigin[0][0] = 0.;
4885 boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
4886 boxorigin[0][2] = 0.;
4887
4888 boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
4889 boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
4890 boxorigin[1][2] = 0.;
4891
4892 boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
4893 + fgkEndCapCoverPlateSmallHoleSeparation[1];
4894 boxorigin[2][1] = boxorigin[1][1];
4895 boxorigin[2][2] = 0.;
4896
4897 boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
4898 + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
4899 boxorigin[3][1] = boxorigin[1][1];
4900 boxorigin[3][2] = 0.;
4901
4902 endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4903 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
4904 - 2.*fgkEndCapCoverPlateSmallHoleRadius),
4905 0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
4906
4907 endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4908 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4909 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4910 + fgkEndCapCoverPlateSmallHoleRadius,
4911 0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
4912
4913 endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4914 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4915 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4916 + fgkEndCapCoverPlateSmallHoleRadius,
4917 0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
4918
4919 endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
4920 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4921 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4922 + fgkEndCapCoverPlateSmallHoleRadius,
4923 0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
4924
4925 endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
e21cdd03 4926 fSSDAlCoolBlockMedium);
9b0c60ab 4927 endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
e21cdd03 4928 fSSDAlCoolBlockMedium);
9b0c60ab 4929 endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
e21cdd03 4930 fSSDAlCoolBlockMedium);
9b0c60ab 4931 endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
e21cdd03 4932 fSSDAlCoolBlockMedium);
9b0c60ab 4933 endcapcoverplatebox[0]->SetLineColor(6);
4934 endcapcoverplatebox[1]->SetLineColor(6);
4935 endcapcoverplatebox[2]->SetLineColor(6);
4936 endcapcoverplatebox[3]->SetLineColor(6);
4937 Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
4938 TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4939 fgkEndCapCoverPlateSmallHoleRadius,
4940 0.5*fgkEndCapCoverPlateThickness,
4941 endcapfillingboxorigin);
4942 TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
e21cdd03 4943 fSSDAlCoolBlockMedium);
9b0c60ab 4944 endcapfillingbox->SetLineColor(6);
4945 ////////////////////////////
851c0ce3 4946 // Contour shape Definition
9b0c60ab 4947 ////////////////////////////
4948 const Int_t kcontourvertexnumber = 10;
4949 Double_t xcontourvertex[kcontourvertexnumber];
4950 Double_t ycontourvertex[kcontourvertexnumber];
4951 xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
4952 xcontourvertex[1] = xcontourvertex[0];
4953 xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
4954 xcontourvertex[3] = xcontourvertex[2];
4955 xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
4956 xcontourvertex[5] = xcontourvertex[4];
4957 xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
4958 xcontourvertex[7] = xcontourvertex[6];
4959 xcontourvertex[8] = xcontourvertex[4];
4960 xcontourvertex[9] = xcontourvertex[8];
4961 ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
4962 - (kendcapcoverplatesmallholenumber[1]-1)
4963 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
4964 ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
4965 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
4966 ycontourvertex[2] = ycontourvertex[1];
4967 ycontourvertex[3] = ycontourvertex[0];
4968 ycontourvertex[4] = ycontourvertex[3];
4969 ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
4970 ycontourvertex[6] = ycontourvertex[5];
4971 ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
4972 * fgkEndCapCoverPlateSmallHoleSeparation[2]
4973 + fgkEndCapCoverPlateSmallHoleRadius;
4974 ycontourvertex[8] = ycontourvertex[7];
4975 ycontourvertex[9] = ycontourvertex[0];
851c0ce3 4976
4977 Double_t xboxin, dxboxin, yboxin, dyboxin;
4978 Double_t xboxout, dxboxout, yboxout, dyboxout;
4979 Double_t coordmin, coordmax;
4980 coordmin = -fgkEndCapCoverPlateLength[0];
4981 coordmax = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
4982 xboxout = 0.5*(coordmin+coordmax);
4983 dxboxout = 0.5*(coordmax-coordmin);
4984 coordmin = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
4985 - (kendcapcoverplatesmallholenumber[1]-1)
4986 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
4987 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
4988 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
4989 yboxout = 0.5*(coordmin+coordmax);
4990 dyboxout = 0.5*(coordmax-coordmin);
4991 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
4992 coordmax = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
4993 xboxin = 0.5*(coordmin+coordmax);
4994 dxboxin = 0.5*(coordmax-coordmin);
4995 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
4996 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
4997 * fgkEndCapCoverPlateSmallHoleSeparation[2]
4998 + fgkEndCapCoverPlateSmallHoleRadius;
4999 yboxin = 0.5*(coordmin+coordmax);
5000 dyboxin = 0.5*(coordmax-coordmin);
5001 new TGeoBBox("EndCapCoverPlateContourBoxOut", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5002 TGeoTranslation *trendCapCoverPlateContourboxout = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut",
5003 xboxout, yboxout, 0.);
5004 trendCapCoverPlateContourboxout->RegisterYourself();
5005 new TGeoBBox("EndCapCoverPlateContourBoxIn", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5006 TGeoTranslation *trendCapCoverPlateContourboxin = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn",
5007 xboxin, yboxin, 0.);
5008 trendCapCoverPlateContourboxin->RegisterYourself();
5009 TGeoCompositeShape *contourshape = new TGeoCompositeShape("contourShape",
5010 "EndCapCoverPlateContourBoxOut:SSD_trEndCapCoverPlateContourBoxOut-EndCapCoverPlateContourBoxIn:SSD_trEndCapCoverPlateContourBoxIn");
5011
e21cdd03 5012 TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
5013 fSSDAlCoolBlockMedium);
9b0c60ab 5014 contour->SetLineColor(6);
5015 /////////////////////////////
851c0ce3 5016 // Hole Contour Shape Definition
9b0c60ab 5017 ////////////////////////////
851c0ce3 5018 coordmin = xcontourvertex[0];
5019 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5020 xboxout = 0.5*(coordmin+coordmax);
5021 dxboxout = 0.5*(coordmax-coordmin);
5022 coordmin = ycontourvertex[1];
5023 coordmax = ycontourvertex[1]+fgkEndCapCoverPlateWidth[2];
5024 yboxout = 0.5*(coordmin+coordmax);
5025 dyboxout = 0.5*(coordmax-coordmin);
5026 coordmin = xcontourvertex[0]+ 0.5*(fgkEndCapCoverPlateLength[2]
5027 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5028 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5029 xboxin = 0.5*(coordmin+coordmax);
5030 dxboxin = 0.5*(coordmax-coordmin);
5031 coordmin = ycontourvertex[1]+0.5*(fgkEndCapCoverPlateWidth[2]
5032 - 2.*fgkEndCapCoverPlateBigHoleRadius);;
5033 coordmax = coordmin +2.*fgkEndCapCoverPlateBigHoleRadius;
5034 yboxin = 0.5*(coordmin+coordmax);
5035 dyboxin = 0.5*(coordmax-coordmin);
5036 new TGeoBBox("EndCapCoverPlateContourBoxOut1", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5037 TGeoTranslation *trendCapCoverPlateContourboxout1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut1",
5038 xboxout, yboxout, 0.);
5039 trendCapCoverPlateContourboxout1->RegisterYourself();
5040 new TGeoBBox("EndCapCoverPlateContourBoxIn1", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5041 TGeoTranslation *trendCapCoverPlateContourboxin1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn1",
5042 xboxin, yboxin, 0.);
5043 trendCapCoverPlateContourboxin1->RegisterYourself();
5044 TGeoCompositeShape *contourshape1 = new TGeoCompositeShape("contourShape1",
5045 "EndCapCoverPlateContourBoxOut1:SSD_trEndCapCoverPlateContourBoxOut1-EndCapCoverPlateContourBoxIn1:SSD_trEndCapCoverPlateContourBoxIn1");
5046
5047
5048 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5049 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5050 xboxout = 0.5*(coordmin+coordmax);
5051 dxboxout = 0.5*(coordmax-coordmin);
5052 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5053 - fgkEndCapCoverPlateWidth[0]);
5054 coordmax = ycontourvertex[0];
5055 yboxout = 0.5*(coordmin+coordmax);
5056 dyboxout = 0.5*(coordmax-coordmin);
5057 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5]+ 0.5*(fgkEndCapCoverPlateLength[2]
5058 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5059 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5060 xboxin = 0.5*(coordmin+coordmax);
5061 dxboxin = 0.5*(coordmax-coordmin);
5062 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5063 - fgkEndCapCoverPlateWidth[0])+0.5*(fgkEndCapCoverPlateWidth[1]
5064 - fgkEndCapCoverPlateWidth[0]
5065 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5066 coordmax = coordmin+2.*fgkEndCapCoverPlateBigHoleRadius;
5067 yboxin = 0.5*(coordmin+coordmax);
5068 dyboxin = 0.5*(coordmax-coordmin);
5069 new TGeoBBox("EndCapCoverPlateContourBoxOut2", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5070 TGeoTranslation *trendCapCoverPlateContourboxout2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut2",
5071 xboxout, yboxout, 0.);
5072 trendCapCoverPlateContourboxout2->RegisterYourself();
5073 new TGeoBBox("EndCapCoverPlateContourBoxIn2", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5074 TGeoTranslation *trendCapCoverPlateContourboxin2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn2",
5075 xboxin, yboxin, 0.);
5076 trendCapCoverPlateContourboxin2->RegisterYourself();
5077 TGeoCompositeShape *contourshape2 = new TGeoCompositeShape("contourShape2",
5078 "EndCapCoverPlateContourBoxOut2:SSD_trEndCapCoverPlateContourBoxOut2-EndCapCoverPlateContourBoxIn2:SSD_trEndCapCoverPlateContourBoxIn2");
5079
5080// const Int_t kholecontourvertexnumber = 10;
5081
9b0c60ab 5082 Double_t xholecontourvertex[2][kcontourvertexnumber];
5083 Double_t yholecontourvertex[2][kcontourvertexnumber];
5084 xholecontourvertex[0][0] = xcontourvertex[0];
5085 xholecontourvertex[0][1] = xholecontourvertex[0][0];
5086 xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5087 xholecontourvertex[0][3] = xholecontourvertex[0][2];
5088 xholecontourvertex[0][4] = xholecontourvertex[0][0]
5089 + 0.5*(fgkEndCapCoverPlateLength[2]
5090 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5091 xholecontourvertex[0][5] = xholecontourvertex[0][4];
5092 xholecontourvertex[0][6] = xholecontourvertex[0][5]
5093 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5094 xholecontourvertex[0][7] = xholecontourvertex[0][6];
5095 xholecontourvertex[0][8] = xholecontourvertex[0][4];
5096 xholecontourvertex[0][9] = xholecontourvertex[0][8];
5097
5098 yholecontourvertex[0][0] = ycontourvertex[1];
5099 yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5100 yholecontourvertex[0][2] = yholecontourvertex[0][1];
5101 yholecontourvertex[0][3] = yholecontourvertex[0][0];
5102 yholecontourvertex[0][4] = yholecontourvertex[0][3];
5103 yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5104 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5105 yholecontourvertex[0][6] = yholecontourvertex[0][5];
5106 yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5107 yholecontourvertex[0][8] = yholecontourvertex[0][7];
5108 yholecontourvertex[0][9] = yholecontourvertex[0][0];
5109
5110 xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5111 xholecontourvertex[1][1] = xholecontourvertex[1][0];
5112 xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5113 xholecontourvertex[1][3] = xholecontourvertex[1][2];
5114 xholecontourvertex[1][4] = xholecontourvertex[1][0]
5115 + 0.5*(fgkEndCapCoverPlateLength[2]
5116 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5117 xholecontourvertex[1][5] = xholecontourvertex[1][4];
5118 xholecontourvertex[1][6] = xholecontourvertex[1][5]
5119 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5120 xholecontourvertex[1][7] = xholecontourvertex[1][6];
5121 xholecontourvertex[1][8] = xholecontourvertex[1][4];
5122 xholecontourvertex[1][9] = xholecontourvertex[1][8];
5123
5124 yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5125 - fgkEndCapCoverPlateWidth[0]);
5126 yholecontourvertex[1][1] = ycontourvertex[0];
5127 yholecontourvertex[1][2] = yholecontourvertex[1][1];
5128 yholecontourvertex[1][3] = yholecontourvertex[1][0];
5129 yholecontourvertex[1][4] = yholecontourvertex[1][3];
5130 yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5131 - fgkEndCapCoverPlateWidth[0]
5132 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5133 yholecontourvertex[1][6] = yholecontourvertex[1][5];
5134 yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5135 yholecontourvertex[1][8] = yholecontourvertex[1][7];
5136 yholecontourvertex[1][9] = yholecontourvertex[1][0];
5137
9b0c60ab 5138 TGeoVolume* holecontour[2];
851c0ce3 5139 holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",contourshape1,
e21cdd03 5140 fSSDAlCoolBlockMedium);
9b0c60ab 5141 holecontour[0]->SetLineColor(6);
851c0ce3 5142 holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",contourshape2,
e21cdd03 5143 fSSDAlCoolBlockMedium);
9b0c60ab 5144 holecontour[1]->SetLineColor(6);
5145 TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5146 + fgkEndCapCoverPlateLength[2],0.,0.);
5147 TGeoTranslation* bigholetrans[3];
5148 bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5149 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5150 bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5151 + fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5152 - fgkEndCapCoverPlateBigHoleRadius,0.0);
5153 bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5154 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5155 /////////////////////////////////
5156 // Mother Volume Xtru Definition
5157 /////////////////////////////////
5158 const Int_t kmothervertexnumber = 12;
5159 Double_t xmothervertex[kmothervertexnumber];
5160 Double_t ymothervertex[kmothervertexnumber];
5161 xmothervertex[0] = xcontourvertex[0];
5162 xmothervertex[1] = xmothervertex[0];
5163 xmothervertex[2] = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5164 xmothervertex[3] = xmothervertex[2];
5165 xmothervertex[4] = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5166 xmothervertex[5] = xmothervertex[4];
5167 xmothervertex[6] = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5168 xmothervertex[7] = xmothervertex[6];
5169 xmothervertex[8] = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5170 + fgkEndCapCoverPlateLength[2];
5171 xmothervertex[9] = xmothervertex[8];
5172 xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5173 xmothervertex[11] = xmothervertex[10];
5174
5175 ymothervertex[0] = ycontourvertex[0];
5176 ymothervertex[1] = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5177 ymothervertex[2] = ymothervertex[1];
5178 ymothervertex[3] = ycontourvertex[1];
5179 ymothervertex[4] = ymothervertex[3];
5180 ymothervertex[5] = ymothervertex[1];
5181 ymothervertex[6] = ymothervertex[5];
5182 ymothervertex[7] = ymothervertex[0];
5183 ymothervertex[8] = ymothervertex[7];
5184 ymothervertex[9] = ymothervertex[8]
5185 - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5186 ymothervertex[10] = ymothervertex[9];
5187 ymothervertex[11] = ymothervertex[8];
5188 TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5189 mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5190 mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5191 mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5192 TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5193 ////////////////////////////////////////
5194 // Adding Nodes
5195 ////////////////////////////////////////
5196// TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5197 TGeoTranslation*** endcapcoverplatesmallholetrans;
5198 endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5199 Double_t transx[4] = {0,
5200 fgkEndCapCoverPlateSmallHoleSeparation[0],
5201 fgkEndCapCoverPlateSmallHoleSeparation[0]
5202 + fgkEndCapCoverPlateSmallHoleSeparation[1],
5203 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5204 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
5205 Int_t index = 0;
5206 for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5207 endcapcoverplatesmallholetrans[i] =
5208 new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5209 for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5210 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5211 endcapcoverplatesmallholetrans[i][j] =
5212 new TGeoTranslation(transx[i],
5213 j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5214 if(index!=10){
5215 mothercoverplate->AddNode(endcapcoverplatesmallhole,
5216 index,endcapcoverplatesmallholetrans[i][j]);
5217 mothercoverplate->AddNode(endcapsmallscrewpiece,
5218 index,endcapcoverplatesmallholetrans[i][j]);
5219 }
5220 if(j<kendcapcoverplatesmallholenumber[1]-1)
5221 mothercoverplate->AddNode(endcapcoverplatebox[0],
5222 index,endcapcoverplatesmallholetrans[i][j]);
5223 }
5224 }
5225 mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5226 mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5227 mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5228 mothercoverplate->AddNode(endcapfillingbox,1);
5229 mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5230 mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5231 mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5232 mothercoverplate->AddNode(holecontour[0],1);
5233 mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5234 mothercoverplate->AddNode(holecontour[1],1);
5235 mothercoverplate->AddNode(contour,1);
045be90c 5236
5237 for (Int_t i = 0; i < kendcapcoverplatesmallholenumber[0]; i++)
5238 delete [] endcapcoverplatesmallholetrans[i];
5239 delete [] endcapcoverplatesmallholetrans;
9b0c60ab 5240 /////////////////////////////////
5241 return mothercoverplate;
5242 }
5243 ////////////////////////////////////////////////////////////////////////////////
5244 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5245 /////////////////////////////////////////////////////////////
5246 // Getting EndCap Cooling Tube
5247 /////////////////////////////////////////////////////////////
5248 TGeoTorus* endcapcoolingtubetorushape[5];
5249 TGeoVolume* endcapcoolingtubetorus[5];
5250 TGeoTube* endcapcoolingtubeshape[4];
5251 TGeoVolume* endcapcoolingtube[4];
a3f8715e 5252 char endcapcoolingtubetorusname[100];
5253 char endcapcoolingtubename[100];
9b0c60ab 5254 TGeoTorus* endcapcoolingwatertubetorushape[5];
5255 TGeoVolume* endcapcoolingwatertubetorus[5];
5256 TGeoTube* endcapcoolingwatertubeshape[4];
5257 TGeoVolume* endcapcoolingwatertube[4];
a3f8715e 5258 char endcapcoolingwatertubetorusname[100];
5259 char endcapcoolingwatertubename[100];
9b0c60ab 5260 for(Int_t i=0; i<5; i++){
045be90c 5261 snprintf(endcapcoolingtubetorusname,100,"EndCapCoolingTubeTorus%d",i+1);
5262 snprintf(endcapcoolingtubename,100,"EndCapCoolingTube%d",i+1);
5263 snprintf(endcapcoolingwatertubetorusname,100,"EndCapCoolingWaterTubeTorus%d",i+1);
5264 snprintf(endcapcoolingwatertubename,100,"EndCapCoolingWaterTube%d",i+1);
5265 if(i==3){
5266 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5267 fgkEndCapCoolingTubeRadiusMin,
5268 fgkEndCapCoolingTubeRadiusMax,
5269 90.0,fgkEndCapCoolingTubeAngle[3]);
5270 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5271 0.,fgkEndCapCoolingTubeRadiusMin,
5272 90.0,fgkEndCapCoolingTubeAngle[3]);
5273 }
5274 else{
5275 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5276 :fgkEndCapCoolingTubeAxialRadius[1],
5277 fgkEndCapCoolingTubeRadiusMin,
5278 fgkEndCapCoolingTubeRadiusMax,
5279 0.,fgkEndCapCoolingTubeAngle[i]);
5280 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5281 :fgkEndCapCoolingTubeAxialRadius[1],
5282 0.,fgkEndCapCoolingTubeRadiusMin,
5283 0.,fgkEndCapCoolingTubeAngle[i]);
9b0c60ab 5284 }
9b0c60ab 5285 endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5286 endcapcoolingtubetorushape[i],
5287 fSSDCoolingTubePhynox);
5288 endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5289 endcapcoolingwatertubetorushape[i],
5290 fSSDCoolingTubeWater);
5291 endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5292 endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5293 if(i<4){
5294 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5295 fgkEndCapCoolingTubeRadiusMax,
5296 0.5*fgkEndCapCoolingTubeLength[i]);
5297 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5298 0.5*fgkEndCapCoolingTubeLength[i]);
5299 endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5300 endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5301 endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5302 endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5303 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5304 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5305 }
5306 }
5307 TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5308 /////////////////////////////////////////
5309 // Transformation for Volume Positioning
5310 /////////////////////////////////////////
5311 TGeoCombiTrans* coolingtubecombitrans[6];
5312 TGeoRotation* coolingtuberot[8];
5313 TGeoTranslation* coolingtubetrans[6];
5314 TGeoHMatrix* coolingtubematrix[4];
5315 TGeoCombiTrans* torustubecombitrans[4];
5316 TGeoRotation* torustuberot[7];
5317 TGeoTranslation* torustubetrans[4];
5318 TGeoHMatrix* torustubematrix[5];
5319 TGeoCombiTrans* coolingwatertubecombitrans[6];
5320 TGeoRotation* coolingwatertuberot[8];
5321 TGeoTranslation* coolingwatertubetrans[6];
5322 TGeoHMatrix* coolingwatertubematrix[4];
5323 TGeoCombiTrans* toruswatertubecombitrans[4];
5324 TGeoRotation* toruswatertuberot[7];
5325 TGeoTranslation* toruswatertubetrans[4];
5326 TGeoHMatrix* toruswatertubematrix[5];
5327 for(Int_t i=0; i<8; i++){
5328 if(i<6){
5329 coolingtubetrans[i] = new TGeoTranslation();
5330 coolingwatertubetrans[i] = new TGeoTranslation();
5331 }
5332 if(i<8){
5333 coolingtuberot[i] = new TGeoRotation();
5334 coolingwatertuberot[i] = new TGeoRotation();
5335 }
5336 if(i<4){
5337 torustubetrans[i] = new TGeoTranslation();
5338 toruswatertubetrans[i] = new TGeoTranslation();
5339 }
5340 if(i<7){
5341 torustuberot[i] = new TGeoRotation();
5342 toruswatertuberot[i] = new TGeoRotation();
5343 }
5344 }
5345 /////////////////////////////////////////
5346 // Transformation for Inox Volume Positioning
5347 /////////////////////////////////////////
5348 coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5349 -endcapcoolingtubeshape[0]->GetDz(),0.);
5350 coolingtuberot[0]->SetAngles(0.,90.,0.);
5351 coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5352 *coolingtuberot[0]);
5353
5354 coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5355 coolingtuberot[1]->SetAngles(0.,90.,0.);
5356 coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5357 *coolingtuberot[1]);
5358
5359 coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5360 *CosD(fgkEndCapCoolingTubeAngle[0]),
5361 fgkEndCapCoolingTubeAxialRadius[0]
5362 *SinD(fgkEndCapCoolingTubeAngle[0]),
5363 0.);
5364 coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5365 coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5366 *coolingtuberot[2]);
5367
5368 coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5369 * (*coolingtubecombitrans[1]));
5370
5371 torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5372 endcapcoolingtubeshape[1]->GetDz());
5373 torustuberot[0]->SetAngles(0.,90.,0.);
5374 torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5375
5376 torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5377
5378 coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5379 -endcapcoolingtubeshape[2]->GetDz(),0.);
5380 coolingtuberot[3]->SetAngles(0.,90.,0.);
5381 coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5382 *coolingtuberot[3]);
5383 coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5384 coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5385 coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5386
5387 torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5388 endcapcoolingtubeshape[2]->GetDz());
5389 torustuberot[1]->SetAngles(0.,90.,0.);
5390 torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5391 torustuberot[2]->SetAngles(180.,0.,0.);
5392 torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5393 torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5394
5395 torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5396 -fgkEndCapCoolingTubeAxialRadius[0]);
5397 torustuberot[3]->SetAngles(0.,90.,0.);
5398 torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5399 torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5400 torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5401 torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5402
5403 coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5404 fgkEndCapCoolingTubeAxialRadius[0],0.);
5405 coolingtuberot[5]->SetAngles(90.,90.,-90.);
5406 coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5407 *coolingtuberot[5]);
5408 coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5409 coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5410 coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5411
5412 torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5413 endcapcoolingtubeshape[0]->GetDz());
5414 torustuberot[5]->SetAngles(0.,90.,0.);
5415 torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5416 torustuberot[6]->SetAngles(-90.,0.,0.);
5417 torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5418 torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5419
5420 coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5421 endcapcoolingtubeshape[3]->GetDz(),0.);
5422 coolingtuberot[6]->SetAngles(0.,90.,0.);
5423 coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5424 *coolingtuberot[6]);
5425 coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5426 coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5427 coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5428 /////////////////////////////////////////
5429 // Transformation for Water Volume Positioning
5430 /////////////////////////////////////////
5431 coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5432 -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5433 coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5434 coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5435 *coolingwatertuberot[0]);
5436
5437 coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5438 coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5439 coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5440 *coolingwatertuberot[1]);
5441
5442 coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5443 *CosD(fgkEndCapCoolingTubeAngle[0]),
5444 fgkEndCapCoolingTubeAxialRadius[0]
5445 *SinD(fgkEndCapCoolingTubeAngle[0]),
5446 0.);
5447 coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5448 coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5449 *coolingwatertuberot[2]);
5450
5451 coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5452 * (*coolingwatertubecombitrans[1]));
5453
5454 toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5455 endcapcoolingwatertubeshape[1]->GetDz());
5456 toruswatertuberot[0]->SetAngles(0.,90.,0.);
5457 toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5458 *toruswatertuberot[0]);
5459
5460 toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5461 * (*toruswatertubecombitrans[0]));
5462
5463 coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5464 -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5465 coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5466 coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5467 *coolingwatertuberot[3]);
5468 coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5469 coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5470 * (*coolingwatertubecombitrans[3]));
5471 coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5472
5473 toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5474 endcapcoolingwatertubeshape[2]->GetDz());
5475 toruswatertuberot[1]->SetAngles(0.,90.,0.);
5476 toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5477 *toruswatertuberot[1]);
5478 toruswatertuberot[2]->SetAngles(180.,0.,0.);
5479 toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5480 * (*toruswatertubecombitrans[1]));
5481 toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5482
5483 toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5484 -fgkEndCapCoolingTubeAxialRadius[0]);
5485 toruswatertuberot[3]->SetAngles(0.,90.,0.);
5486 toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5487 *toruswatertuberot[3]);
5488 toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5489 toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5490 * (*toruswatertubecombitrans[2]));
5491 toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5492
5493 coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5494 fgkEndCapCoolingTubeAxialRadius[0],0.);
5495 coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5496 coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5497 *coolingwatertuberot[5]);
5498 coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5499 coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5500 * (*coolingwatertubecombitrans[4]));
5501 coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5502
5503 toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5504 endcapcoolingwatertubeshape[0]->GetDz());
5505 toruswatertuberot[5]->SetAngles(0.,90.,0.);
5506 toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5507 *toruswatertuberot[5]);
5508 toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5509 toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5510 * (*toruswatertubecombitrans[3]));
5511 toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5512
5513 coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5514 endcapcoolingwatertubeshape[3]->GetDz(),0.);
5515 coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5516 coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5517 *coolingwatertuberot[6]);
5518 coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5519 coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5520 * (*coolingwatertubecombitrans[5]));
5521 coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5522 /////////////////////////////////////////
5523 // Positioning Volumes
5524 /////////////////////////////////////////
5525 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5526 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5527
5528 endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5529 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5530
5531 endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5532 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5533
5534 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5535 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5536
5537 endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5538 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5539
5540 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5541 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5542
5543 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5544 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5545
5546 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5547 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5548
5549 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5550 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5551
5552 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5553 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5554 /////////////////////////////////////////////////////////////
5555 // Deallocating memory
5556 /////////////////////////////////////////////////////////////
5557 for(Int_t i=0; i<8; i++){
5558 if(i<6){
5559 delete coolingtubetrans[i];
5560 delete coolingwatertubetrans[i];
5561 if(i!=0){
5562 delete coolingtubecombitrans[i];
5563 delete coolingwatertubecombitrans[i];
5564 }
5565 }
5566 if(i<8){
5567 delete coolingtuberot[i];
5568 delete coolingwatertuberot[i];
5569 }
5570 if(i<4){
5571 delete torustubetrans[i];
5572 delete toruswatertubetrans[i];
5573 delete torustubecombitrans[i];
5574 delete toruswatertubecombitrans[i];
5575 }
5576 if(i<7){
5577 delete torustuberot[i];
5578 delete toruswatertuberot[i];
5579 }
5580 }
5581 /////////////////////////////////////////////////////////////
5582 return endcapcoolingtubemother;
5583 }
5584 ////////////////////////////////////////////////////////////////////////////////
5585 TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5586 /////////////////////////////////////////////////////////////
5587 // Getting EndCap Cover Side
5588 /////////////////////////////////////////////////////////////
5589 const Int_t kendcapcoverholenumber[2] = {7,5};
5590 const Int_t kvertexnumber = 15;
5591 Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5592 xvertex[0] = 0.0;
5593 xvertex[1] = xvertex[0];
5594 xvertex[2] = fgkEndCapSideCoverLength[0];
5595 xvertex[3] = fgkEndCapSideCoverLength[1];
5596 xvertex[4] = xvertex[3];
5597 xvertex[5] = fgkEndCapSideCoverLength[2];
5598 xvertex[6] = xvertex[5];
5599 xvertex[7] = xvertex[2];
5600 xvertex[8] = xvertex[7];
5601 xvertex[9] = xvertex[6]-fgkEndCapSideCoverLength[0];
5602 xvertex[10] = xvertex[9];
5603 xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5604 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5605 * fgkEndCapSideCoverLength[4];
5606 xvertex[12] = xvertex[11];
5607 xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5608 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5609 * fgkEndCapSideCoverLength[4];
5610 xvertex[14] = xvertex[13];
5611 yvertex[0] = 0.0;
5612 yvertex[1] = fgkEndCapSideCoverWidth[0];
5613 yvertex[2] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5614 yvertex[3] = yvertex[2];
5615 yvertex[4] = fgkEndCapSideCoverWidth[1];
5616 yvertex[5] = yvertex[4];
5617 yvertex[6] = yvertex[0];
5618 yvertex[7] = yvertex[6];
5619 yvertex[8] = fgkEndCapSideCoverWidth[6];
5620 yvertex[9] = yvertex[8];
5621 yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5622 yvertex[11] = yvertex[10];
5623 yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5624 yvertex[13] = yvertex[12];
5625 yvertex[14] = yvertex[6];
851c0ce3 5626 TGeoXtru* endcapsidecovershapeout = new TGeoXtru(2);
5627 endcapsidecovershapeout->SetName("endcapsidecovershapeout");
5628 endcapsidecovershapeout->DefinePolygon(7,xvertex,yvertex);
5629 endcapsidecovershapeout->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5630 endcapsidecovershapeout->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5631 TGeoXtru* endcapsidecovershapein = new TGeoXtru(2);
5632 endcapsidecovershapein->SetName("endcapsidecovershapein");
5633 endcapsidecovershapein->DefinePolygon(6,&xvertex[8],&yvertex[8]);
5634 endcapsidecovershapein->DefineSection(0,-0.5*fgkEndCapSideCoverThickness-0.01);
5635 endcapsidecovershapein->DefineSection(1,0.5*fgkEndCapSideCoverThickness+0.01);
5636
5637
5638 TGeoCompositeShape* endcapsidecovershape = new TGeoCompositeShape("endcapsidecovershape", "endcapsidecovershapeout-endcapsidecovershapein");
9b0c60ab 5639 TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5640 endcapsidecovershape,fSSDCoolingTubePhynox);
5641 endcapsidecover->SetLineColor(fColorPhynox);
5642 ////////////////////////////////////////////
5643 // Defininition of Mother Volume
5644 ////////////////////////////////////////////
5645 const Int_t kmothervertexnumber = 7;
5646 Double_t xmothervertex[kmothervertexnumber];
5647 Double_t ymothervertex[kmothervertexnumber];
5648 for(Int_t i=0; i<kmothervertexnumber; i++){
5649 xmothervertex[i] = xvertex[i];
5650 ymothervertex[i] = yvertex[i];
5651 }
5652 TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5653 endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5654 endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5655 endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5656 TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5657 endcapsidecovermothershape,fSSDAir);
5658 ////////////////////////////////////////////
5659 endcapsidecovermother->AddNode(endcapsidecover,1);
5660 TGeoBBox* endcapsidecoverboxshape[4];
5661 endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5662 + (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5663 0.5*fgkEndCapSideCoverLength[4],
5664 0.5*fgkEndCapSideCoverThickness);
5665 endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5666 + (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5667 0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5668 - fgkEndCapSideCoverLength[4]),
5669 0.5*fgkEndCapSideCoverThickness);
5670 endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5671 0.5*fgkEndCapSideCoverLength[4],
5672 0.5*fgkEndCapSideCoverThickness);
5673 endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5674 0.5*fgkEndCapSideCoverWidth[5],
5675 0.5*fgkEndCapSideCoverThickness);
5676 TGeoVolume* endcapsidecoverbox[4];
5677 endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5678 endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5679 endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5680 endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5681 for(Int_t i=0; i<4; i++) endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5682// TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5683 TGeoTranslation** endcapsidecoverboxtrans;
5684 endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5685 endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5686 + fgkEndCapSideCoverLength[0],
5687 endcapsidecoverboxshape[0]->GetDY()
5688 + yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5689 endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5690 + xvertex[11],
5691 endcapsidecoverboxshape[1]->GetDY()
5692 + yvertex[12],0.);
5693 endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5694 + xvertex[11],
5695 endcapsidecoverboxshape[2]->GetDY()
5696 + yvertex[12]
5697 + 2.*endcapsidecoverboxshape[1]->GetDY()
5698 + fgkEndCapSideCoverWidth[5],0.);
5699 endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5700 endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5701 endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5702 for(Int_t i=0; i<2; i++)
5703 for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5704 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5705 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5706 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5707 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5708 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5709 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5710 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5711 }
5712 for(Int_t i=0; i<2; i++)
5713 for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5714 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5715 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5716 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5717 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5718 +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5719 +fgkEndCapSideCoverLength[4]),0.0);
5720 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5721 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5722 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5723 +i*(kendcapcoverholenumber[1]-1)+j]);
5724 }
b7bd9ab6 5725 delete [] endcapsidecoverboxtrans;
5726 return endcapsidecovermother;
9b0c60ab 5727 }
5728 ////////////////////////////////////////////////////////////////////////////////
5729 TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5730 ////////////////////////////////////////////////////////////////////////////////
5731 // Method returning Interface Card A, Interface Card B, Supply Card
5732 ////////////////////////////////////////////////////////////////////////////////
5733 /////////////////////
5734 // Supply Card
5735 /////////////////////
5736 // Electronic Board Back Al Plane
5737 const Int_t kelectboardbackvertexnumber = 8;
5738 Double_t xelectboardback[kelectboardbackvertexnumber];
5739 Double_t yelectboardback[kelectboardbackvertexnumber];
5740 xelectboardback[0] = 0.0;
5741 xelectboardback[1] = xelectboardback[0];
5742 xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5743 xelectboardback[3] = xelectboardback[2];
5744 xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5745 xelectboardback[5] = xelectboardback[4];
5746 xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5747 xelectboardback[7] = xelectboardback[6];
5748
5749 yelectboardback[0] = 0.0;
5750 yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5751 yelectboardback[2] = yelectboardback[1];
5752 yelectboardback[3] = yelectboardback[0];
5753 yelectboardback[4] = yelectboardback[3];
5754 yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5755 yelectboardback[6] = yelectboardback[5];
5756 yelectboardback[7] = yelectboardback[4];
5757 TGeoXtru* electboardbackshape = new TGeoXtru(2);
5758 electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5759 xelectboardback,yelectboardback);
5760 electboardbackshape->DefineSection(0,0.0);
5761 electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5762 TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5763 electboardbackshape,fSSDSupportRingAl);
5764 electboardback->SetLineColor(fColorAl);
5765 // Electronic Board Kapton Layer
5766 const Int_t kelectlayervertexnumber = 8;
5767 Double_t xelectlayer[kelectlayervertexnumber];
5768 Double_t yelectlayer[kelectlayervertexnumber];
5769 xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5770 xelectlayer[1] = xelectlayer[0];
5771 xelectlayer[2] = fgkEndCapCardElectBoardLength;
5772 xelectlayer[3] = xelectlayer[2];
5773 for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5774
5775 yelectlayer[0] = 0.0;
5776 yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5777 yelectlayer[2] = yelectlayer[1];
5778 yelectlayer[3] = yelectlayer[0];
5779 yelectlayer[4] = yelectlayer[3];
5780 yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5781 yelectlayer[6] = yelectlayer[5];
5782 yelectlayer[7] = yelectlayer[4];
5783 TGeoXtru* electlayershape = new TGeoXtru(2);
5784 electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5785 electlayershape->DefineSection(0,0.0);
5786 electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5787 TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5788 electlayershape,fSSDKaptonFlexMedium);
5789 electlayer->SetLineColor(fColorKapton);
5790 // JMD Connector Female
5791 const Int_t kjmdconnectorvertexnumber = 6;
5792 Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5793 Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5794 xjmdconnectorvertex[0] = 0.0;
5795 xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5796 xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5797 xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5798 xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5799 xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5800
5801 yjmdconnectorvertex[0] = 0.0;
5802 yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
5803 yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
5804 yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
5805 yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
5806 yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
5807 TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
5808 jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
5809 yjmdconnectorvertex);
5810 jmdconnectorshape->DefineSection(0,0.0);
5811 jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
5812 TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
5813 jmdconnectorshape,fSSDMountingBlockMedium);
5814 jmdconnector->SetLineColor(fColorG10);
5815 // Top Cable Connector
5816 const Int_t kcableconnectorvertexnumber = 8;
5817 Double_t xconnectorvertex[kcableconnectorvertexnumber];
5818 Double_t yconnectorvertex[kcableconnectorvertexnumber];
5819 xconnectorvertex[0] = 0.0;
5820 xconnectorvertex[1] = xconnectorvertex[0];
5821 xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
5822 xconnectorvertex[3] = xconnectorvertex[2];
5823 xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
5824 - fgkEndCapCardCableConnectorLength[2];
5825 xconnectorvertex[5] = xconnectorvertex[4];
5826 xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
5827 xconnectorvertex[7] = xconnectorvertex[6];
5828
5829 yconnectorvertex[0] = 0.0;
5830 yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
5831 yconnectorvertex[2] = yconnectorvertex[1];
5832 yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
5833 yconnectorvertex[4] = yconnectorvertex[3];
5834 yconnectorvertex[5] = yconnectorvertex[1];
5835 yconnectorvertex[6] = yconnectorvertex[5];
5836 yconnectorvertex[7] = yconnectorvertex[0];
5837 TGeoXtru* cableconnectorshape = new TGeoXtru(2);
5838 cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
5839 yconnectorvertex);
5840 cableconnectorshape->DefineSection(0,0.0);
5841 cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
5842 TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
5843 cableconnectorshape,fSSDMountingBlockMedium);
5844 cableconnector->SetLineColor(fColorG10);
5845 // Strip Connection
5846 TGeoBBox* endcapstripconnectionshape =
5847 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
5848 0.5*fgkEndCapStripConnectionThickness,
5849 0.5*fgkEndCapStripConnectionWidth);
5850 TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
5851 endcapstripconnectionshape,
5852 fSSDSupportRingAl);
5853 endcapstripconnection->SetLineColor(fColorAl);
5854 // Interface Card B
5855 const Int_t kcardBvertexnumber = 12;
5856 Double_t xcardBvertexnumber[kcardBvertexnumber];
5857 Double_t ycardBvertexnumber[kcardBvertexnumber];
5858
5859 xcardBvertexnumber[0] = 0.0;
5860 xcardBvertexnumber[1] = xcardBvertexnumber[0];
5861 xcardBvertexnumber[2] = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
5862 xcardBvertexnumber[3] = xcardBvertexnumber[2];
5863 xcardBvertexnumber[4] = xcardBvertexnumber[1];
5864 xcardBvertexnumber[5] = xcardBvertexnumber[4];
5865 xcardBvertexnumber[6] = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
5866 xcardBvertexnumber[7] = xcardBvertexnumber[6];
5867 xcardBvertexnumber[8] = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
5868 xcardBvertexnumber[9] = xcardBvertexnumber[8];
5869 xcardBvertexnumber[10] = xcardBvertexnumber[7];
5870 xcardBvertexnumber[11] = xcardBvertexnumber[10];
5871
5872 ycardBvertexnumber[0] = 0.0;
5873 ycardBvertexnumber[1] = fgkEndCapInterfaceCardBWidth[0];
5874 ycardBvertexnumber[2] = ycardBvertexnumber[1];
5875 ycardBvertexnumber[3] = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
5876 ycardBvertexnumber[4] = ycardBvertexnumber[3];
5877 ycardBvertexnumber[5] = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
5878 ycardBvertexnumber[6] = ycardBvertexnumber[5];
5879 ycardBvertexnumber[7] = ycardBvertexnumber[4];
5880 ycardBvertexnumber[8] = ycardBvertexnumber[7];
5881 ycardBvertexnumber[9] = ycardBvertexnumber[1];
5882 ycardBvertexnumber[10] = ycardBvertexnumber[9];
5883 ycardBvertexnumber[11] = ycardBvertexnumber[0];
5884
5885 TGeoXtru* interfacecardBshape = new TGeoXtru(2);
5886 interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
5887 interfacecardBshape->DefineSection(0,0.);
5888 interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
5889 TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
5890 fSSDMountingBlockMedium);
5891 interfacecardB->SetLineColor(46);
5892 // Interface Card B Electronic Board
5893 const Int_t kelectboardcardBvertexnumber = 14;
5894 Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
5895 Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
5896
5897 xelectboardcardBvertex[0] = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
5898 xelectboardcardBvertex[1] = xelectboardcardBvertex[0];
5899 xelectboardcardBvertex[2] = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
5900 xelectboardcardBvertex[3] = xelectboardcardBvertex[2];
5901 xelectboardcardBvertex[4] = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
5902 xelectboardcardBvertex[5] = xelectboardcardBvertex[4];
5903 xelectboardcardBvertex[6] = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
5904 xelectboardcardBvertex[7] = xelectboardcardBvertex[6];
5905 xelectboardcardBvertex[8] = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
5906 xelectboardcardBvertex[9] = xelectboardcardBvertex[8];
5907 xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
5908 xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
5909 xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
5910 xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
5911
5912 yelectboardcardBvertex[0] = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
5913 yelectboardcardBvertex[1] = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
5914 yelectboardcardBvertex[2] = yelectboardcardBvertex[1];
5915 yelectboardcardBvertex[3] = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
5916 yelectboardcardBvertex[4] = yelectboardcardBvertex[3];
5917 yelectboardcardBvertex[5] = yelectboardcardBvertex[2];
5918 yelectboardcardBvertex[6] = yelectboardcardBvertex[5];
5919 yelectboardcardBvertex[7] = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
5920 yelectboardcardBvertex[8] = yelectboardcardBvertex[7];
5921 yelectboardcardBvertex[9] = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
5922 yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
5923 yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
5924 yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
5925 yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
5926
5927 TGeoXtru* electboardcardBshape = new TGeoXtru(2);
5928 electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
5929 xelectboardcardBvertex,yelectboardcardBvertex);
5930 electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
5931 electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
5932 + fgkEndCapInterfaceElectBoardCardBThickness);
5933 TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
5934 fSSDSupportRingAl);
5935 electboardcardB->SetLineColor(fColorAl);
5936 // Generating Stiffener 2
5937 TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
5938 0.5*fgkEndCapStiffenerThickness,
5939 0.5*fgkEndCapStiffenerLength);
5940 TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
5941 endcapstiffener->SetLineColor(fColorAl);
5942 // Generating Mother Interface Card B Container
5943 const Int_t kinterfacecardBmothervertexnumber = 10;
5944 Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5945 Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5946
5947 xinterfacecardBmothervertex[0] = 0.0;
5948 xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
5949 xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
5950 + fgkEndCapInterfaceCardBThickness;
5951 xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
5952 xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
5953 + fgkEndCapInterfaceElectBoardCardBThickness;
5954 xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
5955 xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
5956 xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
5957 xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
5958 + fgkEndCapCardJMDConnectorLength[0];
5959 xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
5960
5961 yinterfacecardBmothervertex[0] = 0.0;
5962 yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
5963 + fgkEndCapInterfaceCardBWidth[1]
5964 + fgkEndCapInterfaceCardBWidth[2];
5965 yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
5966 yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
5967 yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
5968 yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
5969 yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
5970 yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
5971 + fgkEndCapCardJMDConnectorWidth[0]
5972 + fgkEndCapCardJMDConnectorWidth[1];
5973 yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
5974 yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
5975 TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
5976 interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
5977 xinterfacecardBmothervertex,
5978 yinterfacecardBmothervertex);
5979 interfacecardBmothershape->DefineSection(0,-1.e-15);
5980 interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
5981 TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
5982 interfacecardBmothershape,fSSDAir);
5983 electboardcardB->SetLineColor(fColorAl);
5984 // Positioning Volumes Mother Interface Card B Container
5985 TGeoRotation* interfacecardBrot = new TGeoRotation();
5986 TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
5987 interfacecardBrot->SetAngles(90.,-90.,-90.);
5988 interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
5989 TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
5990 TGeoRotation* electboardcardBrot = new TGeoRotation();
5991 TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
5992 electboardcardBrot->SetAngles(90.,90.,-90.);
5993 electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
5994 TGeoCombiTrans* electboardcardBcombitrans =
5995 new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
5996 interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
5997 interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
5998 TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
5999 jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6000 TGeoTranslation* jmdconnectorcardBtrans[3];
6001 TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6002 for(Int_t i=0; i<3; i++){
6003 jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6004 + fgkEndCapCardJMDConnectorLength[0],
6005 fgkEndCapCardElectBoardLayerWidth[1],
6006 0.5*fgkEndCapCardJMDConnectorThickness
6007 + 0.5*(fgkEndCapInterfaceCardBLength[1]
6008 - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6009 + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6010 jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6011 *jmdconnectorcardBrot);
6012 interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6013 }
6014 // Mother Supply Card Container
6015 TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6016 // Interface Card Container
6017 TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6018 // Placing Volumes in Mother Supply Card Container
6019 // JMD Connector Positioning
6020 TGeoTranslation* jmdconnectortrans[2];
6021 for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6022 jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6023 fgkEndCapCardElectBoardBackLength[0]
6024 - fgkEndCapCardJMDConnectorThickness
6025 - fgkEndCapCardJMDConnectorToLayer);
6026 TGeoRotation* jmdconnectorot = new TGeoRotation();
6027 jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6028 + 2.*fgkEndCapCardJMDConnectorLength[0]
6029 + 2.*fgkEndCapCardElectBoardLayerThickness,
6030 fgkEndCapCardElectBoardLayerWidth[1],
6031 fgkEndCapCardJMDConnectorThickness
6032 + fgkEndCapCardJMDConnectorToLayer);
6033 jmdconnectorot->SetAngles(90.,180.,-90);
6034 TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6035 * jmdconnectorot);
6036 mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6037 mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6038 // Top Cable Connector Placing
6039 TGeoRotation* cableconnectorot[2];
6040 for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6041 TGeoTranslation* cableconnectortrans[3];
6042 for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6043 cableconnectorot[0]->SetAngles(90.,0.,0.);
6044 cableconnectorot[1]->SetAngles(0.,-90.,0.);
6045 cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6046 TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6047 *cableconnectorot[0]);
6048 TGeoHMatrix* cableconnectormatrix[2];
6049 for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6050 new TGeoHMatrix((*cableconnectorot[1])
6051 *(*cableconnectorcombitrans));
6052 cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6053 - fgkEndCapCardCableConnectorThickness,
6054 fgkEndCapCardCableConnectorLength[0]
6055 + fgkEndCapCardCableConnectorToLayer);
6056 cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6057 - 2.*fgkEndCapCardCableConnectorThickness
6058 - fgkEndCapCardCableConnectorDistance,
6059 fgkEndCapCardCableConnectorLength[0]
6060 + fgkEndCapCardCableConnectorToLayer);
6061 for(Int_t i=0; i<2; i++){
6062 cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6063 mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6064 }
6065 TGeoRotation* electboardbackrot = new TGeoRotation();
6066 TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6067 electboardbackrot->SetAngles(90.,-90.,-90.);
6068 electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6069 + fgkEndCapCardJMDConnectorLength[0]
6070 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6071 TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6072 *electboardbackrot);
6073 mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6074 // Electronic Board Kapton Layer Positioning
6075 TGeoRotation* electlayerrot = new TGeoRotation();
6076 TGeoTranslation* electlayertrans[2];
6077 TGeoCombiTrans* electlayercombitrans[2];
6078 for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6079 electlayerrot->SetAngles(90.,-90.,-90.);
6080 electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6081 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6082 electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6083 + 2.*fgkEndCapCardElectBoardLayerThickness
6084 + fgkEndCapCardElectBoardBackThickness,0.,0.);
6085 for(Int_t i=0; i<2; i++){
6086 electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6087 mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6088 }
6089 // Placing Volumes in Mother Interface Card Container
6090 motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6091 motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6092 for(Int_t i=0; i<2; i++){
6093 motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6094 }
6095 /////////////////////////////////////////////////////////////
6096 // Generation of Card Interface Container
6097 /////////////////////////////////////////////////////////////
6098 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6099 - fgkEndCapCardJMDConnectorLength[0]
6100 - fgkEndCapInterfaceCardBThickness
6101 - 9.*fgkEndCapStripConnectionThickness
6102 - 8.*fgkEndCapCardElectBoardBackThickness;
6103 const Int_t kcardinterfacecontainervertexnumber = 14;
6104 Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6105 Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6106 xcardinterfacecontainervertex[0] =-6.5*fgkEndCapCardElectBoardBackThickness
6107 - 7.0*fgkEndCapStripConnectionThickness;
6108 xcardinterfacecontainervertex[1] = xcardinterfacecontainervertex[0];
6109 xcardinterfacecontainervertex[2] = xcardinterfacecontainervertex[1]
6110 + fgkEndCapStripConnectionThickness
6111 - fgkEndCapCardElectBoardLayerThickness
6112 - fgkEndCapCardCableConnectorWidth[0];
6113 xcardinterfacecontainervertex[3] = xcardinterfacecontainervertex[2];
6114 xcardinterfacecontainervertex[4] = xcardinterfacecontainervertex[1];
6115 xcardinterfacecontainervertex[5] = xcardinterfacecontainervertex[4];
6116 xcardinterfacecontainervertex[6] = 1.5*fgkEndCapCardElectBoardBackThickness
6117 + 2.0*fgkEndCapStripConnectionThickness;
6118 xcardinterfacecontainervertex[7] = xcardinterfacecontainervertex[6];
6119 xcardinterfacecontainervertex[8] = xcardinterfacecontainervertex[7]
6120 + fgkEndCapInterfaceCardBThickness;
6121 xcardinterfacecontainervertex[9] = xcardinterfacecontainervertex[8];
6122 xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6123 + fgkEndCapInterfaceElectBoardCardBThickness;
6124 xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6125 xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6126 - fgkEndCapInterfaceElectBoardCardBThickness
6127 + fgkEndCapCardJMDConnectorLength[0]
6128 + stiffenertransx+fgkEndCapStiffenerWidth;
6129 xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6130
6131 ycardinterfacecontainervertex[0] = 0.;
6132 ycardinterfacecontainervertex[1] = fgkEndCapCardElectBoardLayerWidth[1]
6133 + fgkEndCapCardJMDConnectorWidth[0]
6134 + fgkEndCapCardJMDConnectorWidth[1];
6135 ycardinterfacecontainervertex[2] = ycardinterfacecontainervertex[1];
6136 ycardinterfacecontainervertex[3] = fgkEndCapCardElectBoardBackWidth[0]
6137 - fgkEndCapStripConnectionWidth;
6138 ycardinterfacecontainervertex[4] = ycardinterfacecontainervertex[3];
6139 ycardinterfacecontainervertex[5] = fgkEndCapCardElectBoardBackWidth[0];
6140 ycardinterfacecontainervertex[6] = ycardinterfacecontainervertex[5];
6141 ycardinterfacecontainervertex[7] = fgkEndCapInterfaceCardBWidth[0]
6142 + fgkEndCapInterfaceCardBWidth[1]
6143 + fgkEndCapInterfaceCardBWidth[2];
6144 ycardinterfacecontainervertex[8] = ycardinterfacecontainervertex[7];
6145 ycardinterfacecontainervertex[9] = yelectboardcardBvertex[3];
6146 ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6147 ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6148 ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6149 ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6150
6151 TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6152 interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6153 xcardinterfacecontainervertex,
6154 ycardinterfacecontainervertex);
6155 interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6156 - fgkEndCapCardElectBoardBackLength[0]));
6157 interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6158 + fgkEndCapCardElectBoardBackLength[0]));
6159 TGeoVolume** cardinterfacecontainer;
6160 cardinterfacecontainer = new TGeoVolume*[4];
6161 cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6162 interfacecardmothershape,fSSDAir);
6163 cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6164 interfacecardmothershape,fSSDAir);
6165 cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6166 interfacecardmothershape,fSSDAir);
6167 cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6168 interfacecardmothershape,fSSDAir);
6169 /////////////////////////////////
6170 // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6171 // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6172 // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6173 // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6174 /////////////////////////////////
6175 TGeoRotation* endcapstripconnectionrot[2];
6176 for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6177 endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6178 endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6179 TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6180 * (*endcapstripconnectionrot[0]));
6181 TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6182 endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6183 -0.5*fgkEndCapCardElectBoardBackThickness,
6184 fgkEndCapCardElectBoardBackWidth[0]
6185 -endcapstripconnectionshape->GetDZ(),
6186 0.5*fgkEndCapCardElectBoardBackLength[0]);
6187 endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6188 TGeoTranslation* cardinterfacetrans[9];
6189 TGeoHMatrix* cardinterfacematrix[9];
6190 for(Int_t i=0; i<7; i++){
6191 cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6192 + fgkEndCapCardElectBoardBackThickness),
6193 0.0,0.0);
6194 cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6195 * (*endcapstripconnectionmatrix));
6196 }
6197 cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6198 + fgkEndCapCardElectBoardBackThickness),
6199 0.0,0.0);
6200 cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6201 * (*endcapstripconnectionmatrix));
6202 cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6203 + fgkEndCapCardElectBoardBackThickness),
6204 0.0,0.0);
6205 cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6206 * (*endcapstripconnectionmatrix));
6207
6208 for(Int_t i=0; i<4; i++){
6209 cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6210 cardinterfacematrix[7]);
6211 cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6212 cardinterfacematrix[8]);
6213 }
6214 TGeoTranslation* mothersupplycardtrans =
6215 new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6216 + 2.*fgkEndCapCardJMDConnectorLength[0]
6217 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6218 TGeoHMatrix* mothersupplycardmatrix[7];
6219 Int_t index[4] = {1,1,1,1};
6220 for(Int_t i=0; i<7; i++){
6221 mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6222 * (*mothersupplycardtrans));
6223 for(Int_t j=0; j<4; j++){
6224 switch(j){
6225 case 0: //Layer5 EndCap Left Side
6226 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6227 cardinterfacematrix[i]);
6228 if(i!=0){
6229 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6230 mothersupplycardmatrix[i]);
6231 index[j]++;
6232
6233 }
6234 break;
6235 case 1: //Layer5 EndCap Rigth Side
6236 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6237 cardinterfacematrix[i]);
6238 if(i>0&&i<6){
6239 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6240 mothersupplycardmatrix[i]);
6241 index[j]++;
6242 }
6243 break;
6244 case 2: //Layer6 EndCap Left Side
6245 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6246 cardinterfacematrix[i]);
6247 if(i!=6){
6248 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6249 mothersupplycardmatrix[i]);
6250 index[j]++;
6251 }
6252 break;
6253 case 3: //Layer6 EndCap Right Side
6254 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6255 cardinterfacematrix[i]);
6256 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6257 mothersupplycardmatrix[i]);
6258 index[j]++;
6259 break;
6260 }
6261 }
6262 }
6263 // Positioning Interface
6264 TGeoTranslation* motherinterfacecardtrans =
6265 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6266 +0.5*fgkEndCapCardElectBoardBackThickness
6267 -fgkEndCapCardElectBoardLayerThickness
6268 +fgkEndCapStripConnectionThickness,0.,0.);
6269 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6270 motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6271 // Positioning Interface Card B
6272 TGeoTranslation* interfacecardBmothertrans =
6273 new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6274 + 2.*fgkEndCapStripConnectionThickness
6275 + fgkEndCapCardElectBoardBackThickness,0.,
6276 -0.5 * (fgkEndCapInterfaceCardBLength[1]
6277 - fgkEndCapCardElectBoardBackLength[0]));
6278 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6279 interfacecardBmothertrans);
6280 // Positioning Stiffener
6281 TGeoTranslation* endcapstiffenertrans =
6282 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6283 + 2.0*fgkEndCapStripConnectionThickness
6284 + fgkEndCapInterfaceCardBThickness
6285 + fgkEndCapCardJMDConnectorLength[0]
6286 + stiffenertransx
6287 + endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6288 endcapstiffenershape->GetDZ()
6289 - 0.5*(fgkEndCapStiffenerLength
6290 - fgkEndCapCardElectBoardBackLength[0]));
6291 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6292 /////////////////////////////////////////////////////////////
6293 // Deallocating memory
6294 /////////////////////////////////////////////////////////////
6295 delete interfacecardBrot;
6296 delete interfacecardBtrans;
6297 delete electboardcardBtrans;
6298 delete electboardcardBrot;
6299 delete jmdconnectorcardBrot;
6300 for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6301 delete jmdconnectorot;
6302 delete jmdconnectortrans[1];
6303 for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6304 delete cableconnectorcombitrans;
6305 delete electboardbacktrans;
6306 delete electboardbackrot;
6307 delete electlayerrot;
6308 for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6309 for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6310 delete mothersupplycardtrans;
6311 for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6312 /////////////////////////////////////////////////////////////
6313 return cardinterfacecontainer;
6314 }
6315 ////////////////////////////////////////////////////////////////////////////////
6316 TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6317 /////////////////////////////////////////////////////////////
6318 // Method returning EndCap Mother Volume
6319 /////////////////////////////////////////////////////////////
6320 const Int_t kendcapcoverplatesmallholenumber = 9;
6321 Double_t endcapmotherorigin[3];
6322 endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6323 + 0.5 *(fgkEndCapCoverPlateLength[3]
6324 + 2.0 * fgkEndCapCoverPlateLength[2]);
6325 endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6326 - fgkEndCapCoverPlateWidth[2]
6327 - (kendcapcoverplatesmallholenumber-1)
6328 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6329 + 0.5*(fgkEndCapSideCoverLength[2]
6330 + fgkEndCapCoverPlateWidth[1]
6331 - fgkEndCapCoverPlateWidth[0])
6332 - (fgkEndCapCoverPlateWidth[1]
6333 - fgkEndCapCoverPlateWidth[0]);
6334 endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6335 + 2.*fgkEndCapCoolingTubeRadiusMax
6336 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6337 + fgkEndCapSideCoverWidth[1]
6338 + fgkEndCapSideCoverThickness
6339 + fgkEndCapKaptonFoilThickness);
6340 TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6341 + 2.0* fgkEndCapCoverPlateLength[2]
6342 + 2.0* fgkEndCapSideCoverThickness),
6343 0.5* (fgkEndCapSideCoverLength[2]
6344 + fgkEndCapCoverPlateWidth[1]
6345 - fgkEndCapCoverPlateWidth[0]),
6346 0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6347 + fgkEndCapSideCoverWidth[1]
6348 + fgkEndCapSideCoverThickness
6349 + fgkEndCapKaptonFoilThickness),
6350 endcapmotherorigin);
6351 TGeoVolume** endcapassembly;
6352 endcapassembly = new TGeoVolume*[4];
6353 endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6354 endcapmothershape,fSSDAir);
6355 endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6356 endcapmothershape,fSSDAir);
6357 endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6358 endcapmothershape,fSSDAir);
6359 endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6360 endcapmothershape,fSSDAir);
6361 /////////////////////////////////
6362 // endcapassembly[0]: Container End Cap Layer 5 Bellegarde Side
6363 // endcapassembly[1]: Container End Cap Layer 5 Gex Side
6364 // endcapassembly[2]: Container End Cap Layer 6 Bellegarde Side
6365 // endcapassembly[3]: Container End Cap Layer 6 Gex Side
6366 /////////////////////////////////
6367 /////////////////////////////////////////////////////
6368 // Placing Endcap Cover Plate
6369 /////////////////////////////////////////////////////
6370 TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6371 TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6372 endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6373 TGeoCombiTrans* endcapcoverplatecombitrans =
6374 new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6375 endcapcoverplaterot);
6376 TGeoTranslation* endcapcoverplatetrans =
6377 new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6378 TGeoHMatrix* endcapcoverplatematrix =
6379 new TGeoHMatrix((*endcapcoverplatetrans)
6380 * (*endcapcoverplatecombitrans));
6381 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6382 /////////////////////////////////////////////////////
6383 // Placing Endcap Side Cover
6384 /////////////////////////////////////////////////////
6385 TGeoVolume* endcapsidecover = GetEndCapSideCover();
6386 TGeoRotation* endcapsidecoverot[2];
6387 TGeoCombiTrans* endcapsidecovercombitrans[3];
6388 for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6389 endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6390 endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6391 - 0.5*(fgkEndCapCoverPlateWidth[0]
6392 - fgkEndCapCoverPlateWidth[2]
6393 - (kendcapcoverplatesmallholenumber-1)
6394 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6395 + 0.*fgkEndCapCoverPlateWidth[0]
6396 + fgkEndCapSideCoverLength[2],
6397 0.5*(fgkEndCapSideCoverThickness
6398 + fgkEndCapCoverPlateThickness)
6399 - 0.5*fgkEndCapCoverPlateThickness,
6400 endcapsidecoverot[0]);
6401 endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6402 endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6403 0.5*fgkEndCapCoverPlateThickness
6404 -fgkEndCapSideCoverWidth[1],
6405 endcapsidecoverot[1]);
6406 endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6407 +fgkEndCapCoverPlateLength[3]
6408 +2.*fgkEndCapCoverPlateLength[2]
6409 +fgkEndCapSideCoverThickness,0.0,
6410 0.5*fgkEndCapCoverPlateThickness
6411 -fgkEndCapSideCoverWidth[1],
6412 endcapsidecoverot[1]);
6413 TGeoHMatrix* endcapsidecovermatrix[2];
6414 for(Int_t i=0; i<2; i++){
6415 endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6416 * (*endcapsidecovercombitrans[0]));
6417 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6418 endcapsidecovermatrix[i]);
6419 }
6420 /////////////////////////////////////////////////////
6421 // Placing Endcap Cooling Tube
6422 /////////////////////////////////////////////////////
6423 TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6424 TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6425 endcapcoolingtuberot->SetAngles(0.,180.,0.);
6426 TGeoCombiTrans* endcapccolingtubecombitrans
6427 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6428 + fgkEndCapCoolingTubeAxialRadius[1])
6429 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6430 - fgkEndCapCoolingTubeToCoverSide,
6431 fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6432 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6433 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6434 endcapccolingtubecombitrans);
6435 /////////////////////////////////////////////////////
6436 // Placing Screws
6437 /////////////////////////////////////////////////////
6438 Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6439 fgkEndCapCoverPlateScrewRadiusMin};
6440 Int_t screwcoverplatedgesnumber[2] = {20,20};
6441 Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6442 fgkEndCapCoverPlateThickness
6443 + fgkEndCapCoolingTubeRadiusMax};
851c0ce3 6444 TGeoShape* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
9b0c60ab 6445 screwcoverplatedgesnumber,
6446 screwcoverplatesection);
6447 TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6448 screwcoverplateshape,
6449 fSSDCoolingTubePhynox);
6450 screwcoverplate->SetLineColor(12);
6451 Double_t transx[4] = {0,
6452 fgkEndCapCoverPlateSmallHoleSeparation[0],
6453 fgkEndCapCoverPlateSmallHoleSeparation[0]
6454 + fgkEndCapCoverPlateSmallHoleSeparation[1],
6455 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6456 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
6457 const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6458// TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6459 TGeoTranslation*** endcapcoverplatescrewtrans;
6460 endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6461 Int_t index = 0;
6462 for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6463 endcapcoverplatescrewtrans[i] =
6464 new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6465 for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6466 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6467 if(index==1||index==9||index==28||index==36){
6468 endcapcoverplatescrewtrans[i][j] =
6469 new TGeoTranslation(transx[i],
6470 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6471 fgkEndCapSideCoverThickness);
6472 }
6473 else{
6474 endcapcoverplatescrewtrans[i][j] =
6475 new TGeoTranslation(transx[i],
6476 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6477 0.);
6478 }
6479 if(index!=19)
6480 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6481 endcapcoverplatescrewtrans[i][j]);
6482 }
6483 }
6484 /////////////////////////////////////////////////////
6485 // Placing Cover Plate Clips
6486 /////////////////////////////////////////////////////
6487 TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6488 0.5*fgkEndCapCoverPlateClipWidth,
6489 0.5*fgkEndCapSideCoverThickness);
6490 TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6491 endcapcoverplateclipshape,
6492 fSSDCoolingTubePhynox);
6493 TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6494 0.5*fgkEndCapCoverPlateDownClipWidth,
6495 0.5*fgkEndCapSideCoverThickness);
6496 TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6497 endcapcoverplatedownclipshape,
6498 fSSDCoolingTubePhynox);
6499 TGeoTranslation* endcapcoverplatecliptrans[4];
6500 endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6501 - fgkEndCapCoverPlateLength[0]
6502 - fgkEndCapSideCoverThickness,
6503 0.0,
6504 0.5*(fgkEndCapSideCoverThickness
6505 + fgkEndCapCoverPlateThickness));
6506 endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6507 - fgkEndCapCoverPlateLength[0]
6508 - fgkEndCapSideCoverThickness,
6509 (kendcapcoverplatescrewnumber[1]-1)
6510 * fgkEndCapSideCoverWidth[5],
6511 0.5*(fgkEndCapSideCoverThickness
6512 + fgkEndCapCoverPlateThickness));
6513 endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6514 - fgkEndCapCoverPlateLength[0]
6515 + fgkEndCapCoverPlateLength[1]
6516 + 2.*fgkEndCapCoverPlateLength[0]
6517 - fgkEndCapCoverPlateClipLength
6518 + fgkEndCapSideCoverThickness,
6519 0.0,
6520 0.5*(fgkEndCapSideCoverThickness
6521 + fgkEndCapCoverPlateThickness));
6522 endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6523 - fgkEndCapCoverPlateLength[0]
6524 + fgkEndCapCoverPlateLength[1]
6525 + 2.*fgkEndCapCoverPlateLength[0]
6526 - fgkEndCapCoverPlateClipLength
6527 + fgkEndCapSideCoverThickness,
6528 (kendcapcoverplatescrewnumber[1]-1)
6529 * fgkEndCapSideCoverWidth[5],
6530 0.5*(fgkEndCapSideCoverThickness
6531 + fgkEndCapCoverPlateThickness));
6532 endcapcoverplateclip->SetLineColor(fColorPhynox);
6533 endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6534 for(Int_t i=0; i<4; i++)
6535 for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6536 endcapcoverplatecliptrans[i]);
6537 TGeoTranslation* endcapcoverplatedowncliptrans[4];
6538 endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6539 - fgkEndCapCoverPlateLength[0]
6540 - fgkEndCapSideCoverThickness,
6541 0.5*(fgkEndCapCoverPlateDownClipWidth
6542 - fgkEndCapCoverPlateClipWidth),
6543 0.5*(fgkEndCapSideCoverThickness
6544 + fgkEndCapCoverPlateThickness)
6545 - fgkEndCapSideCoverWidth[1]
6546 - fgkEndCapSideCoverThickness);
6547 endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6548 - fgkEndCapCoverPlateLength[0]
6549 - fgkEndCapSideCoverThickness,
6550 0.5*(fgkEndCapCoverPlateDownClipWidth
6551 - fgkEndCapCoverPlateClipWidth)
6552 + fgkEndCapSideCoverLength[2]
6553 - fgkEndCapCoverPlateDownClipWidth,
6554 0.5*(fgkEndCapSideCoverThickness
6555 + fgkEndCapCoverPlateThickness)
6556 - fgkEndCapSideCoverWidth[1]
6557 - fgkEndCapSideCoverThickness);
6558 endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6559 - fgkEndCapCoverPlateLength[0]
6560 + fgkEndCapSideCoverThickness
6561 + fgkEndCapCoverPlateLength[1]
6562 + 2.0*fgkEndCapCoverPlateLength[0]
6563 - fgkEndCapCoverPlateDownClipLength,
6564 0.5*(fgkEndCapCoverPlateDownClipWidth
6565 - fgkEndCapCoverPlateClipWidth),
6566 0.5*(fgkEndCapSideCoverThickness
6567 + fgkEndCapCoverPlateThickness)
6568 - fgkEndCapSideCoverWidth[1]
6569 - fgkEndCapSideCoverThickness);
6570 endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6571 - fgkEndCapCoverPlateLength[0]
6572 + fgkEndCapSideCoverThickness
6573 + fgkEndCapCoverPlateLength[1]
6574 + 2.0*fgkEndCapCoverPlateLength[0]
6575 - fgkEndCapCoverPlateDownClipLength,
6576 0.5*(fgkEndCapCoverPlateDownClipWidth
6577 - fgkEndCapCoverPlateClipWidth)
6578 + fgkEndCapSideCoverLength[2]
6579 - fgkEndCapCoverPlateDownClipWidth,
6580 0.5*(fgkEndCapSideCoverThickness
6581 + fgkEndCapCoverPlateThickness)
6582 - fgkEndCapSideCoverWidth[1]
6583 - fgkEndCapSideCoverThickness);
6584 for(Int_t i=0; i<4; i++)
6585 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6586 endcapcoverplatedowncliptrans[i]);
6587 /////////////////////////////////////////////////////
6588 // Placing Kapton Foil
6589 /////////////////////////////////////////////////////
6590 TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6591 0.5*fgkEndCapKaptonFoilWidth,
6592 0.5*fgkEndCapKaptonFoilThickness);
6593 TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6594 endcapkaptonfoilshape,
6595 fSSDKaptonFlexMedium);
6596 endcapkaptonfoil->SetLineColor(8);
6597 TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6598 0.5*fgkEndCapKaptonFoilWidth
6599 - 0.5*fgkEndCapCoverPlateClipWidth,
6600 0.5*fgkEndCapCoverPlateThickness
6601 - 0.5*fgkEndCapKaptonFoilThickness
6602 - fgkEndCapSideCoverWidth[1]
6603 - fgkEndCapSideCoverThickness);
6604 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6605 /////////////////////////////////////////////////////////////
6606 // Placing Electronic Tubes
6607 /////////////////////////////////////////////////////////////
6608 Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6609 - fgkEndCapInterfaceCardBThickness
6610 - 9.*fgkEndCapStripConnectionThickness
6611 - 8.*fgkEndCapCardElectBoardBackThickness,
6612 fgkEndCapKaptonFoilWidth
6613 - fgkEndCapInterfaceCardBThickness
6614 - 9.*fgkEndCapStripConnectionThickness
6615 - 8.*fgkEndCapCardElectBoardBackThickness
6616 - fgkEndCapInterfaceElectBoardCardBThickness};
6617 TGeoVolume* endcapeffectivecables[2];
6618 endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6619 fgkEndCapEffectiveCableRadiusMax,
6620 endcapeffectivecableswidth[0],
6621 10,"EndCapEffectiveCables1");
6622 endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6623 fgkEndCapEffectiveCableRadiusMax,
6624 endcapeffectivecableswidth[1],
6625 25,"EndCapEffectiveCables2");
6626 TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6627 TGeoTranslation* endcapeffectivecablestrans[2];
6628 endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6629 - 0.5*endcapeffectivecableswidth[0]
6630 - 0.5*(fgkEndCapCoverPlateWidth[0]
6631 - fgkEndCapCoverPlateWidth[2]
6632 - (kendcapcoverplatesmallholenumber-1)
6633 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6634 + fgkEndCapSideCoverLength[2],
6635 - 0.5*fgkEndCapCoverPlateThickness
6636 - (fgkEndCapCardElectBoardBackWidth[0]
6637 - fgkEndCapInterfaceCardBWidth[0]
6638 - fgkEndCapInterfaceCardBWidth[1]));
6639 endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6640 - 0.5*endcapeffectivecableswidth[1]
6641 - 0.5*(fgkEndCapCoverPlateWidth[0]
6642 - fgkEndCapCoverPlateWidth[2]
6643 - (kendcapcoverplatesmallholenumber-1)
6644 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6645 + fgkEndCapSideCoverLength[2],
6646 - 0.5*fgkEndCapCoverPlateThickness
6647 - (fgkEndCapCardElectBoardBackWidth[0]
6648 - fgkEndCapInterfaceCardBWidth[0])
6649 - 0.5*fgkEndCapInterfaceCardBWidth[2]);
6650 endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6651 TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6652 endcapeffectivecablescombitrans[0] = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6653 *endcapeffectivecablesrot);
6654 endcapeffectivecablescombitrans[1] = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6655 *endcapeffectivecablesrot);
47f8de53 6656// for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6657// endcapeffectivecablescombitrans[0]);
9b0c60ab 6658 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6659 endcapeffectivecablescombitrans[1]);
6660 /////////////////////////////////////////////////////////////
6661 // Placing End Cap Cards
6662 /////////////////////////////////////////////////////////////
6663 TGeoVolume** endcapcards = GetEndCapCards();
6664 TGeoRotation* endcapcardsrot[2];
6665 for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6666 endcapcardsrot[0]->SetAngles(90.,0.,0.);
6667 TGeoTranslation* endcapcardstrans[2];
6668 endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6669 - fgkEndCapCardElectBoardBackLength[0]));
6670 TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6671 endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6672 TGeoHMatrix* endcapcardsmatrix[2];
6673 endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6674 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6675 - fgkEndCapCardJMDConnectorLength[0]
6676 - fgkEndCapInterfaceCardBThickness
6677 - 9.*fgkEndCapStripConnectionThickness
6678 - 8.*fgkEndCapCardElectBoardBackThickness;
6679 endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6680 - fgkEndCapCoverPlateLength[0]
6681 + 0.5 * (fgkEndCapCoverPlateLength[3]
6682 + 2.0 * fgkEndCapCoverPlateLength[2]),
6683 - stiffenertransx-fgkEndCapStiffenerWidth
6684 - fgkEndCapCardJMDConnectorLength[0]
6685 - fgkEndCapInterfaceCardBThickness
6686 - 2.0 * fgkEndCapStripConnectionThickness
6687 - 1.5 * fgkEndCapInterfaceCardBThickness
6688 - 0.5 * (fgkEndCapCoverPlateWidth[0]
6689 - fgkEndCapCoverPlateWidth[2]
6690 - (kendcapcoverplatesmallholenumber-1)
6691 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6692 + fgkEndCapKaptonFoilWidth,
6693 0.5*fgkEndCapCoverPlateThickness
6694 - fgkEndCapSideCoverWidth[1]);
6695 endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6696 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6697 /////////////////////////////////////////////////////////////
6698 // Deallocating memory
6699 /////////////////////////////////////////////////////////////
6700 delete endcapcoverplaterot;
6701 delete endcapcoverplatecombitrans;
6702 delete endcapcoverplatetrans;
6703 for(Int_t i=0; i<3; i++){
6704 delete endcapsidecovercombitrans[i];
6705 if(i<2) delete endcapsidecoverot[i];
6706 }
6707 for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6708 for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6709 delete endcapcardsmatrix[0];
6710 return endcapassembly;
6711 }
6712 ////////////////////////////////////////////////////////////////////////////////
6713 TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6714 Double_t radiusmax,
6715 Double_t width,
6716 Int_t ncables,
a6e0ebfe 6717 const char* volname){
9b0c60ab 6718 /////////////////////////////////////////////////////////////
6719 // Generating EndCap High Voltage Tubes
6720 /////////////////////////////////////////////////////////////
6721 Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
60e55aee 6722 Double_t effectiveouteradius = TMath::Sqrt(effectiveinneradius*effectiveinneradius+(radiusmax-radiusmin)*(radiusmax-radiusmin));
6723
9b0c60ab 6724 TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6725 TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6726 effectiveouteradius,0.5*width);
6727 TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6728 effectiveinnertubeshape,
6729 fSSDStiffenerConnectorMedium);
6730 effectiveinnertube->SetLineColor(41);
6731 TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6732 effectiveoutertubeshape,
6733 fSSDKaptonChipCableMedium);
6734 effectiveoutertube->SetLineColor(39);
6735 TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6736 TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6737 effectivemothertube->AddNode(effectiveinnertube,1);
6738 effectivemothertube->AddNode(effectiveoutertube,1);
6739 return effectivemothertube;
6740 }
6741 ////////////////////////////////////////////////////////////////////////////////
6742 TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6743 /////////////////////////////////////////////////////////////
6744 // Generating EndCap Support Layer 5 and Layer 6
6745 /////////////////////////////////////////////////////////////
6746 const Int_t knedges = 5;
6747 ///////////////////////////////////////////////
6748 // Setting the vertices for TGeoXtru Up Volume
6749 ///////////////////////////////////////////////
6750 const Int_t klayernumber = 2;
6751 Double_t xupvertex[klayernumber][knedges+3];
6752 Double_t yupvertex[klayernumber][knedges+3];
6753 Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6754 Double_t middledgeangle[klayernumber] = {0.0,0.0};
6755 Double_t middlepsi[klayernumber] = {0.0,0.0};
6756 for(Int_t i=0; i<klayernumber; i++){
6757 xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6758 xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6759 xupvertex[i][2] = -xupvertex[i][1];
6760 xupvertex[i][3] = -xupvertex[i][0];
6761
6762 yupvertex[i][0] = fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6763 yupvertex[i][1] = 0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6764 yupvertex[i][2] = yupvertex[i][1];
6765 yupvertex[i][3] = yupvertex[i][0];
6766
6767 middledgeangle[i] = upedgeangle[i]/knedges;
6768 middlepsi[i] = 90.0-0.5*upedgeangle[i];
6769 for(Int_t j=1; j<knedges; j++){
6770 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6771 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6772 }
6773 }
6774 ////////////////////////////////////
6775 // Generating Up TGeoXtru
6776 ////////////////////////////////////
6777 TGeoXtru* upendcapsupportshape[klayernumber];
6778 TGeoVolume* upendcapsupport[klayernumber];
a3f8715e 6779 char upendcapsupportname[100];
9b0c60ab 6780 for(Int_t i=0; i<klayernumber; i++){
6781 upendcapsupportshape[i] = new TGeoXtru(2);
045be90c 6782 snprintf(upendcapsupportname,100,"UpEndCapSupportPieceLayer%i",i+5);
9b0c60ab 6783 upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6784 upendcapsupportshape[i]->DefineSection(0,0.);
6785 upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6786 upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
e21cdd03 6787 fSSDSupportRingAl);
9b0c60ab 6788 upendcapsupport[i]->SetLineColor(5);
6789 }
6790 ///////////////////////////////////////////////
6791 // Setting the vertices for TGeoXtru Down Volume
6792 ///////////////////////////////////////////////
6793 Double_t xdownvertex[klayernumber][2*(knedges+1)];
6794 Double_t ydownvertex[klayernumber][2*(knedges+1)];
6795 for(Int_t i=0; i<klayernumber; i++){
6796 xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6797 xdownvertex[i][1] = xupvertex[i][0];
6798 ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6799 ydownvertex[i][1] = yupvertex[i][0];
6800 for(Int_t j=0; j<knedges; j++){
6801 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
6802 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
6803 }
6804 for(Int_t j=0; j<knedges; j++){
6805 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6806 * CosD(middlepsi[i]+j*middledgeangle[i]);
6807 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6808 * SinD(middlepsi[i]+j*middledgeangle[i]);
6809 }
6810 }
6811 ////////////////////////////////////
6812 // Generating Down TGeoXtru
6813 ////////////////////////////////////
6814 TGeoXtru* downendcapsupportshape[klayernumber];
6815 TGeoVolume* downendcapsupport[klayernumber];
a3f8715e 6816 char downendcapsupportname[100];
9b0c60ab 6817 for(Int_t i=0; i<klayernumber; i++){
6818 downendcapsupportshape[i] = new TGeoXtru(2);
045be90c 6819 snprintf(downendcapsupportname,100,"DownEndCapSupportPieceLayer%i",i+5);
9b0c60ab 6820 downendcapsupportshape[i] = new TGeoXtru(2);
6821 downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
6822 if(i==0){
6823 downendcapsupportshape[i]->DefineSection(0,0.);
6824 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
6825 }
6826 else{
6827 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
6828 - fgkEndCapSupportLowWidth[i]);
6829 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6830 }
6831 downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
e21cdd03 6832 downendcapsupportshape[i],fSSDSupportRingAl);
9b0c60ab 6833 downendcapsupport[i]->SetLineColor(5);
6834 }
6835 ///////////////////////////////////////////////
6836 // Setting TGeoPgon Volume
6837 ///////////////////////////////////////////////
6838 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6839 fgkSSDLay6LadderNumber};
6840 TGeoPgon* endcapsupportmothershape[klayernumber];
6841 TGeoVolume** endcapsupportmother;
6842 endcapsupportmother = new TGeoVolume*[klayernumber];
a3f8715e 6843 char endcapsupportmothername[100];
9b0c60ab 6844 for(Int_t i=0; i<klayernumber; i++){
6845 endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
045be90c 6846 snprintf(endcapsupportmothername,100,"EndCapSupportMotherLayer%i",i+5);
9b0c60ab 6847 endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
6848 endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
6849 ydownvertex[i][0],yupvertex[i][1]);
6850 endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
e21cdd03 6851 fSSDAir);
9b0c60ab 6852 }
6853 ////////////////////////////////////
6854 TGeoRotation** endcapsupportrot[klayernumber];
6855 for(Int_t i=0; i<2; i++){
6856 endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
6857 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6858 endcapsupportrot[i][j] = new TGeoRotation();
6859 endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
6860 endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
6861 endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
6862 }
6863 }
6864 return endcapsupportmother;
6865 }
6866 ////////////////////////////////////////////////////////////////////////////////
6867 void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
6868 /////////////////////////////////////////////////////////////
6869 // Setting End Cap Support Layer 5 and 6.
6870 /////////////////////////////////////////////////////////////
6871 const Int_t kendcapcoverplatesmallholenumber = 9;
6872 const Int_t klayernumber = 2;
6873 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6874 fgkSSDLay6LadderNumber};
6875 Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
6876 360.0/kssdlayladdernumber[1]};
6877 TGeoVolume** endcapsupport = EndCapSupport();
6878 TGeoVolume** endcapassembly = GetEndCapAssembly();
6879 TGeoPgon* endcapsupportshape[klayernumber];
6880 Double_t* radiusmin[klayernumber];
6881 Double_t* radiusmax[klayernumber];
6882 for(Int_t i=0; i<klayernumber; i++){
6883 endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
6884 radiusmin[i] = endcapsupportshape[i]->GetRmin();
6885 radiusmax[i] = endcapsupportshape[i]->GetRmax();
6886 }
6887 TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
6888 Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
6889 endcapassemblyshape->GetDY(),
6890 endcapassemblyshape->GetDZ()};
6891 ///////////////////////////////////////////////
6892 // Setting TGeoPgon Volume for Mother Container
6893 ///////////////////////////////////////////////
6894 TGeoPgon* endcapsupportsystemshape[klayernumber];
a3f8715e 6895 char endcapsupportsystemothername[100];
9b0c60ab 6896 for(Int_t i=0; i<klayernumber; i++){
6897 endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
045be90c 6898 snprintf(endcapsupportsystemothername,100,"EndCapSupportSystemLayer%i",i+5);
9b0c60ab 6899 endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
6900 - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
6901 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6902 +2.*endcapassemblycenter[2])
6903 /CosD(0.5*upedgeangle[i]));
6904 endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
6905 -(fgkEndCapCoverPlateWidth[1]
6906 - fgkEndCapCoverPlateWidth[0]),
6907 *radiusmin[i],
6908 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6909 +2.*endcapassemblycenter[2])
6910 /CosD(0.5*upedgeangle[i]));
6911 }
e5bf64ae 6912 fgkEndCapSupportSystem = new TGeoVolume*[4];
9b0c60ab 6913 fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
6914 endcapsupportsystemshape[0],fSSDAir);
6915 fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
6916 endcapsupportsystemshape[0],fSSDAir);
6917 fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
6918 endcapsupportsystemshape[1],fSSDAir);
6919 fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
6920 endcapsupportsystemshape[1],fSSDAir);
6921 ///////////////////////////////////////////////
6922 TGeoTranslation* endcapassemblytrans[klayernumber];
6923 for(Int_t i=0; i<klayernumber; i++)
6924 endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
6925 - fgkEndCapSideCoverThickness
6926 + endcapassemblycenter[0],
6927 - 0.5*fgkEndCapCoverPlateThickness
6928 - 2.0*fgkEndCapCoolingTubeRadiusMax
6929 + 2.0*endcapassemblycenter[2]
6930 + 0.5*fgkEndCapSupportLength[i]
6931 / TanD(0.5*upedgeangle[i]),
6932 0.5*(fgkEndCapCoverPlateWidth[0]
6933 - fgkEndCapCoverPlateWidth[2]
6934 - (kendcapcoverplatesmallholenumber-1)
6935 * fgkEndCapCoverPlateSmallHoleSeparation[2]));
6936 TGeoRotation** endcapassemblyrot[klayernumber];
6937 TGeoHMatrix** endcapassemblymatrix[klayernumber];
6938 for(Int_t i=0; i<klayernumber; i++){
6939 endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
6940 endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
6941 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
6942 endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
6943 endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
6944 endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
6945 endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
6946 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6947 endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
6948 endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
6949 }
6950 }
6951 TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
6952 fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
6953 for(Int_t i=0; i<2*klayernumber; i++){
6954 for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
6955 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
6956 endcapassemblymatrix[1][j+2]);
6957 }
6958 fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
6959 }
6960 /////////////////////////////////////////////////////////////
6961 // Deallocating memory
6962 /////////////////////////////////////////////////////////////
6963 for(Int_t i=0; i<klayernumber; i++){
6964 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
6965 delete endcapassemblyrot[i][j];
6966 }
7b208ef4 6967 delete [] endcapassemblyrot[i];
9b0c60ab 6968 delete endcapassemblymatrix[i][0];
6969 delete endcapassemblymatrix[i][1];
6970 }
6971 /////////////////////////////////////////////////////////////
6972 }
6973 void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
6974 /////////////////////////////////////////////////////////////
6975 // Setting End Cap Support + End Cap Assembly of Layer 5.
6976 /////////////////////////////////////////////////////////////
6977 if (! moth) {
160835d5 6978 AliError("Can't insert end cap support of layer5, mother is null!\n");
9b0c60ab 6979 return;
6980 };
e5bf64ae 6981 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 6982 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
6983 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
6984 fgkEndCapSupportCenterLay5ITSPosition
6985 + fgkEndCapSupportCenterLay5Position
6986 - fgkEndCapSideCoverLength[2]);
6987 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
6988 fgkEndCapSideCoverLength[2]
6989 - fgkEndCapSupportCenterLay5Position
6990 - fgkEndCapSupportCenterLay5ITSPosition);
6991 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
6992 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
6993 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
6994 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
6995 moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
6996 moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
6997 /////////////////////////////////////////////////////////////
6998 // Deallocating memory
6999 /////////////////////////////////////////////////////////////
7000 delete endcapsupportsystemrot;
7001 delete endcapsupportsystemITSCentertrans[1];
7002 }
7003 /////////////////////////////////////////////////////////////
7004 void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7005 /////////////////////////////////////////////////////////////
7006 // Setting End Cap Support + End Cap Assembly of Layer 6.
7007 /////////////////////////////////////////////////////////////
7008 if (! moth) {
160835d5 7009 AliError("Can't insert end cap support of layer6, mother is null!\n");
9b0c60ab 7010 return;
7011 };
e5bf64ae 7012 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7013 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7014 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7015 fgkEndCapSupportCenterLay6ITSPosition
7016 + fgkEndCapSupportCenterLay6Position
7017 - fgkEndCapSideCoverLength[2]);
7018 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7019 fgkEndCapSideCoverLength[2]
7020 - fgkEndCapSupportCenterLay6Position
7021 - fgkEndCapSupportCenterLay6ITSPosition);
7022 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7023 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7024 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7025 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7026 moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7027 moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7028 /////////////////////////////////////////////////////////////
7029 // Deallocating memory
7030 /////////////////////////////////////////////////////////////
7031 delete endcapsupportsystemrot;
7032 delete endcapsupportsystemITSCentertrans[1];
7033 }
7034 ////////////////////////////////////////////////////////////////////////////////
7035 void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7036 /////////////////////////////////////////////////////////////
7037 // Setting Ladder Support of Layer 5.
7038 /////////////////////////////////////////////////////////////
7039 if (! moth) {
160835d5 7040 AliError("Can't insert ladder lupport of layer5, mother is null!\n");
9b0c60ab 7041 return;
7042 };
7043 if(!fLay5LadderSupportRing) SetLadderSupport(100);
7044 fMotherVol = moth;
7045 TGeoTranslation* centerITSRingSupportLay5trans[2];
7046 for(Int_t i=0; i<2; i++){
7047 centerITSRingSupportLay5trans[i] =
7048 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7049 moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7050 }
7051 }
7052 ////////////////////////////////////////////////////////////////////////////////
7053 void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7054 /////////////////////////////////////////////////////////////
7055 // Setting Ladder Support of Layer 6.
7056 /////////////////////////////////////////////////////////////
7057 if (! moth) {
160835d5 7058 AliError("Can't insert ladder lupport of layer6, mother is null!\n");
9b0c60ab 7059 return;
7060 };
7061 if(!fLay6LadderSupportRing) SetLadderSupport(100);
7062 fMotherVol = moth;
7063 TGeoTranslation* centerITSRingSupportLay6trans[2];
7064 for(Int_t i=0; i<2; i++){
7065 centerITSRingSupportLay6trans[i] =
7066 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7067 moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7068 }
7069 }
7070 ////////////////////////////////////////////////////////////////////////////////
47f8de53 7071 void AliITSv11GeometrySSD::SSDCone(TGeoVolume* moth){
7072 /////////////////////////////////////////////////////////////
7073 // Setting Ladder Support of Layer 6.
7074 /////////////////////////////////////////////////////////////
7075 if (! moth) {
160835d5 7076 AliError("Can't insert SSD Cone, mother is null!\n");
47f8de53 7077 return;
7078 };
7079 if(!fSSDCone) SetSSDCone();
7080 TGeoTranslation* ssdconetrans = new TGeoTranslation(0.,0.,0.5*fgkSSDCentralSupportLength
7081 + fgkSSDCentralAL3SupportLength);
7082 moth->AddNode(fSSDCone,1,ssdconetrans);
7083}
7084 ////////////////////////////////////////////////////////////////////////////////
7085 void AliITSv11GeometrySSD::SetSSDCone(){
7086 /////////////////////////////////////////////////////////////
7087 // Method generating SSDCone
7088 /////////////////////////////////////////////////////////////
7089 if(!fCreateMaterials) CreateMaterials();
7090 fSSDCone = new TGeoVolumeAssembly("ITSssdCone");
7091 Double_t ssdpconesectionradiusmax[16];
7092 Double_t ssdpconesectionradiusmin[16];
7093 Double_t ssdpconezsection[16];
7094 TGeoPcon* ssdpconelittleholeshape[8];
7095 TGeoVolume* ssdpconelittlehole[8];
7096 ssdpconezsection[0] = (fgkSSDPConeZLength[0]-fgkSSDPConeZLength[1]);
7097 ssdpconesectionradiusmin[0] = fgkSSDLowerPConeRadius;
7098 ssdpconesectionradiusmax[0] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7099 / SinD(fgkSSDPConeAngle)
7100 + ssdpconesectionradiusmin[0];
7101 ssdpconesectionradiusmin[1] = fgkSSDPConeLittleHoleRadius
7102 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7103 / SinD(fgkSSDPConeAngle);
7104 ssdpconesectionradiusmax[1] = fgkSSDPConeLittleHoleRadius;
7105 ssdpconezsection[1] = (ssdpconesectionradiusmin[1]-ssdpconesectionradiusmin[0])
7106 * TanD(fgkSSDPConeAngle)+ssdpconezsection[0];
7107 ssdpconelittleholeshape[0] = new TGeoPcon(0.,360.,2);
7108 for(Int_t i=0; i<2;i++) ssdpconelittleholeshape[0]->DefineSection(i,ssdpconezsection[i],
7109 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7110 ssdpconelittlehole[0] = new TGeoVolume("SSDConeLittleHole1",ssdpconelittleholeshape[0],fSSDCarbonFiberMedium);
7111 ssdpconelittlehole[0]->SetLineColor(4);
7112 /////////////////////////////////////////////////////////////
7113 ssdpconezsection[2] = ssdpconezsection[1];
7114 ssdpconesectionradiusmin[2] = ssdpconesectionradiusmin[1];
7115 ssdpconesectionradiusmax[2] = ssdpconesectionradiusmax[1];
7116 ssdpconesectionradiusmin[3] = fgkSSDPConeLittleHoleRadius+fgkSSDPConeLittleHoleLength
7117 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7118 / SinD(fgkSSDPConeAngle);
7119 ssdpconesectionradiusmax[3] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7120 / SinD(fgkSSDPConeAngle)+ssdpconesectionradiusmin[3];
7121 ssdpconezsection[3] = (ssdpconesectionradiusmin[3]-ssdpconesectionradiusmin[2])
7122 * TanD(fgkSSDPConeAngle)+ssdpconezsection[2];
7123 Double_t ssdpconelittleholeangle = fgkSSDPConeLittleHoleLength/fgkSSDPConeLittleHoleRadius
7124 * TMath::RadToDeg();
7125 ssdpconelittleholeshape[1] = new TGeoPcon(30.+0.5*ssdpconelittleholeangle,
7126 60.-ssdpconelittleholeangle,2);
7127 for(Int_t i=2;i<4;i++) ssdpconelittleholeshape[1]->DefineSection(i-2,ssdpconezsection[i],
7128 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7129 ssdpconelittlehole[1] = new TGeoVolume("SSDConeLittleHole2",ssdpconelittleholeshape[1],fSSDCarbonFiberMedium);
7130 ssdpconelittlehole[1]->SetLineColor(4);
7131 TGeoRotation* ssdconelittleholerot[6];
7132 for(Int_t i=0; i<6; i++){
7133 ssdconelittleholerot[i] = new TGeoRotation();
7134 ssdconelittleholerot[i]->SetAngles(i*60,0.,0.);
7135 }
7136 /////////////////////////////////////////////////////////////
7137 ssdpconezsection[4] = ssdpconezsection[3];
7138 ssdpconesectionradiusmin[4] = ssdpconesectionradiusmin[3];
7139 ssdpconesectionradiusmax[4] = ssdpconesectionradiusmax[3];
7140 ssdpconesectionradiusmin[5] = fgkSSDConeMiddleRadius-ssdpconezsection[0]
7141 * CosD(fgkSSDPConeAngle)
7142 / SinD(fgkSSDPConeAngle);
7143 ssdpconesectionradiusmax[5] = fgkSSDConeMiddleRadius;
7144 ssdpconezsection[5] = (ssdpconesectionradiusmin[5]-ssdpconesectionradiusmin[4])
7145 * TanD(fgkSSDPConeAngle)+ssdpconezsection[4];
7146 ssdpconelittleholeshape[2] = new TGeoPcon(0.,360.,2);
7147 for(Int_t i=4; i<6;i++) ssdpconelittleholeshape[2]->DefineSection(i-4,ssdpconezsection[i],
7148 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7149 ssdpconelittlehole[2] = new TGeoVolume("SSDConeLittleHole3",ssdpconelittleholeshape[2],fSSDCarbonFiberMedium);
7150 ssdpconelittlehole[2]->SetLineColor(4);
7151 ///////////////////////////////////////////////////
7152 ssdpconezsection[6] = ssdpconezsection[5];
7153 ssdpconesectionradiusmin[6] = ssdpconesectionradiusmin[5];
7154 ssdpconesectionradiusmax[6] = ssdpconesectionradiusmax[5];
7155 ssdpconesectionradiusmin[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength
7156 -ssdpconezsection[0]
7157 * CosD(fgkSSDPConeAngle)
7158 / SinD(fgkSSDPConeAngle);
7159 ssdpconesectionradiusmax[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength;
7160 ssdpconezsection[7] = (ssdpconesectionradiusmin[7]-ssdpconesectionradiusmin[6])
7161 * TanD(fgkSSDPConeAngle)+ssdpconezsection[6];
7162 Double_t ssdpconemiddleholeangle = fgkSSDPConeMiddleWidth/fgkSSDConeMiddleRadius
7163 * TMath::RadToDeg();
7164 ssdpconelittleholeshape[3] = new TGeoPcon(22.5+0.5*ssdpconemiddleholeangle,
7165 45.-ssdpconemiddleholeangle,2);
7166 for(Int_t i=6;i<8;i++) ssdpconelittleholeshape[3]->DefineSection(i-6,ssdpconezsection[i],
7167 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7168 ssdpconelittlehole[3] = new TGeoVolume("SSDConeLittleHole4",ssdpconelittleholeshape[3],fSSDCarbonFiberMedium);
7169 ssdpconelittlehole[3]->SetLineColor(4);
7170 TGeoRotation* ssdconemiddleholerot[8];
7171 for(Int_t i=0; i<8; i++){
7172 ssdconemiddleholerot[i] = new TGeoRotation();
7173 ssdconemiddleholerot[i]->SetAngles(i*45,0.,0.);
7174 }
7175 /////////////////////////////////////////////////////////////
7176 ssdpconezsection[8] = ssdpconezsection[7];
7177 ssdpconesectionradiusmin[8] = ssdpconesectionradiusmin[7];
7178 ssdpconesectionradiusmax[8] = ssdpconesectionradiusmax[7];
7179 ssdpconesectionradiusmin[9] = fgkSSDPConeUpRadius-ssdpconezsection[0]
7180 * CosD(fgkSSDPConeAngle)
7181 / SinD(fgkSSDPConeAngle);
7182 ssdpconesectionradiusmax[9] = fgkSSDPConeUpRadius;
7183 ssdpconezsection[9] = (ssdpconesectionradiusmin[9]-ssdpconesectionradiusmin[8])
7184 * TanD(fgkSSDPConeAngle)+ssdpconezsection[8];
7185 ssdpconelittleholeshape[4] = new TGeoPcon(0.,360.,2);
7186 for(Int_t i=8; i<10;i++) ssdpconelittleholeshape[4]->DefineSection(i-8,ssdpconezsection[i],
7187 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7188 ssdpconelittlehole[4] = new TGeoVolume("SSDConeLittleHole5",ssdpconelittleholeshape[4],fSSDCarbonFiberMedium);
7189 ssdpconelittlehole[4]->SetLineColor(4);
7190 /////////////////////////////////////////////////////////////
7191 Double_t ssdconetrapezoidheight = fgkSSDPConeUpMaxRadius-fgkSSDPConeUpRadius;
7192 Double_t ssdconetrapezoidbasis = fgkSSDPConeTrapezoidBasis-2.0
7193 * (0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)
7194 - 0.5*ssdconetrapezoidheight/(fgkSSDPConeUpMaxRadius
7195 - 0.5*ssdconetrapezoidheight)*(0.5*fgkSSDPConeTrapezoidBasis
7196 - 0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)));
7197 Double_t ssdconetrapezoidsection = (2.0*TMath::Pi()*fgkSSDPConeUpMaxRadius-8.0*ssdconetrapezoidbasis)/8.;
7198 Double_t ssdpconetrapezoidsectionangle = ssdconetrapezoidsection/fgkSSDPConeUpMaxRadius
7199 * TMath::RadToDeg();
7200 ssdpconezsection[10] = ssdpconezsection[9];
7201 ssdpconesectionradiusmin[10] = ssdpconesectionradiusmin[9];
7202 ssdpconesectionradiusmax[10] = ssdpconesectionradiusmax[9];
7203 ssdpconesectionradiusmin[11] = fgkSSDPConeUpMaxRadius-ssdpconezsection[0]
7204 * CosD(fgkSSDPConeAngle)
7205 / SinD(fgkSSDPConeAngle);
7206 ssdpconesectionradiusmax[11] = fgkSSDPConeUpMaxRadius;
7207 ssdpconezsection[11] = (ssdpconesectionradiusmin[11]-ssdpconesectionradiusmin[10])
7208 * TanD(fgkSSDPConeAngle)+ssdpconezsection[10];
7209 ssdpconelittleholeshape[5] = new TGeoPcon(90.-0.5*ssdpconetrapezoidsectionangle,
7210 ssdpconetrapezoidsectionangle,2);
7211 for(Int_t i=10;i<12;i++) ssdpconelittleholeshape[5]->DefineSection(i-10,ssdpconezsection[i],
7212 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7213 ssdpconelittlehole[5] = new TGeoVolume("SSDConeLittleHole6",ssdpconelittleholeshape[5],fSSDCarbonFiberMedium);
7214 ssdpconelittlehole[5]->SetLineColor(4);
7215 TGeoRotation* ssdconeupradiusrot[8];
7216 for(Int_t i=0; i<8; i++){
7217 ssdconeupradiusrot[i] = new TGeoRotation();
7218 ssdconeupradiusrot[i]->SetAngles(i*45,0.,0.);
7219 }
7220 /////////////////////////////////////////////////////////////
7221 ssdpconezsection[12] = ssdpconezsection[11];
7222 ssdpconezsection[13] = ssdpconezsection[12]+fgkSSDPConeRadiusWidth;
7223 ssdpconesectionradiusmin[12] = ssdpconesectionradiusmin[11];
7224 ssdpconesectionradiusmax[12] = fgkSSDPConeExternalRadius;
7225 ssdpconesectionradiusmin[13] = ssdpconesectionradiusmin[12];
7226 ssdpconesectionradiusmax[13] = fgkSSDPConeExternalRadius;
7227 ssdpconelittleholeshape[6] = new TGeoPcon(0.,360.,2);
7228 for(Int_t i=12; i<14;i++) ssdpconelittleholeshape[6]->DefineSection(i-12,ssdpconezsection[i],
7229 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7230 ssdpconelittlehole[6] = new TGeoVolume("SSDConeLittleHole7",ssdpconelittleholeshape[6],fSSDCarbonFiberMedium);
7231 ssdpconelittlehole[6]->SetLineColor(4);
7232 /////////////////////////////////////////////////////////////
7233 ssdpconezsection[14] = 0.0;
7234 ssdpconezsection[15] = ssdpconezsection[0];
7235 ssdpconesectionradiusmin[14] = ssdpconesectionradiusmin[0];
7236 ssdpconesectionradiusmax[14] = ssdpconesectionradiusmin[14];
7237 ssdpconesectionradiusmin[15] = ssdpconesectionradiusmin[0];
7238 ssdpconesectionradiusmax[15] = ssdpconesectionradiusmax[0];
7239 ssdpconelittleholeshape[7] = new TGeoPcon(0.,360.,2);
7240 for(Int_t i=14; i<16;i++) ssdpconelittleholeshape[7]->DefineSection(i-14,ssdpconezsection[i],
7241 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7242 ssdpconelittlehole[7] = new TGeoVolume("SSDConeLittleHole8",ssdpconelittleholeshape[7],fSSDCarbonFiberMedium);
7243 ssdpconelittlehole[7]->SetLineColor(4);
7244 /////////////////////////////////////////////////////////////
7245 TGeoTube* ssdtubeconeshape[2];
7246 TGeoVolume* ssdtubecone[2];
7247 TGeoTranslation* ssdtubeconetrans[2];
7248 ssdtubeconeshape[0] = new TGeoTube(fgkSSDPConeUpMiddleRadius,
7249 fgkSSDPConeExternalRadius,
7250 0.5*(fgkSSDPConeLength-ssdpconezsection[13]));
7251 ssdtubeconeshape[1] = new TGeoTube(fgkSSDPConeDownRadius,ssdpconesectionradiusmin[0],
7252 0.5*ssdpconezsection[0]);
7253 ssdtubecone[0] = new TGeoVolume("SSDConeTube1",ssdtubeconeshape[0],fSSDSupportRingAl);
7254 ssdtubecone[1] = new TGeoVolume("SSDConeTube2",ssdtubeconeshape[1],fSSDSupportRingAl);
7255 ssdtubeconetrans[0] = new TGeoTranslation(0.,0.,
7256 0.5*(fgkSSDPConeLength-ssdpconezsection[13])
7257 + ssdpconezsection[13]);
7258 ssdtubeconetrans[1] = new TGeoTranslation(0.,0.,0.5*ssdpconezsection[0]);
7259 ssdtubecone[0]->SetLineColor(4);
7260 ssdtubecone[1]->SetLineColor(4);
7261 /////////////////////////////////////////////////////////////
7262 // Mother Volume Container
7263 /////////////////////////////////////////////////////////////
7264 Double_t ssdconemotherradiusmin[8];
7265 Double_t ssdconemotherradiusmax[8];
7266 Double_t ssdconemothersection[8];
7267 ssdconemotherradiusmin[0] = fgkSSDPConeDownRadius;
7268 ssdconemotherradiusmax[0] = ssdpconesectionradiusmin[0];
7269 ssdconemotherradiusmin[1] = fgkSSDPConeDownRadius;
7270 ssdconemotherradiusmax[1] = ssdpconesectionradiusmax[0];
7271 ssdconemotherradiusmin[2] = ssdpconesectionradiusmin[0];
7272 ssdconemotherradiusmax[2] = ssdpconesectionradiusmax[0];
7273 ssdconemotherradiusmin[3] = ssdpconesectionradiusmin[11];
7274 ssdconemotherradiusmax[3] = ssdpconesectionradiusmax[11];
7275 ssdconemotherradiusmin[4] = ssdpconesectionradiusmin[12];
7276 ssdconemotherradiusmax[4] = ssdpconesectionradiusmax[12];
7277 ssdconemotherradiusmin[5] = ssdpconesectionradiusmin[13];
7278 ssdconemotherradiusmax[5] = ssdpconesectionradiusmax[13];
7279 ssdconemotherradiusmin[6] = fgkSSDPConeUpMiddleRadius;
7280 ssdconemotherradiusmax[6] = fgkSSDPConeExternalRadius;
7281 ssdconemotherradiusmin[7] = fgkSSDPConeUpMiddleRadius;
7282 ssdconemotherradiusmax[7] = fgkSSDPConeExternalRadius;
7283 ssdconemothersection[0] = 0.0;
7284 ssdconemothersection[1] = ssdpconezsection[0];
7285 ssdconemothersection[2] = ssdpconezsection[0];
7286 ssdconemothersection[3] = ssdpconezsection[11];
7287 ssdconemothersection[4] = ssdpconezsection[11];
7288 ssdconemothersection[5] = ssdpconezsection[13];
7289 ssdconemothersection[6] = ssdpconezsection[13];
7290 ssdconemothersection[7] = fgkSSDPConeLength;
7291 TGeoPcon* ssdconemothershape = new TGeoPcon(0.,360,8);
7292 for(Int_t i=0; i<8; i++) ssdconemothershape->DefineSection(i,ssdconemothersection[i],
7293 ssdconemotherradiusmin[i],ssdconemotherradiusmax[i]);
7294 TGeoVolume* ssdconemother = new TGeoVolume("SSDMotherCone",ssdconemothershape,fSSDAir);
7295 /////////////////////////////////////////////////////////////
7296 //Placing the Volumes into Mother
7297 /////////////////////////////////////////////////////////////
7298 ssdconemother->AddNode(ssdpconelittlehole[0],1);
7299 for(Int_t i=0; i<6; i++){
7300 ssdconemother->AddNode(ssdpconelittlehole[1],i+1,ssdconelittleholerot[i]);
7301 }
7302 ssdconemother->AddNode(ssdpconelittlehole[2],1);
7303 for(Int_t i=0; i<8; i++){
7304 ssdconemother->AddNode(ssdpconelittlehole[3],i+1,ssdconemiddleholerot[i]);
7305 }
7306 ssdconemother->AddNode(ssdpconelittlehole[4],1);
7307 for(Int_t i=0; i<8; i++){
7308 ssdconemother->AddNode(ssdpconelittlehole[5],i+1,ssdconeupradiusrot[i]);
7309 }
7310 ssdconemother->AddNode(ssdpconelittlehole[6],1);
7311 ssdconemother->AddNode(ssdpconelittlehole[7],1);
7312 ssdconemother->AddNode(ssdtubecone[0],1,ssdtubeconetrans[0]);
7313 ssdconemother->AddNode(ssdtubecone[1],1,ssdtubeconetrans[1]);
7314 /////////////////////////////////////////////////////////////
7315 // ITS General Support
7316 /////////////////////////////////////////////////////////////
7317 TGeoTube* ssdcentralsupportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7318 fgkSSDCentralSupportRadius,0.5*fgkSSDCentralSupportLength);
7319 TGeoVolume* ssdcentralsupport = new TGeoVolume("SSDCentralSupport",ssdcentralsupportshape,fSSDRohaCellCone);
7320 TGeoTranslation* ssdcentralsupportrans = new TGeoTranslation(0.,0.,-0.5*fgkSSDCentralSupportLength
7321 - fgkSSDCentralAL3SupportLength);
7322 ssdcentralsupport->SetLineColor(4);
7323 fSSDCone->AddNode(ssdcentralsupport,1,ssdcentralsupportrans);
7324 TGeoTube* ssdcentralal3supportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7325 fgkSSDCentralSupportRadius,0.25*fgkSSDCentralAL3SupportLength);
7326 TGeoVolume* ssdcentralal3support = new TGeoVolume("SSDCentralAl3Support",ssdcentralal3supportshape,fSSDSupportRingAl);
7327 TGeoTranslation* ssdcentralal3supportrans[3];
7328 ssdcentralal3supportrans[0] = new TGeoTranslation(0.,0.,-0.75*fgkSSDCentralAL3SupportLength);
7329 ssdcentralal3supportrans[1] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7330 - 1.25*fgkSSDCentralAL3SupportLength);
7331 ssdcentralal3support->SetLineColor(4);
7332 fSSDCone->AddNode(ssdcentralal3support,1,ssdcentralal3supportrans[0]);
7333 fSSDCone->AddNode(ssdcentralal3support,2,ssdcentralal3supportrans[1]);
7334 TGeoPcon* ssdpconcentralal3shape = new TGeoPcon(0.,360.,2);
7335 Double_t ssdpconcentralradiusmin[2];
7336 Double_t ssdpconcentralradiusmax[2];
7337 Double_t ssdpconcentralsection[2];
7338 ssdpconcentralradiusmin[0] = fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth;
7339 ssdpconcentralradiusmin[1] = fgkSSDCentralSupportRadius-fgkSSDCentralAL3SupportWidth;
7340 ssdpconcentralradiusmax[0] = fgkSSDCentralSupportRadius;
7341 ssdpconcentralradiusmax[1] = fgkSSDCentralSupportRadius;
7342 ssdpconcentralsection[0] = -0.5*fgkSSDCentralAL3SupportLength;
7343 ssdpconcentralsection[1] = 0.;
7344 for(Int_t i=0; i<2;i++) ssdpconcentralal3shape->DefineSection(i,ssdpconcentralsection[i],
7345 ssdpconcentralradiusmin[i],ssdpconcentralradiusmax[i]);
7346 TGeoVolume* ssdpconcentralal3 = new TGeoVolume("SSDPConeCentralAl3",ssdpconcentralal3shape,fSSDSupportRingAl);
7347 ssdpconcentralal3->SetLineColor(4);
7348 fSSDCone->AddNode(ssdpconcentralal3,1);
7349 TGeoRotation* ssdcentralal3supportrot = new TGeoRotation();
7350 ssdcentralal3supportrot->SetAngles(90.,180,-90.);
7351 ssdcentralal3supportrans[2] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7352 -2.*fgkSSDCentralAL3SupportLength);
7353 TGeoCombiTrans* ssdcentralal3supporcombitrans = new TGeoCombiTrans(*ssdcentralal3supportrans[2],
7354 *ssdcentralal3supportrot);
7355 fSSDCone->AddNode(ssdpconcentralal3,2,ssdcentralal3supporcombitrans);
7356 TGeoRotation* ssdconemotherot = new TGeoRotation();
7357 ssdconemotherot->SetAngles(90.,180.,-90.);
7358 TGeoTranslation* ssdconemothertrans = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7359 -2.*fgkSSDCentralAL3SupportLength);
7360 TGeoCombiTrans* ssdconemothercombitrans = new TGeoCombiTrans(*ssdconemothertrans,*ssdconemotherot);
7361 fSSDCone->AddNode(ssdconemother,1);
7362 fSSDCone->AddNode(ssdconemother,2,ssdconemothercombitrans);
7363 /////////////////////////////////////////////////////////////
7364 // Deallocating memory
7365 /////////////////////////////////////////////////////////////
7366 delete ssdcentralal3supportrot;
7367 delete ssdcentralal3supportrans[2];
7368 delete ssdconemotherot;
7369 delete ssdconemothertrans;
7370 /////////////////////////////////////////////////////////////
7371 }
fcfbdd23 7372 ////////////////////////////////////////////////////////////////////////////////
7373 void AliITSv11GeometrySSD::SSDCables(TGeoVolume* moth){
7374 /////////////////////////////////////////////////////////////
7375 // Setting SSD Cables
7376 /////////////////////////////////////////////////////////////
7377 if (! moth) {
160835d5 7378 AliError("Can't insert SSD Cables, mother is null!\n");
fcfbdd23 7379 return;
7380 };
7381 TGeoVolume* ssdcables = SetSSDCables();
7382 moth->AddNode(ssdcables,1);
7383}
47f8de53 7384 ////////////////////////////////////////////////////////////////////////////////
7385 TGeoVolume* AliITSv11GeometrySSD::SetSSDCables(){
f7cd318e 7386 /////////////////////////////////////////////////////////////
7387 // Method generating SSDCables
7388 /////////////////////////////////////////////////////////////
7389
7390 /////////////////////////////////////////////////////////////////////////////////
7391 // SSD Cables Parameters (lengths are in mm and angles in degrees)
7392 /////////////////////////////////////////////////////////////////////////////////
7393
7394 const Double_t kSSDCablesLay5TubeRadiusMin = 11.9*fgkmm;
7395 const Double_t kSSDCablesLay6TubeRadiusMin = 11.9*fgkmm;
7396
7397 // Cable thickness for rings at outer Z
7398 // Average: 9/2 = 4.5 cables per quadrant
7399 // Ideally 1/16 * 38(34) cables, but take factor to (1/8) to accomodate kinks and loops (there are only 2 different cable lengths); 21 mm^2 Cu each
7400
7401 const Double_t kSSDCablesLay5RingArea = 21.*34./8.*fgkmm*fgkmm; // to be fixed in order to reproduce material budget
7402 const Double_t kSSDCablesLay6RingArea = 21.*38./8.*fgkmm*fgkmm; // to be fixed in order to reproduce material budget
7403
7404
7405 const Double_t kSSDCablesHeight = 3.2*fgkmm; // 3.2 mm*13 cm width = 18 cables, 185g/m each Add fudge factor of 2 to get to ~25 kg measured
7406
7407 const Double_t kSSDCableAngle = 22.5;
7408 // MvL: remove water?
7409 const Double_t kSSDCablesLay5RightSideWaterHeight = 2.5*fgkmm; // to be fixed in order to reproduce material budget
7410 const Double_t kSSDCablesPatchPanel2RB26Angle[2] = {25.0,53.2};
7411 const Double_t kSSDCablesPatchPanel2RB24Angle[2] = {23.0,53.6};
7412 const Double_t kSSDPatchPanel2RB26ITSDistance = 975.0*fgkmm;
7413 const Double_t kSSDPatchPanel2RB24ITSDistance = 1020.0*fgkmm;
7414 const Double_t kSSDPatchPanel2RB26Radius = 451.3*fgkmm;
7415 const Double_t kSSDPatchPanel2RB24Radius = 451.3*fgkmm;
7416 const Double_t kSSDPatchPanelHeight = 87.5*fgkmm;
7417
7418 // SSD Layer 5 Cables
7419 //////////////////////////////////////////////////////////////////////////////////////////////////
7420 TGeoVolumeAssembly* ssdcablesmother = new TGeoVolumeAssembly("SSDCables");
7421 Double_t ssdcablelayvertical = 0.05; // Internal variables to control overlapping with SDD cables
7422 Double_t ssdcablelaylateral = 0.55; // Internal variables to control overlapping with SDD cables
7423 //////////////////////////////////////////////////////////////////////////////////////////////////
7424 // Printf(Form("Cable ring: rad min: %g length %g thick %g", ssdcableslay5rigthsideradiusmin, ssdcablelay5rightsidelength, kSSDCablesLay5RingArea/ssdcablelay5rightsidelength));
7425
7426
7427
47f8de53 7428 ////////////////////////////////////
7429 // Double_t cablescapacity[20];
7430 // cablescapacity[0] = ssdcablelay5rightubeshape->Capacity();
7431 ////////////////////////////////////
f7cd318e 7432 //ssdcablesmother->AddNode(ssdcablelay5righttube,1,ssdcablelay5rightrans);
47f8de53 7433 ////////////////////////////////////
7434 // TGeoPCone Volumes
7435 ///////////////////////////////////
7436 TGeoPcon* ssdcableslay5pconshape[3];
7437 TGeoVolume* ssdcableslay5pcon[3];
7438 ssdcableslay5pconshape[0] = new TGeoPcon(0.,360.,2);
7439 Double_t ssdcableslay5pconzsection[6];
7440 Double_t ssdcableslay5pconrmin[6];
7441 Double_t ssdcableslay5pconrmax[6];
f7cd318e 7442 ssdcableslay5pconrmin[0] = fgkEndCapSupportMiddleRadius[0]+kSSDCablesLay5TubeRadiusMin;
47f8de53 7443 ssdcableslay5pconrmin[1] = fgkSSDPConeUpRadius*(1.0+ssdcablelayvertical);
f7cd318e 7444
47f8de53 7445 ssdcableslay5pconzsection[0] = fgkEndCapSupportCenterLay5ITSPosition
f7cd318e 7446 + fgkEndCapSupportCenterLay5Position;
7447 //+ 2.*ssdcablelay5rightsidelength; // removing this generates overlap with the water ring
7448 // Keeping it generates overlap with the cones...
7449 // SSDCables/SSDCableLay5RightSideWaterTube_2 ovlp=0.0939792
47f8de53 7450 ssdcableslay5pconzsection[1] = 0.5*fgkSSDCentralSupportLength
7451 + fgkSSDCentralAL3SupportLength
7452 + (fgkSSDPConeUpRadius-fgkSSDLowerPConeRadius)
7453 * TanD(fgkSSDPConeAngle);
f7cd318e 7454 Double_t dz = ssdcableslay5pconzsection[1]-ssdcableslay5pconzsection[0];
7455 Double_t pconethickness = kSSDCablesLay5RingArea/TMath::Abs(dz);
7456 ssdcableslay5pconrmax[0] = ssdcableslay5pconrmin[0]+pconethickness;
7457 ssdcableslay5pconrmax[1] = ssdcableslay5pconrmin[1]+pconethickness;
7458 //Printf(Form("pcone: r1 %g r2 %g z1 %g z2 %g thickness %g", ssdcableslay5pconrmax[0], ssdcableslay5pconrmax[1],
7459 // ssdcableslay5pconzsection[0],ssdcableslay5pconzsection[1],pconethickness));
7460
47f8de53 7461 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[0]->DefineSection(i,ssdcableslay5pconzsection[i],
7462 ssdcableslay5pconrmin[i],ssdcableslay5pconrmax[i]);
7463 ssdcableslay5pcon[0] = new TGeoVolume("SSDCableLay5RightSidePCon1",
7464 ssdcableslay5pconshape[0],fSSDCopper);
7465 ssdcableslay5pcon[0]->SetLineColor(9);
7466 ssdcablesmother->AddNode(ssdcableslay5pcon[0],1);
f7cd318e 7467
7468 Double_t totvol = ssdcableslay5pcon[0]->Capacity();
7469 // Printf(Form("Cables, lay5, pCone,volume: %g", ssdcableslay5pcon[0]->Capacity()));
47f8de53 7470////////////////////////////////////
7471// cablescapacity[1] = ssdcableslay5pconshape[0]->Capacity();
7472////////////////////////////////////
f7cd318e 7473
7474 //
7475 // PCon 2 and 3 are cables going through/towards holes in supports
7476 //
47f8de53 7477 ssdcableslay5pconzsection[2] = ssdcableslay5pconzsection[1];
7478 ssdcableslay5pconzsection[3] = 0.5*fgkSSDCentralSupportLength
7479 + fgkSSDCentralAL3SupportLength
7480 + 0.25*TanD(fgkSSDPConeAngle)*(fgkSSDPConeUpMaxRadius
7481 + 3.*fgkSSDPConeUpRadius-4.*fgkSSDLowerPConeRadius);
7482 Double_t ssdcableangle = (fgkSSDPConeTrapezoidBasis-2.*(fgkSSDPConeUpMaxRadius
7483 - fgkSSDPConeUpRadius)/TanD(fgkSSDPConeTrapezoidAngle))
7484 / fgkSSDPConeUpRadius*TMath::RadToDeg()*2;
f7cd318e 7485 ssdcableslay5pconshape[1] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
7486 ssdcableangle,2);
7487 // Printf(Form("PCon2, phi %g dphi %g ",90.0-kSSDCableAngle-0.5*ssdcableangle, ssdcableangle));
47f8de53 7488 ssdcableslay5pconrmin[2] = ssdcableslay5pconrmin[1];
f7cd318e 7489 ssdcableslay5pconrmax[2] = ssdcableslay5pconrmax[1];
47f8de53 7490 ssdcableslay5pconrmin[3] = 0.25*(fgkSSDPConeUpMaxRadius+3.*fgkSSDPConeUpRadius
7491 - 4.*fgkSSDLowerPConeRadius)+fgkSSDLowerPConeRadius;
7492 ssdcableslay5pconrmin[3]*=(1.0+ssdcablelayvertical);
f7cd318e 7493 ssdcableslay5pconrmax[3] = ssdcableslay5pconrmin[3] + kSSDCablesHeight;
47f8de53 7494 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[1]->DefineSection(i,ssdcableslay5pconzsection[i+2],
7495 ssdcableslay5pconrmin[i+2],ssdcableslay5pconrmax[i+2]);
7496 ssdcableslay5pcon[1] = new TGeoVolume("SSDCableLay5RightSidePCon2",ssdcableslay5pconshape[1],fSSDCopper);
7497 ssdcableslay5pcon[1]->SetLineColor(9);
7498 ////////////////////////////////////
f7cd318e 7499 ssdcableslay5pconshape[2] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
47f8de53 7500 ssdcableangle,2);
7501 ssdcableslay5pconrmin[4] = ssdcableslay5pconrmin[3];
7502 ssdcableslay5pconrmax[4] = ssdcableslay5pconrmax[3];
7503 ssdcableslay5pconrmin[5] = ssdcableslay5pconrmin[4];
7504 ssdcableslay5pconrmax[5] = ssdcableslay5pconrmax[4];
7505 ssdcableslay5pconzsection[4] = ssdcableslay5pconzsection[3];
7506 ssdcableslay5pconzsection[5] = (ssdcableslay5pconrmin[5]-fgkSSDLowerPConeRadius)
7507 * TanD(fgkSSDPConeAngle)
7508 + 0.5*fgkSSDCentralSupportLength
7509 + fgkSSDCentralAL3SupportLength;
7510 ssdcableslay5pconzsection[5]-= ssdcablelaylateral;
7511 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[2]->DefineSection(i,ssdcableslay5pconzsection[i+4],
7512 ssdcableslay5pconrmin[i+4],ssdcableslay5pconrmax[i+4]);
7513 ssdcableslay5pcon[2] = new TGeoVolume("SSDCableLay5RightSidePCon3",ssdcableslay5pconshape[2],fSSDCopper);
7514 ssdcableslay5pcon[2]->SetLineColor(9);
7515////////////////////////////////////
7516 TGeoRotation* ssdcableslay5pconrot[4];
7517 for(Int_t i=0; i<4; i++){
7518 ssdcableslay5pconrot[i] = new TGeoRotation();
7519 ssdcableslay5pconrot[i]->SetAngles(90.0*i,0.,0.);
7520 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+1,ssdcableslay5pconrot[i]);
7521 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+1,ssdcableslay5pconrot[i]);
f7cd318e 7522 // Printf(Form("Pcon2, Pcon3, vol %g %g",ssdcableslay5pcon[1]->Capacity(),ssdcableslay5pcon[2]->Capacity()));
7523 totvol += ssdcableslay5pcon[1]->Capacity()+ssdcableslay5pcon[2]->Capacity();
47f8de53 7524 }
7525 ////////////////////////////////////
7526 //cablescapacity[2] = 4.0*ssdcableslay5pconshape[1]->Capacity();
7527 //cablescapacity[3] = 4.0*ssdcableslay5pconshape[2]->Capacity();
7528 ////////////////////////////////////
7529 // Positioning Left SSD Cables Part
7530 ////////////////////////////////////
47f8de53 7531 TGeoRotation* ssdcablesLay5RightPConToLeftRot = new TGeoRotation();
7532 ssdcablesLay5RightPConToLeftRot->SetAngles(90.,180.,-90);
7533 ssdcablesmother->AddNode(ssdcableslay5pcon[0],2,ssdcablesLay5RightPConToLeftRot);
7534 TGeoHMatrix* ssdcablesLay5RightPConToLeftMatrix[4];
7535 for(Int_t i=0; i<4; i++){ ssdcablesLay5RightPConToLeftMatrix[i] =
7536 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconrot[i]));
7537 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7538 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7539 }
7540 ////////////////////////////////////
7541 //cablescapacity[4] = ssdcablelay5rightubeshape->Capacity();
7542 //cablescapacity[5] = ssdcableslay5pconshape[0]->Capacity();
7543 //cablescapacity[6] = 4.*ssdcableslay5pconshape[1]->Capacity();
7544 //cablescapacity[7] = 4.*ssdcableslay5pconshape[2]->Capacity();
7545 /////////////////////////////////////////////////////////////
7546 // Water Tubes Layer 5
7547 /////////////////////////
f7cd318e 7548 /* Remove ring; could be replaced with a PCone next to/on top of the cables
7549
7550 //
7551 // MvL: Remove ring; put everything in PCone
7552 //
7553 // Need to keep dimensions for water ring...
7554
7555 Double_t ssdcablesfactor = 0.5; // Internal variables to control overlapping with SDD cables
7556
7557 Double_t ssdcableslay5rigthsideradiusmin = fgkEndCapSupportMiddleRadius[0]+kSSDCablesLay5TubeRadiusMin;
7558 Double_t ssdcableslay5endconedistance = (ssdcableslay5rigthsideradiusmin
7559 - fgkSSDLowerPConeRadius)
7560 * TanD(fgkSSDPConeAngle);
7561 Double_t ssdcableslay5startconedistance = fgkEndCapSupportCenterLay5ITSPosition
7562 + fgkEndCapSupportCenterLay5Position
7563 - 0.5*fgkSSDCentralSupportLength-fgkSSDCentralAL3SupportLength;
7564 Double_t ssdcablelay5rightsidelength = ssdcableslay5endconedistance
7565 - ssdcableslay5startconedistance;
7566 ssdcablelay5rightsidelength *= ssdcablesfactor;
7567 Double_t ssdcableslay5rightsideradiusmax = ssdcableslay5rigthsideradiusmin+kSSDCablesLay5RingArea/ssdcablelay5rightsidelength;
7568
7569
7570 TGeoTranslation* ssdcablelay5rightrans =
7571 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay5ITSPosition
7572 + fgkEndCapSupportCenterLay5Position
7573 + 0.5*ssdcablelay5rightsidelength);
7574
7575 TGeoTranslation* ssdcablesLay5RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7576 - 0.5*ssdcablelay5rightsidelength
7577 - fgkEndCapSupportCenterLay5Position
7578 - fgkEndCapSupportCenterLay5ITSPosition);
7579
47f8de53 7580 TGeoTube* ssdcablelay5rightubewatershape = new TGeoTube(ssdcableslay5rightsideradiusmax,
7581 ssdcableslay5rightsideradiusmax
f7cd318e 7582 + kSSDCablesLay5RightSideWaterHeight,
47f8de53 7583 0.5*ssdcablelay5rightsidelength);
7584 TGeoVolume* ssdcablelay5rightwatertube = new TGeoVolume("SSDCableLay5RightSideWaterTube",
7585 ssdcablelay5rightubewatershape,
7586 fSSDCoolingTubeWater);
7587 ssdcablelay5rightwatertube->SetLineColor(7);
7588 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,1,ssdcablelay5rightrans);
7589 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,2,ssdcablesLay5RightTubeToLeftrans);
f7cd318e 7590 */
47f8de53 7591 ////////////////////////////////////
7592 // TGeoPCone Water Volumes Layer
7593 ///////////////////////////////////
7594 TGeoPcon* ssdcableslay5pconwatershape[3];
7595 TGeoVolume* ssdcableslay5pconwater[3];
7596 ssdcableslay5pconwatershape[0] = new TGeoPcon(0.,360.,2);
7597 Double_t ssdcableslay5pconwaterzsection[6];
7598 Double_t ssdcableslay5pcwateronrmin[6];
7599 Double_t ssdcableslay5pconwaterrmax[6];
7600 ssdcableslay5pcwateronrmin[0] = ssdcableslay5pconrmax[0];
7601 ssdcableslay5pconwaterrmax[0] = ssdcableslay5pcwateronrmin[0]
f7cd318e 7602 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7603 ssdcableslay5pcwateronrmin[1] = ssdcableslay5pconrmax[1];
7604 ssdcableslay5pconwaterrmax[1] = ssdcableslay5pcwateronrmin[1]
f7cd318e 7605 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7606 ssdcableslay5pconwaterzsection[0] = ssdcableslay5pconzsection[0];
7607 ssdcableslay5pconwaterzsection[1] = ssdcableslay5pconzsection[1];
7608 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[0]->DefineSection(i,ssdcableslay5pconwaterzsection[i],
7609 ssdcableslay5pcwateronrmin[i],ssdcableslay5pconwaterrmax[i]);
7610 ssdcableslay5pconwater[0] = new TGeoVolume("SSDCableLay5RightSidePConWater1",
7611 ssdcableslay5pconwatershape[0],fSSDCoolingTubeWater);
7612 ssdcableslay5pconwater[0]->SetLineColor(7);
7613 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],1);
7614 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],2,ssdcablesLay5RightPConToLeftRot);
7615////////////////////////////////////
7616 ssdcableslay5pconwaterzsection[2] = ssdcableslay5pconzsection[2];
7617 ssdcableslay5pconwaterzsection[3] = ssdcableslay5pconzsection[3];
f7cd318e 7618 ssdcableslay5pconwatershape[1] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
47f8de53 7619 ssdcableangle,2);
7620 ssdcableslay5pcwateronrmin[2] = ssdcableslay5pconrmax[1];
7621 ssdcableslay5pconwaterrmax[2] = ssdcableslay5pcwateronrmin[2]
f7cd318e 7622 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7623 ssdcableslay5pcwateronrmin[3] = ssdcableslay5pconrmax[3];
7624 ssdcableslay5pconwaterrmax[3] = ssdcableslay5pcwateronrmin[3]
f7cd318e 7625 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7626 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[1]->DefineSection(i,ssdcableslay5pconwaterzsection[i+2],
7627 ssdcableslay5pcwateronrmin[i+2],ssdcableslay5pconwaterrmax[i+2]);
7628 ssdcableslay5pconwater[1] = new TGeoVolume("SSDCableLay5RightSidePConWater2",
7629 ssdcableslay5pconwatershape[1],fSSDCoolingTubeWater);
7630 ssdcableslay5pconwater[1]->SetLineColor(7);
7631////////////////////////////////////
f7cd318e 7632 ssdcableslay5pconwatershape[2] = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
47f8de53 7633 ssdcableangle,2);
7634 ssdcableslay5pcwateronrmin[4] = ssdcableslay5pconrmax[3];
7635 ssdcableslay5pconwaterrmax[4] = ssdcableslay5pcwateronrmin[4]
f7cd318e 7636 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7637 ssdcableslay5pcwateronrmin[5] = ssdcableslay5pconrmax[4];
7638 ssdcableslay5pconwaterrmax[5] = ssdcableslay5pcwateronrmin[4]
f7cd318e 7639 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7640 ssdcableslay5pconwaterzsection[4] = ssdcableslay5pconzsection[4];
7641 ssdcableslay5pconwaterzsection[5] = ssdcableslay5pconzsection[5];
7642 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[2]->DefineSection(i,ssdcableslay5pconwaterzsection[i+4],
7643 ssdcableslay5pcwateronrmin[i+4],ssdcableslay5pconwaterrmax[i+4]);
7644 ssdcableslay5pconwater[2] = new TGeoVolume("SSDCableLay5RightSidePConWater3",
7645 ssdcableslay5pconwatershape[2],fSSDCoolingTubeWater);
7646 ssdcableslay5pconwater[2]->SetLineColor(7);
7647////////////////////////////////////
7648 TGeoRotation* ssdcableslay5pconwaterot[4];
7649 TGeoHMatrix* ssdcablesLay5RightPConWaterToLeftMatrix[4];
7650 for(Int_t i=0; i<4; i++){
7651 ssdcableslay5pconwaterot[i] = new TGeoRotation();
7652 ssdcableslay5pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7653 ssdcablesLay5RightPConWaterToLeftMatrix[i] =
7654 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconwaterot[i]));
7655 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+1,ssdcableslay5pconwaterot[i]);
7656 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7657 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+1,ssdcableslay5pconwaterot[i]);
7658 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7659 }
7660 /////////////////////////
7661 // SSD Layer 6 Cables
7662 /////////////////////////
f7cd318e 7663 Double_t ssdcableslay6rigthsideradiusmin = fgkEndCapSupportMiddleRadius[1]+kSSDCablesLay6TubeRadiusMin;
7664 Double_t ssdcablelay6rightsidelength = 2.; // cm was 2.*ssdcablelay5rightsidelength;
7665 Double_t ssdcableslay6rightsideradiusmax = ssdcableslay6rigthsideradiusmin+kSSDCablesLay6RingArea/ssdcablelay6rightsidelength;
7666 // Printf(Form("Lay 6 cables, length %g, radius %g, thickness %g", ssdcablelay6rightsidelength, ssdcableslay6rigthsideradiusmin, kSSDCablesLay6RingArea/ssdcablelay6rightsidelength));
47f8de53 7667 TGeoTube* ssdcablelay6rightubeshape = new TGeoTube(ssdcableslay6rigthsideradiusmin,
7668 ssdcableslay6rightsideradiusmax,
7669 0.5*ssdcablelay6rightsidelength);
7670 TGeoVolume* ssdcablelay6righttube = new TGeoVolume("SSDCableLay6RightSideTube",
7671 ssdcablelay6rightubeshape,
7672 fSSDCopper);
7673 ssdcablelay6righttube->SetLineColor(9);
7674 TGeoTranslation* ssdcablelay6rightrans =
7675 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay6ITSPosition
7676 + fgkEndCapSupportCenterLay6Position
7677 + 0.5*ssdcablelay6rightsidelength);
7678 TGeoTranslation* ssdcablesLay6RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7679 - 0.5*ssdcablelay6rightsidelength
7680 - fgkEndCapSupportCenterLay6Position
7681 - fgkEndCapSupportCenterLay6ITSPosition);
7682 ssdcablesmother->AddNode(ssdcablelay6righttube,1,ssdcablelay6rightrans);
7683 ssdcablesmother->AddNode(ssdcablelay6righttube,2,ssdcablesLay6RightTubeToLeftrans);
f7cd318e 7684 // Printf(Form("Cables; ring layer 6, volume: %g",ssdcablelay6rightubeshape->Capacity()));
7685 totvol += ssdcablelay6rightubeshape->Capacity();
47f8de53 7686 ////////////////////////////////////
7687 //cablescapacity[8] = 2.*ssdcablelay6rightubeshape->Capacity();
7688 ////////////////////////////////////
f7cd318e 7689 // MvL: PCon is part of connection to patch panels;
7690 // removed since current volume is too thick; now absorbed in rings+connections
7691 /*
7692 TGeoPcon* ssdcableslay6pconshape = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
47f8de53 7693 ssdcableangle,2);
7694 TGeoVolume* ssdcableslay6pcon;
7695 Double_t ssdcableslay6pconrmin[2];
7696 Double_t ssdcableslay6pconrmax[2];
7697 Double_t ssdcableslay6pconzsection[2];
7698 ssdcableslay6pconrmin[0] = ssdcableslay6rigthsideradiusmin;
7699 ssdcableslay6pconrmax[0] = ssdcableslay6rightsideradiusmax;
7700 ssdcableslay6pconrmin[1] = ssdcableslay6pconrmin[0];
7701 ssdcableslay6pconrmax[1] = ssdcableslay6pconrmax[0];
7702 ssdcableslay6pconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7703 + fgkEndCapSupportCenterLay6Position
7704 + ssdcablelay6rightsidelength;
7705 ssdcableslay6pconzsection[1] = ssdcableslay5pconwaterzsection[5];
7706 for(Int_t i=0; i<2;i++) ssdcableslay6pconshape->DefineSection(i,ssdcableslay6pconzsection[i],
7707 ssdcableslay6pconrmin[i],ssdcableslay6pconrmax[i]);
f7cd318e 7708
47f8de53 7709 ssdcableslay6pcon = new TGeoVolume("SSDCableLay6RightSidePCon",
7710 ssdcableslay6pconshape,fSSDCopper);
7711 ssdcableslay6pcon->SetLineColor(9);
7712 for(Int_t i=0; i<4; i++){
7713 ssdcablesmother->AddNode(ssdcableslay6pcon,i+1,ssdcableslay5pconrot[i]);
7714 ssdcablesmother->AddNode(ssdcableslay6pcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7715 }
f7cd318e 7716 */
47f8de53 7717 ////////////////////////////////////
7718 //cablescapacity[9] = 8.*ssdcableslay6pconshape->Capacity();
7719 /////////////////////////
7720 // Water Tubes Layer 6
7721 /////////////////////////
7722 TGeoTube* ssdcablelay6righwatertubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax,
7723 ssdcableslay6rightsideradiusmax
f7cd318e 7724 + kSSDCablesLay5RightSideWaterHeight,
47f8de53 7725 0.5*ssdcablelay6rightsidelength);
7726 TGeoVolume* ssdcablelay6rightwatertube = new TGeoVolume("SSDCableLay6RightSideWaterTube",
7727 ssdcablelay6righwatertubeshape,
7728 fSSDCoolingTubeWater);
7729 ssdcablelay6rightwatertube->SetLineColor(7);
7730 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,1,ssdcablelay6rightrans);
7731 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,2,ssdcablesLay6RightTubeToLeftrans);
f7cd318e 7732 TGeoPcon* ssdcableslay6waterpconshape = new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,
47f8de53 7733 ssdcableangle,2);
7734 TGeoVolume* ssdcableslay6waterpcon;
7735 Double_t ssdcableslay6waterpconrmin[2];
7736 Double_t ssdcableslay6waterpconrmax[2];
7737 Double_t ssdcableslay6waterpconzsection[2];
7738 ssdcableslay6waterpconrmin[0] = ssdcableslay6rightsideradiusmax;
7739 ssdcableslay6waterpconrmax[0] = ssdcableslay6rightsideradiusmax
f7cd318e 7740 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7741 ssdcableslay6waterpconrmin[1] = ssdcableslay6waterpconrmin[0];
7742 ssdcableslay6waterpconrmax[1] = ssdcableslay6waterpconrmax[0];
7743 ssdcableslay6waterpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7744 + fgkEndCapSupportCenterLay6Position
7745 + ssdcablelay6rightsidelength;
7746 ssdcableslay6waterpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7747 for(Int_t i=0; i<2;i++) ssdcableslay6waterpconshape->DefineSection(i,ssdcableslay6waterpconzsection[i],
7748 ssdcableslay6waterpconrmin[i],ssdcableslay6waterpconrmax[i]);
7749 ssdcableslay6waterpcon = new TGeoVolume("SSDCableLay6RightSideWaterPCon",
7750 ssdcableslay6waterpconshape,fSSDCoolingTubeWater);
7751 ssdcableslay6waterpcon->SetLineColor(7);
7752 TGeoRotation* ssdcableslay6pconwaterot[4];
7753 TGeoRotation* ssdcablesLay6RightPConToLeftRot = new TGeoRotation();
7754 ssdcablesLay6RightPConToLeftRot->SetAngles(90.,180.,-90);
7755 TGeoHMatrix* ssdcablesLay6RightPConToLeftMatrix[4];
7756 for(Int_t i=0; i<4; i++){
7757 ssdcableslay6pconwaterot[i] = new TGeoRotation();
7758 ssdcableslay6pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7759 ssdcablesLay6RightPConToLeftMatrix[i] = new TGeoHMatrix((*ssdcablesLay6RightPConToLeftRot)
7760 * (*ssdcableslay6pconwaterot[i]));
7761 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+1,ssdcableslay6pconwaterot[i]);
7762 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+5,ssdcablesLay6RightPConToLeftMatrix[i]);
7763 }
7764 ////////////////////////////////////////
7765 // From ITS Ring to Patch Panel3-RB26
7766 ////////////////////////////////////////
7767 Double_t ssdcablepatchpanel3BB26radiusmin[2];
7768 Double_t ssdcablepatchpanel3BB26radiusmax[2];
7769 Double_t ssdcablepatchpanel3RB26zsection[2];
f7cd318e 7770 ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*kSSDPatchPanelHeight;// +2.8+0.003;//Avoid small overlap with SPDshieldring;
47f8de53 7771 ssdcablepatchpanel3BB26radiusmax[0] = ssdcablepatchpanel3BB26radiusmin[0]
f7cd318e 7772 + kSSDCablesHeight;
7773 ssdcablepatchpanel3BB26radiusmin[1] = kSSDPatchPanel2RB26Radius;
47f8de53 7774 ssdcablepatchpanel3BB26radiusmax[1] = ssdcablepatchpanel3BB26radiusmin[1]
f7cd318e 7775 + kSSDCablesHeight;
47f8de53 7776 ssdcablepatchpanel3RB26zsection[0] = 0.5*fgkSSDCentralSupportLength
f7cd318e 7777 + fgkSSDCentralAL3SupportLength
47f8de53 7778 + fgkSSDPConeZLength[0];
f7cd318e 7779 ssdcablepatchpanel3RB26zsection[1] = kSSDPatchPanel2RB26ITSDistance;
7780 // Printf(Form("RB26 cable length %g",ssdcablepatchpanel3RB26zsection[1]-ssdcablepatchpanel3RB26zsection[0]));
7781 // Printf(Form("Angular range %g",ssdcableangle));
7782
47f8de53 7783 TGeoPcon* ssdcablepatchpanel3RB26pconshape =
f7cd318e 7784 new TGeoPcon(90.0-kSSDCablesPatchPanel2RB26Angle[0]
47f8de53 7785 - 0.5*ssdcableangle,ssdcableangle,2);
7786 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB26pconshape->DefineSection(i,ssdcablepatchpanel3RB26zsection[i],
7787 ssdcablepatchpanel3BB26radiusmin[i],ssdcablepatchpanel3BB26radiusmax[i]);
7788 TGeoVolume* ssdcablepatchpanel3RB26pcon = new TGeoVolume("SSDCablePatchPanel3RB26",
7789 ssdcablepatchpanel3RB26pconshape,fSSDCopper);
7790 ssdcablepatchpanel3RB26pcon->SetLineColor(9);
85f741d8 7791 TGeoRotation* ssdcablepatchpanel3B26rot[4];
47f8de53 7792 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation();
67446e8a 7793 ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0);
f7cd318e 7794 ssdcablepatchpanel3B26rot[1]->SetAngles(kSSDCablesPatchPanel2RB26Angle[0]
7795 + kSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
67446e8a 7796 ssdcablepatchpanel3B26rot[2]->SetAngles(180.0,0.0,0.0);
f7cd318e 7797 ssdcablepatchpanel3B26rot[3]->SetAngles(180.0 + kSSDCablesPatchPanel2RB26Angle[0]
7798 + kSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
47f8de53 7799 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB26pcon,i+1,ssdcablepatchpanel3B26rot[i]);
f7cd318e 7800 // Printf(Form("Cable to patch panels RB26 volume: %g (x4)",ssdcablepatchpanel3RB26pcon->Capacity()));
47f8de53 7801 ////////////////////////////////////
7802 //cablescapacity[10] = 4.*ssdcablepatchpanel3RB26pconshape->Capacity();
7803 ////////////////////////////////////////
7804 // ITS Ring Cables RB26 Part
7805 ////////////////////////////////////////
7806 Double_t ssdcableitsring3BB26pconzsection[2];
7807 Double_t ssdcableitsring3BB26pconrmin[2];
7808 Double_t ssdcableitsring3BB26pconrmax[2];
7809 ssdcableitsring3BB26pconzsection[0] = 0.5*fgkSSDCentralSupportLength
7810 + fgkSSDCentralAL3SupportLength
7811 + (4.0/5.0)*fgkSSDPConeZLength[0];
7812 ssdcableitsring3BB26pconzsection[1] = ssdcablepatchpanel3RB26zsection[0];
f7cd318e 7813 ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*kSSDPatchPanelHeight;
7814 ssdcableitsring3BB26pconrmax[0] = ssdcableitsring3BB26pconrmin[0] + 2.5*kSSDCablesHeight; // widths of cable bunch is about half of patch panels; need factor 2.5
7815
47f8de53 7816 ssdcableitsring3BB26pconrmin[1] = ssdcablepatchpanel3BB26radiusmin[0];
7817 ssdcableitsring3BB26pconrmax[1] = ssdcablepatchpanel3BB26radiusmax[0];
7818 TGeoPcon* ssdcableitsring3BB26pconshape[4];
f7cd318e 7819 ssdcableitsring3BB26pconshape[0] = new TGeoPcon(90.0 - kSSDCablesPatchPanel2RB26Angle[0]
47f8de53 7820 - 0.5*ssdcableangle,ssdcableangle
f7cd318e 7821 + (kSSDCablesPatchPanel2RB26Angle[0]
7822 - kSSDCableAngle),2);
7823 ssdcableitsring3BB26pconshape[1] = new TGeoPcon(90.0 + kSSDCablesPatchPanel2RB26Angle[1]
47f8de53 7824 - 0.5*ssdcableangle,ssdcableangle
f7cd318e 7825 + 3.0*kSSDCableAngle
7826 - kSSDCablesPatchPanel2RB26Angle[1],2);
7827 ssdcableitsring3BB26pconshape[2] = new TGeoPcon(270-kSSDCablesPatchPanel2RB26Angle[0]
47f8de53 7828 - 0.5*ssdcableangle,ssdcableangle
f7cd318e 7829 - kSSDCableAngle
7830 + kSSDCablesPatchPanel2RB26Angle[0],2);
7831 ssdcableitsring3BB26pconshape[3] = new TGeoPcon(270.0+kSSDCablesPatchPanel2RB26Angle[1]
47f8de53 7832 - 0.5*ssdcableangle,ssdcableangle
f7cd318e 7833 + 3.0*kSSDCableAngle
7834 - kSSDCablesPatchPanel2RB26Angle[1],2);
47f8de53 7835 for(Int_t i=0;i<4;i++)
7836 for(Int_t j=0; j<2; j++) ssdcableitsring3BB26pconshape[i]->DefineSection(j,ssdcableitsring3BB26pconzsection[j],
7837 ssdcableitsring3BB26pconrmin[j],
7838 ssdcableitsring3BB26pconrmax[j]);
7839 TGeoVolume* ssdcableitsring3BB26pcon[4];
7840 ssdcableitsring3BB26pcon[0] = new TGeoVolume("SSDCableITSRing3RB26Part1",
7841 ssdcableitsring3BB26pconshape[0],fSSDCopper);
7842 ssdcableitsring3BB26pcon[1] = new TGeoVolume("SSDCableITSRing3RB26Part2",
7843 ssdcableitsring3BB26pconshape[1],fSSDCopper);
7844 ssdcableitsring3BB26pcon[2] = new TGeoVolume("SSDCableITSRing3RB26Part3",
7845 ssdcableitsring3BB26pconshape[2],fSSDCopper);
7846 ssdcableitsring3BB26pcon[3] = new TGeoVolume("SSDCableITSRing3RB26Part4",
7847 ssdcableitsring3BB26pconshape[3],fSSDCopper);
7848 for(Int_t i=0;i<4;i++){
7849 ssdcableitsring3BB26pcon[i]->SetLineColor(9);
5ef8864c 7850 ssdcablesmother->AddNode(ssdcableitsring3BB26pcon[i],1);
f7cd318e 7851 //Printf(Form("Cable to patch panels RB26 volume part 2: %g (%d)",ssdcableitsring3BB26pcon[i]->Capacity(),i));
47f8de53 7852}
f7cd318e 7853
47f8de53 7854 ////////////////////////////////////
7855 //cablescapacity[11] = ssdcableitsring3BB26pconshape[0]->Capacity()
7856 // + ssdcableitsring3BB26pconshape[1]->Capacity()
7857 // + ssdcableitsring3BB26pconshape[2]->Capacity()
7858 // + ssdcableitsring3BB26pconshape[3]->Capacity();
7859 ////////////////////////////////////////
7860 // From ITS Ring to Patch Panel2-RB24
7861 ////////////////////////////////////////
7862 Double_t ssdcablepatchpanel3BB24radiusmin[2];
7863 Double_t ssdcablepatchpanel3BB24radiusmax[2];
7864 Double_t ssdcablepatchpanel3RB24zsection[2];
7865 ssdcablepatchpanel3BB24radiusmin[0] = ssdcablepatchpanel3BB26radiusmin[0];
7866 ssdcablepatchpanel3BB24radiusmax[0] = ssdcablepatchpanel3BB26radiusmax[0];
f7cd318e 7867 ssdcablepatchpanel3BB24radiusmin[1] = kSSDPatchPanel2RB24Radius;
47f8de53 7868 ssdcablepatchpanel3BB24radiusmax[1] = ssdcablepatchpanel3BB24radiusmin[1]
f7cd318e 7869 + kSSDCablesHeight;
47f8de53 7870 ssdcablepatchpanel3RB24zsection[0] = -0.5*fgkSSDCentralSupportLength
7871 - fgkSSDCentralAL3SupportLength
7872 - fgkSSDPConeZLength[0];
f7cd318e 7873 ssdcablepatchpanel3RB24zsection[1] = -kSSDPatchPanel2RB24ITSDistance;
7874 //Printf(Form("RB24 cable length %g",ssdcablepatchpanel3RB24zsection[1]-ssdcablepatchpanel3RB24zsection[0]));
47f8de53 7875 TGeoPcon* ssdcablepatchpanel3RB24pconshape =
f7cd318e 7876 new TGeoPcon(90.0-kSSDCablesPatchPanel2RB24Angle[1]
47f8de53 7877 - 0.5*ssdcableangle,ssdcableangle,2);
7878 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB24pconshape->DefineSection(i,ssdcablepatchpanel3RB24zsection[i],
7879 ssdcablepatchpanel3BB24radiusmin[i],ssdcablepatchpanel3BB24radiusmax[i]);
7880 TGeoVolume* ssdcablepatchpanel3RB24pcon = new TGeoVolume("SSDCablePatchPanel3RB24",
7881 ssdcablepatchpanel3RB24pconshape,
7882 fSSDCopper);
7883 ssdcablepatchpanel3RB24pcon->SetLineColor(9);
85f741d8 7884 TGeoRotation* ssdcablepatchpanel3B24rot[4];
47f8de53 7885 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation();
67446e8a 7886 ssdcablepatchpanel3B24rot[0]->SetAngles(-6.0,0.0,0.0);
f7cd318e 7887 ssdcablepatchpanel3B24rot[1]->SetAngles(kSSDCablesPatchPanel2RB24Angle[0]
7888 + kSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
67446e8a 7889 ssdcablepatchpanel3B24rot[2]->SetAngles(174.0,0.0,0.0);
f7cd318e 7890 ssdcablepatchpanel3B24rot[3]->SetAngles(180.0+kSSDCablesPatchPanel2RB24Angle[0]
7891 + kSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
47f8de53 7892 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB24pcon,i+1,ssdcablepatchpanel3B24rot[i]);
f7cd318e 7893 //Printf(Form("Cable to patch panels RB24 volume: %g (x4)",ssdcablepatchpanel3RB24pcon->Capacity()));
47f8de53 7894 ////////////////////////////////////
7895 //cablescapacity[12] = 4.*ssdcablepatchpanel3RB24pconshape->Capacity();
7896 ////////////////////////////////////////
7897 // ITS Ring Cables RB24 Part
7898 ////////////////////////////////////////
7899 Double_t ssdcableitsring3BB24pconzsection[2];
7900 Double_t ssdcableitsring3BB24pconrmin[2];
7901 Double_t ssdcableitsring3BB24pconrmax[2];
7902 ssdcableitsring3BB24pconzsection[0] = -ssdcableitsring3BB26pconzsection[0];
7903 ssdcableitsring3BB24pconzsection[1] = ssdcablepatchpanel3RB24zsection[0];
f7cd318e 7904 ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*kSSDPatchPanelHeight;
7905 ssdcableitsring3BB24pconrmax[0] = ssdcableitsring3BB24pconrmin[0] + 2.5*kSSDCablesHeight; // Cable bunch width smaller; make it thicker
7906
47f8de53 7907 ssdcableitsring3BB24pconrmin[1] = ssdcablepatchpanel3BB24radiusmin[0];
7908 ssdcableitsring3BB24pconrmax[1] = ssdcablepatchpanel3BB24radiusmax[0];
7909 TGeoPcon* ssdcableitsring3BB24pconshape[4];
f7cd318e 7910 ssdcableitsring3BB24pconshape[0] = new TGeoPcon(kSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7911 + (90.0-kSSDCablesPatchPanel2RB24Angle[1]
7912 - kSSDCableAngle),2);
7913 ssdcableitsring3BB24pconshape[1] = new TGeoPcon(90.0+kSSDCableAngle-0.5*ssdcableangle,
7914 ssdcableangle-kSSDCableAngle
7915 + kSSDCablesPatchPanel2RB24Angle[0],2);
7916 ssdcableitsring3BB24pconshape[2] = new TGeoPcon(180.0+kSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7917 - kSSDCableAngle
7918 + 90.0 - kSSDCablesPatchPanel2RB24Angle[1],2);
7919 ssdcableitsring3BB24pconshape[3] = new TGeoPcon(270.0+kSSDCableAngle-0.5*ssdcableangle,
7920 ssdcableangle-kSSDCableAngle
7921 + kSSDCablesPatchPanel2RB24Angle[0],2);
47f8de53 7922 for(Int_t i=0;i<4;i++)
7923 for(Int_t j=0; j<2; j++) ssdcableitsring3BB24pconshape[i]->DefineSection(j,ssdcableitsring3BB24pconzsection[j],
7924 ssdcableitsring3BB24pconrmin[j],
7925 ssdcableitsring3BB24pconrmax[j]);
7926 TGeoVolume* ssdcableitsring3BB24pcon[4];
7927 ssdcableitsring3BB24pcon[0] = new TGeoVolume("SSDCableITSRing3RB24Part1",
7928 ssdcableitsring3BB24pconshape[0],fSSDCopper);
7929 ssdcableitsring3BB24pcon[1] = new TGeoVolume("SSDCableITSRing3RB24Part2",
7930 ssdcableitsring3BB24pconshape[1],fSSDCopper);
7931 ssdcableitsring3BB24pcon[2] = new TGeoVolume("SSDCableITSRing3RB24Part3",
7932 ssdcableitsring3BB24pconshape[2],fSSDCopper);
7933 ssdcableitsring3BB24pcon[3] = new TGeoVolume("SSDCableITSRing3RB24Part4",
7934 ssdcableitsring3BB24pconshape[3],fSSDCopper);
7935 for(Int_t i=0;i<4;i++){
7936 ssdcableitsring3BB24pcon[i]->SetLineColor(9);
5ef8864c 7937 ssdcablesmother->AddNode(ssdcableitsring3BB24pcon[i],1);
f7cd318e 7938 // Printf(Form("Cable to patch panels RB24 (part 2) volume: %g (%d)",ssdcableitsring3BB24pcon[i]->Capacity(),i));
47f8de53 7939}
f7cd318e 7940
47f8de53 7941 ////////////////////////////////////
7942 //cablescapacity[13] = ssdcableitsring3BB24pconshape[0]->Capacity()
7943 // + ssdcableitsring3BB24pconshape[1]->Capacity()
7944 // + ssdcableitsring3BB24pconshape[2]->Capacity()
7945 // + ssdcableitsring3BB24pconshape[3]->Capacity();
47f8de53 7946
f7cd318e 7947 // MvL: Pcon are connection to patch panels (part of)
7948 // Removed; do not contribute much; put into ring structure
7949 /*
47f8de53 7950 TGeoPcon* ssdcablelay6materialbudgetpconshape =
f7cd318e 7951 new TGeoPcon(90.0-kSSDCableAngle-0.5*ssdcableangle,ssdcableangle,2);
47f8de53 7952 TGeoVolume* ssdcablelay6materialbudgetpcon;
7953 Double_t ssdcablelay6materialbudgetpconrmin[2];
7954 Double_t ssdcablelay6materialbudgetpconrmax[2];
7955 Double_t ssdcablelay6materialbudgetpconzsection[2];
7956 ssdcablelay6materialbudgetpconrmin[0] = ssdcableslay6rightsideradiusmax
f7cd318e 7957 + kSSDCablesLay5RightSideWaterHeight;
47f8de53 7958 ssdcablelay6materialbudgetpconrmax[0] = ssdcablelay6materialbudgetpconrmin[0]
f7cd318e 7959 + kSSDCableMaterialBudgetHeight;
47f8de53 7960 ssdcablelay6materialbudgetpconrmin[1] = ssdcablelay6materialbudgetpconrmin[0];
7961 ssdcablelay6materialbudgetpconrmax[1] = ssdcablelay6materialbudgetpconrmax[0];
7962 ssdcablelay6materialbudgetpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7963 + fgkEndCapSupportCenterLay6Position
7964 + ssdcablelay6rightsidelength;
7965 ssdcablelay6materialbudgetpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7966 for(Int_t i=0; i<2;i++) ssdcablelay6materialbudgetpconshape->DefineSection(i,
7967 ssdcablelay6materialbudgetpconzsection[i],
7968 ssdcablelay6materialbudgetpconrmin[i],
7969 ssdcablelay6materialbudgetpconrmax[i]);
7970 ssdcablelay6materialbudgetpcon = new TGeoVolume("SSDCableLay6MaterialBudgetPCon",
7971 ssdcablelay6materialbudgetpconshape,fSSDCopper);
7972 ssdcablelay6materialbudgetpcon->SetLineColor(9);
7973 for(Int_t i=0; i<4; i++){
7974 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+1,ssdcableslay5pconrot[i]);
7975 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7976 }
f7cd318e 7977 */
47f8de53 7978////////////////////////////////////
7979 /* cablescapacity[14] = 2.*ssdcablelay6materialbudgetubeshape->Capacity();
7980 cablescapacity[15] = 2.*ssdcablelay6materialbudgetpconshape->Capacity();
7981 Double_t ssdcablesvolume = 0.0;
7982 for(Int_t i=0;i<16;i++) ssdcablesvolume+=cablescapacity[i];
7983 std::cout << ssdcablesvolume << std::endl;*/
f7cd318e 7984 // Printf(Form("Total volume (one side; without conn to patch panel): %g",totvol));
47f8de53 7985 return ssdcablesmother;
7986 }
7987 ////////////////////////////////////////////////////////////////////////////////
277f0a14 7988TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3 const * const vertexpos[4] , const Double_t* width,
b671cde1 7989 Double_t height, const char* shapename, Int_t isign) const{
44285dfa 7990 /////////////////////////////////////////////////////////////
7991 // Method generating an Arb shape
7992 /////////////////////////////////////////////////////////////
7993 const Int_t kvertexnumber = 8;
7994 const Int_t ktransvectnumber = 2;
b671cde1 7995 TVector3 vertex[kvertexnumber];
7996 TVector3 transvector[2];
7997 for(Int_t i=0; i<ktransvectnumber; i++) transvector[i].SetY(width[i]);
44285dfa 7998 /////////////////////////////////////////////////////////////
d7599219 7999 //Setting the vertices for TGeoArb8
44285dfa 8000 /////////////////////////////////////////////////////////////
b671cde1 8001 vertex[0] = *vertexpos[0];
8002 vertex[1] = *vertexpos[1];
8003 vertex[2] = vertex[1];
8004 vertex[3] = vertex[0];
8005 vertex[4] = *vertexpos[2];
8006 vertex[5] = *vertexpos[3];
8007 vertex[6] = vertex[5];
8008 vertex[7] = vertex[4];
8009
8010 // NB: order of points is clockwise
8011 if (isign < 0) {
8012 vertex[2] -= transvector[0];
8013 vertex[3] -= transvector[0];
8014 vertex[6] -= transvector[1];
8015 vertex[7] -= transvector[1];
8016 }
8017 else {
8018 vertex[0] += transvector[0];
8019 vertex[1] += transvector[0];
8020 vertex[4] += transvector[1];
8021 vertex[5] += transvector[1];
8022 }
8023
44285dfa 8024 /////////////////////////////////////////////////////////////
8025 TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
b671cde1 8026 for(Int_t i = 0; i<kvertexnumber;i++) {
8027 arbshape->SetVertex(i,vertex[i].X(),vertex[i].Y());
8028 }
8029
44285dfa 8030 return arbshape;
d7599219 8031}
bf210566 8032///////////////////////////////////////////////////////////////////////////////
8033TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
8034 Double_t rmax, Int_t nedges, Double_t height){
8035 /////////////////////////////////////////////////////////////
8036 // Method generating Arc shape
8037 /////////////////////////////////////////////////////////////
8038 const Int_t kvertexnumber = 2*nedges+2;
8039 TGeoXtru* arcshape = new TGeoXtru(2);
8040 TVector3** vertexposition[2];
8041 for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
8042 Double_t angle = 0.;
8043 for(Int_t i=0; i<nedges+1; i++){
8044 angle = 90.+0.5*phi-i*(phi/nedges);
8045 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle));
8046 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle));
8047 }
8048 Double_t *xvertexpoints = new Double_t[kvertexnumber];
8049 Double_t *yvertexpoints = new Double_t[kvertexnumber];
8050 for(Int_t i=0; i<kvertexnumber; i++){
8051 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
8052 yvertexpoints[i] = vertexposition[0][i]->Y();
8053 }
8054 else if(i>=1&&i<nedges+2)
8055 {
8056 xvertexpoints[i] = vertexposition[1][i-1]->X();
8057 yvertexpoints[i] = vertexposition[1][i-1]->Y();
8058 }
8059 else
8060 {
8061 xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
8062 yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
8063 }
8064 }
8065 arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
8066 arcshape->DefineSection(0,-0.5*height);
8067 arcshape->DefineSection(1,0.5*height);
44285dfa 8068 /////////////////////////////////////////////////////////////
bf210566 8069 // Deallocating memory
44285dfa 8070 /////////////////////////////////////////////////////////////
bf210566 8071 for(Int_t i=0; i<2; i++){
8072 for(Int_t j=0; j<nedges+1; j++)
8073 delete vertexposition[i][j];
8074 delete [] vertexposition[i];
8075 }
8076 delete [] xvertexpoints;
8077 delete [] yvertexpoints;
8078 /////////////////////////////////////////////////////////////
8079 return arcshape;
d7599219 8080}
8081////////////////////////////////////////////////////////////////////////////////
5cb5bc3d 8082TGeoShape* AliITSv11GeometrySSD::GetScrewShape(const Double_t* radius,const Int_t* edgesnumber,const Double_t* section) const {
9b0c60ab 8083 ///////////////////////////////////////////////////////////////////////
8084 // Method Generating the Screw Shape
8085 // radius[0]: outer radius
8086 // radius[1]: inner radius
8087 // edgesnumber[0]: outer number of edges
8088 // edgesnumber[1]: inner number of edges
8089 // section[0]: lower section position
8090 // section[1]: higher section position
8091 ///////////////////////////////////////////////////////////////////////
8092 Double_t outradius = radius[0];
8093 Double_t inradius = radius[1];
8094 Int_t outvertexnumber = edgesnumber[0];
8095 Int_t invertexnumber = edgesnumber[1];
851c0ce3 8096 Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8097 Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8098 for(Int_t i=0; i<outvertexnumber; i++){
9b0c60ab 8099 xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
8100 yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
8101 }
851c0ce3 8102 for(Int_t i=0; i<invertexnumber; i++){
8103 xscrewvertex[outvertexnumber+i] = inradius*CosD(90.+i*360./invertexnumber);
8104 yscrewvertex[outvertexnumber+i] = inradius*SinD(90.+i*360./invertexnumber);
9b0c60ab 8105 }
851c0ce3 8106 TGeoXtru* screwshapeout = new TGeoXtru(2);
8107 screwshapeout->DefinePolygon(outvertexnumber,xscrewvertex,yscrewvertex);
8108 screwshapeout->DefineSection(0,section[0]);
8109 screwshapeout->DefineSection(1,section[1]);
8110 TGeoXtru* screwshapein = new TGeoXtru(2);
8111 screwshapein->DefinePolygon(invertexnumber,&xscrewvertex[outvertexnumber],&yscrewvertex[outvertexnumber]);
8112 screwshapein->DefineSection(0,section[0]-0.01); // make inner part bigger in Z
8113 screwshapein->DefineSection(1,section[1]+0.01); // safer when we subtract it
8114 TGeoSubtraction *snode = new TGeoSubtraction(screwshapeout, screwshapein);
8115 TGeoCompositeShape *screwshape = new TGeoCompositeShape("", snode);
8116
9b0c60ab 8117 delete [] xscrewvertex;
8118 delete [] yscrewvertex;
8119 return screwshape;
8120}
8121////////////////////////////////////////////////////////////////////////////////
5cb5bc3d 8122TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, const Double_t *section) const {
9b0c60ab 8123 ///////////////////////////////////////////////////////////////////////
8124 // Method Generating the Hole Shape
8125 // radius of the Hole
8126 // nedges: number of edges to approximate the circle
8127 ///////////////////////////////////////////////////////////////////////
851c0ce3 8128 Double_t* xholevertex = new Double_t[nedges];
8129 Double_t* yholevertex = new Double_t[nedges];
8130 Double_t z = 0.5*(section[0]+section[1]);
8131 Double_t dz = 0.5*(section[1]-section[0]);
8132 TGeoTranslation *tr = 0;
8133 if (TMath::Abs(z) > TGeoShape::Tolerance()) {
8134 tr = new TGeoTranslation(0.,0.,z);
8135 tr->RegisterYourself();
8136 }
8137 TGeoBBox *box = new TGeoBBox("",radius,radius,dz);
8138 for(Int_t i=0; i<nedges; i++){
8139 xholevertex[i] = radius*CosD(i*360./nedges);
8140 yholevertex[i] = radius*SinD(i*360./nedges);
9b0c60ab 8141 }
851c0ce3 8142 TGeoXtru* holeshapeout = new TGeoXtru(2);
8143 holeshapeout->DefinePolygon(nedges,xholevertex,yholevertex);
8144 holeshapeout->DefineSection(0,section[0]-0.01); // make subtracted part larger in Z
8145 holeshapeout->DefineSection(1,section[1]+0.01);
8146 TGeoSubtraction *snode = new TGeoSubtraction(box,holeshapeout,tr);
8147 TGeoCompositeShape *holeshape = new TGeoCompositeShape("", snode);
8148
9b0c60ab 8149 delete [] xholevertex;
8150 delete [] yholevertex;
8151 return holeshape;
8152}
8153////////////////////////////////////////////////////////////////////////////////
5cb5bc3d 8154TVector3* AliITSv11GeometrySSD::GetReflection(const TVector3* vector,const Double_t* param) const{
44285dfa 8155 /////////////////////////////////////////////////////////////
8156 // Given an axis specified by param, it gives the reflection of the point
8157 // respect to the axis
8158 /////////////////////////////////////////////////////////////
8159 TVector3* n = new TVector3(param[0],param[1],param[2]);
8160 Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
8161 TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
bf210566 8162 /////////////////////////////////////////////////////////////
8163 // Deallocating memory
8164 /////////////////////////////////////////////////////////////
8165 delete n;
8166 /////////////////////////////////////////////////////////////
44285dfa 8167 return reflectedvector;
d7599219 8168}
8169////////////////////////////////////////////////////////////////////////////////
f510fd70 8170TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(const TGeoHMatrix* ct,
d7599219 8171 Double_t dx,
8172 Double_t dy,
8173 Double_t dz) const{
44285dfa 8174 /////////////////////////////////////////////////////////////
d7599219 8175 // Add a dx,dy,dz translation to the initial TGeoCombiTrans
44285dfa 8176 /////////////////////////////////////////////////////////////
bf210566 8177 TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
8178 const Double_t *vect = hmatrix->GetTranslation();
44285dfa 8179 Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
bf210566 8180 hmatrix->SetTranslation(newvect);
8181 TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
8182 delete hmatrix;
8183 return matrix;
d7599219 8184}
8185////////////////////////////////////////////////////////////////////////////////
d7599219 8186TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
44285dfa 8187 /////////////////////////////////////////////////////////////
8188 // Method returning the Medium type
8189 /////////////////////////////////////////////////////////////
a3f8715e 8190 char ch[100];
045be90c 8191 snprintf(ch,100, "ITS_%s",mediumName);
d7599219 8192 TGeoMedium* medium = gGeoManager->GetMedium(ch);
8193 if (! medium)
160835d5 8194 AliError(Form("medium %s not found !\n", mediumName));
d7599219 8195 return medium;
8196}
8197////////////////////////////////////////////////////////////////////////////////
d7599219 8198void AliITSv11GeometrySSD::CreateMaterials(){
8199///////////////////////////////////
8200// This part has to be modified
8201///////////////////////////////////
8202 ///////////////////////////////////
8203 // Silicon for Sensor
8204 ///////////////////////////////////
bf210566 8205 fSSDSensorMedium = GetMedium("SI$");
d7599219 8206 ///////////////////////////////////
8207 // Silicon Mixture for Sensor
8208 ///////////////////////////////////
44285dfa 8209 fSSDChipMedium = GetMedium("SPD SI CHIP$");
8210 fSSDChipGlueMedium = GetMedium("EPOXY$");
d7599219 8211 ///////////////////////////////////
8212 // Stiffener Components Materials
8213 ///////////////////////////////////
bf210566 8214 fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
d7599219 8215 ///////////////////////////
8216 // Stiffener Connectors
8217 ///////////////////////////
bf210566 8218 fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
d7599219 8219 ////////////////////////////////
8220 // Stiffener 0603-1812 Capacitor
8221 ////////////////////////////////
bf210566 8222 fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8223 fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
78e34526 8224 fSSDStiffenerCapacitorCapMedium = GetMedium("NiSn$");
d7599219 8225 ///////////////////////////
8226 // Stiffener Hybrid Wire
8227 ///////////////////////////
bf210566 8228 fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
d7599219 8229 ///////////////////////////
8230 // Al for Cooling Block
8231 ///////////////////////////
bf210566 8232 fSSDAlCoolBlockMedium = GetMedium("AL$");
d7599219 8233 //////////////////////////////////////////////////////
8234 // Kapton and Al for Chip Cable Flex and Ladder Cables
8235 //////////////////////////////////////////////////////
bf210566 8236 fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8237 fSSDAlTraceChipCableMedium = GetMedium("AL$");
8238 fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
8239 fSSDAlTraceFlexMedium = GetMedium("AL$");
8240 fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8241 fSSDAlTraceLadderCableMedium = GetMedium("AL$");
d7599219 8242 /////////////////////////////////////////////////////////////////
8243 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
8244 //////////////////////////////////////////////////////////////////
44285dfa 8245 fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
d7599219 8246 /////////////////////////////////////////////////////////////////
8247 // G10 for Detector Leg, TubeHolder
8248 //////////////////////////////////////////////////////////////////
44285dfa 8249 fSSDTubeHolderMedium = GetMedium("G10FR4$");
8250 fSSDSensorSupportMedium = GetMedium("G10FR4$");
8251 fSSDMountingBlockMedium = GetMedium("G10FR4$");
8252 fSSDMountingBlockMedium = GetMedium("G10FR4$");
d7599219 8253 /////////////////////////////////////////////////////////////////
8254 // Water and Phynox for Cooling Tube
8255 //////////////////////////////////////////////////////////////////
bf210566 8256 fSSDCoolingTubeWater = GetMedium("WATER$");
44285dfa 8257 fSSDCoolingTubePhynox = GetMedium("INOX$");
bf210566 8258 /////////////////////////////////////////////////////////////////////
9b0c60ab 8259 // Material for Support Rings
8260 /////////////////////////////////////////////////////////////////////
8261 fSSDSupportRingAl = GetMedium("AL$");
47f8de53 8262 fSSDRohaCellCone = GetMedium("ROHACELL$");
9b0c60ab 8263 /////////////////////////////////////////////////////////////////////
bf210566 8264 fSSDAir = GetMedium("SDD AIR$");
47f8de53 8265 fSSDCopper = GetMedium("COPPER$");
78e34526 8266 fSSDSn = GetMedium("Sn$");
bf210566 8267 fCreateMaterials = kTRUE;
d7599219 8268}
8269/////////////////////////////////////////////////////////////////////
277f0a14 8270