]> 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
Added fit macro from M. Putis
[u/mrichter/AliRoot.git] / ITS / AliITSv11GeometrySSD.cxx
CommitLineData
d7599219 1/**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 * *
4 * Author: The ALICE Off-line Project. *
5 * Contributors are mentioned in the code where appropriate. *
6 * *
7 * Permission to use, copy, modify and distribute this software and its *
8 * documentation strictly for non-commercial purposes is hereby granted *
9 * without fee, provided that the above copyright notice appears in all *
10 * copies and that both the copyright notice and this permission notice *
11 * appear in the supporting documentation. The authors make no claims *
12 * about the suitability of this software for any purpose. It is *
13 * provided "as is" without express or implied warranty. *
14 **************************************************************************/
15
5ef8864c 16/* $Id$ */
d7599219 17
18//*************************************************************************
19// SSD geometry, based on ROOT geometrical modeler
20//
21// Enrico Cattaruzza ecattar@ts.infn.it
22//*************************************************************************
23#include "TMath.h"
24#include "TGeoVolume.h"
d7599219 25#include "TGeoMatrix.h"
26#include <TGeoManager.h>
d7599219 27#include "TVector3.h"
28#include "TGeoArb8.h"
29#include "TList.h"
30#include "TGeoMatrix.h"
31#include "TGeoCompositeShape.h"
851c0ce3 32#include "TGeoBoolNode.h"
d7599219 33#include "TGeoTube.h"
34#include "TGeoBBox.h"
bf210566 35#include "TGeoXtru.h"
9b0c60ab 36#include "TGeoTorus.h"
37#include "TGeoPgon.h"
47f8de53 38#include "TGeoPcon.h"
9b0c60ab 39#include "TRotation.h"
44285dfa 40#include "AliITSv11GeometrySSD.h"
78e34526 41
d7599219 42/////////////////////////////////////////////////////////////////////////////////
bf210566 43// Names of the Sensitive Volumes of Layer 5 and Layer 6
44/////////////////////////////////////////////////////////////////////////////////
02d4acf9 45const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName5 = "ITSssdSensitivL5";
46const char* AliITSv11GeometrySSD::fgSSDsensitiveVolName6 = "ITSssdSensitivL6";
bf210566 47/////////////////////////////////////////////////////////////////////////////////
d7599219 48//Parameters for SSD Geometry
49/////////////////////////////////////////////////////////////////////////////////
e21cdd03 50// Variable for Vertical Disalignement of Modules
51/////////////////////////////////////////////////////////////////////////////////
ca86fdb4 52const Double_t AliITSv11GeometrySSD::fgkSSDTolerance = 0.0001*fgkmm;
0fb26117 53const Double_t AliITSv11GeometrySSD::fgkSSDModuleVerticalDisalignment = 0.2*fgkmm;
54const Double_t AliITSv11GeometrySSD::fgkSSDModuleSideDisalignment = 0.2*fgkmm;
160835d5 55// For ladders:
cd2243fb 56const Double_t AliITSv11GeometrySSD::fgkSSDLadderVerticalDisalignment = 0.520*fgkmm;
e21cdd03 57/////////////////////////////////////////////////////////////////////////////////
d7599219 58// Layer5 (lengths are in mm and angles in degrees)
59/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 60const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength = 950.7*fgkmm;
d7599219 61const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber = 22;
62const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber = 34;
9acf2ecc 63const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin = 378.0*fgkmm;
64const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax = 384.0*fgkmm;
65const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition = 467.85*fgkmm;
d7599219 66/////////////////////////////////////////////////////////////////////////////////
67// Layer6 (lengths are in mm and angles in degrees)
68/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 69const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength = 1068.0*fgkmm;
d7599219 70const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber = 25;
71const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber = 38;
9acf2ecc 72const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin = 428.0*fgkmm;
73const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax = 434.0*fgkmm;
74const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition = 526.50*fgkmm;
d7599219 75/////////////////////////////////////////////////////////////////////////////////
76// SSD Chips and Hybrid (lengths are in mm and angles in degrees)
77/////////////////////////////////////////////////////////////////////////////////
78const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber = 6;
9acf2ecc 79const Double_t AliITSv11GeometrySSD::fgkSSDChipLength = 11.100*fgkmm;
80const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth = 3.850*fgkmm;
81const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight = 0.180*fgkmm;
82const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength = 1.000*fgkmm;
bf210566 83const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength = fgkSSDChipLength;
84const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth = fgkSSDChipWidth;
9acf2ecc 85const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight = 0.030*fgkmm;
d7599219 86/////////////////////////////////////////////////////////////////////////////////
87// Stiffener (lengths are in mm and angles in degrees)
88/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 89const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength = 73.000*fgkmm;
90const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth = 6.500*fgkmm;
78e34526 91const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 0.295*fgkmm;
9acf2ecc 92const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist = 2.500*fgkmm;
78e34526 93const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603CapLength = 0.900*fgkmm; // Includes solder
bf210566 94const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length = 1.600*fgkmm;
9acf2ecc 95const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width = 0.870*fgkmm;
96const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height = 0.800*fgkmm;
78e34526 97const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812CapLength = 0.215*fgkmm;
9acf2ecc 98const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length = 4.600*fgkmm;
99const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width = 3.400*fgkmm;
78e34526 100const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height = 1.400*fgkmm;
9acf2ecc 101const Double_t AliITSv11GeometrySSD::fgkSSDWireLength = 30.000*fgkmm;
102const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius = 0.185*fgkmm;
78e34526 103const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2] = {44.32*fgkmm, 0.33*fgkmm};
bf210566 104const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation = 0.44*fgkmm;
105const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength = 2.16*fgkmm;
106const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth = 3.60*fgkmm;
78e34526 107const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight = 0.25*fgkSSDStiffenerHeight;
bf210566 108const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight = 0.030*fgkmm;
109const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight = 0.002*fgkmm;
78e34526 110const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSnHeight = 0.15*fgkmm;
d7599219 111/////////////////////////////////////////////////////////////////////////////////
112// Cooling Block (lengths are in mm and angles in degrees)
113/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 114const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength = 3.000*fgkmm;
115const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth = 4.000*fgkmm;
bf210566 116const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
117 {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
d7599219 118const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
78e34526 119 {1.025*fgkmm, 0.120*fgkmm}; // Added 50 micron tolerance for thicker wall cooling pipe (March 2010)
d7599219 120const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
bf210566 121 {1.900*fgkmm, 0.400*fgkmm};
d7599219 122const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter =
9acf2ecc 123 1.500*fgkmm;
d7599219 124const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight =
9acf2ecc 125 0.300*fgkmm;
d7599219 126/////////////////////////////////////////////////////////////////////////////////
127// SSD Sensor (lengths are in mm and angles in degrees)
128/////////////////////////////////////////////////////////////////////////////////
129const char* AliITSv11GeometrySSD::fgkSSDSensitiveVolName =
bf210566 130 "SSDSensorSensitiveVol";
9acf2ecc 131const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength = 42.000*fgkmm;
132const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight = 0.300*fgkmm;
133const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth = 75.000*fgkmm;
d7599219 134const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap =
9acf2ecc 135 fgkSSDSensorLength-39.1*fgkmm;
bf210566 136const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength = 1.*fgkmm;
137const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth = 1.*fgkmm;
d7599219 138/////////////////////////////////////////////////////////////////////////////////
139// Flex (lengths are in mm and angles in degrees)
140/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 141const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength = 106.000*fgkmm;
d7599219 142const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4] =
bf210566 143 {0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
144 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
145 0.5 * (fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
146 + (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)
147 - 4.000*fgkmm, 9.500*fgkmm, 10.000*fgkmm};
d7599219 148const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2] =
bf210566 149 { 9.340*fgkmm, 5.380*fgkmm};
d7599219 150const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2] =
bf210566 151 { 0.030*fgkmm, 0.020*fgkmm};
d7599219 152const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle = 30.000;
9acf2ecc 153const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength = 1.430*fgkmm;
154const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth = 3.000*fgkmm;
d7599219 155const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
bf210566 156 {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
d7599219 157const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
bf210566 158 {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
d7599219 159/////////////////////////////////////////////////////////////////////////////////
160// SSD Ladder Cable (lengths are in mm and angles in degrees)
161/////////////////////////////////////////////////////////////////////////////////
bf210566 162const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth = 23.5*fgkmm;
78e34526 163const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableHeight[2] = { 0.030*fgkmm*17.5/23.5, 1.25 * 0.030*fgkmm}; // Al covers ~ 17.5/23.5 of surface, Kapton includes glue+foam
d7599219 164/////////////////////////////////////////////////////////////////////////////////
165// SSD Module (lengths are in mm and angles in degrees)
166/////////////////////////////////////////////////////////////////////////////////
167const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2] =
bf210566 168 { 1.000*fgkmm, 3.900*fgkmm};
d7599219 169const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
9acf2ecc 170 45.600*fgkmm;
d7599219 171const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor =
9acf2ecc 172 5.075*fgkmm;
d7599219 173/////////////////////////////////////////////////////////////////////////////////
174// Sensor Support (lengths are in mm and angles in degrees)
175/////////////////////////////////////////////////////////////////////////////////
bf210566 176const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength =
177 5.800*fgkmm;
d7599219 178const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth =
bf210566 179 2.000*fgkmm;
d7599219 180const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
0fb26117 181 { 4.620*fgkmm-fgkSSDModuleVerticalDisalignment,
182 5.220*fgkmm-fgkSSDModuleVerticalDisalignment};
ca86fdb4 183//const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
184// { 4.520*fgkmm, 5.130*fgkmm};
bf210566 185const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] =
186 { 0.450*fgkmm, 0.450*fgkmm};
187const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition
188 = 0.5 * (fgkSSDModuleSensorSupportDistance
189 + fgkSSDSensorSideSupportThickness[0])
190 - fgkSSDSensorSideSupportLength;
d7599219 191const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength =
bf210566 192 5.250*fgkmm;
d7599219 193const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth =
bf210566 194 1.680*fgkmm;
195const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]
196 = {fgkSSDSensorSideSupportHeight[0]
197 + fgkSSDSensorSideSupportThickness[0],
198 fgkSSDSensorSideSupportHeight[1]
199 + fgkSSDSensorSideSupportThickness[1]};
200const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2]
201 = {fgkSSDSensorSideSupportThickness[0],
202 fgkSSDSensorSideSupportThickness[1]};
d7599219 203const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition =
bf210566 204 19.000*fgkmm;
d7599219 205/////////////////////////////////////////////////////////////////////////////////
206// Chip Cables (lengths are in mm and angles in degrees)
207/////////////////////////////////////////////////////////////////////////////////
208const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2] =
bf210566 209 {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
d7599219 210const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4] =
bf210566 211 { 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
212 - (fgkSSDSensorSideSupportHeight[1]
213 - fgkSSDSensorSideSupportHeight[0])
0fb26117 214 - fgkSSDModuleVerticalDisalignment
bf210566 215 - fgkSSDCoolingBlockHoleCenter
216 - fgkSSDStiffenerHeight
217 - fgkSSDChipHeight-fgkSSDSensorHeight,
218 fgkSSDModuleCoolingBlockToSensor
0fb26117 219 - fgkSSDModuleVerticalDisalignment
bf210566 220 - fgkSSDCoolingBlockHoleCenter
221 - fgkSSDStiffenerHeight
222 - fgkSSDChipHeight-fgkSSDSensorHeight};
d7599219 223const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3] =
bf210566 224 { 11.000*fgkmm, 0.800*fgkmm, 0.600*fgkmm};
d7599219 225/////////////////////////////////////////////////////////////////////////////////
226// Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
227/////////////////////////////////////////////////////////////////////////////////
228const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
bf210566 229 3.820*fgkmm;
230//const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
231// 3.780;
d7599219 232const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth =
bf210566 233 fgkSSDSensorLength-fgkSSDSensorOverlap;
d7599219 234const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2] =
bf210566 235 { 0.86*fgkmm, 0.30*fgkmm};
d7599219 236const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2] =
bf210566 237 { 30.00, 90.00};
d7599219 238const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
bf210566 239 1.78*fgkmm;
d7599219 240/////////////////////////////////////////////////////////////////////////////////
241//Carbon Fiber Parameters (lengths are in mm and angles in degrees)
242/////////////////////////////////////////////////////////////////////////////////
bf210566 243const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength
244 = fgkSSDModuleSensorSupportDistance
245 - 2. * fgkCarbonFiberJunctionToSensorSupport;
246const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00;
d7599219 247const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2] =
bf210566 248 { 0.751*fgkmm, 0.482*fgkmm};
249const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength =
250 1.630*fgkmm;
251const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth = 0.950*fgkmm;
252const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength
253 = fgkCarbonFiberTriangleLength
254 - 0.5*fgkCarbonFiberSupportTopEdgeDist[1]
255 / TMath::Cos(fgkCarbonFiberTriangleAngle
256 * TMath::DegToRad());
257const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength
258 = 0.5*(fgkCarbonFiberJunctionWidth
259 - fgkCarbonFiberSupportWidth)
260 - fgkCarbonFiberSupportTopEdgeDist[0]
261 - fgkCarbonFiberSupportWidth;
d7599219 262/////////////////////////////////////////////////////////////////////////////////
263// Carbon Fiber Lower Support Parameters (lengths are in mm)
264/////////////////////////////////////////////////////////////////////////////////
c40ebacc 265const Double_t AliITSv11GeometrySSD::fgkLowerSupportToSensorZ = 11.575*fgkmm;
d7599219 266const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
9acf2ecc 267 = 0.950*fgkmm;
d7599219 268const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
9acf2ecc 269 = 1.600*fgkmm;
d7599219 270const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
9acf2ecc 271 = 0.830*fgkmm;
d7599219 272const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
273 = 0.5*fgkCarbonFiberSupportWidth;
274const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
bf210566 275 = fgkCarbonFiberJunctionWidth
276 - 2. * (fgkCarbonFiberLowerSupportWidth
277 + fgkCarbonFiberLowerSupportVolumeSeparation);
d7599219 278const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
bf210566 279 = {fgkCarbonFiberLowerSupportWidth
280 + fgkCarbonFiberLowerSupportVolumeSeparation,
281 fgkCarbonFiberLowerSupportWidth
282 + fgkCarbonFiberLowerSupportVolumeSeparation
283 + fgkCarbonFiberLowerSupportTransverseWidth};
d7599219 284/////////////////////////////////////////////////////////////////////////////////
285// End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
286/////////////////////////////////////////////////////////////////////////////////
287const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
bf210566 288 {0.5 * (fgkSSDLay5LadderLength
289 - fgkSSDLay5SensorsNumber
290 * fgkCarbonFiberJunctionWidth
291 - fgkCarbonFiberLowerSupportWidth),
292 0.5 * (fgkSSDLay5LadderLength
293 - fgkSSDLay5SensorsNumber
294 * fgkCarbonFiberJunctionWidth
295 + fgkCarbonFiberLowerSupportWidth)};
d7599219 296const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
bf210566 297 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
298 fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
d7599219 299const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
bf210566 300 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
301 fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
9b0c60ab 302const Double_t AliITSv11GeometrySSD::fgkendladdercoolingsupportdistance[3] =
303 {15.0*fgkmm, 13.5*fgkmm, 14.5*fgkmm};
d7599219 304/////////////////////////////////////////////////////////////////////////////////
305// Cooling Tube Support (lengths are in mm and angles in degrees)
306/////////////////////////////////////////////////////////////////////////////////
bf210566 307const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax = 1.45*fgkmm;
d7599219 308const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
309 = fgkSSDCoolingBlockHoleRadius[0];
bf210566 310const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength = 8.55*fgkmm;
311const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight = 0.85*fgkmm;
312const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth = 2.00*fgkmm;
d7599219 313const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation =
bf210566 314 fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
315const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber =
316 11.70*fgkmm;
d7599219 317/////////////////////////////////////////////////////////////////////////////////
318// Cooling Tube (lengths are in mm and angles in degrees)
319/////////////////////////////////////////////////////////////////////////////////
bf210566 320const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
78e34526 321const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 1.915*fgkmm/2; // Nominal + 50 micron tolerance; real pipes are closer to 450 micron wall thickness
bf210566 322const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
d7599219 323 fgkCarbonFiberJunctionWidth;
324const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
bf210566 325 fgkSSDModuleSensorSupportDistance
326 + fgkSSDCoolingBlockLength;
9b0c60ab 327const Double_t AliITSv11GeometrySSD::fgkMountingBlockToSensorSupport = 30.7*fgkmm;
d7599219 328/////////////////////////////////////////////////////////////////////////////////
329// SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
330/////////////////////////////////////////////////////////////////////////////////
331const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3] =
bf210566 332 { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
d7599219 333const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4] =
bf210566 334 { 4.0*fgkmm, 8.0*fgkmm, 5.0*fgkmm, 0.2*fgkmm};
d7599219 335const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth =
bf210566 336 20.0*fgkmm;
d7599219 337const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle =
bf210566 338 40.0;
d7599219 339const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight =
340 0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
341const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
bf210566 342 2.5*fgkmm;
d7599219 343const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2] =
bf210566 344 { 56.0*fgkmm, 12.0*fgkmm};
d7599219 345const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2] =
bf210566 346 { 5.0*fgkmm, 2.9*fgkmm};
d7599219 347const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius =
bf210566 348 1.0*fgkmm;
d7599219 349const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge =
bf210566 350 6.0*fgkmm;
cd2243fb 351const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeight =
bf210566 352 4.0*fgkmm;
d7599219 353const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2] =
bf210566 354 { 1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
d7599219 355/////////////////////////////////////////////////////////////////////////////////
9b0c60ab 356// SSD Mounting Block Clip Parameters (lengths are in mm and angles in degrees)
357/////////////////////////////////////////////////////////////////////////////////
358const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipLength = 15.1*fgkmm;
359const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipThickness = 0.3*fgkmm;
360const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewRadius = 1.6*fgkmm;
361const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewPosition = 4.0*fgkmm;
362const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibWidth = 9.0*fgkmm;
363/////////////////////////////////////////////////////////////////////////////////
364// SSD Mounting Block Support Parameters (lengths are in mm and angles in degrees)
365/////////////////////////////////////////////////////////////////////////////////
366const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportWidth[2] = {9.5*fgkmm,10.0*fgkmm};
367const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportDownHeight = 4.0*fgkmm;
368const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDLay5RadiusMin
369 - fgkSSDMountingBlockHeight[1]
370 + 0.5*fgkCoolingTubeSupportHeight
371 + fgkSSDModuleCoolingBlockToSensor
372 - fgkMountingBlockSupportDownHeight,
373 fgkSSDLay6RadiusMin
374 - fgkSSDMountingBlockHeight[1]
375 + 0.5*fgkCoolingTubeSupportHeight
376 + fgkSSDModuleCoolingBlockToSensor
377 - fgkMountingBlockSupportDownHeight};
378const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax
379 - fgkSSDMountingBlockHeight[1]
380 + 0.5*fgkCoolingTubeSupportHeight
381 + fgkSSDModuleCoolingBlockToSensor
382 - fgkMountingBlockSupportRadius[0],
383 fgkSSDLay6RadiusMax
384 - fgkSSDMountingBlockHeight[1]
385 + 0.5*fgkCoolingTubeSupportHeight
386 + fgkSSDModuleCoolingBlockToSensor
387 - fgkMountingBlockSupportRadius[1]};
cd2243fb 388const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeight = 10.0*fgkmm; // To be verified
9b0c60ab 389const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
390const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
391/////////////////////////////////////////////////////////////////////////////////
392// SSD End Cap Cover Plate Parameters (lengths are in mm and angles in degrees)
393/////////////////////////////////////////////////////////////////////////////////
394const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleRadius = 1.25*fgkmm;
395const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateBigHoleRadius = 2.45*fgkmm;
396const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateThickness = 0.5*fgkmm;
397const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleSeparation[3] =
398 {16.5*fgkmm,22.0*fgkmm,7.*fgkmm};
399const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateLength[6] =
400 {7.*fgkmm,55.*fgkmm,8.0*fgkmm,53.*fgkmm,61.0*fgkmm,25.5*fgkmm};
401const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateWidth[3] =
402 {68.5*fgkmm,75.5*fgkmm,6.5*fgkmm};
403const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMin = 0.750*fgkmm;
404const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMax = 2.*fgkmm;
405const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipLength = 10.4*fgkmm;
406const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipWidth = 6.0*fgkmm;
407const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipLength = 5.7*fgkmm;
408const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipWidth = 5.0*fgkmm;
409/////////////////////////////////////////////////////////////////////////////////
410// SSD End Cap Kapton Foil Parameters (lengths are in mm and angles in degrees)
411/////////////////////////////////////////////////////////////////////////////////
412const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilThickness = 0.4*fgkmm;
413const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilLength = 68.0*fgkmm;
414const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilWidth = 75.0*fgkmm;
415/////////////////////////////////////////////////////////////////////////////////
416// SSD End Cap Cooling Tube Parameters (lengths are in mm and angles in degrees)
417/////////////////////////////////////////////////////////////////////////////////
418const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAxialRadius[2] =
419 {10.5*fgkmm,9.25*fgkmm};
420const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMin = 1.3*fgkmm;
421const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMax = 1.5*fgkmm;
422const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAngle[5] =
423 {182.3,177.9,84.4,70.0,35.0};
424const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeLength[5] =
425 {49.5*fgkmm,41.7*fgkmm,47.6*fgkmm,5.0*fgkmm};
426const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeToCoverSide = 13.0*fgkmm;
427/////////////////////////////////////////////////////////////////////////////////
428// SSD End Cap Cover Side Parameters (lengths are in mm and angles in degrees)
429/////////////////////////////////////////////////////////////////////////////////
430const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverLength[5] = {3.5*fgkmm,
431 6.5*fgkmm,75.0*fgkmm,8.0*fgkmm,2.0*fgkmm};
432const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverWidth[7] = {30.9*fgkmm,
433 47.5*fgkmm,12.6*fgkmm,5.6*fgkmm,
434 20.0*fgkmm,7.0*fgkmm,5.9*fgkmm};
435const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverThickness = 0.4*fgkmm;
436/////////////////////////////////////////////////////////////////////////////////
437// SSD End Cap Cards Parameters (lengths are in mm and angles in degrees)
438/////////////////////////////////////////////////////////////////////////////////
439const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackLength[3] =
440 {62.0*fgkmm,21.87*fgkmm};
441const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackWidth[2] =
7708d5f3 442 {47.0*fgkmm,0.35*fgkmm};
9b0c60ab 443const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackThickness =
444 1.0*fgkmm;
445const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLength = 61.8*fgkmm;
446const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerWidth[2] =
447 {43.5*fgkmm, 0.70*fgkmm};
448const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerThickness =
449 0.15*fgkmm;
450const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorThickness =
451 19.0*fgkmm;
452const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorLength[2] =
453 {4.80*fgkmm,1.1*fgkmm};
454const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorWidth[2] =
455 {3.3*fgkmm,1.10*fgkmm};
456const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorToLayer =
457 2.1*fgkmm;
458const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorLength[3] =
459 {5.2*fgkmm,3.5*fgkmm,1.2*fgkmm};
460const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorWidth[2] =
461 {1.9*fgkmm,0.15*fgkmm};
462const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorThickness =
463 19*fgkmm;
464const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorDistance =
465 1.0*fgkmm;
466const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorToLayer =
467 3.6*fgkmm;
468const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionLength =
469 61.0*fgkmm;
470const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionThickness =
471 5.97*fgkmm;
472const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionWidth = 3.0*fgkmm;
473const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBLength[7] =
474 {3.1*fgkmm,68.0*fgkmm,3.6*fgkmm,
475 1.9*fgkmm,2.5*fgkmm,14.2*fgkmm,1.5*fgkmm};
476const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBWidth[5] =
477 {17.0*fgkmm,10.0*fgkmm,5.9*fgkmm,6.4*fgkmm,3.9*fgkmm};
478const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBThickness =
479 1.0*fgkmm;
480const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceElectBoardCardBThickness
481 = 0.15*fgkmm;
482const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBJMDConnectorSeparation =
483 20.0*fgkmm;
484const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerLength = 68.0*fgkmm;
485const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerWidth = 5.0*fgkmm;
486const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerThickness = 5.0*fgkmm;
487const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMin = 1.25*fgkmm; // To Be Checked
488const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMax = 1.575*fgkmm; // To Be Checked
489/////////////////////////////////////////////////////////////////////////////////
490// SSD End Cap SupportLayer5/6 Side Parameters (lengths are in mm and angles in degrees)
491/////////////////////////////////////////////////////////////////////////////////
492const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLength[2] = {70.424*fgkmm,72.919*fgkmm};
493const Double_t AliITSv11GeometrySSD::fgkEndCapSupportMiddleRadius[2] = {377.0*fgkmm,437.0*fgkmm};
47f8de53 494const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {375.0*fgkmm,435.0*fgkmm};
9b0c60ab 495const Double_t AliITSv11GeometrySSD::fgkEndCapSupportHighWidth = 20.0*fgkmm;
496const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowWidth[2] = {3.0*fgkmm,3.0*fgkmm};
497const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 625.0*fgkmm;
498const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm;
499const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm;
500const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm;
501/////////////////////////////////////////////////////////////////////////////////
47f8de53 502// SSD Cone Parameters (lengths are in mm and angles in degrees)
503/////////////////////////////////////////////////////////////////////////////////
504const Double_t AliITSv11GeometrySSD::fgkSSDLowerPConeRadius = 296.5*fgkmm;
505const Double_t AliITSv11GeometrySSD::fgkSSDPConeAngle = 39.0;
fcfbdd23 506const Double_t AliITSv11GeometrySSD::fgkSSDPConeZLength[2] = {168.0*fgkmm,153.0*fgkmm};
47f8de53 507const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleRadius = 317.5*fgkmm;
508const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleLength = 20.*fgkmm;
509const Double_t AliITSv11GeometrySSD::fgkSSDConeMiddleRadius = 350.*fgkmm;
510const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleLength = 30.*fgkmm;
511const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleWidth = 40.*fgkmm;
512const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpRadius = 400.*fgkmm;
fcfbdd23 513const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMaxRadius = 459.*fgkmm;
47f8de53 514const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMiddleRadius = 472.5*fgkmm;
515const Double_t AliITSv11GeometrySSD::fgkSSDPConeDownRadius = 282.0*fgkmm;
516const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidAngle = 42.0;
517const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidBasis = 200.0*fgkmm;
518const Double_t AliITSv11GeometrySSD::fgkSSDPConeExternalRadius = 492.5*fgkmm;
519const Double_t AliITSv11GeometrySSD::fgkSSDPConeRadiusWidth = 16.75*fgkmm;
fcfbdd23 520const Double_t AliITSv11GeometrySSD::fgkSSDPConeLength = 168.0*fgkmm;
47f8de53 521const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportLength = 1020.*fgkmm;
522const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportRadius = 297.5*fgkmm;
523const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportWidth = 6.28*fgkmm;
524const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportLength = 60.0*fgkmm;
525const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportWidth = 2.5*fgkSSDCentralSupportWidth;
526/////////////////////////////////////////////////////////////////////////////////
527// SSD Cables Parameters (lengths are in mm and angles in degrees)
528/////////////////////////////////////////////////////////////////////////////////
529const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5TubeRadiusMin = 11.9*fgkmm;
530const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay6TubeRadiusMin = 11.9*fgkmm;
531const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5RightSideHeight = 7.*fgkmm; // to be fixed in order to reproduce material budget
532const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay6RightSideHeight = 7.*fgkmm; // to be fixed in order to reproduce material budget
533const Double_t AliITSv11GeometrySSD::fgkSSDCableAngle = 22.5;
534const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5RightSideWaterHeight = 2.5*fgkmm; // to be fixed in order to reproduce material budget
535const Double_t AliITSv11GeometrySSD::fgkSSDCablesPatchPanel2RB26Angle[2] = {25.0,53.2};
536const Double_t AliITSv11GeometrySSD::fgkSSDCablesPatchPanel2RB24Angle[2] = {23.0,53.6};
537const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26ITSDistance = 975.0*fgkmm;
538const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24ITSDistance = 1020.0*fgkmm;
539const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = 451.3*fgkmm;
540const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = 451.3*fgkmm;
cd2243fb 541const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanelHeight = 87.5*fgkmm;
47f8de53 542const Double_t AliITSv11GeometrySSD::fgkSSDCableMaterialBudgetHeight = 20.0*fgkmm;
543//const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = fgkSSDPConeExternalRadius;
544//const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = fgkSSDPConeExternalRadius;
545/////////////////////////////////////////////////////////////////////////////////
44285dfa 546ClassImp(AliITSv11GeometrySSD)
547/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 548AliITSv11GeometrySSD::AliITSv11GeometrySSD():
549 AliITSv11Geometry(),
44285dfa 550 fSSDChipMedium(),
551 fSSDChipGlueMedium(),
552 fSSDStiffenerMedium(),
553 fSSDStiffenerConnectorMedium(),
554 fSSDStiffener0603CapacitorMedium(),
555 fSSDStiffener1812CapacitorMedium(),
78e34526 556 fSSDStiffenerCapacitorCapMedium(),
44285dfa 557 fSSDStiffenerHybridWireMedium(),
558 fSSDKaptonFlexMedium(),
559 fSSDAlTraceFlexMedium(),
560 fSSDAlTraceLadderCableMedium(),
561 fSSDKaptonLadderCableMedium(),
562 fSSDKaptonChipCableMedium(),
563 fSSDAlTraceChipCableMedium(),
564 fSSDAlCoolBlockMedium(),
565 fSSDSensorMedium(),
566 fSSDSensorSupportMedium(),
567 fSSDCarbonFiberMedium(),
568 fSSDTubeHolderMedium(),
569 fSSDCoolingTubeWater(),
570 fSSDCoolingTubePhynox(),
9b0c60ab 571 fSSDSupportRingAl(),
44285dfa 572 fSSDMountingBlockMedium(),
47f8de53 573 fSSDRohaCellCone(),
bf210566 574 fSSDAir(),
47f8de53 575 fSSDCopper(),
78e34526 576 fSSDSn(),
bf210566 577 fCreateMaterials(kFALSE),
578 fTransformationMatrices(kFALSE),
579 fBasicObjects(kFALSE),
580 fcarbonfiberjunction(),
581 fcoolingtubesupport(),
582 fhybridmatrix(),
583 fssdcoolingblocksystem(),
584 fcoolingblocksystematrix(),
585 fssdstiffenerflex(),
586 fssdendflex(),
cd2243fb 587 fcoolingtube(0),
9b0c60ab 588 fendladdercoolingtubesupportmatrix(),
bf210566 589 fendladdermountingblock(),
9b0c60ab 590 fendladdermountingblockclip(),
bf210566 591 fSSDSensor5(),
592 fSSDSensor6(),
593 fSSDLayer5(),
594 fSSDLayer6(),
595 fMotherVol(),
9b0c60ab 596 fLay5LadderSupportRing(),
597 fLay6LadderSupportRing(),
e5bf64ae 598 fgkEndCapSupportSystem(),
47f8de53 599 fSSDCone(),
44285dfa 600 fColorCarbonFiber(4),
601 fColorRyton(5),
bf210566 602 fColorPhynox(14),
44285dfa 603 fColorSilicon(3),
bf210566 604 fColorAl(38),
78e34526 605 fColorNiSn(40),
44285dfa 606 fColorKapton(6),
607 fColorPolyhamide(5),
608 fColorStiffener(9),
bf210566 609 fColorEpoxy(30),
610 fColorWater(7),
611 fColorG10(41)
44285dfa 612{
613 ////////////////////////
614 // Standard constructor
615 ////////////////////////
44285dfa 616}
617/////////////////////////////////////////////////////////////////////////////////
618AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
9acf2ecc 619 AliITSv11Geometry(s.GetDebug()),
44285dfa 620 fSSDChipMedium(s.fSSDChipMedium),
621 fSSDChipGlueMedium(s.fSSDChipGlueMedium),
622 fSSDStiffenerMedium(s.fSSDStiffenerMedium),
623 fSSDStiffenerConnectorMedium(s.fSSDStiffenerConnectorMedium),
624 fSSDStiffener0603CapacitorMedium(s.fSSDStiffener0603CapacitorMedium),
625 fSSDStiffener1812CapacitorMedium(s.fSSDStiffener1812CapacitorMedium),
78e34526 626 fSSDStiffenerCapacitorCapMedium(s.fSSDStiffenerCapacitorCapMedium),
44285dfa 627 fSSDStiffenerHybridWireMedium(s.fSSDStiffenerHybridWireMedium),
628 fSSDKaptonFlexMedium(s.fSSDKaptonFlexMedium),
629 fSSDAlTraceFlexMedium(s.fSSDAlTraceFlexMedium),
630 fSSDAlTraceLadderCableMedium(s.fSSDAlTraceLadderCableMedium),
631 fSSDKaptonLadderCableMedium(s.fSSDKaptonLadderCableMedium),
632 fSSDKaptonChipCableMedium(s.fSSDKaptonChipCableMedium),
633 fSSDAlTraceChipCableMedium(s.fSSDAlTraceChipCableMedium),
634 fSSDAlCoolBlockMedium(s.fSSDAlCoolBlockMedium),
635 fSSDSensorMedium(s.fSSDSensorMedium),
636 fSSDSensorSupportMedium(s.fSSDSensorSupportMedium),
637 fSSDCarbonFiberMedium(s.fSSDCarbonFiberMedium),
638 fSSDTubeHolderMedium(s.fSSDTubeHolderMedium),
639 fSSDCoolingTubeWater(s.fSSDCoolingTubeWater),
640 fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox),
9b0c60ab 641 fSSDSupportRingAl(s.fSSDSupportRingAl),
44285dfa 642 fSSDMountingBlockMedium(s.fSSDMountingBlockMedium),
47f8de53 643 fSSDRohaCellCone(s.fSSDRohaCellCone),
bf210566 644 fSSDAir(s.fSSDAir),
78e34526 645 fSSDCopper(s.fSSDCopper),
646 fSSDSn(s.fSSDSn),
bf210566 647 fCreateMaterials(s.fCreateMaterials),
648 fTransformationMatrices(s.fTransformationMatrices),
649 fBasicObjects(s.fBasicObjects),
650 fcarbonfiberjunction(s.fcarbonfiberjunction),
651 fcoolingtubesupport(s.fcoolingtubesupport),
652 fhybridmatrix(s.fhybridmatrix),
653 fssdcoolingblocksystem(s.fssdcoolingblocksystem),
654 fcoolingblocksystematrix(s.fcoolingblocksystematrix),
655 fssdstiffenerflex(s.fssdstiffenerflex),
656 fssdendflex(s.fssdendflex),
cd2243fb 657 fcoolingtube(s.fcoolingtube),
9b0c60ab 658 fendladdercoolingtubesupportmatrix(s.fendladdercoolingtubesupportmatrix),
bf210566 659 fendladdermountingblock(s.fendladdermountingblock),
9b0c60ab 660 fendladdermountingblockclip(s.fendladdermountingblockclip),
bf210566 661 fSSDSensor5(s.fSSDSensor5),
662 fSSDSensor6(s.fSSDSensor6),
663 fSSDLayer5(s.fSSDLayer5),
664 fSSDLayer6(s.fSSDLayer6),
44285dfa 665 fMotherVol(s.fMotherVol),
9b0c60ab 666 fLay5LadderSupportRing(s.fLay5LadderSupportRing),
667 fLay6LadderSupportRing(s.fLay6LadderSupportRing),
e5bf64ae 668 fgkEndCapSupportSystem(s.fgkEndCapSupportSystem),
47f8de53 669 fSSDCone(s.fSSDCone),
44285dfa 670 fColorCarbonFiber(s.fColorCarbonFiber),
671 fColorRyton(s.fColorRyton),
672 fColorPhynox(s.fColorPhynox),
673 fColorSilicon(s.fColorSilicon),
674 fColorAl(s.fColorAl),
78e34526 675 fColorNiSn(s.fColorNiSn),
44285dfa 676 fColorKapton(s.fColorKapton),
677 fColorPolyhamide(s.fColorPolyhamide),
678 fColorStiffener(s.fColorStiffener),
bf210566 679 fColorEpoxy(s.fColorEpoxy),
680 fColorWater(s.fColorWater),
681 fColorG10(s.fColorG10)
44285dfa 682{
683 ////////////////////////
684 // Copy Constructor
685 ////////////////////////
d7599219 686}
687/////////////////////////////////////////////////////////////////////////////////
44285dfa 688AliITSv11GeometrySSD& AliITSv11GeometrySSD::
689operator=(const AliITSv11GeometrySSD &s){
690 ////////////////////////
691 // Assignment operator
692 ////////////////////////
693 this->~AliITSv11GeometrySSD();
694 new(this) AliITSv11GeometrySSD(s);
695 return *this;
696/*
697 if(&s == this) return *this;
698 fMotherVol = s.fMotherVol;
699 return *this;
700 */
701}
bf210566 702///////////////////////////////////////////////////////////////////////////////
703void AliITSv11GeometrySSD::CreateTransformationMatrices(){
704 ///////////////////////////////////////////////////////////////////////
705 // Method generating the trasformation matrix for the whole SSD Geometry
706 ///////////////////////////////////////////////////////////////////////
707 // Setting some variables for Carbon Fiber Supportmatrix creation
708 //////////////////////////////////////////////////////////////////////
709 Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
710 * CosD(fgkCarbonFiberJunctionAngle[0]);
711 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
712 + fgkCarbonFiberSupportTopEdgeDist[0]
713 + fgkCarbonFiberSupportWidth);
714 Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
715 * TanD(fgkCarbonFiberJunctionAngle[0]);
716 TGeoRotation* carbonfiberot[3];
717 for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
718 carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
719 carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
720 carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
721 Double_t transvector[3] = {fgkCarbonFiberTriangleLength
722 * CosD(fgkCarbonFiberTriangleAngle),0.,
723 - fgkCarbonFiberTriangleLength
724 * SinD(fgkCarbonFiberTriangleAngle)};
725 ///////////////////////////////////////////
726 //Setting Local Translations and Rotations:
727 ///////////////////////////////////////////
728 TGeoCombiTrans* localcarbonfibersupportmatrix[3];
729 localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
730 0.5*carbonfibersupportheight,NULL);
731 localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
732 2.*symmetryplaneposition+transvector[1],
733 transvector[2], carbonfiberot[2]);
734 localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
735 /////////////////////////////////////////////////////////////
736 // Carbon Fiber Support Transformations
737 /////////////////////////////////////////////////////////////
738 const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
739 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
740 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
741 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
742 fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
743 }
744 /////////////////////////////////////////////////////////////
745 // Carbon Fiber Junction Transformation
746 /////////////////////////////////////////////////////////////
747 const Int_t kcarbonfiberjunctionmatrixnumber = 2;
748 TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
749 TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
750 TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
751 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
752 localcarbonfiberjunctionmatrix[i] =
753 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
754 localcarbonfiberjunctionrot[i] =
755 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
756 localcarbonfiberjunctiontrans[i] =
757 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
d7599219 758 }
bf210566 759 ///////////////////////
760 // Setting Translations
761 ///////////////////////
762 localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
763 localcarbonfiberjunctiontrans[1][0] =
764 new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
765 localcarbonfiberjunctiontrans[2][0] =
766 new TGeoTranslation(fgkCarbonFiberTriangleLength
767 * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
768 fgkCarbonFiberTriangleLength
769 * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
770 localcarbonfiberjunctiontrans[0][1] =
771 new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
772 localcarbonfiberjunctiontrans[1][1] =
773 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
774 localcarbonfiberjunctiontrans[2][1] =
775 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
776 ////////////////////
777 // Setting Rotations
778 ////////////////////
779 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
780 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
781 localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
782 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
783 localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
784 localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
785 localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
786 localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
787 ////////////////////////////////////////
788 // Setting Carbon Fiber Junction matrix
789 ////////////////////////////////////////
790 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
791 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
792 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
793 localcarbonfiberjunctionmatrix[i][j] =
794 new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
795 *localcarbonfiberjunctionrot[i][j]);
796 fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
797 }
d7599219 798 }
bf210566 799 /////////////////////////////////////////////////////////////
800 // Carbon Fiber Lower Support Transformations
801 /////////////////////////////////////////////////////////////
802 TGeoTranslation* localcarbonfiberlowersupportrans[2];
803 localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
804 fgkCarbonFiberLowerSupportVolumePosition[1]
805 + fgkCarbonFiberLowerSupportVolumePosition[0],
806 0.0);
807 localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
808 fgkCarbonFiberJunctionWidth
809 - fgkCarbonFiberLowerSupportWidth
810 - fgkCarbonFiberLowerSupportVolumePosition[0]
811 - fgkCarbonFiberLowerSupportVolumePosition[1],
812 - 0.5*fgkCarbonFiberLowerSupportHeight);
813 localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
814 fcarbonfiberlowersupportrans[0] =
815 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
816 fcarbonfiberlowersupportrans[1] =
817 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
818 /////////////////////////////////////////////////////////////
819 // SSD Sensor Support Transformations
820 /////////////////////////////////////////////////////////////
821 const Int_t kssdsensorsupportmatrixnumber = 3;
822 TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
823 TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
824 TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
825 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
826 localssdsensorsupportmatrix[i] =
827 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
828 localssdsensorsupportrot[i] =
829 new TGeoRotation*[kssdsensorsupportmatrixnumber];
830 localssdsensorsupportrans[i] =
831 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
d7599219 832 }
bf210566 833 ///////////////////////
834 // Setting Translations
835 ///////////////////////
836 localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
837 0.5*fgkSSDSensorSideSupportWidth,
838 0.0);
839 localssdsensorsupportrans[1][0] =
840 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
841 localssdsensorsupportrans[2][0] =
842 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
843 localssdsensorsupportrans[0][1] =
844 new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
845 0.5*fgkSSDSensorSideSupportThickness[0],
846 0.0);
847 localssdsensorsupportrans[1][1] =
848 new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
849 - 0.5*fgkSSDSensorSideSupportThickness[0]
850 - fgkSSDModuleSensorSupportDistance,
851 0.0);
852 localssdsensorsupportrans[2][1] =
853 new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
854 - fgkSSDSensorCenterSupportPosition,
855 0.5*fgkSSDSensorCenterSupportWidth
856 - 0.5*fgkSSDModuleSensorSupportDistance,
857 fgkSSDSensorCenterSupportThickness[0]);
858 localssdsensorsupportrans[0][2] =
859 new TGeoTranslation(fgkCarbonFiberTriangleLength
860 + fgkCarbonFiberJunctionToSensorSupport,
861 fgkCarbonFiberJunctionWidth
862 - 0.5*(fgkCarbonFiberLowerSupportWidth
863 + fgkSSDSensorCenterSupportLength
864 - fgkSSDSensorCenterSupportThickness[0])
865 - fgkSSDSensorCenterSupportPosition,
866 0.0);
867 localssdsensorsupportrans[1][2] =
868 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
869 localssdsensorsupportrans[2][2] =
870 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
871 ////////////////////
872 // Setting Rotations
873 ////////////////////
874 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
875 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
876 localssdsensorsupportrot[i][j] = new TGeoRotation();
877 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
878 localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
879 localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
d7599219 880 }
bf210566 881 localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
882 localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
883 localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
884 ////////////////////////////////////////
885 // SSD Sensor Support matrix
886 ////////////////////////////////////////
887 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
888 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
889 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
890 localssdsensorsupportmatrix[i][j] =
891 new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
892 *localssdsensorsupportrot[i][j]);
893 fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
894 }
d7599219 895 }
44285dfa 896 /////////////////////////////////////////////////////////////
bf210566 897 // SSD Cooling Tube Support Transformations
44285dfa 898 /////////////////////////////////////////////////////////////
bf210566 899 const Int_t kcoolingtubesupportmatrixnumber = 2;
900 TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
901 TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
902 TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
44285dfa 903 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
d7599219 904 /fgkCoolingTubeSupportRmax);
bf210566 905 localcoolingtubesupportrans[0] =
906 new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
d7599219 907 + 2.*(fgkCoolingTubeSupportLength
44285dfa 908 - fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
d7599219 909 + fgkCarbonFiberTriangleLength
bf210566 910 - 2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
911 localcoolingtubesupportrans[1] =
912 new TGeoTranslation(fgkCarbonFiberJunctionLength
913 - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
914 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
915 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
916 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
917 - 0.5*(fgkCarbonFiberLowerSupportWidth
918 + fgkSSDSensorCenterSupportLength
919 - fgkSSDSensorCenterSupportThickness[0])
920 + 0.5*fgkSSDSensorLength,
921 - 0.5*fgkCoolingTubeSupportHeight);
922 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
923 localcoolingtubesupportrot[i] = new TGeoRotation();
924 localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
925 localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
926 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
927 localcoolingtubesupportmatrix[i] =
928 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
929 *localcoolingtubesupportrot[i]);
930 fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
931 fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
932 (*localcoolingtubesupportmatrix[0]));
933 /////////////////////////////////////////////////////////////
9b0c60ab 934 // End Ladder SSD Cooling Tube Support Transformations
935 /////////////////////////////////////////////////////////////
936 TGeoTranslation** localendladdercooltubetrans[2];
937 localendladdercooltubetrans[0] = new TGeoTranslation*[4];
938 localendladdercooltubetrans[1] = new TGeoTranslation*[2];
939 for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
940 localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
941 - (fgkCoolingTubeSupportLength
942 - fgkCoolingTubeSupportRmax),
943 fgkEndLadderMountingBlockPosition[0]
944 - fgkendladdercoolingsupportdistance[0]
945 + 0.5*fgkCoolingTubeSupportWidth,
946 - 0.5*fgkCoolingTubeSupportHeight);
947 localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
948 - (fgkCoolingTubeSupportLength
949 - fgkCoolingTubeSupportRmax),
950 fgkEndLadderMountingBlockPosition[0]
951 + fgkendladdercoolingsupportdistance[1]
952 + 0.5*fgkCoolingTubeSupportWidth,
953 - 0.5*fgkCoolingTubeSupportHeight);
954 localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
955 - fgkCoolingTubeSupportRmax)
956 + fgkCarbonFiberTriangleLength
957 - 2.0*fgkCarbonFiberJunctionLength,
958 0.0,
959 0.0);
960 localendladdercooltubetrans[0][3]->SetTranslation(0.0,
961 fgkendladdercoolingsupportdistance[0]
962 + fgkendladdercoolingsupportdistance[1],
963 0.0);
964 for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
965 localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
966 + fgkCarbonFiberJunctionLength
967 - fgkCoolingTubeSupportLength,
968 fgkEndLadderCarbonFiberLowerJunctionLength[1]
969 - 0.5*fgkCoolingTubeSupportWidth
970 -fgkendladdercoolingsupportdistance[2],
971 - 0.5*fgkCoolingTubeSupportHeight);
972 localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
973 + fgkCoolingTubeSupportLength
974 - fgkCoolingTubeSupportRmax
975 - fgkCarbonFiberJunctionLength,
976 fgkEndLadderCarbonFiberLowerJunctionLength[1]
977 - 0.5*fgkCoolingTubeSupportWidth
978 - fgkendladdercoolingsupportdistance[2],
979 - 0.5*fgkCoolingTubeSupportHeight);
980 fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
981 fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
982 fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
983 fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
984 (*localcoolingtubesupportrot[1]));
985 fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
986 (*localcoolingtubesupportrot[1]));
987 fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
988 fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
989 fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
990 fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
991 fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
992
993 fendladdercoolingtubesupportmatrix[1][0] =
994 new TGeoHMatrix((*localendladdercooltubetrans[1][0])
995 *(*localcoolingtubesupportrot[1]));
996 fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
997 fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
998 fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
999 /////////////////////////////////////////////////////////////
bf210566 1000 // SSD Cooling Tube Transformations
1001 /////////////////////////////////////////////////////////////
1002 TGeoRotation* localcoolingtuberot = new TGeoRotation();
1003 localcoolingtuberot->SetAngles(0.,90.,0.);
cd2243fb 1004 TGeoTranslation* localcoolingtubetrans[2];
1005 TVector3* localcoolingtubevect[2];
1006
1007 localcoolingtubevect[0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
bf210566 1008 -fgkCarbonFiberTriangleLength),
cd2243fb 1009 fgkCarbonFiberJunctionWidth // Y-coord is local Z, from sensor translation
1010 - fgkCarbonFiberLowerSupportWidth
1011 - fgkLowerSupportToSensorZ ,
bf210566 1012 - 0.5*fgkCoolingTubeSupportHeight);
cd2243fb 1013 localcoolingtubevect[1] = new TVector3( -localcoolingtubevect[0]->X()+fgkCarbonFiberTriangleLength,
1014 localcoolingtubevect[0]->Y(),
1015 localcoolingtubevect[0]->Z());
78e34526 1016 for(Int_t j=0; j<2; j++){
1017 localcoolingtubetrans[j] =
1018 new TGeoTranslation(localcoolingtubevect[j]->X(),
1019 localcoolingtubevect[j]->Y(),
1020 localcoolingtubevect[j]->Z());
1021 fcoolingtubematrix[j] = new TGeoHMatrix((*localcoolingtubetrans[j])
1022 *(*localcoolingtuberot));
1023 }
bf210566 1024 /////////////////////////////////////////////////////////////
9b0c60ab 1025 // SSD End Ladder Cooling Tube Transformations
1026 /////////////////////////////////////////////////////////////
1027 TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
1028 localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
1029 TGeoTranslation** localendlladdercoolingtubetrans[2];
cd2243fb 1030 localendlladdercoolingtubetrans[0] = new TGeoTranslation*[2];
1031 localendlladdercoolingtubetrans[1] = new TGeoTranslation*[2];
9b0c60ab 1032 for(Int_t i=0; i<2; i++)
cd2243fb 1033 for(Int_t j=0; j<2; j++)
9b0c60ab 1034 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
cd2243fb 1035
1036 Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
9b0c60ab 1037 localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1038 - fgkCoolingTubeSupportRmax)
1039 + fgkCarbonFiberJunctionLength,
cd2243fb 1040 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
9b0c60ab 1041 - 0.5*fgkCoolingTubeSupportHeight);
1042 localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1043 - fgkCoolingTubeSupportRmax)
1044 - fgkCarbonFiberJunctionLength
1045 + fgkCarbonFiberTriangleLength,
cd2243fb 1046 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0]+sensZshift),
9b0c60ab 1047 - 0.5*fgkCoolingTubeSupportHeight);
cd2243fb 1048
9b0c60ab 1049 localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
cd2243fb 1050 - fgkCoolingTubeSupportRmax)
1051 + fgkCarbonFiberJunctionLength,
1052 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
9b0c60ab 1053 - 0.5*fgkCoolingTubeSupportHeight);
1054 localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1055 - fgkCoolingTubeSupportRmax)
1056 - fgkCarbonFiberJunctionLength
1057 + fgkCarbonFiberTriangleLength,
cd2243fb 1058 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1]-sensZshift),
9b0c60ab 1059 - 0.5*fgkCoolingTubeSupportHeight);
9b0c60ab 1060 for(Int_t i=0; i<2; i++)
cd2243fb 1061 for(Int_t j=0; j<2; j++){
9b0c60ab 1062 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1063 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1064 }
1065 /////////////////////////////////////////////////////////////
bf210566 1066 // SSD Hybrid Components Transformations
1067 /////////////////////////////////////////////////////////////
1068 const Int_t khybridmatrixnumber = 3;
1069 TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1070 localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1071 0.5*fgkSSDStiffenerWidth,
1072 0.5*fgkSSDStiffenerHeight);
1073 localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1074 fgkSSDModuleStiffenerPosition[1],0.0);
1075
1076 localhybridtrans[2] = new TGeoTranslation(
1077 - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1078 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1079 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1080 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1081 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1082 - fgkSSDSensorCenterSupportThickness[0]),
1083 - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
ca86fdb4 1084 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight
0fb26117 1085 - fgkSSDModuleVerticalDisalignment));
bf210566 1086 fhybridmatrix = new TGeoHMatrix();
1087 for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1088 /////////////////////////////////////////////////////////////
1089 // SSD Cooling Block Transformations
1090 /////////////////////////////////////////////////////////////
78e34526 1091 TGeoTranslation localcoolingblocktrans (fcoolingtubematrix[0]->GetTranslation()[0]
1092 - 0.5*fgkSSDCoolingBlockLength,
1093 fhybridmatrix->GetTranslation()[1]-0.5*fgkSSDStiffenerWidth,
1094 fhybridmatrix->GetTranslation()[2]+0.5*fgkSSDStiffenerHeight+
1095 0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1096 fcoolingblocksystematrix = new TGeoHMatrix(localcoolingblocktrans);
bf210566 1097 /////////////////////////////////////////////////////////////
1098 // SSD Stiffener Flex Transformations
1099 /////////////////////////////////////////////////////////////
1100 const Int_t klocalflexmatrixnumber = 4;
1101 TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1102 for(Int_t i=0; i<fgkflexnumber; i++)
1103 localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1104 for(Int_t i=0; i<fgkflexnumber; i++)
1105 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1106 localflexmatrix[i][j] = new TGeoCombiTrans();
1107 Double_t ssdstiffenerseparation = fgkSSDSensorLength
1108 - 2.*fgkSSDModuleStiffenerPosition[1]
1109 - fgkSSDStiffenerWidth;
1110 localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1111 +0.5*fgkSSDStiffenerLength,
1112 0.5*fgkSSDStiffenerWidth,
1113 -0.5*fgkSSDStiffenerHeight
1114 -0.5*fgkSSDFlexHeight[0]);
1115 localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1116 +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1117 -0.5*fgkSSDStiffenerWidth,
1118 -0.5*fgkSSDStiffenerHeight
1119 -0.5*fgkSSDFlexHeight[0]);
1120 TGeoRotation* localflexrot = new TGeoRotation();
1121 localflexrot->SetAngles(180.,0.,0.);
1122 localflexmatrix[1][0]->SetRotation(localflexrot);
1123 for(Int_t i=0; i<fgkflexnumber; i++)
1124 for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1125 localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1126 for(Int_t i=0; i<fgkflexnumber; i++){
1127 fstiffenerflexmatrix[i] = new TGeoHMatrix();
1128 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1129 fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
d7599219 1130 }
bf210566 1131 /////////////////////////////////////////////////////////////
1132 // SSD End Flex Transformations
1133 /////////////////////////////////////////////////////////////
1134 TGeoRotation* localendflexrot = new TGeoRotation();
1135 localendflexrot->SetAngles(0.0,90.0,0.0);
1136 TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1137 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1138 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1139 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1140 * TMath::DegToRad()*ssdflexradiusmax
1141 - fgkSSDFlexLength[2]-TMath::Pi()
0fb26117 1142 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1143 - 0.1*fgkSSDFlexFullLength;
bf210566 1144 Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1145 + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1146 + fgkSSDFlexLength[2];
1147 localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1148 0.5*fgkSSDFlexWidth[0],
1149 2.*fgkSSDStiffenerHeight
1150 + 0.5*fgkSSDFlexHeight[0]);
1151 localendflexmatrix->SetRotation(localendflexrot);
1152 for(Int_t i=0; i<fgkflexnumber; i++)
1153 fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1154 /////////////////////////////////////////////////////////////
1155 // End Ladder Carbon Fiber Junction
1156 /////////////////////////////////////////////////////////////
1157 TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1158 TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1159 TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1160 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1161 localendladdercarbonfiberjunctionmatrix[i]
1162 = new TGeoCombiTrans*[fgkendladdercabonfiberjunctionmatrixnumber];
1163 localendladdercarbonfiberjunctionrot[i]
1164 = new TGeoRotation*[fgkendladdercabonfiberjunctionmatrixnumber];
1165 localendladdercarbonfiberjunctiontrans[i]
1166 = new TGeoTranslation*[fgkendladdercabonfiberjunctionmatrixnumber];
1167 fendladdercarbonfiberjunctionmatrix[i]
1168 = new TGeoHMatrix*[fgkendladdercabonfiberjunctionmatrixnumber];
d7599219 1169 }
bf210566 1170 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1171 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1172 localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1173 localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1174 }
1175 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1176 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
1177 localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1178 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1179 localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1180 0.0,0.0);
1181 localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1182 * CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1183 * SinD(fgkCarbonFiberTriangleAngle),
1184 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1185 - fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1186 }
1187 TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1188 TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1189 TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1190 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1191 localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1192 localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1193 localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1194 localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1195 0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1196 localendladdercarbonfiberjunctionglobalmatrix[i] =
1197 new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1198 *localendladdercarbonfiberjunctionglobalrot[i]);
1199 }
1200 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1201 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1202 localendladdercarbonfiberjunctionmatrix[i][j] =
1203 new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1204 *localendladdercarbonfiberjunctionrot[i][j]);
1205 fendladdercarbonfiberjunctionmatrix[i][j] =
1206 new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1207 * (*localendladdercarbonfiberjunctionmatrix[i][j]));
1208 }
1209 /////////////////////////////////////////////////////////////
1210 // End Ladder Carbon Fiber Support
1211 /////////////////////////////////////////////////////////////
1212 TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1213 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1214 localendladdercarbonfibertrans[i] = new TGeoTranslation();
1215 localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1216 i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1217 fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1218 }
1219 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1220 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1221 fendladdercarbonfibermatrix[i][j] =
1222 new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1223 *(*fcarbonfibersupportmatrix[j]));
1224 /////////////////////////////////////////////////////////////
1225 // End Ladder SSD Mounting Block
1226 /////////////////////////////////////////////////////////////
1227 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
9b0c60ab 1228 fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1229 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1230 fendladdermountingblockcombitrans[i]->SetTranslation(- 0.25*(fgkSSDMountingBlockLength[0]
bf210566 1231 + fgkSSDMountingBlockLength[1])
1232 + 0.5*fgkCarbonFiberTriangleLength,
1233 fgkEndLadderMountingBlockPosition[i],
1234 - fgkSSDMountingBlockHeight[1]
1235 + 0.5*fgkSSDMountingBlockHeight[0]);
9b0c60ab 1236 TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1237 endladdermountingblockrot->SetAngles(0.,90.,0.);
1238 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1239 fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1240 /////////////////////////////////////////////////////////////
1241 // End Ladder SSD Mounting Block Clip Matrix
1242 /////////////////////////////////////////////////////////////
1243 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1244 fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1245
1246 TGeoRotation* localendladdercliprot = new TGeoRotation();
1247 TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1248 localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1249 - fgkSSDMountingBlockLength[1])
1250 + fgkSSDMountingBlockLength[0],0.,0.);
1251 localendladdercliprot->SetAngles(90.,180.,-90.);
1252 TGeoCombiTrans* localendladderclipcombitrans =
1253 new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1254 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1255 for(Int_t j=0; j<2; j++){
1256 fendladdermountingblockclipmatrix[i][j] =
1257 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1258 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1259 }
bf210566 1260 /////////////////////////////////////////////////////////////
1261 // End Ladder Carbon Fiber Lower Support
1262 /////////////////////////////////////////////////////////////
1263 for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1264 fendladderlowersupptrans[i] =
1265 new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1266 + 0.5*fgkSSDMountingBlockWidth),
1267 - 0.5*fgkCarbonFiberLowerSupportHeight);
1268 fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1269 fgkCarbonFiberLowerSupportVolumePosition[1]
1270 + fgkCarbonFiberLowerSupportVolumePosition[0],
1271 0.0);
1272 fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1273 /////////////////////////////////////////////////////////////
1274 // Matrix for positioning Ladder into mother volume
1275 /////////////////////////////////////////////////////////////
1276 TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1277 for(Int_t i=0; i<fgkladdernumber; i++)
1278 ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1279 TGeoRotation* localladdermotherrot = new TGeoRotation();
1280 localladdermotherrot->SetAngles(0.,90.,0.);
1281 TGeoTranslation* localladdermothertrans[fgkladdernumber];
1282 TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1283 for(Int_t i=0; i<fgkladdernumber; i++){
1284 localladdermothertrans[i] = new TGeoTranslation(0.,
1285 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1286 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1287 + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1288 * fgkCarbonFiberJunctionWidth,0.);
1289 localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1290 *localladdermotherrot);
1291 ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1292 ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
d7599219 1293 }
44285dfa 1294 /////////////////////////////////////////////////////////////
bf210566 1295 // Ladder Cables Matrices
44285dfa 1296 /////////////////////////////////////////////////////////////
44285dfa 1297 Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
d7599219 1298 + fgkSSDFlexHeight[1];
44285dfa 1299 Double_t ssdladdercabletransx[3];
1300 ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
bf210566 1301 * SinD(2.*fgkSSDFlexAngle)
1302 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1303 ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1304 - ssdladdercabletransx[0]
bf210566 1305 / SinD(2.*fgkSSDFlexAngle))
1306 * CosD(fgkSSDFlexAngle);
44285dfa 1307 ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1308 * TMath::DegToRad()*ssdflexradiusmax
d7599219 1309 - fgkSSDFlexLength[2]-TMath::Pi()
1310 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1311 - fgkSSDLadderCableWidth)
bf210566 1312 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1313 Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
bf210566 1314 * TanD(2.*fgkSSDFlexAngle),
44285dfa 1315 ssdladdercabletransx[1]
bf210566 1316 * TanD(fgkSSDFlexAngle),
44285dfa 1317 ssdladdercabletransx[2]
bf210566 1318 * TanD(2.*fgkSSDFlexAngle)};
44285dfa 1319 TGeoRotation* localladdercablerot[3];
bf210566 1320 for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1321 localladdercablerot[0]->SetAngles(90.,0.,0.);
1322 localladdercablerot[1]->SetAngles(90.,60.,-90.);
44285dfa 1323 localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1324 * (*localladdercablerot[0]));
cd2243fb 1325 //TGeoRotation* localladdercablerot = new TGeoRotation();
1326 //localladdercablerot->SetAngles(90.,0.,0.);
44285dfa 1327 ////////////////////////////////////////////
1328 // LocalLadderCableCombiTransMatrix
1329 ////////////////////////////////////////////
1330 const Int_t klocalladdersidecablesnumber = 2;
1331 const Int_t klocalladdercombitransnumber = 5;
1332 TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1333 for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1334 localladdercablecombitransmatrix[i] =
1335 new TGeoCombiTrans*[klocalladdercombitransnumber];
1336 ///////////////////////////////////////////
1337 // Left Side Ladder Cables Transformations
1338 ///////////////////////////////////////////
1339 localladdercablecombitransmatrix[0][0] =
d7599219 1340 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1341 0.,0.,NULL);
bf210566 1342 localladdercablecombitransmatrix[0][1] =
1343 new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1344 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1345 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1346 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1347 - 0.5*(fgkCarbonFiberLowerSupportWidth
1348 + fgkSSDSensorCenterSupportLength
1349 - fgkSSDSensorCenterSupportThickness[0]),
1350 - (fgkSSDModuleCoolingBlockToSensor
1351 + 0.5*fgkCoolingTubeSupportHeight
1352 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1353 - fgkSSDChipHeight),NULL);
44285dfa 1354 localladdercablecombitransmatrix[0][2] =
d7599219 1355 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1356 fgkSSDModuleStiffenerPosition[1],0.,0);
bf210566 1357 localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1358 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1359 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1360 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1361 - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1362 new TGeoRotation("",180.,0.,0.));
44285dfa 1363 localladdercablecombitransmatrix[0][4] =
1364 new TGeoCombiTrans(-ssdladdercabletransx[0]
1365 - ssdladdercabletransx[1]-ssdladdercabletransx[2]
d7599219 1366 + fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1367 0.,
1368 0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1369 + fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
44285dfa 1370 + ssdladdercabletransz[0]-ssdladdercabletransz[1]
1371 + ssdladdercabletransz[2],localladdercablerot[2]);
1372 ///////////////////////////////////////////
1373 // Rigth Side Ladder Cables Transformations
1374 ///////////////////////////////////////////
bf210566 1375 TGeoCombiTrans* localladdercablessdmodulematrix =
1376 new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1377 - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1378 fgkSSDStiffenerWidth,
1379 - 0.5*fgkSSDFlexHeight[0],NULL);
44285dfa 1380 for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1381 localladdercablecombitransmatrix[1][i] =
bf210566 1382 (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1383 new TGeoCombiTrans(*localladdercablessdmodulematrix));
44285dfa 1384 ///////////////////////////////////////////
bf210566 1385 // Setting LadderCableHMatrix
44285dfa 1386 ///////////////////////////////////////////
bf210566 1387 Int_t beamaxistrans[2][3];
1388 beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1389 beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1390 beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1391 beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1392 beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1393 beamaxistrans[1][2] = beamaxistrans[1][0];
1394 TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1395 TGeoRotation* laddercablerot = new TGeoRotation();
1396 TGeoTranslation* laddercabletrans = new TGeoTranslation();
1397 TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1398 Double_t* laddercabletransvector;
1399 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1400 localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1401 fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1402 }
1403 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1404 for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1405 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1406 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1407 localladdercablehmatrix[i][j]->MultiplyLeft(
1408 localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1409 }
1410 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1411 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1412 laddercabletrans->SetTranslation(laddercabletransvector[0],
44285dfa 1413 laddercabletransvector[1]
bf210566 1414 + (j==0 ? beamaxistrans[i][0] : 0.)
d7599219 1415 * fgkCarbonFiberJunctionWidth,
bf210566 1416 laddercabletransvector[2]);
1417 laddercablecombitrans->SetRotation(*laddercablerot);
1418 laddercablecombitrans->SetTranslation(*laddercabletrans);
1419 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1420 }
1421 fladdercablematrix[i][2] =
1422 AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1423 beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1424 fladdercablematrix[i][3] =
1425 AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1426 beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
1427 }
1428 for(Int_t i=0; i<fgkladdercablesnumber; i++)
78e34526 1429 for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1430 fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1431
bf210566 1432 ///////////////////////////////////////////
1433 // Setting Ladder HMatrix
1434 ///////////////////////////////////////////
1435 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1436 fgkSSDLay6SensorsNumber};
1437 for(Int_t i=0; i<fgkladdernumber; i++){
1438 fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1439 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1440 fladdermatrix[i][j] = new TGeoHMatrix();
1441 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1442 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1443 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1444 }
1445 }
1446 ///////////////////////////////////////////
1447 // Setting SSD Sensor Matrix
1448 ///////////////////////////////////////////
1449 TGeoCombiTrans* localssdsensorcombitrans[2];
1450 TGeoRotation* localssdsensorrot = new TGeoRotation();
1451 localssdsensorrot->SetAngles(0.,90.,0.);
1452 TGeoTranslation* localssdsensortrans[2];
1453 for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1454 localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
c40ebacc 1455 fgkCarbonFiberJunctionWidth
1456 - fgkCarbonFiberLowerSupportWidth
1457 - fgkLowerSupportToSensorZ,
bf210566 1458 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
0fb26117 1459 - fgkSSDModuleCoolingBlockToSensor
e21cdd03 1460 + (fgkSSDSensorSideSupportHeight[1]
0fb26117 1461 - fgkSSDSensorSideSupportHeight[0]));
bf210566 1462 localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
c40ebacc 1463 fgkCarbonFiberJunctionWidth
1464 - fgkCarbonFiberLowerSupportWidth
1465 - fgkLowerSupportToSensorZ,
bf210566 1466 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
0fb26117 1467 -fgkSSDModuleCoolingBlockToSensor);
cd2243fb 1468
bf210566 1469 for(Int_t i=0; i<2; i++)
1470 localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1471 *localssdsensorrot);
1472 for(Int_t i=0; i<fgkladdernumber; i++){
1473 fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1474 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1475 switch(i){
1476 case 0: //Ladder of Layer5
1477 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1478 * ((j%2==0 ? *localssdsensorcombitrans[0] :
1479 *localssdsensorcombitrans[1])));
1480 break;
1481 case 1: //Ladder of Layer6
1482 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1483 * ((j%2==0 ? *localssdsensorcombitrans[1] :
1484 *localssdsensorcombitrans[0])));
1485 break;
1486 }
1487 }
1488 }
1489 //////////////////////////
1490 // Setting SSD End Ladder
1491 //////////////////////////
1492 for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1493 for(Int_t i=0; i<2; i++){
1494 fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1495 fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1496 fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1497 fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1498 fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1499 fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1500 fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1501 fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1502 }
1503 /////////////////////////////////////////////////////
1504 // Setting the CombiTransformation to pass ITS center
1505 /////////////////////////////////////////////////////
1506 Double_t itscentertransz[fgklayernumber];
1507 itscentertransz[0] = fgkSSDLay5LadderLength
1508 - fgkLay5CenterITSPosition;
1509 itscentertransz[1] = fgkSSDLay6LadderLength
1510 - fgkLay6CenterITSPosition;
1511 Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1512 + 0.5*fgkCoolingTubeSupportHeight;
1513 TGeoRotation* itscenterrot[3];
1514 for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1515 itscenterrot[0]->SetAngles(90.,180.,-90.);
1516 itscenterrot[1]->SetAngles(0.,90.,0.);
1517 itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1518 TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1519 for(Int_t i=0; i<fgklayernumber; i++)
1520 itscentercombitrans[i] = new TGeoCombiTrans(0.,
1521 itssensortransy,
1522 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1523 - itscentertransz[i],itscenterrot[2]);
1524 TGeoRotation** locallayerrot[fgklayernumber];
1525 TGeoTranslation** locallayertrans[fgklayernumber];
1526 TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1527 TGeoTranslation* localbeamaxistrans[fgklayernumber];
1528 localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1529 - fgkLay5CenterITSPosition);
1530 localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1531 - fgkLay6CenterITSPosition);
1532 const Int_t kssdlayladdernumber[fgklayernumber] =
1533 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1534 for(Int_t i=0; i<fgklayernumber; i++){
1535 locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1536 locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1537 locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1538 flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
1539 }
1540 Double_t layerladderangleposition[fgklayernumber] =
1541 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1542 Double_t layerradius = 0.;
1543 for(Int_t i=0; i<fgklayernumber; i++){
1544 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1545 switch(i){
1546 case 0: //Ladder of Layer5
1547 layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1548 break;
1549 case 1: //Ladder of Layer6
1550 layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1551 break;
1552 }
1553 locallayerrot[i][j] = new TGeoRotation();
1554 locallayertrans[i][j] = new TGeoTranslation();
1555 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1556 locallayertrans[i][j]->SetTranslation(layerradius
1557 * CosD(90.0+j*layerladderangleposition[i]),
1558 layerradius
1559 * SinD(90.0+j*layerladderangleposition[i]),0.);
1560 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1561 *locallayerrot[i][j]);
1562 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1563 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1564 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
1565 }
1566 }
44285dfa 1567 /////////////////////////////////////////////////////////////
bf210566 1568 // Deallocating memory
44285dfa 1569 /////////////////////////////////////////////////////////////
bf210566 1570 for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1571 delete carbonfiberot[i];
1572 delete localcarbonfibersupportmatrix[i];
1573 }
1574 for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1575 for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1576 delete localcarbonfiberjunctionmatrix[i][j];
1577 delete localcarbonfiberjunctionrot[i][j];
1578 delete localcarbonfiberjunctiontrans[i][j];
1579 }
1580 delete [] localcarbonfiberjunctionmatrix[i];
1581 delete [] localcarbonfiberjunctionrot[i];
1582 delete [] localcarbonfiberjunctiontrans[i];
1583 }
1584 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1585 delete localcarbonfiberlowersupportrans[i];
1586 for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1587 for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1588 delete localssdsensorsupportmatrix[i][j];
1589 delete localssdsensorsupportrot[i][j];
1590 delete localssdsensorsupportrans[i][j];
1591 }
1592 delete [] localssdsensorsupportmatrix[i];
1593 delete [] localssdsensorsupportrot[i];
1594 delete [] localssdsensorsupportrans[i];
1595 }
1596 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1597 delete localcoolingtubesupportmatrix[i];
1598 delete localcoolingtubesupportrot[i];
1599 delete localcoolingtubesupportrans[i];
1600 }
cd2243fb 1601 for(Int_t j=0; j<2; j++){
1602 delete localcoolingtubevect[j];
1603 delete localcoolingtubetrans[j];
bf210566 1604 }
9b0c60ab 1605 delete endladdermountingblockrot;
bf210566 1606 for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
bf210566 1607 for(Int_t i=0; i<fgkflexnumber; i++){
1608 for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1609 delete localflexmatrix[i][j];
1610 delete [] localflexmatrix[i];
1611 }
9b0c60ab 1612 delete localendlladdercoolingtuberot;
1613 for(Int_t i=0; i<2; i++){
cd2243fb 1614 for(Int_t j=0; j<2; j++)
1615 delete localendlladdercoolingtubetrans[i][j];
9b0c60ab 1616 delete [] localendlladdercoolingtubetrans[i];
1617 }
1618
bf210566 1619 delete localflexrot;
1620 delete localendflexrot;
1621 delete localendflexmatrix;
1622 for(Int_t i=0; i<fgkladdernumber; i++){
1623 delete localladdermothertrans[i];
1624 delete localladdermothercombitrans[i];
1625 }
1626 delete localladdermotherrot;
1627 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1628 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1629 delete localendladdercarbonfiberjunctionmatrix[i][j];
1630 delete localendladdercarbonfiberjunctionrot[i][j];
1631 delete localendladdercarbonfiberjunctiontrans[i][j];
1632 }
1633 delete [] localendladdercarbonfiberjunctionmatrix[i];
1634 delete [] localendladdercarbonfiberjunctionrot[i];
1635 delete [] localendladdercarbonfiberjunctiontrans[i];
1636 delete localendladdercarbonfiberjunctionglobalrot[i];
1637 delete localendladdercarbonfiberjunctionglobaltrans[i];
1638 delete localendladdercarbonfiberjunctionglobalmatrix[i];
1639 }
9b0c60ab 1640 for(Int_t i=0; i<2; i++){
1641 for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1642 delete [] localendladdercooltubetrans[i];
1643 }
1644 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
bf210566 1645 delete localendladdercarbonfibertrans[i];
1646 for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1647 for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1648 for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1649 delete localladdercablecombitransmatrix[i][j];
1650 delete []localladdercablecombitransmatrix[i];
1651 }
9b0c60ab 1652 delete localendladdercliprot;
1653 delete localendladdercliptrans;
bf210566 1654 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1655 for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1656 delete localladdercablehmatrix[i][j];
1657 delete []localladdercablehmatrix[i];
1658 }
1659 delete laddercablerot;
1660 delete laddercabletrans;
1661 delete laddercablecombitrans;
1662 delete localladdercablessdmodulematrix;
1663 delete localssdsensorrot;
1664 for(Int_t i=0; i<2; i++){
1665 delete localssdsensortrans[i];
1666 delete localssdsensorcombitrans[i];
1667 }
1668 for(Int_t i=0; i<fgklayernumber; i++){
1669 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1670 delete locallayerrot[i][j];
1671 delete locallayertrans[i][j];
1672 delete locallayercombitrans[i][j];
1673 }
1674 delete [] locallayerrot[i];
1675 delete [] locallayertrans[i];
1676 delete [] locallayercombitrans[i];
1677 delete localbeamaxistrans[i];
1678 }
1679 for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1680 for(Int_t i=0; i<fgkladdernumber; i++){
1681 for(Int_t j=0; j<fgkladdernumber; j++)
1682 delete ladderglobalmatrix[i][j];
1683 delete [] ladderglobalmatrix[i];
1684 }
1685 /////////////////////////////////////////////////////////////
1686 fTransformationMatrices = kTRUE;
d7599219 1687}
bf210566 1688///////////////////////////////////////////////////////////////////////////////
1689void AliITSv11GeometrySSD::CreateBasicObjects(){
1690 /////////////////////////////////////////////////////////////
1691 // Method generating the Objects of SSD Geometry
1692 /////////////////////////////////////////////////////////////
1693 // SSD Sensor
1694 ///////////////////////////////////
1695 SetSSDSensor();
1696 /////////////////////////////////////////////////////////////
1697 // Carbon Fiber Support
1698 /////////////////////////////////////////////////////////////
1699 TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1700 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1701 fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
44285dfa 1702 /////////////////////////////////////////////////////////////
bf210566 1703 // Carbon Fiber Junction
44285dfa 1704 /////////////////////////////////////////////////////////////
ca86fdb4 1705 fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth-fgkSSDTolerance);
bf210566 1706 /////////////////////////////////////////////////////////////
1707 // Carbon Fiber Lower Support
1708 /////////////////////////////////////////////////////////////
1709 TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1710 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1711 fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
1712 /////////////////////////////
1713 // SSD Sensor Support
1714 /////////////////////////////
1715 for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1716 new TGeoVolume*[fgkssdsensorsupportnumber];
44285dfa 1717 Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
bf210566 1718 fgkSSDSensorSideSupportThickness[1]};
1719 for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1720 fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1721 fgkSSDSensorSideSupportHeight[i],
1722 fgkSSDSensorSideSupportWidth,
1723 sidesupporthickness);
1724 fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1725 fgkSSDSensorCenterSupportHeight[i],
1726 fgkSSDSensorCenterSupportWidth,
1727 sidesupporthickness);
1728 }
1729 /////////////////////////////////////////////////////////////
1730 // SSD Cooling Tube Support
1731 /////////////////////////////////////////////////////////////
3c057f23 1732 Int_t edgesnumber = 3;
bf210566 1733 fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
1734 /////////////////////////////////////////////////////////////
1735 // SSD Hybrid
1736 /////////////////////////////////////////////////////////////
1737 TList* ssdhybridcomponentslist = GetSSDHybridParts();
1738 for(Int_t i=0; i<fgkhybridcompnumber; i++)
1739 fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
1740 /////////////////////////////////////////////////////////////
1741 // SSD Cooling Block System
1742 /////////////////////////////////////////////////////////////
1743 fssdcoolingblocksystem = GetCoolingBlockSystem();
1744 /////////////////////////////////////////////////////////////
1745 // SSD Cooling Tube
1746 /////////////////////////////////////////////////////////////
cd2243fb 1747 CreateCoolingTubes();
bf210566 1748 /////////////////////////////////////////////////////////////
1749 // SSD Flex
1750 /////////////////////////////////////////////////////////////
1751 fssdstiffenerflex = GetSSDStiffenerFlex();
1752 fssdendflex = GetSSDEndFlex();
1753 ///////////////////////////////////
1754 // End Ladder Carbon Fiber Junction
1755 ///////////////////////////////////
1756 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1757 fendladdercarbonfiberjunction[i] =
1758 new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1759 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1760 fendladdercarbonfiberjunction[i][0] =
ca86fdb4 1761 GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]-fgkSSDTolerance);
bf210566 1762 fendladdercarbonfiberjunction[i][1] =
ca86fdb4 1763 GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]-fgkSSDTolerance);
bf210566 1764 }
1765 ///////////////////////////////////
1766 // End Ladder Mounting Block
1767 ///////////////////////////////////
1768 fendladdermountingblock = GetSSDMountingBlock();
9b0c60ab 1769 ///////////////////////////////////
1770 // End Ladder Mounting Block
1771 ///////////////////////////////////
1772 fendladdermountingblockclip = GetMountingBlockClip();
1773 ///////////////////////////////////
1774 // Ladder Support
1775 ///////////////////////////////////
1776 TList* laddersupportlist = GetMountingBlockSupport(20);
1777 fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1778 fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1779 fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1780 fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
bf210566 1781 /////////////////////////////////////////////////////////////
1782 // Deallocating memory
44285dfa 1783 /////////////////////////////////////////////////////////////
bf210566 1784 delete carbonfibersupportlist;
1785 delete carbonfiberlowersupportlist;
1786 delete ssdhybridcomponentslist;
9b0c60ab 1787 delete laddersupportlist;
44285dfa 1788 /////////////////////////////////////////////////////////////
bf210566 1789 fBasicObjects = kTRUE;
1790}
1791/////////////////////////////////////////////////////////////////////////////////
1792void AliITSv11GeometrySSD::SetSSDSensor(){
1793 ////////////////////////////////////////////////////////////////
1794 // Method generating SSD Sensors: it sets the private variables
1795 // fSSDSensor5, fSSDSensor6
1796 ////////////////////////////////////////////////////////////////
44285dfa 1797 Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1798 Double_t ssdsensitivewidth = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1799 TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
44285dfa 1800 0.5*ssdsensitivewidth,
bf210566 1801 0.5*fgkSSDSensorHeight,
1802 0.5*ssdsensitivelength);
1803 TGeoVolume* ssdsensorsensitiveLay5 =
02d4acf9 1804 new TGeoVolume(fgSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1805 TGeoVolume* ssdsensorsensitiveLay6 =
02d4acf9 1806 new TGeoVolume(fgSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1807 ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1808 ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
44285dfa 1809 TGeoBBox* ssdsensorinsensitiveshape[2];
1810 ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
d7599219 1811 0.5*fgkSSDSensorInsensitiveWidth,
bf210566 1812 0.5*fgkSSDSensorHeight,
1813 0.5*fgkSSDSensorLength);
44285dfa 1814 ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
44285dfa 1815 0.5*ssdsensitivewidth,
bf210566 1816 0.5*fgkSSDSensorHeight,
1817 0.5*fgkSSDSensorInsensitiveWidth);
44285dfa 1818 const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
d7599219 1819 "SSDSensorInsensitive2"};
44285dfa 1820 TGeoVolume* ssdsensorinsensitive[2];
1821 for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1822 new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1823 fSSDSensorMedium);
1824 ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
d7599219 1825 }
bf210566 1826 /////////////////////////////////////////////////////////////
1827 // Virtual Volume containing SSD Sensor
1828 /////////////////////////////////////////////////////////////
1829 TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1830 0.5*fgkSSDSensorWidth,
1831 0.5*fgkSSDSensorHeight,
1832 0.5*fgkSSDSensorLength);
ef9451a3 1833 fSSDSensor5 = new TGeoVolume("ITSssdSensor5",virtualSSDSensorShape,
bf210566 1834 fSSDAir);
ef9451a3 1835 fSSDSensor6 = new TGeoVolume("ITSssdSensor6",virtualSSDSensorShape,
bf210566 1836 fSSDAir);
1837 /////////////////////////////////////////////////////////////
1838 for(Int_t i=0; i<4; i++){
1839 fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1840 ssdsensorinsensitive[1],i<2?1:2,
1841 new TGeoTranslation(
1842 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1843 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1844 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1845 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1846 fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
44285dfa 1847 ssdsensorinsensitive[1],i<2?1:2,
bf210566 1848 new TGeoTranslation(
1849 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1850 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1851 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1852 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1853 }
1854 fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1855 fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
d7599219 1856}
bf210566 1857///////////////////////////////////////////////////////////////////////////////
1858TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1859 /////////////////////////////////////////////////////////////
1860 // Method generating the Carbon Fiber Support
1861 /////////////////////////////////////////////////////////////
1862 const Int_t kvertexnumber = 4;
1863 const Int_t kshapesnumber = 2;
1864 TVector3** vertexposition[kshapesnumber];
1865 for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1866 Double_t carbonfibersupportxaxisEdgeproj =
1867 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1868 * TMath::DegToRad());
1869 Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
1870 / fgkCarbonFiberSupportXAxisLength);
1871 /////////////////////
1872 //Vertex Positioning
1873 ////////////////////
1874 vertexposition[0][0] = new TVector3();
1875 vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
1876 fgkCarbonFiberSupportYAxisLength);
1877 vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
1878 carbonfibersupportxaxisEdgeproj
1879 * TMath::Tan(theta));
1880 vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
1881 - carbonfibersupportxaxisEdgeproj,
1882 fgkCarbonFiberSupportYAxisLength
1883 - vertexposition[0][2]->Y());
1884 ////////////////////////////////////////////////////
1885 //Setting the parameters for Isometry Transformation
1886 ////////////////////////////////////////////////////
1887 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
1888 + fgkCarbonFiberSupportTopEdgeDist[0]
1889 + fgkCarbonFiberSupportWidth);
1890 Double_t* param = new Double_t[4];
1891 param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
1892 for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
160835d5 1893 new TVector3((GetReflection(vertexposition[0][j],param))->X(),
1894 (GetReflection(vertexposition[0][j],param))->Y());
a6e0ebfe 1895 const char* carbonfibersupportshapename[kshapesnumber] =
bf210566 1896 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
a6e0ebfe 1897 const char* carbonfibersupportname[kshapesnumber] =
bf210566 1898 {"CarbonFiberSupport1","CarbonFiberSupport2"};
1899 TGeoArb8* carbonfibersupportshape[kshapesnumber];
1900 TGeoVolume* carbonfibersupport[kshapesnumber];
1901 TList* carbonfibersupportlist = new TList();
1902 Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
1903 Double_t carbonfibersupportheight =
1904 carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1905 *TMath::DegToRad());
1906 for(Int_t i = 0; i< kshapesnumber; i++){
1907 carbonfibersupportshape[i] =
1908 GetArbShape(vertexposition[i],width,carbonfibersupportheight,
1909 carbonfibersupportshapename[i],i==0 ? 1: -1);
1910 carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
1911 carbonfibersupportshape[i],fSSDCarbonFiberMedium);
1912 carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
1913 carbonfibersupportlist->Add(carbonfibersupport[i]);
1914 }
1915 /////////////////////////////////////////////////////////////
1916 // Deallocating memory
1917 /////////////////////////////////////////////////////////////
1918 for(Int_t i=0; i< kshapesnumber; i++){
1919 for(Int_t j=0; j< kvertexnumber; j++)
1920 delete vertexposition[i][j];
1921 delete [] vertexposition[i];
1922 }
1923 delete [] param;
44285dfa 1924 /////////////////////////////////////////////////////////////
bf210566 1925 return carbonfibersupportlist;
d7599219 1926}
1927/////////////////////////////////////////////////////////////////////////////////
bf210566 1928TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
44285dfa 1929 /////////////////////////////////////////////////////////////
bf210566 1930 // Method generating SSD Carbon Fiber Junction
44285dfa 1931 /////////////////////////////////////////////////////////////
bf210566 1932 const Int_t kvertexnumber = 6;
1933 TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
d4ff3e0a 1934 Double_t reflectionparam[4] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
1935 * TMath::DegToRad()),-1.,0.,0.};
bf210566 1936 TVector3* vertex[kvertexnumber];
1937 vertex[0] = new TVector3();
1938 vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
1939 * TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1940 * TMath::DegToRad()),
1941 fgkCarbonFiberJunctionEdge[0]
1942 * TMath::Sin(fgkCarbonFiberJunctionAngle[0]
1943 * TMath::DegToRad()));
1944 vertex[4] = new TVector3(fgkCarbonFiberJunctionLength,
1945 fgkCarbonFiberJunctionEdge[1]);
1946 vertex[5] = new TVector3(fgkCarbonFiberJunctionLength);
1947 vertex[1] = GetReflection(vertex[5],reflectionparam);
1948 vertex[2] = GetReflection(vertex[4],reflectionparam);
1949 Double_t xvertexpoints[6], yvertexpoints[6];
1950 for(Int_t i=0; i<kvertexnumber; i++)
1951 xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
1952 carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
1953 carbonfiberjunctionshape->DefineSection(0,-0.5*width);
1954 carbonfiberjunctionshape->DefineSection(1,0.5*width);
1955 TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
1956 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
1957 carbonfiberjunction->SetLineColor(fColorCarbonFiber);
1958 /////////////////////////////////////////////////////////////
1959 // Deallocating memory
1960 /////////////////////////////////////////////////////////////
1961 for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
1962 /////////////////////////////////////////////////////////////
1963 return carbonfiberjunction;
1964}
1965////////////////////////////////////////////////////////////////////////////////
1966TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
1967 /////////////////////////////////////////////////////////////
1968 // Method generating the Carbon Fiber Lower Support
1969 /////////////////////////////////////////////////////////////
1970 const Int_t kvertexnumber = 4;
1971 const Int_t kshapesnumber = 2;
1972 Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
1973 fgkCarbonFiberLowerSupportWidth};
1974 TVector3** vertexposition[kshapesnumber];
1975 for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
1976 new TVector3*[kvertexnumber];
1977 //First Shape Vertex Positioning
1978 vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
1979 vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
1980 - fgkCarbonFiberLowerSupportLowerLenght);
1981 vertexposition[0][2] = new TVector3();
1982 vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
1983 //Second Shape Vertex Positioning
1984 Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
1985 - fgkCarbonFiberLowerSupportVolumePosition[0])
1986 / fgkCarbonFiberTriangleLength);
1987 vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
1988 vertexposition[0][0]->X()*TMath::Tan(theta)
1989 + fgkCarbonFiberLowerSupportVolumePosition[0]);
1990 vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
1991 vertexposition[0][1]->X()*TMath::Tan(theta)
1992 + fgkCarbonFiberLowerSupportVolumePosition[0]);
1993 vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
1994 vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
1995 fgkCarbonFiberLowerSupportVolumePosition[1]);
a6e0ebfe 1996 const char* carbonfiberlowersupportshapename[kshapesnumber] =
bf210566 1997 {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
a6e0ebfe 1998 const char* carbonfiberlowersupportname[kshapesnumber] =
bf210566 1999 {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
2000 TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
2001 TGeoVolume* carbonfiberlowersupport[kshapesnumber];
2002 TList* carbonfiberlowersupportlist = new TList();
2003 for(Int_t i = 0; i< kshapesnumber; i++){
2004 carbonfiberlowersupportshape[i] =
2005 GetArbShape(vertexposition[i],width,
2006 fgkCarbonFiberLowerSupportHeight,
2007 carbonfiberlowersupportshapename[i]);
2008 carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
2009 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
2010 carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
2011 carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
2012 }
2013 /////////////////////////////////////////////////////////////
2014 // Deallocating memory
2015 /////////////////////////////////////////////////////////////
2016 for(Int_t i=0; i< kshapesnumber; i++){
2017 for(Int_t j=0; j< kvertexnumber; j++)
2018 delete vertexposition[i][j];
2019 delete [] vertexposition[i];
2020 }
2021 /////////////////////////////////////////////////////////////
2022 return carbonfiberlowersupportlist;
2023}
2024///////////////////////////////////////////////////////////////////////////////
2025TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
2026 Double_t width, Double_t* thickness)const{
2027 /////////////////////////////////////////////////////////////
2028 // Method generating the Sensor Support
2029 /////////////////////////////////////////////////////////////
2030 const Int_t kvertexnumber = 6;
2031 TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2032 TVector3* vertexposition[kvertexnumber];
2033 vertexposition[0] = new TVector3();
2034 vertexposition[1] = new TVector3(0.0,length);
2035 vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y());
2036 vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]);
2037 vertexposition[4] = new TVector3(height,vertexposition[3]->Y());
2038 vertexposition[5] = new TVector3(vertexposition[4]->X());
2039 Double_t xvertexpoints[6], yvertexpoints[6];
2040 for(Int_t i=0; i<kvertexnumber; i++)
2041 xvertexpoints[i] = vertexposition[i]->X(),
2042 yvertexpoints[i] = vertexposition[i]->Y();
2043 ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2044 ssdsensorsupportshape->DefineSection(0,-0.5*width);
2045 ssdsensorsupportshape->DefineSection(1,0.5*width);
2046 TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2047 ssdsensorsupportshape,fSSDSensorSupportMedium);
2048 /////////////////////////////////////////////////////////////
2049 // Deallocating memory
2050 /////////////////////////////////////////////////////////////
2051 for (Int_t i=0; i<kvertexnumber; i++)
2052 delete vertexposition[i];
2053 /////////////////////////////////////////////////////////////
2054 return ssdsensorsupport;
2055}
2056////////////////////////////////////////////////////////////////////////////////
2057TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
2058 /////////////////////////////////////////////////////////////
2059 // Method generating the Cooling Tube Support
2060 /////////////////////////////////////////////////////////////
2061 if(nedges%2!=0) nedges--;
2062 const Int_t kvertexnumber = nedges+5;
2063 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
2064 / fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
2065 Double_t angle = 90.+phi;
2066 Double_t psi = 90.-phi;
2067 ///////////////////////////////////////
2068 // Vertex Positioning for TGeoXTru
2069 ///////////////////////////////////////
2070 TVector3** vertexposition = new TVector3*[kvertexnumber];
cd2243fb 2071
3c057f23 2072 Double_t Router = fgkCoolingTubeSupportRmin/CosD(phi/nedges); // Recalc inner radius so that tube fits inside
cd2243fb 2073 vertexposition[0] = new TVector3(Router*CosD(angle),
2074 Router*SinD(angle));
bf210566 2075 vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2076 fgkCoolingTubeSupportRmax*SinD(angle));
2077 vertexposition[2] = new TVector3(vertexposition[1]->X(),
2078 fgkCoolingTubeSupportRmax);
2079 vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2080 fgkCoolingTubeSupportRmax);
2081 vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2082 vertexposition[1]->Y());
cd2243fb 2083
bf210566 2084 for(Int_t i=0; i<nedges; i++)
2085 vertexposition[i+5] =
cd2243fb 2086 new TVector3(Router*CosD(psi+i*(2.*phi/nedges)),
2087 Router*SinD(psi+i*(2.*phi/nedges)));
bf210566 2088 ///////////////////////////////////////////////////////////////////////
2089 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2090 ///////////////////////////////////////////////////////////////////////
2091 TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2092 Double_t* xvertexpoints = new Double_t[kvertexnumber];
2093 Double_t* yvertexpoints = new Double_t[kvertexnumber];
2094 for(Int_t i=0; i<kvertexnumber; i++){
2095 xvertexpoints[i] = vertexposition[i]->X();
2096 yvertexpoints[i] = vertexposition[i]->Y();
2097 }
2098 coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2099 yvertexpoints);
2100 coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2101 coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2102 TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2103 coolingtubesupportarcshape,
2104 fSSDTubeHolderMedium);
2105 coolingtubesupportarc->SetLineColor(fColorG10);
2106 //////////////////////////////////////////////////////////////////////////
2107 // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2108 //////////////////////////////////////////////////////////////////////////
2109 TGeoTubeSeg* coolingtubesupportsegshape =
2110 new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2111 fgkCoolingTubeSupportRmax,
2112 0.5*fgkCoolingTubeSupportWidth,
2113 phi,360-phi);
2114 TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2115 coolingtubesupportsegshape,
2116 fSSDTubeHolderMedium);
2117 coolingtubesupportseg->SetLineColor(fColorG10);
2118 //////////////////////////////////////////////////////////////////////////
2119 // TGeoBBox Volume definition for Cooling Tube Support Box Part
2120 //////////////////////////////////////////////////////////////////////////
2121 Double_t* boxorigin = new Double_t[3];
2122 Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2123 boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2124 TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2125 0.5*fgkCoolingTubeSupportHeight,
2126 0.5*fgkCoolingTubeSupportWidth,boxorigin);
2127 TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2128 coolingtubesupportboxshape,fSSDTubeHolderMedium);
2129 coolingtubesupportbox->SetLineColor(fColorG10);
2130 //////////////////////////////////////////////////////////////////////////
2131 // Cooling Tube for Cooling Tube Support
2132 //////////////////////////////////////////////////////////////////////////
2133 TGeoXtru* coolingtubearcshape[2];
2134 coolingtubearcshape[0] = new TGeoXtru(2);
2135 Double_t* xvert = new Double_t[nedges+2];
2136 Double_t* yvert = new Double_t[nedges+2];
2137 Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2138 ////////////////////////////////////////
2139 // Positioning the vertices for TGeoXTru
2140 ////////////////////////////////////////
2141 xvert[0] = 0., yvert[0] = 0.;
2142 xvert[1] = vertexposition[0]->X()*ratio, yvert[1] = vertexposition[0]->Y()*ratio;
2143 for(Int_t i=0; i< nedges; i++)
2144 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2145 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2146 ////////////////////////////////////////
2147 // Defining TGeoXTru PolyGone
2148 ////////////////////////////////////////
2149 coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2150 coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2151 coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2152 coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2153 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2154 TGeoVolume* coolingtubearc[2];
2155 coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2156 coolingtubearcshape[0],fSSDCoolingTubeWater);
2157 coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2158 coolingtubearcshape[1],fSSDCoolingTubePhynox);
2159 coolingtubearc[0]->SetLineColor(fColorWater);
2160 coolingtubearc[1]->SetLineColor(fColorPhynox);
2161 ////////////////////////////////////////////
2162 // Defining TGeoTubeSeg Part of Cooling Tube
2163 ////////////////////////////////////////////
2164 TGeoTubeSeg* coolingtubesegshape[2];
2165 coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2166 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2167 coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2168 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2169 TGeoVolume* coolingtubeseg[2];
2170 coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2171 coolingtubesegshape[0],fSSDCoolingTubePhynox);
2172 coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2173 coolingtubesegshape[1],fSSDCoolingTubeWater);
2174 coolingtubeseg[0]->SetLineColor(fColorPhynox);
2175 coolingtubeseg[1]->SetLineColor(fColorWater);
2176 /////////////////////////////////////////////////////////////
2177 // Virtual Volume containing Cooling Tube Support
2178 /////////////////////////////////////////////////////////////
2179 TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2180 const Int_t kvirtualvertexnumber = 8;
2181 TVector3* virtualvertex[kvirtualvertexnumber];
2182 ////////////////////////////////////////
2183 // Positioning the vertices for TGeoXTru
2184 ////////////////////////////////////////
2185 virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax);
2186 virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y());
2187 virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y());
2188 virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight);
2189 virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y());
2190 virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y());
2191 virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y());
2192 virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y());
2193 Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2194 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2195 xmothervertex[i] = virtualvertex[i]->X(),
2196 ymothervertex[i] = virtualvertex[i]->Y();
2197 ////////////////////////////////////////
2198 // Defining TGeoXTru PolyGone
2199 ////////////////////////////////////////
2200 virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2201 ymothervertex);
2202 virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2203 virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
cd2243fb 2204 /*TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2205 virtualCoolingTubeSupportShape,fSSDAir); */
2206 TGeoVolume* virtualcoolingtubesupport = new TGeoVolumeAssembly("CoolingTubeSupport");
2207
bf210566 2208 ////////////////////////////////////////
2209 // Positioning Volumes in Virtual Volume
2210 ////////////////////////////////////////
2211 TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2212 coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2213 virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2214 virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2215 virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
cd2243fb 2216 //virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2217 //virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2218 //virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2219 //virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
bf210566 2220 /////////////////////////////////////////////////////////////
2221 // Deallocating memory
2222 /////////////////////////////////////////////////////////////
2223 delete [] vertexposition;
3e008bd7 2224 delete [] xvertexpoints;
2225 delete [] yvertexpoints;
2226 delete [] xvert;
2227 delete [] yvert;
bf210566 2228 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2229 delete virtualvertex[i];
2230 /////////////////////////////////////////////////////////////
2231 return virtualcoolingtubesupport;
2232}
2233/////////////////////////////////////////////////////////////////////////////////
2234TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2235 /////////////////////////////////////////////////////////////
2236 // Method generating List containing SSD Hybrid Components
2237 /////////////////////////////////////////////////////////////
2238 TList* ssdhybridlist = new TList();
2239 const Int_t kssdstiffenernumber = 2;
2240 Double_t ssdstiffenerseparation = fgkSSDSensorLength
2241 - 2.*fgkSSDModuleStiffenerPosition[1]
2242 - fgkSSDStiffenerWidth;
2243 Double_t ssdchipcablesradius[kssdstiffenernumber];
2244 for(Int_t i=0; i<kssdstiffenernumber; i++)
2245 ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2246 - fgkSSDChipCablesHeight[0]
2247 - fgkSSDChipCablesHeight[1]);
2248 /////////////////////////////////////////////////////////////
2249 // Mother Volumes Containers
2250 /////////////////////////////////////////////////////////////
2251 const Int_t kmothernumber = 2;
3cf6a656 2252 const Int_t kmothervertexnumber = 8;
bf210566 2253 Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2254 Double_t ymothervertex[kmothernumber][kmothervertexnumber];
3cf6a656 2255
2256 TGeoVolumeAssembly* ssdhybridassembly[kmothernumber];
2257 TGeoVolume* ssdhybridmother[kmothernumber][2];
2258
2259 TGeoRotation hybridmotherrotR(TGeoRotation("",-90.0,0.0,0.0)*TGeoRotation("",0.0,90.0,0.0)*TGeoRotation("",90.,180.,-90));
2260 TGeoRotation hybridmotherrotL(TGeoRotation("",180.,0.0,0.0)*hybridmotherrotR);
2261 TGeoRotation *hybridmotherrotInv = new TGeoRotation(hybridmotherrotR.Inverse());
2262
bf210566 2263 const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2264 for(Int_t i=0; i<kmothernumber; i++){
3cf6a656 2265 xmothervertex[i][0] = -0.5*fgkSSDStiffenerWidth;
2266 ymothervertex[i][0] = 0.5*fgkSSDStiffenerHeight;
2267 xmothervertex[i][1] = -0.5*fgkSSDStiffenerWidth;
2268 ymothervertex[i][1] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2269 -fgkSSDChipCablesHeight[i+2];
2270
2271 xmothervertex[i][2] = 0.5*(fgkSSDSensorLength-ssdstiffenerseparation); //0.5*fgkSSDStiffenerWidth;
2272 ymothervertex[i][2] = -0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight -fgkSSDChipCablesHeight[i+2];
2273 xmothervertex[i][3] = xmothervertex[i][2];
2274 ymothervertex[i][3] = ymothervertex[i][2]+fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1];
2275
2276 xmothervertex[i][4] = xmothervertex[i][2]-0.4;
2277 ymothervertex[i][4] = ymothervertex[i][3];
2278 xmothervertex[i][5] = xmothervertex[i][4];
2279 ymothervertex[i][5] = ymothervertex[i][4]+2*ssdchipcablesradius[i];
2280
2281 xmothervertex[i][6] = 0.5*fgkSSDStiffenerWidth+ssdchipcablesradius[i]+0.3*fgkmm;
2282 ymothervertex[i][6] = ymothervertex[i][5];
2283
2284 xmothervertex[i][7] = xmothervertex[i][6];
2285 ymothervertex[i][7] = 0.5*fgkSSDStiffenerHeight;
3cf6a656 2286 TGeoXtru *shape = new TGeoXtru(2);
2287 shape->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
2288 shape->DefineSection(0,-0.5*fgkSSDStiffenerLength);
2289 shape->DefineSection(1,0.5*fgkSSDStiffenerLength);
2290 ssdhybridmother[i][0] = new TGeoVolume(TString(ssdhybridmothername[i])+"L",shape,fSSDAir);
2291 ssdhybridmother[i][1] = new TGeoVolume(TString(ssdhybridmothername[i])+"R",shape,fSSDAir);
2292 ssdhybridassembly[i] = new TGeoVolumeAssembly(ssdhybridmothername[i]);
bf210566 2293 }
2294 /////////////////////////////////////////////////////////////
2295 // SSD Stiffener
2296 /////////////////////////////////////////////////////////////
2297 TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2298 0.5*fgkSSDStiffenerLength,
ca86fdb4 2299 0.5*(fgkSSDStiffenerWidth-fgkSSDTolerance),
bf210566 2300 0.5*fgkSSDStiffenerHeight);
2301 TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2302 fSSDStiffenerMedium);
2303 ssdstiffener->SetLineColor(fColorStiffener);
3cf6a656 2304
bf210566 2305////////////////////////////
2306// Capacitor 0603-2200 nF
2307///////////////////////////
2308 const Int_t knapacitor0603number = 5;
78e34526 2309 TGeoBBox* capacitor0603mothershape = new TGeoBBox("Capacitor0603MotherShape",
2310 0.5*fgkSSDCapacitor0603Length + fgkSSDCapacitor0603CapLength,
2311 0.5*fgkSSDCapacitor0603Width,
2312 0.5*fgkSSDCapacitor0603Height);
2313 TGeoVolume* capacitor0603mother = new TGeoVolume("Capacitor0603Mother",capacitor0603mothershape,
2314 fSSDAir);
2315
bf210566 2316 TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
3cf6a656 2317 0.5*fgkSSDCapacitor0603Length,
78e34526 2318 0.5*fgkSSDCapacitor0603Width,
3cf6a656 2319 0.5*fgkSSDCapacitor0603Height);
bf210566 2320 TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
44285dfa 2321 fSSDStiffener0603CapacitorMedium);
2322 capacitor0603->SetLineColor(fColorAl);
78e34526 2323 TGeoTranslation *cap0603trans = new TGeoTranslation(0.,0.,0.);
2324 capacitor0603mother->AddNode(capacitor0603,1,cap0603trans);
2325
2326 TGeoBBox* capacitor0603capshape = new TGeoBBox("Capacitor0603CapShape",
2327 0.5*fgkSSDCapacitor0603CapLength,
2328 0.5*fgkSSDCapacitor0603Width,
2329 0.5*fgkSSDCapacitor0603Height);
2330 TGeoVolume* capacitor0603cap = new TGeoVolume("Capacitor0603Cap",capacitor0603capshape,
2331 fSSDStiffenerCapacitorCapMedium);
2332 capacitor0603cap->SetLineColor(fColorNiSn);
2333 TGeoTranslation *cap0603captrans1 = new TGeoTranslation(- capacitor0603shape->GetDX() - capacitor0603capshape->GetDX(),0.,0.);
2334 capacitor0603mother->AddNode(capacitor0603cap,1,cap0603captrans1);
2335 TGeoTranslation *cap0603captrans2 = new TGeoTranslation(capacitor0603shape->GetDX() + capacitor0603capshape->GetDX(),0.,0.);
2336 capacitor0603mother->AddNode(capacitor0603cap,2,cap0603captrans2);
2337
3cf6a656 2338
2339 TGeoVolume* ssdchip = GetSSDChip();
2340
2341 const Int_t knedges = 5;
2342 TGeoVolume *ssdchipcables[2];
2343
bf210566 2344 for(Int_t i=0; i<kmothernumber; i++){
3cf6a656 2345 for(Int_t j=0; j<kssdstiffenernumber; j++){
2346 ssdhybridmother[i][j]->AddNode(ssdstiffener,1,hybridmotherrotInv);
2347 for(Int_t k=1; k<knapacitor0603number+1; k++){
78e34526 2348 ssdhybridmother[i][j]->AddNode(capacitor0603mother,k,
3cf6a656 2349 new TGeoCombiTrans("",
2350 -0.5*(fgkSSDStiffenerWidth - fgkSSDCapacitor0603Width),
2351 -0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height),
2352 (k-3.)/6*fgkSSDStiffenerLength,
2353 hybridmotherrotInv));
2354 }
2355 }
2356
2357 GetSSDChipCables(ssdchipcables[0],ssdchipcables[1],fgkSSDChipCablesHeight[i+2],knedges);
2358 for(Int_t k=0; k<fgkSSDChipNumber; k++){
2359 TGeoTranslation *chipcabletrans = new TGeoTranslation("",0.5*fgkSSDStiffenerWidth-fgkSSDChipWidth,
2360 - 0.5*fgkSSDStiffenerHeight - fgkSSDChipHeight
2361 - fgkSSDChipCablesHeight[i+2],
2362 (k+0.5-fgkSSDChipNumber/2)*
2363 (fgkSSDChipLength + fgkSSDChipSeparationLength));
2364 TGeoCombiTrans *chiptrans = new TGeoCombiTrans("",0.5*(fgkSSDStiffenerWidth-fgkSSDChipWidth),
2365 - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight),
2366 (k+0.5-fgkSSDChipNumber/2)*(fgkSSDChipLength + fgkSSDChipSeparationLength),
2367 hybridmotherrotInv);
bf210566 2368 for(Int_t j=0; j<kssdstiffenernumber; j++){
3cf6a656 2369 ssdhybridmother[i][j]->AddNode(ssdchipcables[j],k+1,chipcabletrans);
2370 ssdhybridmother[i][j]->AddNode(ssdchip,k+1,chiptrans);
2371 }
2372 }
2373 // Final placement by assembly
2374 ssdhybridassembly[i]->AddNode(ssdhybridmother[i][0],1,new TGeoCombiTrans(TGeoTranslation("",0,0,0),hybridmotherrotL));
2375 ssdhybridassembly[i]->AddNode(ssdhybridmother[i][1],1,new TGeoCombiTrans(TGeoTranslation("",0,ssdstiffenerseparation,0),hybridmotherrotR));
2376 ssdhybridlist->Add(ssdhybridassembly[i]);
bf210566 2377 }
3cf6a656 2378 /////////////////////////////////////////////////////////////
2379 // Mother Volume Containing Capacitor Part
2380 /////////////////////////////////////////////////////////////
bf210566 2381 const Int_t kcapacitormothernumber = 8;
2382 Double_t xcapacitorvertex[kcapacitormothernumber];
2383 Double_t ycapacitorvertex[kcapacitormothernumber];
2384 ///////////////////////
2385 // Setting the vertices
2386 ///////////////////////
2387 xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2388 xcapacitorvertex[1] = xcapacitorvertex[0];
2389 xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2390 xcapacitorvertex[3] = xcapacitorvertex[2];
2391 xcapacitorvertex[4] = xcapacitorvertex[0];
2392 xcapacitorvertex[5] = xcapacitorvertex[0];
2393 xcapacitorvertex[6] = -xcapacitorvertex[0];
2394 xcapacitorvertex[7] = xcapacitorvertex[6];
2395 ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2396 ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2397 ycapacitorvertex[2] = ycapacitorvertex[1];
2398 ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2399 ycapacitorvertex[4] = ycapacitorvertex[3];
2400 ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2401 ycapacitorvertex[6] = ycapacitorvertex[5];
2402 ycapacitorvertex[7] = ycapacitorvertex[0];
2403 TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2404 ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2405 ycapacitorvertex);
2406 ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2407 ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
ca86fdb4 2408// TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2409// fSSDAir);
2410 TGeoVolumeAssembly* ssdhybridcapacitormother = new TGeoVolumeAssembly("SSDHybridCapacitorMother");
d7599219 2411////////////////////////////
bf210566 2412// Connector
d7599219 2413///////////////////////////
78e34526 2414 const Int_t kssdconnectorlayernumber = 3;
2415 TGeoBBox* ssdconnectorshape[kssdconnectorlayernumber];
2416 Double_t ssdConnectorThickness[kssdconnectorlayernumber]={fgkSSDConnectorAlHeight,fgkSSDConnectorNiHeight,fgkSSDConnectorSnHeight};
2417 /*
bf210566 2418 Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2419 Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2420 + fgkSSDConnectorAlHeight};
78e34526 2421 */
2422 Double_t ssdconnectororigin[3] = {0,0,0.5*fgkSSDStiffenerHeight};
2423 const char* ssdconnectorname[kssdconnectorlayernumber] = {"SSDConnectorAl","SSDConnectorNi","SSDConnectorSn"};
2424 TGeoMedium *ssdConnectorMedium[kssdconnectorlayernumber]={fSSDAlTraceFlexMedium,fSSDStiffenerConnectorMedium,fSSDSn};
2425 TGeoVolume* ssdconnector[kssdconnectorlayernumber];
2426 for(Int_t i=0; i<kssdconnectorlayernumber; i++){
2427 ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
bf210566 2428 ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2429 0.5*fgkSSDConnectorWidth,
78e34526 2430 0.5*ssdConnectorThickness[i],
2431 ssdconnectororigin);
2432 ssdconnectororigin[2]+= 0.5*ssdConnectorThickness[i];
bf210566 2433 ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
78e34526 2434 ssdConnectorMedium[i]);
2435 ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorNiSn);
bf210566 2436 }
78e34526 2437 const Int_t kssdconnectornumber = 4;
2438 TGeoTranslation* ssdconnectortrans[kssdconnectornumber];
bf210566 2439 ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2440 + fgkSSDConnectorPosition[0]
2441 - fgkSSDConnectorSeparation
2442 - 1.5*fgkSSDConnectorLength,
2443 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2444 - fgkSSDConnectorPosition[1]
2445 - ssdconnectorshape[0]->GetDY(),0.0);
2446 ssdconnectortrans[1] = new TGeoTranslation(
2447 - ssdstiffenershape->GetDX()
2448 + fgkSSDConnectorPosition[0]
2449 - 0.5*fgkSSDConnectorLength,
2450 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2451 - fgkSSDConnectorPosition[1]
2452 - ssdconnectorshape[0]->GetDY(),0.0);
2453 ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2454 - fgkSSDConnectorPosition[0]
2455 + fgkSSDConnectorSeparation
2456 + 1.5*fgkSSDConnectorLength,
2457 -(ssdstiffenershape->GetDY()
2458 - fgkSSDConnectorPosition[1]
2459 - ssdconnectorshape[0]->GetDY()),0.0);
2460 ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2461 - fgkSSDConnectorPosition[0]
2462 + 0.5*fgkSSDConnectorLength,
2463 -(ssdstiffenershape->GetDY()
2464 - fgkSSDConnectorPosition[1]
2465 - ssdconnectorshape[0]->GetDY()),0.0);
78e34526 2466 for(Int_t i=0; i<kssdconnectornumber; i++) {
2467 Int_t nlay = kssdconnectorlayernumber - 1;
2468 if (i == 1 || i == 2)
2469 nlay++;
2470 for(Int_t j=0; j<nlay; j++)
2471 ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2472 }
bf210566 2473////////////////////////////
2474// Capacitor 1812-330 nF
2475///////////////////////////
78e34526 2476// Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
44285dfa 2477 TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape",
d7599219 2478 0.5*fgkSSDCapacitor1812Length,
2479 0.5*fgkSSDCapacitor1812Width,
78e34526 2480 0.5*fgkSSDCapacitor1812Height);
2481 // ssdcapacitor1812origin);
44285dfa 2482 TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2483 fSSDStiffener1812CapacitorMedium);
2484 capacitor1812->SetLineColor(fColorAl);
bf210566 2485 TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2486 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
78e34526 2487 - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
bf210566 2488 ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
78e34526 2489
2490 TGeoBBox* capacitor1812capshape = new TGeoBBox("Capacitor1812CapShape",
2491 0.5*fgkSSDCapacitor1812CapLength, 0.5*fgkSSDCapacitor1812Width,
2492 0.5*fgkSSDCapacitor1812Height);
2493 TGeoVolume* capacitor1812cap = new TGeoVolume("Capacitor1812Cap",capacitor1812capshape,
2494 fSSDStiffenerCapacitorCapMedium);
2495 capacitor1812cap->SetLineColor(fColorNiSn);
2496 TGeoTranslation* capacitor1812captrans1 = new TGeoTranslation(
2497 - capacitor1812shape->GetDX() - capacitor1812capshape->GetDX(),
2498 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2499 - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
2500 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2501 ssdhybridcapacitormother->AddNode(capacitor1812cap,1,capacitor1812captrans1);
2502 TGeoTranslation* capacitor1812captrans2 = new TGeoTranslation(
2503 capacitor1812shape->GetDX() + capacitor1812capshape->GetDX(),
2504 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2505 - capacitor1812shape->GetDY() - fgkSSDConnectorPosition[1],
2506 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height));
2507 ssdhybridcapacitormother->AddNode(capacitor1812cap,2,capacitor1812captrans2);
2508
d7599219 2509////////////////////////////
2510//Hybrid Wire
2511////////////////////////////
44285dfa 2512 Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
d7599219 2513 - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2514 - fgkSSDConnectorSeparation;
44285dfa 2515 Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
d7599219 2516 - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
60e55aee 2517 Double_t ssdwireradius = TMath::Sqrt(wirex*wirex+wirey*wirey);
2518
44285dfa 2519 Double_t wireangle = TMath::ATan(wirex/wirey);
2520 TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2521 fgkSSDWireRadius, 0.5*ssdwireradius);
2522 TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2523 fSSDStiffenerHybridWireMedium);
2524 hybridwire->SetLineColor(fColorPhynox);
2525 TGeoCombiTrans* hybridwirecombitrans[2];
2526 hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
d7599219 2527 0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2528 + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
44285dfa 2529 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
d7599219 2530 + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
bf210566 2531 ssdstiffenershape->GetDZ()
78e34526 2532 + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight+fgkSSDConnectorSnHeight,
d7599219 2533 new TGeoRotation("HybridWireRot1",0.,90.,0.));
44285dfa 2534 hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
bf210566 2535 0.0,
2536 - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2537 0.0,
2538 new TGeoRotation("HybridWireRot2",
2539 - wireangle*TMath::RadToDeg(),0.,0.));
44285dfa 2540 TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2541 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2542 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
bf210566 2543 ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2544 ssdhybridlist->Add(ssdhybridcapacitormother);
44285dfa 2545 /////////////////////////////////////////////////////////////
bf210566 2546 // Deallocating memory
44285dfa 2547 /////////////////////////////////////////////////////////////
bf210566 2548 delete hybridwirecombitrans[0];
2549 delete hybridwirecombitrans[1];
bf210566 2550 return ssdhybridlist;
2551 /////////////////////////////////////////////////////////////
2552}
2553///////////////////////////////////////////////////////////////////////////////
2554TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2555 /////////////////////////////////////////////////////////////
2556 // SSD Cooling Block System
2557 /////////////////////////////////////////////////////////////
2558 // SSD Cooling Block and Cooling Tube Transformations
2559 /////////////////////////////////////////////////////////////
2560 TGeoRotation* localcoolingblockrot = new TGeoRotation();
2561 localcoolingblockrot->SetAngles(0.,90.,0.);
535e8862 2562 TGeoCombiTrans localcoolingblockmatrix(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
bf210566 2563 TVector3* coolingblocktransvector;
78e34526 2564 coolingblocktransvector = new TVector3(fgkCoolingTubeSeparation,
bf210566 2565 fgkSSDSensorLength
2566 - 2.*fgkSSDModuleStiffenerPosition[1]
2567 - fgkSSDCoolingBlockWidth);
2568 const Int_t kcoolingblocktransnumber = 2;
2569 const Int_t kcoolingblocknumber = 4;
2570 TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
bf210566 2571 TGeoRotation* localcoolingtuberot = new TGeoRotation();
2572 localcoolingtuberot->SetAngles(0.0,90.0,0.0);
bf210566 2573 for(Int_t i=0; i<kcoolingblocktransnumber; i++){
535e8862 2574 for(Int_t j=0; j<kcoolingblocktransnumber; j++){
78e34526 2575 TGeoTranslation localcoolingblocktrans(i*coolingblocktransvector->X(),//+2*coolingtubedistance,
535e8862 2576 j*coolingblocktransvector->Y(),
2577 - 0.5*(fgkSSDCoolingBlockHoleCenter
2578 + fgkCoolingTubeRmax));
2579 coolingblockmatrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingblockmatrix);
535e8862 2580 }
d7599219 2581 }
ca86fdb4 2582 TGeoVolume* coolingsystemother = new TGeoVolumeAssembly("CoolingBlockSystem");
bf210566 2583 TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2584 /////////////////////////////////////////////////////////////
2585 // Adding Cooling block to mother volume
2586 /////////////////////////////////////////////////////////////
3cf6a656 2587 for(Int_t i=0; i<kcoolingblocknumber; i++){
2588 coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
d7599219 2589 }
bf210566 2590 /////////////////////////////////////////////////////////////
2591 // Deallocating memory
2592 /////////////////////////////////////////////////////////////
3cf6a656 2593 delete coolingblocktransvector;
2594 delete localcoolingblockrot;
2595
2596 return coolingsystemother;
d7599219 2597}
2598/////////////////////////////////////////////////////////////////////////////////
bf210566 2599TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
44285dfa 2600 /////////////////////////////////////////////////////////////
bf210566 2601 // SSD Flex
44285dfa 2602 /////////////////////////////////////////////////////////////
bf210566 2603 const Int_t kssdflexlayernumber = 2;
2604 TGeoXtru* ssdflexshape[kssdflexlayernumber];
2605 for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2606 const Int_t kmothervertexnumber = 17;
2607 Double_t xmothervertex[kmothervertexnumber];
2608 Double_t ymothervertex[kmothervertexnumber];
2609 /////////////////////////////////////////////
2610 // Auxiliary variables for vertex positioning
2611 /////////////////////////////////////////////
2612 const Int_t kssdflexboxnumber = 5;
44285dfa 2613 Double_t ssdflexboxlength[kssdflexboxnumber];
2614 ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
d7599219 2615 * fgkSSDChipLength+(fgkSSDChipNumber-1)
2616 * fgkSSDChipSeparationLength
2617 - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2618 - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
44285dfa 2619 ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2620 ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
d7599219 2621 - fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
44285dfa 2622 ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2623 ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2624 - ssdflexboxlength[1];
44285dfa 2625 Double_t ssdflexboxwidth[kssdflexboxnumber];
2626 ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2627 ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2628 ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2629 ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2630 ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
bf210566 2631 ///////////////////////
2632 // Setting the vertices
2633 ///////////////////////
2634 xmothervertex[0] = 0.0;
2635 xmothervertex[1] = xmothervertex[0];
2636 xmothervertex[2] = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2637 xmothervertex[3] = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2638 + ssdflexboxlength[4];
2639 xmothervertex[4] = xmothervertex[3];
2640 xmothervertex[5] = xmothervertex[4]-ssdflexboxlength[4];
2641 xmothervertex[6] = xmothervertex[5];
2642 xmothervertex[7] = xmothervertex[6]-fgkSSDFlexHoleLength;
2643 xmothervertex[8] = xmothervertex[7];
2644 xmothervertex[9] = xmothervertex[8]-ssdflexboxlength[2];
2645 xmothervertex[10] = xmothervertex[9];
2646 xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2647 xmothervertex[12] = xmothervertex[11];
2648 xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2649 xmothervertex[14] = xmothervertex[13];
2650 xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2651 xmothervertex[16] = xmothervertex[15];
2652 ymothervertex[0] = 0.0;
2653 ymothervertex[1] = fgkSSDFlexWidth[1];
2654 ymothervertex[2] = fgkSSDFlexWidth[0];
2655 ymothervertex[3] = ymothervertex[2];
2656 ymothervertex[4] = ymothervertex[0];
2657 ymothervertex[5] = ymothervertex[4];
2658 ymothervertex[6] = ssdflexboxwidth[2];
2659 ymothervertex[7] = ymothervertex[6];
2660 ymothervertex[8] = ymothervertex[0];
2661 ymothervertex[9] = ymothervertex[8];
2662 ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2663 ymothervertex[11] = ymothervertex[10];
2664 ymothervertex[12] = ymothervertex[0];
2665 ymothervertex[13] = ymothervertex[12];
2666 ymothervertex[14] = ymothervertex[7];
2667 ymothervertex[15] = ymothervertex[14];
2668 ymothervertex[16] = ymothervertex[0];
2669 /////////////////////////////////////////////////////////////
2670 // First Mother Volume containing SSDFlex
2671 /////////////////////////////////////////////////////////////
2672 TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2673 ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2674 ymothervertex);
2675 ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2676 ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
ca86fdb4 2677 TGeoVolumeAssembly* ssdflexmother = new TGeoVolumeAssembly("SSDFlexMother");
2678// TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2679// fSSDAir);
bf210566 2680 /////////////////////////////////////////////////////////////
2681 // SSDFlex Layer Shapes
2682 /////////////////////////////////////////////////////////////
2683 for(Int_t i=0; i<kssdflexlayernumber; i++){
2684 ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2685 ymothervertex);
2686 ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2687 ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2688 }
2689 /////////////////////////////////////
2690 // Setting Layers into Mother Volume
2691 /////////////////////////////////////
2692 Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2693 TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2694 fSSDKaptonFlexMedium};
2695 const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2696 "AlFlexLay2","KaptonFlexLay2"};
2697 TGeoVolume* ssdflex[2*kssdflexlayernumber];
2698 TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2699 for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2700 ssdflex[i] = new TGeoVolume(ssdflexname[i],
2701 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2702 i%2==0 ? ssdflexmed[0] : ssdflexmed[1]);
2703 ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2704 ssdflextrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2705 + fgkSSDFlexHeight[1]));
2706 ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2707 }
bf210566 2708 return ssdflexmother;
d7599219 2709}
2710/////////////////////////////////////////////////////////////////////////////////
bf210566 2711TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
44285dfa 2712 /////////////////////////////////////////////////////////////
2713 // Method generating SSD End Flex
d7599219 2714 /////////////////////////////////////////
bf210566 2715 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2716 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2717 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2718 * TMath::DegToRad()*ssdflexradiusmax
2719 - fgkSSDFlexLength[2]-TMath::Pi()
0fb26117 2720 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
2721 - 0.1*fgkSSDFlexFullLength;
bf210566 2722 const Int_t knedges = 20;
2723 const Int_t karcnumber = 2;
2724 TVector3* vertexposition[karcnumber*(knedges+1)];
2725 Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2726 Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2727 Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2728 Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2729 - 90.0*TMath::DegToRad()};
2730 TVector3* referencetrans[karcnumber];
2731 referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2732 + radius[0]*SinD(2.*fgkSSDFlexAngle),
2733 radius[0]);
2734 referencetrans[1] = new TVector3(referencetrans[0]->X()
2735 + fgkSSDFlexLength[2],
2736 - fgkSSDStiffenerHeight);
2737for(Int_t i=0; i<karcnumber; i++){
2738 for(Int_t j=0; j<knedges+1; j++){
2739 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2740 radius[i]*SinD(angle[i]));
2741 angle[i] += deltangle[i]*(1.0-2.0*i);
2742 }
2743 }
2744 ///////////////////////
2745 // Setting the vertices
2746 ///////////////////////
2747 const Int_t kendflexlayernumber = 4;
2748 const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2749 TVector3** vertex[kendflexlayernumber];
2750 for(Int_t i=0; i<kendflexlayernumber; i++)
2751 vertex[i] = new TVector3*[kendflexvertexnumber];
2752 TVector3* transvector[kendflexlayernumber+1];
2753 TVector3* deltatransvector = new TVector3();
2754 for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2755 transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2756 + radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2757 for(Int_t i=1; i<kendflexlayernumber+1; i++){
2758 deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2759 * CosD(fgkSSDFlexAngle),
2760 (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2761 * SinD(fgkSSDFlexAngle),0.0);
2762 *transvector[i] = *transvector[i-1]+*deltatransvector;
2763 }
2764 Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2765 ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2766 for(Int_t i=0; i<karcnumber; i++){
2767 for(Int_t j=1; j<kendflexlayernumber+1; j++){
2768 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2769 * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2770 /radius[i];
2771 }
2772 }
2773 for(Int_t i=0; i<kendflexlayernumber; i++){
2774 vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y());
2775 vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y());
2776 for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2777 if(j<(knedges+1)){
2778 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2779 vertexposition[j]->Y()*ratioradius[0][i+1]);
2780 vertex[i][j+2]->RotateZ(referenceangle[0]);
2781 *vertex[i][j+2] += *referencetrans[0];
2782 vertex[i][4*(knedges+1)-j+1] =
2783 new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2784 vertexposition[j]->Y()*ratioradius[0][i]);
2785 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2786 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2787 }
2788 else{
2789
2790 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2791 vertexposition[j]->Y()*ratioradius[1][i+1]);
2792 vertex[i][j+2]->RotateZ(referenceangle[1]);
2793 *vertex[i][j+2] += *referencetrans[1];
2794 vertex[i][4*(knedges+1)-j+1] =
2795 new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2796 vertexposition[j]->Y()*ratioradius[1][i]);
2797 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2798 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2799 }
2800 }
2801 }
44285dfa 2802 /////////////////////////////////////////////////////////////
bf210566 2803 // First Mother Volume containing SSDEndFlex
2804 /////////////////////////////////////////////////////////////
2805 TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2806 Double_t xmothervertex[kendflexvertexnumber];
2807 Double_t ymothervertex[kendflexvertexnumber];
2808 xmothervertex[0] = vertex[0][0]->X();
2809 ymothervertex[0] = vertex[0][0]->Y();
2810 for(Int_t i=1; i<kendflexvertexnumber; i++){
2811 if(i<2*(knedges+1)+2){
2812 xmothervertex[i] = vertex[3][i]->X();
2813 ymothervertex[i] = vertex[3][i]->Y();
2814 }
2815 else{
2816 xmothervertex[i] = vertex[0][i]->X();
2817 ymothervertex[i] = vertex[0][i]->Y();
2818 }
2819 }
2820 ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2821 xmothervertex,ymothervertex);
2822 ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2823 ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
0fb26117 2824// TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2825// ssdendflexmothershape,fSSDAir);
2826 TGeoVolumeAssembly* ssdendflexmother = new TGeoVolumeAssembly("SSDEndFlexMother");
bf210566 2827 //////////////////////////////////////
2828 // End Flex TGeoXtru Layer Definition
2829 //////////////////////////////////////
2830 TGeoXtru* ssdendflexshape[kendflexlayernumber];
2831 TGeoVolume* ssdendflex[kendflexlayernumber];
2832 for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2833 Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2834 Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2835 Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2836 TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2837 fSSDKaptonFlexMedium};
2838 const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2839 "AlEndFlexLay2","KaptonEndFlexLay2"};
2840 for(Int_t i=0; i<kendflexlayernumber; i++){
2841 for(Int_t j=0; j<4*(knedges+1)+2; j++){
2842 xvertex[i][j] = vertex[i][j]->X();
2843 yvertex[i][j] = vertex[i][j]->Y();
2844 }
2845 ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2846 ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2847 ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2848 ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2849 i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2850 ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2851 ssdendflexmother->AddNode(ssdendflex[i],1);
2852 }
44285dfa 2853 /////////////////////////////////////////////////////////////
bf210566 2854 // Deallocating memory
44285dfa 2855 /////////////////////////////////////////////////////////////
bf210566 2856 for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
2857 for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
2858 for(Int_t i=0; i<kendflexlayernumber; i++){
2859 for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
2860 delete [] vertex[i];
2861 }
2862 for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
2863 delete deltatransvector;
44285dfa 2864 /////////////////////////////////////////////////////////////
6727e2db 2865 //ssdendflexmother->CheckOverlaps(0.01);
bf210566 2866 return ssdendflexmother;
d7599219 2867}
9b0c60ab 2868///////////////////////////////////////////////////////////////////////////////
bf210566 2869TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
44285dfa 2870 /////////////////////////////////////////////////////////////
9b0c60ab 2871 // Method generating the Mounting Block
bf210566 2872 /////////////////////////////////////////////////////////////
9b0c60ab 2873 const Int_t kvertexnumber = 8;
2874 Double_t xvertex[kvertexnumber];
2875 Double_t yvertex[kvertexnumber];
2876 xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
2877 xvertex[1] = xvertex[0];
2878 xvertex[2] = -xvertex[0];
2879 xvertex[3] = xvertex[2];
2880 xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
2881 - fgkSSDMountingBlockLength[2]);
2882 xvertex[5] = xvertex[4];
2883 xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
2884 - 0.5*fgkSSDMountingBlockScrewHoleEdge
2885 - fgkSSDMountingBlockScrewHoleRadius[0];
2886 xvertex[7] = xvertex[6];
2887 yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
0fb26117 2888 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
9b0c60ab 2889 yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
2890 yvertex[2] = yvertex[1];
2891 yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
2892 yvertex[4] = yvertex[3];
2893 yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
2894 - fgkSSDMountingBlockHeight[0];
2895 yvertex[6] = yvertex[5];
2896 yvertex[7] = yvertex[0];
160835d5 2897
9b0c60ab 2898 ///////////////////////////////////////////////////////////////////////
2899 // TGeoXTru Volume definition for Mounting Block Part
2900 ///////////////////////////////////////////////////////////////////////
2901 TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
2902 ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
2903 ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
2904 ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
bf210566 2905 TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
9b0c60ab 2906 ssdmountingblockshape,
2907 fSSDMountingBlockMedium);
2908 ssdmountingblock->SetLineColor(fColorG10);
2909 TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
2910 mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
2911 TGeoRotation* mountingblockrot = new TGeoRotation();
2912 mountingblockrot->SetAngles(90.,180.,-90.);
2913 mountingblockcombitrans->SetRotation(*mountingblockrot);
2914 /////////////////////////////////////////////////////////////
2915 // Generating the Mounting Block Screw Vertices
2916 /////////////////////////////////////////////////////////////
2917 const Int_t kscrewvertexnumber = 15;
2918 Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
2919 - fgkSSDMountingBlockScrewHoleEdge)
2920 / fgkSSDMountingBlockScrewHoleRadius[0])
2921 * TMath::RadToDeg();
2922 Double_t phi0 = 90.+alpha;
2923 Double_t phi = 270.-2*alpha;
2924 Double_t deltaphi = phi/kscrewvertexnumber;
2925 TVector3* screwvertex[kscrewvertexnumber+1];
2926 for(Int_t i=0; i<kscrewvertexnumber+1; i++)
2927 screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
2928 *CosD(phi0+i*deltaphi),
2929 fgkSSDMountingBlockScrewHoleRadius[0]
2930 *SinD(phi0+i*deltaphi));
2931 Double_t xscrewvertex[kscrewvertexnumber+6];
2932 Double_t yscrewvertex[kscrewvertexnumber+6];
2933 xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
2934 yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
2935 - fgkSSDMountingBlockScrewHoleEdge);
2936 xscrewvertex[1] = xscrewvertex[0];
2937 yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2938 xscrewvertex[2] = screwvertex[0]->X();
2939 yscrewvertex[2] = yscrewvertex[1];
2940 for(Int_t i=0; i<kscrewvertexnumber+1; i++){
2941 xscrewvertex[i+3] = screwvertex[i]->X();
2942 yscrewvertex[i+3] = screwvertex[i]->Y();
2943 }
2944 xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
2945 yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
2946 xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
2947 yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
2948 TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
2949 ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
2950 ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
2951 ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
2952 + fgkSSDMountingBlockHeight[2]);
2953 TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
2954 ssdmountingblockscrewshape,
2955 fSSDMountingBlockMedium);
2956 ssdmountingblockscrew->SetLineColor(fColorG10);
2957 TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
2958 for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
2959 ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2960 - yscrewvertex[1],
2961 0.5*fgkSSDMountingBlockHeight[0]
2962 - fgkSSDMountingBlockHeight[2]
2963 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2964 + fgkSSDMountingBlockHeight[2]
2965 - yvertex[0]));
2966 ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
2967 -0.5*fgkSSDMountingBlockScrewHoleEdge,
2968 yscrewvertex[1]
2969 -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2970 +fgkSSDMountingBlockHeight[2]
2971 -yvertex[0]));
2972 ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
2973 yscrewvertex[1],
2974 - 0.5*fgkSSDMountingBlockHeight[0]
2975 + fgkSSDMountingBlockHeight[2]
2976 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2977 + fgkSSDMountingBlockHeight[2]
2978 - yvertex[0]));
2979 ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
2980 yscrewvertex[1],
2981 - yscrewvertex[1]
2982 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2983 + fgkSSDMountingBlockHeight[2]
2984 - yvertex[0]));
2985 TGeoRotation* ssdmountingblockscrewrot[4];
2986 for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
2987 ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
2988 ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
2989 ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
2990 for(Int_t i=1; i<4; i++)
2991 ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
2992 TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
2993 ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
2994 TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
2995 ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
2996 + xvertex[0],yscrewvertex[1]
2997 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
2998 + fgkSSDMountingBlockHeight[2]
2999 - yvertex[0]),0.);
3000 TGeoHMatrix* ssdmountingblockscrewmatrix[4];
3001 for(Int_t i=0; i<4; i++){
3002 ssdmountingblockscrewmatrix[i] =
3003 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
3004 ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
3005 }
3006 ///////////////////////////////////////////////////////////////////////
3007 // TGeoXtru for Mother Volume
3008 ///////////////////////////////////////////////////////////////////////
3009 const Int_t kvertexmothernumber = 12;
3010 Double_t xmothervertex[kvertexmothernumber];
3011 Double_t ymothervertex[kvertexmothernumber];
3012 for(Int_t i=0; i<6; i++){
3013 xmothervertex[i] = xvertex[i];
3014 ymothervertex[i] = yvertex[i];
3015 }
3016 xmothervertex[6] = xvertex[5]+fgkSSDMountingBlockLength[2];
3017 ymothervertex[6] = ymothervertex[5];
3018 xmothervertex[7] = xmothervertex[6];
3019 ymothervertex[7] = ymothervertex[4];
3020 xmothervertex[8] = xmothervertex[7]
3021 + 0.5*(fgkSSDMountingBlockLength[1]
3022 - fgkSSDMountingBlockLength[2]);
3023 ymothervertex[8] = ymothervertex[4];
3024 xmothervertex[9] = xmothervertex[8];
3025 ymothervertex[9] = ymothervertex[2];
3026 xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
3027 ymothervertex[10] = ymothervertex[1];
3028 xmothervertex[11] = xmothervertex[10];
3029 ymothervertex[11] = ymothervertex[0];
3030 TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3031 ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3032 ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3033 ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3034 TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3035 ssdmountingblockmothershape,
3036 fSSDAir);
3037 /////////////////////////////////////////////////////////////
3038 // Placing the Volumes into Mother Volume
3039 /////////////////////////////////////////////////////////////
3040 ssdmountingblockmother->AddNode(ssdmountingblock,1);
3041 ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3042 for(Int_t i=0; i<4; i++)
3043 ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3044 ssdmountingblockscrewmatrix[i]);
3045 /////////////////////////////////////////////////////////////
3046 // Deallocating memory
3047 /////////////////////////////////////////////////////////////
3048 delete mountingblockrot;
3049 for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3050 delete ssdmountingblockglobalrot;
3051 delete ssdmountingblockglobaltrans;
3052 /////////////////////////////////////////////////////////////
3053 return ssdmountingblockmother;
3054}
3055///////////////////////////////////////////////////////////////////////////////
3056 TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3057 /////////////////////////////////////////////////////////////
3058 // Method generating the Mounting Block Clip
3059 /////////////////////////////////////////////////////////////
3060 const Int_t kmothervertexnumber = 10;
3061 Double_t xmothervertex[kmothervertexnumber];
3062 Double_t ymothervertex[kmothervertexnumber];
3063 xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3064 - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3065 xmothervertex[1] = xmothervertex[0];
3066 xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3067 - fgkMountingBlockClibScrewRadius);
3068 xmothervertex[3] = xmothervertex[2];
3069 xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3070 xmothervertex[5] = xmothervertex[4];
3071 xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3072 xmothervertex[7] = xmothervertex[6];
3073 xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3074 xmothervertex[9] = xmothervertex[8];
3075 ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
0fb26117 3076 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
9b0c60ab 3077 ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3078 ymothervertex[2] = ymothervertex[1];
3079 ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3080 - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3081 - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);
3082 ymothervertex[4] = ymothervertex[3];
3083 ymothervertex[5] = ymothervertex[2];
3084 ymothervertex[6] = ymothervertex[5];
3085 ymothervertex[7] = ymothervertex[6]-fgkMountingBlockClipThickness;
3086 ymothervertex[8] = ymothervertex[7];
3087 ymothervertex[9] = ymothervertex[0];
160835d5 3088
9b0c60ab 3089 ///////////////////////////////////////////////////////////////////////
3090 // TGeoXTru Volume definition for Mounting Block Clip Part
3091 ///////////////////////////////////////////////////////////////////////
3092 TGeoXtru* ssdmountingblockclipshape = new TGeoXtru(2);
3093 ssdmountingblockclipshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3094 ssdmountingblockclipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3095 ssdmountingblockclipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3096 TGeoVolume* ssdmountingblockclip = new TGeoVolume("SSDMountingBlockClip",
3097 ssdmountingblockclipshape,fSSDAir);
3098 ssdmountingblockclip->SetLineColor(4);
3099 ///////////////////////////////////////////////////////////////////////
3100 // TGeoXTru Volume definition for Clip
3101 ///////////////////////////////////////////////////////////////////////
3102 const Int_t kclipvertexnumber = 6;
3103 Double_t xclipvertex[kclipvertexnumber];
3104 Double_t yclipvertex[kclipvertexnumber];
3105 xclipvertex[0] = xmothervertex[0];
3106 xclipvertex[1] = xclipvertex[0];
3107 xclipvertex[2] = xmothervertex[6];
3108 xclipvertex[3] = xclipvertex[2];
3109 xclipvertex[4] = xclipvertex[0]+fgkMountingBlockClipThickness;
3110 xclipvertex[5] = xclipvertex[4];
3111 yclipvertex[0] = ymothervertex[0];
3112 yclipvertex[1] = ymothervertex[1];
3113 yclipvertex[2] = yclipvertex[1];
3114 yclipvertex[3] = yclipvertex[1]-fgkMountingBlockClipThickness;
3115 yclipvertex[4] = yclipvertex[3];
3116 yclipvertex[5] = yclipvertex[0];
3117 TGeoXtru* clipshape = new TGeoXtru(2);
3118 clipshape->DefinePolygon(kclipvertexnumber,xclipvertex,yclipvertex);
3119 clipshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockClibWidth);
3120 clipshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]
3121 + fgkMountingBlockClibWidth);
3122 TGeoVolume* clip = new TGeoVolume("SSDClip",clipshape,fSSDMountingBlockMedium);
3123 clip->SetLineColor(18);
3124 ///////////////////////////////////////////////////////////////////////
3125 // Ladder Support Piece
3126 ///////////////////////////////////////////////////////////////////////
3127 const Int_t ksupportvertexnumber = 4;
3128 Double_t xsupportvertex[ksupportvertexnumber];
3129 Double_t ysupportvertex[ksupportvertexnumber];
3130 xsupportvertex[0] = xclipvertex[5];
3131 xsupportvertex[1] = xsupportvertex[0];
3132 xsupportvertex[2] = xmothervertex[9];
3133 xsupportvertex[3] = xsupportvertex[2];
3134 ysupportvertex[0] = yclipvertex[0];
3135 ysupportvertex[1] = yclipvertex[3];
3136 ysupportvertex[2] = ysupportvertex[1];
3137 ysupportvertex[3] = ysupportvertex[0];
3138 TGeoXtru* supportshape = new TGeoXtru(2);
3139 supportshape->DefinePolygon(ksupportvertexnumber,xsupportvertex,ysupportvertex);
3140 supportshape->DefineSection(0,0.5*fgkSSDMountingBlockWidth-fgkMountingBlockSupportWidth[0]);
3141 supportshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3142 TGeoVolume* support = new TGeoVolume("RingSupport",supportshape,fSSDMountingBlockMedium);
3143 support->SetLineColor(9);
3144 ///////////////////////////////////////////////////////////////////////
3145 // TGeoXTru Volume definition for Screw
3146 ///////////////////////////////////////////////////////////////////////
3147 Double_t radius[2] = {fgkMountingBlockClibScrewRadius,
3148 0.5*fgkMountingBlockClibScrewRadius};
3149 Int_t edgesnumber[2] = {50,6};
3150 Double_t section[2] = {-0.5*(ymothervertex[3]-ymothervertex[2]),
3151 +0.5*(ymothervertex[3]-ymothervertex[2])};
851c0ce3 3152 TGeoShape* clipscrewshape = GetScrewShape(radius,edgesnumber,section);
9b0c60ab 3153 TGeoVolume* clipscrew = new TGeoVolume("ClipScrewShape",clipscrewshape,fSSDSupportRingAl);
3154 clipscrew->SetLineColor(12);
3155 TGeoRotation* screwrot = new TGeoRotation();
3156 screwrot->SetAngles(0.,90.,0.);
3157 TGeoTranslation* screwtrans = new TGeoTranslation();
3158 screwtrans->SetTranslation(xmothervertex[3]+fgkMountingBlockClibScrewRadius,
3159 0.5*(ymothervertex[3]+ymothervertex[2]),
3160 0.5*fgkSSDMountingBlockWidth+
3161 -0.5*fgkMountingBlockSupportWidth[0]);
3162 TGeoCombiTrans* screwcombitrans = new TGeoCombiTrans(*screwtrans,*screwrot);
3163 ///////////////////////////////////////////////////////////////////////
3164 // Placing the Volumes
3165 ///////////////////////////////////////////////////////////////////////
3166 ssdmountingblockclip->AddNode(clip,1);
3167 ssdmountingblockclip->AddNode(support,1);
3168 ssdmountingblockclip->AddNode(clipscrew,1,screwcombitrans);
3169 /////////////////////////////////////////////////////////////
3170 // Deallocating memory
3171 /////////////////////////////////////////////////////////////
3172 delete screwtrans;
3173 delete screwrot;
3174 /////////////////////////////////////////////////////////////
3175 return ssdmountingblockclip;
d7599219 3176}
bf210566 3177///////////////////////////////////////////////////////////////////////////////
cd2243fb 3178void AliITSv11GeometrySSD::CreateCoolingTubes() {
44285dfa 3179 /////////////////////////////////////////////////////////////
bf210566 3180 // Method generating the Cooling Tube
cd2243fb 3181 // sets fcoolingtube and returns list for endladdercoolingtube
44285dfa 3182 /////////////////////////////////////////////////////////////
cd2243fb 3183 TGeoTube *coolingtubeshape[2];
3184 // Ladder Cooling Tubes
3185
3186 // MvL: Simplified cooling tubes
3187 coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,0.5*fgkCoolingTubeLength);
3188 coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,coolingtubeshape[0]->GetDz());
3189
3190 // End Ladder Cooling Tubes
3191 TGeoTube** endladdercoolingtubeshape[fgkendladdercoolingtubenumber];
3192 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3193 endladdercoolingtubeshape[i] = new TGeoTube*[2];
3194
3195 Double_t sensZshift = 0.5*fgkCarbonFiberJunctionWidth - fgkCarbonFiberLowerSupportWidth - fgkLowerSupportToSensorZ;
3196 endladdercoolingtubeshape[0][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3197 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[0] - sensZshift));
3198 endladdercoolingtubeshape[0][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3199 endladdercoolingtubeshape[0][0]->GetDz());
3200 endladdercoolingtubeshape[1][0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
3201 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[1] + sensZshift));
3202 endladdercoolingtubeshape[1][1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
3203 endladdercoolingtubeshape[1][0]->GetDz()-0.5*fgkSSDTolerance);
3204 // Ladder Cooling Tubes
3205 TGeoVolume* coolingtube[2];
3206 coolingtube[0] = new TGeoVolume("OuterCoolingTube1",coolingtubeshape[0], fSSDCoolingTubePhynox);
3207 coolingtube[1] = new TGeoVolume("InnerCoolingTube1",coolingtubeshape[1], fSSDCoolingTubeWater);
3208 coolingtube[0]->SetLineColor(fColorPhynox);
3209 coolingtube[1]->SetLineColor(fColorWater);
3210
3211 // End Ladder Cooling Tubes
3212 TGeoVolume** endladdercoolingtube[fgkendladdercoolingtubenumber];
3213 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
3214 endladdercoolingtube[i] = new TGeoVolume*[2];
3215 endladdercoolingtube[0][0] = new TGeoVolume("OuterEndLadderCoolingTube1",
3216 endladdercoolingtubeshape[0][0],
3217 fSSDCoolingTubePhynox);
3218 endladdercoolingtube[0][1] = new TGeoVolume("InnerEndlLadderCoolingTube1",
3219 endladdercoolingtubeshape[0][1],
3220 fSSDCoolingTubeWater);
3221 endladdercoolingtube[1][0] = new TGeoVolume("OuterEndLadderCoolingTube2",
3222 endladdercoolingtubeshape[1][0],
3223 fSSDCoolingTubePhynox);
3224 endladdercoolingtube[1][1] = new TGeoVolume("InnerEndlLadderCoolingTube2",
3225 endladdercoolingtubeshape[1][1],
3226 fSSDCoolingTubeWater);
3227 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++){
3228 endladdercoolingtube[i][0]->SetLineColor(fColorPhynox);
3229 endladdercoolingtube[i][1]->SetLineColor(fColorWater);
3230 }
0fb26117 3231
bf210566 3232 /////////////////////////////////////////////////////////////
3233 // Virtual Volume containing Cooling Tubes
3234 /////////////////////////////////////////////////////////////
9b0c60ab 3235 // Ladder Cooling Tubes
cd2243fb 3236 TGeoTube* virtualcoolingtubeshape = new TGeoTube(coolingtubeshape[1]->GetRmin(),
3237 coolingtubeshape[0]->GetRmax(),
3238 coolingtubeshape[0]->GetDz());
3239 fcoolingtube = new TGeoVolume("CoolingTube1",virtualcoolingtubeshape, fSSDAir);
3240 fcoolingtube->AddNode(coolingtube[0],1);
3241 fcoolingtube->AddNode(coolingtube[1],1);
3242
9b0c60ab 3243 // End Ladder Cooling Tubes
3244 TGeoTube* endladdervirtualcoolingtubeshape[fgkendladdercoolingtubenumber];
3245 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
cd2243fb 3246 endladdervirtualcoolingtubeshape[i] = new TGeoTube(endladdercoolingtubeshape[i][1]->GetRmin(),
3247 endladdercoolingtubeshape[i][0]->GetRmax(),
3248 endladdercoolingtubeshape[i][0]->GetDz());
3249 fendladdercoolingtube[0] = new TGeoVolume("EndLadderCoolingTube1",
3250 endladdervirtualcoolingtubeshape[0],
3251 fSSDAir);
3252 fendladdercoolingtube[1] = new TGeoVolume("EndLadderCoolingTube2",
3253 endladdervirtualcoolingtubeshape[1],
3254 fSSDAir);
3255 fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][0],1);
3256 fendladdercoolingtube[0]->AddNode(endladdercoolingtube[0][1],1);
3257 fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][0],1);
3258 fendladdercoolingtube[1]->AddNode(endladdercoolingtube[1][1],1);
d7599219 3259}
bf210566 3260///////////////////////////////////////////////////////////////////////////////
3261TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(Int_t nedges){
44285dfa 3262 /////////////////////////////////////////////////////////////
bf210566 3263 // Method generating SSD Cooling Block
44285dfa 3264 /////////////////////////////////////////////////////////////
bf210566 3265 const Int_t kvertexnumber = 8;
3266 ///////////////////////////////////////
3267 // Vertex Positioning for TGeoXTru
3268 ///////////////////////////////////////
3269 TVector3** vertexposition = new TVector3*[2*kvertexnumber+nedges+1];
3270 vertexposition[0] = new TVector3(0.0,0.0);
3271 vertexposition[1] = new TVector3(0.0,fgkSSDCoolingBlockHeight[1]);
3272 vertexposition[2] = new TVector3(fgkSSDCoolingBlockHoleLength[1],
3273 vertexposition[1]->Y());
3274 vertexposition[3] = new TVector3(vertexposition[2]->X(),
3275 vertexposition[2]->Y()+fgkSSDCoolingBlockHeight[2]);
3276 vertexposition[4] = new TVector3(vertexposition[1]->X(),vertexposition[3]->Y());
3277 vertexposition[5] = new TVector3(vertexposition[4]->X(),
3278 + vertexposition[3]->Y()+fgkSSDCoolingBlockHoleRadius[1]);
3279 vertexposition[6] = new TVector3(Xfrom2Points(vertexposition[5]->X(),
3280 vertexposition[5]->Y(),0.5*(fgkSSDCoolingBlockLength
3281 - fgkSSDCoolingBlockHoleLength[0]
3282 - 4.*fgkSSDCoolingBlockHoleRadius[1]),
3283 fgkSSDCoolingBlockHeight[0]
3284 - fgkSSDCoolingBlockHoleRadius[1],
3285 fgkSSDCoolingBlockHeight[0]),fgkSSDCoolingBlockHeight[0]);
3286 vertexposition[7] = new TVector3(0.5*(fgkSSDCoolingBlockLength
3287 - fgkSSDCoolingBlockHoleLength[0]),
3288 vertexposition[6]->Y());
3289 Double_t alpha = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
3290 / fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
3291 Double_t phi = 180.-alpha;
3292 Double_t psi = 180.+2.*alpha;
3293 Double_t deltapsi = psi/nedges;
3294 Double_t radius = fgkSSDCoolingBlockHoleRadius[0]/CosD(0.5*deltapsi);
3295 TVector3* transvector = new TVector3(0.5*fgkSSDCoolingBlockLength,
3296 fgkSSDCoolingBlockHoleCenter);
3297 for(Int_t i=0; i<nedges+1; i++){
3298 vertexposition[kvertexnumber+i] = new TVector3(radius*CosD(phi+i*deltapsi),
3299 radius*SinD(phi+i*deltapsi));
3300 *vertexposition[kvertexnumber+i] += (*transvector);
3301 }
3302 Double_t param[4] = {1.0,0.0,0.0,-0.5*fgkSSDCoolingBlockLength};
3303 for(Int_t i=0; i<kvertexnumber; i++)
3304 vertexposition[kvertexnumber+nedges+1+i] =
3305 GetReflection(vertexposition[kvertexnumber-1-i],param);
3306 ///////////////////////////////////////////////////////////////////////
3307 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
3308 ///////////////////////////////////////////////////////////////////////
3309 TGeoXtru* ssdcoolingblockshape = new TGeoXtru(2);
3310 Double_t* xvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3311 Double_t* yvertexpoints = new Double_t[2*kvertexnumber+nedges+1];
3312 for(Int_t i=0; i<2*kvertexnumber+nedges+1; i++){
3313 xvertexpoints[i] = vertexposition[i]->X();
3314 yvertexpoints[i] = vertexposition[i]->Y();
3315 }
3316 ssdcoolingblockshape->DefinePolygon(2*kvertexnumber+nedges+1,xvertexpoints,
3317 yvertexpoints);
3318 ssdcoolingblockshape->DefineSection(0,-0.5*fgkSSDCoolingBlockWidth);
3319 ssdcoolingblockshape->DefineSection(1,0.5*fgkSSDCoolingBlockWidth);
3320 TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
3321 ssdcoolingblockshape,
3322 fSSDAlCoolBlockMedium);
3323 ssdcoolingblock->SetLineColor(fColorAl);
3324 /////////////////////////////////////////////////////////////
3325 // Deallocating memory
3326 /////////////////////////////////////////////////////////////
3327 delete [] vertexposition;
7b208ef4 3328 delete [] xvertexpoints;
3329 delete [] yvertexpoints;
bf210566 3330 /////////////////////////////////////////////////////////////
3331 return ssdcoolingblock;
3332}
3333/////////////////////////////////////////////////////////////////////////////////
3cf6a656 3334void AliITSv11GeometrySSD::GetSSDChipCables(TGeoVolume *&cableL, TGeoVolume *&cableR, Double_t SSDChipCablesHeight, Int_t nedges){
d7599219 3335 ///////////////////////////////////////////////////////
cd2243fb 3336 static const Int_t kssdchipcablesnumber = 2; // Number of cables: left and right
3337 static const Int_t kssdchipcableslaynumber = 2; // Number of layers: Al and Kapton
3338 static const Int_t kvertexnumber = 4*(nedges+1)+4;
bf210566 3339 Int_t ssdchipcablescolor[kssdchipcableslaynumber] = {fColorAl,fColorPolyhamide};
3340 Double_t ssdchipcablesradius[kssdchipcableslaynumber];
cd2243fb 3341 ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeight
bf210566 3342 - fgkSSDChipCablesHeight[0]
3343 - fgkSSDChipCablesHeight[1]);
3344 ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
3345 Double_t ssdchipcablespiecelength[kssdchipcablesnumber];
3346 ssdchipcablespiecelength[0] = 0.5*(fgkSSDChipCablesWidth[0]
3347 - 2.*TMath::Pi()*ssdchipcablesradius[0]
3348 - ssdchipcablesradius[0]
3349 - fgkSSDChipCablesWidth[1]
3350 - fgkSSDChipCablesWidth[2]);
3351 ssdchipcablespiecelength[1] = ssdchipcablespiecelength[0]
3352 - 0.5*(fgkSSDModuleStiffenerPosition[1]
3353 + fgkSSDChipCablesHeight[1]
3354 + fgkSSDSensorHeight);
d7599219 3355 ///////////////////////////////////////////////////////
bf210566 3356 // Vertex Positioning for TGeoXTrue Layer 1 and Layer 2
3357 ///////////////////////////////////////////////////////
3358 TVector3** vertexposition[kssdchipcableslaynumber];
3359 for(Int_t i=0; i<kssdchipcableslaynumber; i++) vertexposition[i] =
3360 new TVector3*[4*(nedges+1)+4];
3361 Double_t ratio[4];
3362 ratio[0] = ssdchipcablesradius[1]/ssdchipcablesradius[0];
3363 ratio[1] = (ssdchipcablesradius[1]-fgkSSDChipCablesHeight[1])
3364 / ssdchipcablesradius[0];
3365 ratio[2] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0])
3366 / ssdchipcablesradius[0];
3367 ratio[3] = (ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
3368 + fgkSSDChipCablesHeight[1])
3369 / ssdchipcablesradius[0];
3370 Double_t phi = 180.;
3371 Double_t deltaphi = 180./nedges;
3372 Double_t angle = 0.0;
3373 Double_t **xvertexpoints = new Double_t*[kssdchipcableslaynumber];
3374 Double_t **yvertexpoints = new Double_t*[kssdchipcableslaynumber];
3375 for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3376 xvertexpoints[i] = new Double_t[kvertexnumber];
3377 yvertexpoints[i] = new Double_t[kvertexnumber];
3378 }
3379 TVector3* vertex = new TVector3();
3380 TVector3* transvector[kssdchipcableslaynumber];
3381 transvector[0] = new TVector3(fgkSSDChipWidth,
cd2243fb 3382 SSDChipCablesHeight-ssdchipcablesradius[0]);
bf210566 3383 transvector[1] = new TVector3();
cd2243fb 3384 TGeoXtru* ssdchipcableshape[kssdchipcableslaynumber*kssdchipcablesnumber];
3385 TGeoVolume* ssdchipcable[kssdchipcableslaynumber*kssdchipcablesnumber];
3386 const char* ssdchipcablename[kssdchipcableslaynumber*kssdchipcablesnumber] =
bf210566 3387 {"SSDChipcableAllay1Left","SSDChipcableKaptonlay2Left",
3388 "SSDChipcableAllay1Right","SSDChipcableKaptonlay2Right"};
3389 for(Int_t k=0; k<kssdchipcablesnumber; k++){
3390 transvector[1]->SetX(fgkSSDChipWidth-ssdchipcablespiecelength[k]);
3391 transvector[1]->SetY(ssdchipcablesradius[0]
3392 + fgkSSDChipCablesHeight[0]
3393 + fgkSSDChipCablesHeight[1]);
3394 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
cd2243fb 3395 vertexposition[i][0] = new TVector3(0.,SSDChipCablesHeight
bf210566 3396 - fgkSSDChipCablesHeight[0]-i*fgkSSDChipCablesHeight[1]);
cd2243fb 3397 vertexposition[i][1] = new TVector3(0.,SSDChipCablesHeight
bf210566 3398 - i*fgkSSDChipCablesHeight[0]);
3399 vertexposition[i][2*(nedges+1)+2] =
3400 new TVector3(fgkSSDChipWidth+ssdchipcablesradius[0]
3401 + fgkSSDChipCablesWidth[1]
3402 + fgkSSDChipCablesWidth[2],
3403 ((1.-i)*fgkSSDChipCablesHeight[i]
3404 + fgkSSDChipCablesHeight[1]));
3405 vertexposition[i][2*(nedges+1)+3] =
3406 new TVector3(vertexposition[i][2*(nedges+1)+2]->X(),
3407 vertexposition[i][2*(nedges+1)+2]->Y()
3408 - fgkSSDChipCablesHeight[i]);
3409 for(Int_t j=0; j<nedges+1; j++){
3410 angle = 0.5*phi+TMath::Power(-1,i+1)*j*deltaphi;
3411 vertex->SetX(ssdchipcablesradius[0]*CosD(angle));
3412 vertex->SetY(ssdchipcablesradius[0]*SinD(angle));
3413 vertexposition[0][(nedges+1)*i+j+2] =
3414 new TVector3(*vertex+*transvector[i]);
3415 vertexposition[1][(nedges+1)*i+j+2] =
3416 new TVector3(vertex->X()*ratio[2*i]+transvector[i]->X(),
3417 vertex->Y()*ratio[2*i]+transvector[i]->Y());
3418 vertexposition[0][(4-i)*(nedges+1)+4-j-1] =
3419 new TVector3(*vertexposition[1][(nedges+1)*i+j+2]);
3420 vertexposition[1][(4-i)*(nedges+1)+4-j-1] =
3421 new TVector3(vertex->X()*ratio[2*i+1]
3422 + transvector[i]->X(),
3423 vertex->Y()*ratio[2*i+1]
3424 + transvector[i]->Y());
3425 }
3426 }
3427 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
3428 for(Int_t j=0; j<kvertexnumber; j++){
3429 xvertexpoints[i][j] = vertexposition[i][j]->X();
3430 yvertexpoints[i][j] = vertexposition[i][j]->Y();
3431 }
3432 ssdchipcableshape[kssdchipcablesnumber*k+i] = new TGeoXtru(2);
3433 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefinePolygon(kvertexnumber,
3434 xvertexpoints[i],yvertexpoints[i]);
3435 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3436 ssdchipcableshape[kssdchipcablesnumber*k+i]->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3437 ssdchipcable[kssdchipcablesnumber*k+i] =
3438 new TGeoVolume(ssdchipcablename[kssdchipcablesnumber*k+i],
3439 ssdchipcableshape[kssdchipcablesnumber*k+i],
3440 (kssdchipcablesnumber*k+i)%2==0?
3441 fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
3442 ssdchipcable[kssdchipcablesnumber*k+i]->SetLineColor(ssdchipcablescolor[i]);
3443 }
3444 for(Int_t i=0; i<kssdchipcableslaynumber; i++)
3445 for(Int_t j=0; j<kvertexnumber; j++) delete vertexposition[i][j];
3446 }
44285dfa 3447 /////////////////////////////////////////////////////////////
bf210566 3448 // Mother Volume definition
3449 /////////////////////////////////////////////////////////////
cd2243fb 3450 static const Int_t kmothervertexnumber = 8;
3451 Double_t xmothervertex[kmothervertexnumber];
3452 Double_t ymothervertex[kmothervertexnumber];
3453 xmothervertex[0] = xvertexpoints[0][1];
3454 ymothervertex[0] = yvertexpoints[0][1];
3455 xmothervertex[1] = xvertexpoints[0][2+nedges/2];
3456 ymothervertex[1] = yvertexpoints[0][1];
3457 xmothervertex[2] = xvertexpoints[0][2+nedges/2];
3458 ymothervertex[2] = yvertexpoints[0][2+nedges];
3459 xmothervertex[3] = xvertexpoints[0][3+nedges];
3460 ymothervertex[3] = yvertexpoints[0][3+nedges];
3461 xmothervertex[4] = xvertexpoints[0][3+2*nedges];
3462 ymothervertex[4] = yvertexpoints[0][3+2*nedges];
3463 xmothervertex[5] = xvertexpoints[0][4+2*nedges];
3464 ymothervertex[5] = yvertexpoints[0][4+2*nedges];
3465 xmothervertex[6] = xvertexpoints[1][5+2*nedges];
3466 ymothervertex[6] = yvertexpoints[1][5+2*nedges];
3467 xmothervertex[7] = xvertexpoints[0][1];
3468 ymothervertex[7] = yvertexpoints[1][5+2*nedges];
3469 TGeoXtru *ssdchipcablemothershape = new TGeoXtru(2);
3470 ssdchipcablemothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
3471 ssdchipcablemothershape->DefineSection(0,-0.5*fgkSSDChipCablesLength[1]);
3472 ssdchipcablemothershape->DefineSection(1,+0.5*fgkSSDChipCablesLength[1]);
3473
3cf6a656 3474 cableL = new TGeoVolume("SSDChipCableMotherLeft",ssdchipcablemothershape,fSSDAir);
3475 cableR = new TGeoVolume("SSDChipCableMotherRight",ssdchipcablemothershape,fSSDAir);
cd2243fb 3476
3cf6a656 3477 cableL->AddNode(ssdchipcable[0],1);
3478 cableL->AddNode(ssdchipcable[1],1);
3479 cableR->AddNode(ssdchipcable[2],1);
3480 cableR->AddNode(ssdchipcable[3],1);
cd2243fb 3481
bf210566 3482 /////////////////////////////////////////////////////////////
3483 // Deallocating memory
3484 /////////////////////////////////////////////////////////////
3485 for(Int_t i=0; i<kssdchipcableslaynumber;i++){
3486 delete [] xvertexpoints[i];
3487 delete [] yvertexpoints[i];
3488 }
3489 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete [] vertexposition[i];
3490 for(Int_t i=0; i<kssdchipcableslaynumber; i++) delete transvector[i];
3491 delete vertex;
bf210566 3492 /////////////////////////////////////////////////////////////
d7599219 3493}
5bf92139 3494//_____________________________________________________________________________
3cf6a656 3495TGeoVolume* AliITSv11GeometrySSD::GetSSDChip() const{
44285dfa 3496 /////////////////////////////////////////////////////////////
bf210566 3497 // SSD Chip Assembly Generation
3498 /////////////////////////////////////////////////////////////
bf210566 3499 TGeoBBox* ssdchipcompshape[2];
3500 ssdchipcompshape[0] = new TGeoBBox("SSDChipCompShape",
3501 0.5*fgkSSDChipLength,
3502 0.5*fgkSSDChipWidth,
3503 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
3504 ssdchipcompshape[1] = new TGeoBBox("SSDChipGlueCompShape",
3505 0.5*fgkSSDChipLength,
3506 0.5*fgkSSDChipWidth,
3507 0.5*fgkSSDChipGlueHeight);
3508 TGeoVolume* ssdchipcomp[2];
3509 ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
3510 ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
3511 fSSDChipGlueMedium);
3512 ssdchipcomp[0]->SetLineColor(fColorSilicon);
3513 ssdchipcomp[1]->SetLineColor(fColorEpoxy);
3514 TGeoTranslation* ssdchipcomptrans[2];
3515 ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
3516 ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
3517 /////////////////////////////////////////////////////////////
3518 // Virtual Volume containing SSDChip
3519 /////////////////////////////////////////////////////////////
3520 TGeoBBox* ssdvirtualchipshape = new TGeoBBox("SSDChipShape",0.5*fgkSSDChipLength,
3521 0.5*fgkSSDChipWidth,
3522 0.5*fgkSSDChipHeight);
e21cdd03 3523 TGeoVolume* ssdchip = new TGeoVolume("SSDChip",ssdvirtualchipshape,fSSDAir);
bf210566 3524 /////////////////////////////////////////////////////////////
3525 for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
3cf6a656 3526 return ssdchip;
d7599219 3527}
bf210566 3528/////////////////////////////////////////////////////////////////////////////////
3529TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
44285dfa 3530 /////////////////////////////////////////////////////////////
bf210566 3531 // Method returning a List containing pointers to Ladder Cable Volumes
cd2243fb 3532 //
3533 // Return list contains 3 assemblies: cable box, cable arb shape and the end part of the cable
3534 // each contains 2 volumes, one for polyamide and one for aluminium
44285dfa 3535 /////////////////////////////////////////////////////////////
bf210566 3536 const Int_t kladdercablesegmentnumber = 2;
3537 /////////////////////////////////////////
3538 // LadderSegmentBBox Volume
3539 /////////////////////////////////////////
160835d5 3540 static TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber] = {0,0};
bf210566 3541 const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
3542 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
160835d5 3543
3544
3545 const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
3546 {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
3547 static TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
3548
3549 static TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber] = {
3550 new TGeoTranslation("LadderCableSegmentBBoxTrans1",
3551 0.5*fgkSSDFlexWidth[0],
3552 0.5*fgkSSDLadderCableWidth,
78e34526 3553 0.5*fgkSSDLadderCableHeight[0]),
160835d5 3554 new TGeoTranslation("LadderCableSegmentBBoxTrans2",
3555 0.5*fgkSSDFlexWidth[0],
3556 0.5*fgkSSDLadderCableWidth,
78e34526 3557 fgkSSDLadderCableHeight[0]
3558 +0.5*fgkSSDLadderCableHeight[1])
160835d5 3559 };
3560 static TGeoVolume* laddercablesegmentbboxassembly = new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly") ;
3561 static TGeoVolume* laddercablesegmentarbassembly =
3562 new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
3563
3564 static TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
3565 static TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
3566
3567 if (laddercablesegmentbboxshape[0] == 0) {
3568 // Initialise static shapes and volumes
bf210566 3569 for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
3570 new TGeoBBox(laddercablesegmentbboxshapename[i],
3571 0.5*fgkSSDFlexWidth[0],
3572 0.5*fgkSSDLadderCableWidth,
78e34526 3573 0.5*fgkSSDLadderCableHeight[i]);
160835d5 3574
bf210566 3575 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3576 laddercablesegmentbbox[i] =
3577 new TGeoVolume(laddercablesegmentbboxname[i],
3578 laddercablesegmentbboxshape[i],
3579 (i==0?fSSDAlTraceLadderCableMedium:
3580 fSSDKaptonLadderCableMedium));
3581 laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3582 fColorPolyhamide);
3583 }
160835d5 3584
bf210566 3585 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3586 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
3587 laddercablesegmentbboxtrans[i]);
3588/////////////////////////////////////////
3589// LadderSegmentArb8 Volume
3590/////////////////////////////////////////
3591 const Int_t kvertexnumber = 4;
3592 TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
3593 for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
3594 new TVector3*[kvertexnumber];
3595//Shape Vertex Positioning
3596 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3597 laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
3598 laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
3599 i*fgkSSDFlexHeight[0]);
3600 laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
3601 + fgkSSDFlexHeight[1]
3602 + i*fgkSSDFlexHeight[0]);
3603 laddercablesegmentvertexposition[i][3] =
3604 new TVector3(laddercablesegmentvertexposition[i][1]->X(),
3605 laddercablesegmentvertexposition[i][2]->Y());
3606 }
3607 Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
3608 {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
a6e0ebfe 3609 const char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
bf210566 3610 {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
160835d5 3611
bf210566 3612 for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
3613 GetArbShape(laddercablesegmentvertexposition[i],
3614 laddercablesegmentwidth[i],
3615 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
3616 laddercablesegmentarbshapename[i]);
3617 const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
3618 {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
160835d5 3619
bf210566 3620 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3621 laddercablesegmentarb[i] =
3622 new TGeoVolume(laddercablesegmentarbname[i],
3623 laddercablesegmentarbshape[i],
3624 (i==0?fSSDAlTraceLadderCableMedium:
3625 fSSDKaptonLadderCableMedium));
3626 laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
3627 fColorPolyhamide);
d7599219 3628}
bf210566 3629 TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
3630 laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
3631 90.,90,-90.);
3632 laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
3633 0.,90.,0.);
3634 TGeoCombiTrans* laddercablesegmentarbcombitrans =
3635 new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
3636 0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
3637 + fgkSSDFlexWidth[0],0.,0.,
3638 new TGeoRotation((*laddercablesegmentarbrot[1])
3639 *(*laddercablesegmentarbrot[0])));
bf210566 3640 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3641 laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
3642 laddercablesegmentarbcombitrans);
160835d5 3643 } // End of static initialisations
bf210566 3644/////////////////////////////////////////
3645// End Ladder Cable Volume
160835d5 3646// Note: this part depends explicitly on the length passed as an argument to the function
bf210566 3647/////////////////////////////////////////
3648 TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
3649 const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
3650 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
3651 for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
3652 new TGeoBBox(ladderendcablesegmentbboxshapename[i],
3653 0.5*ssdendladdercablelength,
3654 0.5*fgkSSDLadderCableWidth,
78e34526 3655 0.5*fgkSSDLadderCableHeight[i]);
bf210566 3656 const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
3657 {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
3658 TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
3659 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
3660 ladderendcablesegmentbbox[i] =
3661 new TGeoVolume(ladderendcablesegmentbboxname[i],
3662 ladderendcablesegmentbboxshape[i],
3663 (i==0?fSSDAlTraceLadderCableMedium:
3664 fSSDKaptonLadderCableMedium));
3665 ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
3666 fColorPolyhamide);
3667 }
3668 TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
3669 ladderendcablesegmentbboxtrans[0] =
3670 new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
3671 0.5*ssdendladdercablelength,
3672 0.5*fgkSSDLadderCableWidth,
78e34526 3673 0.5*fgkSSDLadderCableHeight[0]);
bf210566 3674 ladderendcablesegmentbboxtrans[1] =
3675 new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
3676 0.5*ssdendladdercablelength,
3677 0.5*fgkSSDLadderCableWidth,
78e34526 3678 fgkSSDLadderCableHeight[0]
3679 +0.5*fgkSSDLadderCableHeight[1]);
bf210566 3680 TGeoVolume* ladderendcablesegmentbboxassembly =
3681 new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
3682 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
3683 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
3684 ladderendcablesegmentbboxtrans[i]);
3685/////////////////////////////////////////
3686 TList* laddercablesegmentlist = new TList();
3687 laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
3688 laddercablesegmentlist->Add(laddercablesegmentarbassembly);
3689 laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
3690 return laddercablesegmentlist;
160835d5 3691}
3692
bf210566 3693/////////////////////////////////////////////////////////////////////////////////
3694TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
44285dfa 3695 /////////////////////////////////////////////////////////////
cd2243fb 3696 // Method generating Ladder Cable of given length (n modules + end)
3697 // Called by GetLadderCableAssembly
44285dfa 3698 /////////////////////////////////////////////////////////////
bf210566 3699 TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
3700 TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
3701 for(Int_t i=0; i<n; i++){
3702 TGeoTranslation* laddercabletrans = new TGeoTranslation(
3703 i*(fgkCarbonFiberJunctionWidth),
3704 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
78e34526 3705 i*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
bf210566 3706 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
cd2243fb 3707 if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
3708
d7599219 3709 }
bf210566 3710 TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
3711 (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
cd2243fb 3712 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
78e34526 3713 (n-1)*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]));
bf210566 3714 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
3715 return laddercable;
3716}
3717/////////////////////////////////////////////////////////////////////////////////
3718TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
cd2243fb 3719 ///////////////////////////////////////////////////////////////////
3720 // Main method generating Ladder Cable bundles containing n cables
3721 ///////////////////////////////////////////////////////////////////
3722 Double_t totalLength = ssdendladdercablelength+(n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0];
78e34526 3723 Double_t cableOrig[3] = {0.5*totalLength,1.5*fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1])};
3724 TGeoBBox *laddercableshape = new TGeoBBox(0.5*totalLength,0.5*fgkSSDLadderCableWidth,0.5*n*(fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]),cableOrig);
cd2243fb 3725 TGeoVolume* laddercable = new TGeoVolume("LadderCableMother", laddercableshape, fSSDAir);
a3f8715e 3726 char laddercabletransname[100];
bf210566 3727 for(Int_t i=0; i<n; i++){
3728 sprintf(laddercabletransname,"LadderCableTrans%i",i+1);
cd2243fb 3729 laddercable->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
3730 new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0,0));
d7599219 3731 }
cd2243fb 3732 return laddercable;
bf210566 3733}
3734/////////////////////////////////////////////////////////////////////////////////
3735TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
3736 /////////////////////////////////////////////////////////////
3737 // Method generating Ladder Cable List Assemblies
cd2243fb 3738 // containing two cables bundles, i.e. P+N readout for one endcap
bf210566 3739 /////////////////////////////////////////////////////////////
cd2243fb 3740 const Int_t kladdercableassemblynumber = 2;
bf210566 3741 TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
3742 TGeoVolume* ladderCable[kladdercableassemblynumber];
a3f8715e 3743 char laddercableassemblyname[100];
bf210566 3744 TList* laddercableassemblylist = new TList();
3745 for(Int_t i=0; i<kladdercableassemblynumber; i++){
3746 sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
3747 ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
3748 ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
3749 new TGeoCombiTrans((n-1)
3750 * fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
3751 2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
3752 0.,new TGeoRotation("",180,0.,0.)));
3753 laddercableassemblylist->Add(ladderCable[i]);
3754}
3755 return laddercableassemblylist;
3756}
3757///////////////////////////////////////////////////////////////////////////////
3758void AliITSv11GeometrySSD::SetLadderSegment(){
3759 /////////////////////////////////////////////////////////////
3760 // Method Generating Ladder Segment Array
3761 /////////////////////////////////////////////////////////////
3762 fladdersegment[0] = new TGeoVolumeAssembly("LadderSegment1");
3763 fladdersegment[1] = new TGeoVolumeAssembly("LadderSegment2");
cd2243fb 3764
3765 /* MvL: tried to create mother volume. Requires changes in all rotations, bc xtru is always along z-axis
3766 TGeoXtru *laddersegmentshape = new TGeoXtru(2);
3767 static const Int_t ntrianglevtx = 3;
3768 Double_t xtrianglevtx[ntrianglevtx]={-0.5*fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength, 0};
3769 Double_t ytrianglevtx[ntrianglevtx]={0, 0, fgkCarbonFiberTriangleLength * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
3770 laddersegmentshape->DefinePolygon(ntrianglevtx,xtrianglevtx,ytrianglevtx);
3771 laddersegmentshape->DefineSection(0,0);
3772 laddersegmentshape->DefineSection(1,fgkCarbonFiberJunctionWidth); // MVL
3773 fladdersegment[0] = new TGeoVolume("LadderSegment1",laddersegmentshape,fSSDAir);
3774 fladdersegment[1] = new TGeoVolume("LadderSegment2",laddersegmentshape,fSSDAir);
3775 */
3776
bf210566 3777 if(!fCreateMaterials) CreateMaterials();
3778 if(!fTransformationMatrices) CreateTransformationMatrices();
3779 if(!fBasicObjects) CreateBasicObjects();
3780 for(Int_t i=0; i<fgkladdersegmentnumber; i++){
3781 // Placing Carbon Fiber Support
3782 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++){
3783 fladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3784 fcarbonfibersupportmatrix[j]);
3785 fladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3786 fcarbonfibersupportmatrix[j]);
d7599219 3787 }
bf210566 3788 // Placing Carbon Fiber Junction
cd2243fb 3789 for(Int_t j=0; j<fgkcarbonfiberjunctionumber; j++) {
bf210566 3790 fladdersegment[i]->AddNode(fcarbonfiberjunction,j+1,
3791 fcarbonfiberjunctionmatrix[j]);
cd2243fb 3792 }
bf210566 3793 // Placing Carbon Fiber Lower Support
cd2243fb 3794 for(Int_t j=0; j<fgkcarbonfiberlowersupportnumber; j++) {
bf210566 3795 fladdersegment[i]->AddNode(fcarbonfiberlowersupport[j],j+1,
3796 fcarbonfiberlowersupportrans[j]);
cd2243fb 3797 }
bf210566 3798 // Placing SSD Sensor Support
3799 for(Int_t j=0; j<fgkssdsensorsupportnumber; j++)
cd2243fb 3800 fladdersegment[i]->AddNode(j<2 ? fssdsensorsupport[0][i] :
bf210566 3801 fssdsensorsupport[1][i],
3802 j+1,fssdsensorsupportmatrix[j]);
3803 // Placing SSD Cooling Tube Support
3804 for(Int_t j=0; j<fgkcoolingtubesupportnumber; j++)
3805 fladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3806 fcoolingtubesupportmatrix[j]);
3807 // Placing SSD Cooling Tube
cd2243fb 3808 fladdersegment[i]->AddNode(fcoolingtube,1,fcoolingtubematrix[0]);
3809 fladdersegment[i]->AddNode(fcoolingtube,2,fcoolingtubematrix[1]);
bf210566 3810 // Placing SSD Hybrid
3811 switch(i){
3812 case 0:
3813 fladdersegment[i]->AddNode(fssdhybridcomponent[0],1,fhybridmatrix);
3814 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3815 break;
3816 case 1:
3817 fladdersegment[i]->AddNode(fssdhybridcomponent[1],1,fhybridmatrix);
3818 fladdersegment[i]->AddNode(fssdhybridcomponent[2],1,fhybridmatrix);
3819 break;
3820 }
3821 // Placing Cooling Block System
cd2243fb 3822 fladdersegment[i]->AddNode(fssdcoolingblocksystem,1,fcoolingblocksystematrix);
bf210566 3823 // Placing SSD Flex
cd2243fb 3824 for(Int_t j=0; j<fgkflexnumber; j++){
3825 fladdersegment[i]->AddNode(fssdstiffenerflex,j+1,fstiffenerflexmatrix[j]);
3826 fladdersegment[i]->AddNode(fssdendflex,j+1,fendflexmatrix[j]);
3827 }
bf210566 3828 }
d7599219 3829}
bf210566 3830///////////////////////////////////////////////////////////////////////////////
3831void AliITSv11GeometrySSD::SetEndLadderSegment(){
3832 /////////////////////////////////////////////////////////////
3833 // Method Generating End Ladder
3834 /////////////////////////////////////////////////////////////
3835 // End Ladder Carbon Fiber Junction
3836 /////////////////////////////////////////////////////////////
3837 fendladdersegment[0] = new TGeoVolumeAssembly("EndLadder1");
3838 fendladdersegment[1] = new TGeoVolumeAssembly("EndLadder2");
3839 if(!fCreateMaterials) CreateMaterials();
3840 if(!fTransformationMatrices) CreateTransformationMatrices();
3841 if(!fBasicObjects) CreateBasicObjects();
3842 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
3843 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
3844 fendladdersegment[i]->AddNode(j==2 ?
3845 fendladdercarbonfiberjunction[i][1] :
3846 fendladdercarbonfiberjunction[i][0],
3847 j+1,fendladdercarbonfiberjunctionmatrix[i][j]);
3848 }
3849 /////////////////////////////////////////////////////////////
3850 // End Ladder Carbon Fiber Support
3851 /////////////////////////////////////////////////////////////
3852 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
3853 for(Int_t j=0; j<fgkendladdercarbonfibermatrixnumber; j++){
3854 fendladdersegment[i]->AddNode(fcarbonfibersupport[0],j+1,
3855 fendladdercarbonfibermatrix[i][j]);
3856 fendladdersegment[i]->AddNode(fcarbonfibersupport[1],j+1,
3857 fendladdercarbonfibermatrix[i][j]);
3858 }
3859 /////////////////////////////////////////////////////////////
3860 // End Ladder Mounting Block
3861 /////////////////////////////////////////////////////////////
9b0c60ab 3862 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3863 fendladdersegment[i]->AddNode(fendladdermountingblock,i+1,
e21cdd03 3864 fendladdermountingblockcombitrans[i]);
9b0c60ab 3865 /////////////////////////////////////////////////////////////
e5bf64ae 3866 // End Ladder Mounting Block Clip
9b0c60ab 3867 /////////////////////////////////////////////////////////////
3868 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
3869 for(Int_t j=0; j<2; j++)
e21cdd03 3870 fendladdersegment[i]->AddNode(fendladdermountingblockclip,j+1,
3871 fendladdermountingblockclipmatrix[i][j]);
bf210566 3872 /////////////////////////////////////////////////////////////
3873 // End Ladder Lower Supports
44285dfa 3874 /////////////////////////////////////////////////////////////
bf210566 3875 fendladdersegment[0]->AddNode(fcarbonfiberlowersupport[0],1,
e21cdd03 3876 fendladderlowersupptrans[0]);
bf210566 3877 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],2,
e21cdd03 3878 fendladderlowersupptrans[1]);
bf210566 3879 fendladdersegment[1]->AddNode(fcarbonfiberlowersupport[0],3,
e21cdd03 3880 fendladderlowersupptrans[2]);
9b0c60ab 3881 /////////////////////////////////////////////////////////////
3882 // End Ladder Cooling Tube Support
3883 /////////////////////////////////////////////////////////////
3884 for(Int_t i=0; i<2; i++)
3885 for(Int_t j=0; j<(i==0?4:2); j++)
e21cdd03 3886 fendladdersegment[i]->AddNode(fcoolingtubesupport,j+1,
3887 fendladdercoolingtubesupportmatrix[i][j]);
9b0c60ab 3888 /////////////////////////////////////////////////////////////
3889 // End Ladder Cooling Tube Support
3890 /////////////////////////////////////////////////////////////
cd2243fb 3891 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],1,fendladdercoolingtubematrix[0][0]);
3892 fendladdersegment[0]->AddNode(fendladdercoolingtube[0],2,fendladdercoolingtubematrix[0][1]);
3893 fendladdersegment[1]->AddNode(fendladdercoolingtube[1],1,fendladdercoolingtubematrix[1][0]);
3894 fendladdersegment[1]->AddNode(fendladdercoolingtube[1],2,fendladdercoolingtubematrix[1][1]);
bf210566 3895}
3896///////////////////////////////////////////////////////////////////////////////
3897void AliITSv11GeometrySSD::SetLadder(){
3898 /////////////////////////////////////////////////////////////
3899 // Method Generating Ladder of Layer 5 and 6
44285dfa 3900 /////////////////////////////////////////////////////////////
bf210566 3901 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
3902 fgkSSDLay6SensorsNumber};
3903 /////////////////////////////////////////////////////////////////////////////
3904 /// Generating Ladder Mother Volume Containing Ladder
3905 /////////////////////////////////////////////////////////////////////////////
3906 TGeoXtru* laddershape[fgkladdernumber];
3907 for(Int_t i=0; i<fgkladdernumber; i++) laddershape[i] = new TGeoXtru(2);
3908 const Int_t kmothervertexnumber = 8;
3909 Double_t xmothervertex[fgkladdernumber][kmothervertexnumber];
3910 Double_t ymothervertex[fgkladdernumber][kmothervertexnumber];
3911 ///////////////////////
3912 // Setting the vertices
3913 ///////////////////////
3914 Double_t laddercablethickness = (fgkSSDLay6SensorsNumber+2)
78e34526 3915 * (fgkSSDLadderCableHeight[0]+fgkSSDLadderCableHeight[1]);
bf210566 3916 xmothervertex[0][0] = -0.5*fgkSSDSensorWidth;
0fb26117 3917 ymothervertex[0][0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor;
bf210566 3918 xmothervertex[0][1] = xmothervertex[0][0];
78e34526 3919 ymothervertex[0][1] = -0.5*fgkCoolingTubeSupportHeight; // 0.0; MvL 20-apr-2010
bf210566 3920 xmothervertex[0][2] = - 0.5*fgkSSDModuleSensorSupportDistance-2.*fgkCoolingTubeSupportRmax
3921 - laddercablethickness/SinD(2.*fgkSSDFlexAngle);
3922 ymothervertex[0][2] = ymothervertex[0][1];
3923 ymothervertex[0][3] = 0.5*fgkCarbonFiberTriangleLength*TanD(2.*fgkSSDFlexAngle);
3924 xmothervertex[0][3] = xmothervertex[0][2]+ymothervertex[0][3]/TanD(2.*fgkSSDFlexAngle);
3925 xmothervertex[0][4] = -xmothervertex[0][3];
3926 ymothervertex[0][4] = ymothervertex[0][3];
3927 xmothervertex[0][5] = -xmothervertex[0][2];
3928 ymothervertex[0][5] = ymothervertex[0][2];
3929 xmothervertex[0][6] = -xmothervertex[0][1];
3930 ymothervertex[0][6] = ymothervertex[0][1];
3931 xmothervertex[0][7] = -xmothervertex[0][0];
3932 ymothervertex[0][7] = ymothervertex[0][0];
3933 for(Int_t i=0; i<kmothervertexnumber; i++){
3934 xmothervertex[1][i] = xmothervertex[0][i];
3935 ymothervertex[1][i] = ymothervertex[0][i];
3936 }
0fb26117 3937///////////////////////////////////////////////////////////////////////////
3938// Disalignement Mother Volume corrections 25/08/08
3939///////////////////////////////////////////////////////////////////////////
160835d5 3940 TGeoXtru* leftladdershape1[fgkladdernumber];
3941 TGeoXtru* leftladdershape2[fgkladdernumber];
0fb26117 3942 TGeoXtru* centersensorladdershape[fgkladdernumber];
160835d5 3943 TGeoXtru* rightladdershape1[fgkladdernumber];
3944 TGeoXtru* rightladdershape2[fgkladdernumber];
bf210566 3945 for(Int_t i=0; i<fgkladdernumber; i++){
160835d5 3946 leftladdershape1[i] = new TGeoXtru(2);
3947 leftladdershape2[i] = new TGeoXtru(2);
3948 centersensorladdershape[i] = new TGeoXtru(2);
3949 rightladdershape1[i] = new TGeoXtru(2);
3950 rightladdershape2[i] = new TGeoXtru(2);
3951 }
0fb26117 3952 //////////////////////////////////////
160835d5 3953 // Setting the names for shapes
0fb26117 3954 //////////////////////////////////////
160835d5 3955 leftladdershape1[0]->SetName("Lay5Left1LadderSegmentContainer");
3956 leftladdershape2[0]->SetName("Lay5Left2LadderSegmentContainer");
3957 leftladdershape1[1]->SetName("Lay6Left1LadderSegmentContainer");
3958 leftladdershape2[1]->SetName("Lay6Left2LadderSegmentContainer");
0fb26117 3959 centersensorladdershape[0]->SetName("Lay5CenterSensorContainer");
3960 centersensorladdershape[1]->SetName("Lay6CenterSensorContainer");
160835d5 3961 rightladdershape1[0]->SetName("Lay5Right1LadderSegmentContainer");
3962 rightladdershape2[0]->SetName("Lay5Right2LadderSegmentContainer");
3963 rightladdershape1[1]->SetName("Lay6Right1LadderSegmentContainer");
3964 rightladdershape2[1]->SetName("Lay6Right2LadderSegmentContainer");
0fb26117 3965 //////////////////////////////////////
160835d5 3966 Double_t xend1laddervertex[fgkladdernumber][kmothervertexnumber];
3967 Double_t yend1laddervertex[fgkladdernumber][kmothervertexnumber];
0fb26117 3968 Double_t xcentersensorvertex[fgkladdernumber][kmothervertexnumber];
3969 Double_t ycentersensorvertex[fgkladdernumber][kmothervertexnumber];
160835d5 3970 Double_t xend2laddervertex[fgkladdernumber][kmothervertexnumber];
3971 Double_t yend2laddervertex[fgkladdernumber][kmothervertexnumber];
3972 for(Int_t i=0; i<fgkladdernumber; i++) {
3973 for(Int_t j=0; j<kmothervertexnumber; j++){
3974 xcentersensorvertex[i][j] = xmothervertex[i][j];
3975 ycentersensorvertex[i][j] = ymothervertex[i][j];
3976 xend1laddervertex[i][j] = xmothervertex[i][j];
3977 yend1laddervertex[i][j] = ymothervertex[i][j];
3978 xend2laddervertex[i][j] = xmothervertex[i][j];
3979 yend2laddervertex[i][j] = ymothervertex[i][j];
3980 }
3981 // Add some space around sensors to accommodate misalignments
3982 xcentersensorvertex[i][0] -= fgkSSDModuleSideDisalignment;
3983 xcentersensorvertex[i][1] = xcentersensorvertex[0][0];
3984 xcentersensorvertex[i][6] = -xcentersensorvertex[0][1];
3985 xcentersensorvertex[i][7] = -xcentersensorvertex[0][0];
3986
3987 ycentersensorvertex[i][0] -= fgkSSDModuleVerticalDisalignment;
3988 ycentersensorvertex[i][7] = ycentersensorvertex[0][0];
3989
3990 // Center Ladder Piece
3991 centersensorladdershape[i]->DefinePolygon(kmothervertexnumber,xcentersensorvertex[i],
3992 ycentersensorvertex[i]);
3993 centersensorladdershape[i]->DefineSection(0, - fgkEndLadderCarbonFiberLowerJunctionLength[1]
3994 + 1.45*fgkSSDMountingBlockWidth);
3995 centersensorladdershape[i]->DefineSection(1, ssdlaysensorsnumber[i] * fgkCarbonFiberJunctionWidth
3996 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
3997 - 2.4*fgkSSDMountingBlockWidth);
0fb26117 3998
160835d5 3999 // Left and Right Ladder Pieces: Mother volumes around ladder mounting areas
0fb26117 4000
160835d5 4001 // Cuts off first corner (neg x)
4002 xend1laddervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4003 xend1laddervertex[i][1] = -0.5*fgkSSDMountingBlockLength[0];
4004 // Cuts off last part (pos x)
4005 xend2laddervertex[i][6] = 0.5*fgkSSDMountingBlockLength[0];
4006 xend2laddervertex[i][7] = 0.5*fgkSSDMountingBlockLength[0];
0fb26117 4007
160835d5 4008 leftladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
4009 yend1laddervertex[i]);
4010 leftladdershape1[i]->DefineSection(0,-fgkEndLadderCarbonFiberLowerJunctionLength[1]);
4011 leftladdershape1[i]->DefineSection(1, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
4012 - fgkEndLadderMountingBlockPosition[0]);
4013
4014 leftladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
4015 yend2laddervertex[i]);
4016 leftladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[0][i]->GetTranslation()[2]
4017 - fgkEndLadderMountingBlockPosition[0]);
4018 leftladdershape2[i]->DefineSection(1,- fgkEndLadderCarbonFiberLowerJunctionLength[1]
4019 + 1.45*fgkSSDMountingBlockWidth); // connect to main volume at -1.6725 cm
4020
4021 rightladdershape1[i]->DefinePolygon(kmothervertexnumber,xend1laddervertex[i],
4022 yend1laddervertex[i]);
4023 rightladdershape1[i]->DefineSection(0,ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4024 +fgkEndLadderCarbonFiberLowerJunctionLength[0]
4025 -2.4*fgkSSDMountingBlockWidth);
4026 rightladdershape1[i]->DefineSection(1,fendladdersegmentmatrix[1][i]->GetTranslation()[2]
4027 + fgkEndLadderMountingBlockPosition[1]);
4028
4029 rightladdershape2[i]->DefinePolygon(kmothervertexnumber,xend2laddervertex[i],
4030 yend2laddervertex[i]);
4031 rightladdershape2[i]->DefineSection(0, fendladdersegmentmatrix[1][i]->GetTranslation()[2]
4032 + fgkEndLadderMountingBlockPosition[1]);
4033 rightladdershape2[i]->DefineSection(1, ssdlaysensorsnumber[i]*fgkCarbonFiberJunctionWidth
4034 + fgkEndLadderCarbonFiberLowerJunctionLength[0]);
4035 }
4036 TGeoCompositeShape* laddershapecontainer[2];
4037 laddershapecontainer[0] = new TGeoCompositeShape("Lay5LadderCompositeShape",
4038 "Lay5Left1LadderSegmentContainer+Lay5Left2LadderSegmentContainer"
4039 "+Lay5CenterSensorContainer"
4040 "+Lay5Right1LadderSegmentContainer+Lay5Right2LadderSegmentContainer");
4041 laddershapecontainer[1] = new TGeoCompositeShape("Lay6LadderCompositeShape",
4042 "Lay6Left1LadderSegmentContainer+Lay6Left2LadderSegmentContainer"
4043 "+Lay6CenterSensorContainer"
4044 "+Lay6Right1LadderSegmentContainer+Lay6Right2LadderSegmentContainer");
4045 const char* laddername[fgkladdernumber] = {"ITSssdLay5Ladd","ITSssdLay6Ladd"};
4046 for(Int_t i=0; i<fgkladdernumber; i++){
4047 fladder[i] = new TGeoVolume(laddername[i],laddershapecontainer[i],fSSDAir);
4048 fladder[i]->SetLineColor(4);
4049 }
bf210566 4050///////////////////////////////////////////////////////////////////////////
4051 if(!fCreateMaterials) CreateMaterials();
4052 if(!fTransformationMatrices) CreateTransformationMatrices();
4053 if(!fBasicObjects) CreateBasicObjects();
4054 SetLadderSegment();
4055 SetEndLadderSegment();
4056 for(Int_t i=0; i<fgkladdernumber; i++){
4057 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
4058 //////////////////////////
4059 /// Placing Ladder Segment
4060 //////////////////////////
4061 fladder[i]->AddNode(j%2==0 ? fladdersegment[i==0 ? 0 : 1] :
4062 fladdersegment[i==0 ? 1 : 0],
4063 ssdlaysensorsnumber[i]-j-1,fladdermatrix[i][j]);
4064 //////////////////////////
4065 /// Placing SSD Sensor
4066 //////////////////////////
ca86fdb4 4067 if(i==0&&ssdlaysensorsnumber[i]-j-1==13) fSSDSensor5->SetLineColor(kRed);
bf210566 4068 fladder[i]->AddNode(i==0?fSSDSensor5:fSSDSensor6,ssdlaysensorsnumber[i]-j-1,
4069 fssdsensormatrix[i][j]);
4070 }
4071 ///////////////////////////////
4072 /// Placing End Ladder Segment
4073 ///////////////////////////////
160835d5 4074 fladder[i]->AddNode(fendladdersegment[0],1,fendladdersegmentmatrix[0][i]);
bf210566 4075 fladder[i]->AddNode(fendladdersegment[1],1,fendladdersegmentmatrix[1][i]);
4076 }
d7599219 4077/////////////////////////////////////////////////////////////////////////////
4078/// Placing Ladder Cables
4079/////////////////////////////////////////////////////////////////////////////
bf210566 4080 Int_t sidecablenumber[2][2];
4081 sidecablenumber[0][0] = fgkSSDLay5SensorsNumber/2+1;
4082 sidecablenumber[0][1] = sidecablenumber[0][0]-2;
4083 sidecablenumber[1][0] = (fgkSSDLay6SensorsNumber-1)/2+1;
4084 sidecablenumber[1][1] = sidecablenumber[1][0]-1;
4085 Double_t carbonfibertomoduleposition[3];
4086 carbonfibertomoduleposition[0] = -0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength);
4087 carbonfibertomoduleposition[1] = - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
4088 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
4089 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
4090 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
4091 - fgkSSDSensorCenterSupportThickness[0]);
4092 carbonfibertomoduleposition[2] = - (fgkSSDModuleCoolingBlockToSensor
4093 + 0.5*fgkCoolingTubeSupportHeight
4094 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight);
4095 const Double_t kendladdercablecorrection = 1.72*fgkmm; //this has to be tuned
44285dfa 4096 Double_t ssdendladdercablelength[4];
4097 ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
d7599219 4098 + fgkSSDSensorLength
4099 - fgkSSDModuleStiffenerPosition[1]
4100 - fgkSSDStiffenerWidth
4101 - fgkSSDFlexWidth[0]
bf210566 4102 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4103 ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
d7599219 4104 + fgkSSDModuleStiffenerPosition[1]
4105 + fgkSSDStiffenerWidth
bf210566 4106 + fgkEndLadderCarbonFiberLowerJunctionLength[1]-0.000001*kendladdercablecorrection;
44285dfa 4107 ssdendladdercablelength[2] = ssdendladdercablelength[1]
d7599219 4108 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
bf210566 4109 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
4110 - kendladdercablecorrection;
44285dfa 4111 ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
4112 + carbonfibertomoduleposition[1]
d7599219 4113 - fgkSSDModuleStiffenerPosition[1]
4114 - fgkSSDStiffenerWidth)
bf210566 4115 + fgkEndLadderCarbonFiberLowerJunctionLength[0]-0.000001*kendladdercablecorrection;
78e34526 4116
44285dfa 4117 TList* laddercableassemblylist[4];
4118 const Int_t kendladdercablesnumber = 4;
cd2243fb 4119 TGeoRotation *laddercablerot = new TGeoRotation();
4120 laddercablerot->SetAngles(90.,60.,-90.);
bf210566 4121 for(Int_t i=0; i<fgkladdercablesnumber; i++)
4122 for(Int_t j=0; j<kendladdercablesnumber; j++){
4123 laddercableassemblylist[j] =
4124 GetLadderCableAssemblyList(sidecablenumber[i][j<2?0:1],
4125 ssdendladdercablelength[j]);
0fb26117 4126 fladder[i]->AddNode((TGeoVolume*)laddercableassemblylist[j]->At(j%2==0?0:1),
4127 j<2?1:2,fladdercablematrix[i][j]);
bf210566 4128 }
bf210566 4129}
4130////////////////////////////////////////////////////////////////////////////////
4131void AliITSv11GeometrySSD::SetLayer(){
d7599219 4132////////////////////////////////////////////////////////////////////////////////
bf210566 4133 // Creating Ladder of Layer 5 and Layer 6
4134 /////////////////////////////////////////////////////////////
4135 if(!fCreateMaterials) CreateMaterials();
4136 if(!fTransformationMatrices) CreateTransformationMatrices();
4137 if(!fBasicObjects) CreateBasicObjects();
4138 SetLadder(); // Generating the ladder of Layer5 and Layer6
4139 const Int_t kssdlayladdernumber[fgklayernumber] =
4140 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4141 /////////////////////////////////////////////////////////////
4142 // Generating mother volumes for Layer5 and Layer6
4143 /////////////////////////////////////////////////////////////
e5bf64ae 4144 fSSDLayer5 = new TGeoVolumeAssembly("ITSssdLayer5");
4145 fSSDLayer6 = new TGeoVolumeAssembly("ITSssdLayer6");
bf210566 4146 Int_t *ladderindex[fgklayernumber];
4147 Int_t index[fgklayernumber] = {8,9};
4148 for(Int_t i=0; i<fgklayernumber; i++) ladderindex[i] = new Int_t[kssdlayladdernumber[i]];
4149 for(Int_t i=0; i<fgklayernumber; i++)
4150 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4151 ladderindex[i][j] = ((j>=0)&&(j<=kssdlayladdernumber[i]-index[i]-1)) ?
4152 j+index[i] : j+index[i]-kssdlayladdernumber[i];
4153 i ==0 ? fSSDLayer5->AddNode(fladder[0],ladderindex[i][j],flayermatrix[i][j]) :
4154 fSSDLayer6->AddNode(fladder[1],ladderindex[i][j],flayermatrix[i][j]);
4155 }
44285dfa 4156 /////////////////////////////////////////////////////////////
bf210566 4157 // Deallocating memory
4158 /////////////////////////////////////////////////////////////
7b208ef4 4159 for(Int_t i=0; i<fgklayernumber; i++) delete [] ladderindex[i];
d7599219 4160}
4161////////////////////////////////////////////////////////////////////////////////
4162void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
44285dfa 4163 /////////////////////////////////////////////////////////////
4164 // Insert the layer 5 in the mother volume.
4165 /////////////////////////////////////////////////////////////
4166 if (! moth) {
160835d5 4167 AliError("Can't insert layer5, mother is null!\n");
44285dfa 4168 return;
4169 };
bf210566 4170 if(!fSSDLayer5) SetLayer();
4171 fMotherVol = moth;
4172 TGeoTranslation* centerITSlayer5trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay5LadderLength
4173 + fgkLay5CenterITSPosition);
4174 moth->AddNode(fSSDLayer5,1,centerITSlayer5trans);
44285dfa 4175 }
d7599219 4176////////////////////////////////////////////////////////////////////////////////
4177void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
44285dfa 4178 /////////////////////////////////////////////////////////////
4179 // Insert the layer 6 in the mother volume.
4180 /////////////////////////////////////////////////////////////
4181 if (! moth) {
160835d5 4182 AliError("AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
44285dfa 4183 return;
4184 };
bf210566 4185 if(!fSSDLayer6) SetLayer();
4186 fMotherVol = moth;
4187 TGeoTranslation* centerITSlayer6trans = new TGeoTranslation(0.,0.,-0.5*fgkSSDLay6LadderLength
4188 + fgkLay6CenterITSPosition);
4189 moth->AddNode(fSSDLayer6,1,centerITSlayer6trans);
44285dfa 4190 }
bf210566 4191 ////////////////////////////////////////////////////////////////////////////////
9b0c60ab 4192 TList* AliITSv11GeometrySSD::GetMountingBlockSupport(Int_t nedges){
4193 /////////////////////////////////////////////////////////////
4194 // Method generating the Arc structure of Ladder Support
4195 /////////////////////////////////////////////////////////////
4196 const Int_t kssdlayladdernumber[fgklayernumber] =
4197 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4198 Double_t mountingsupportedge[fgklayernumber];
4199 Double_t mountingblockratio[fgklayernumber];
4200 Double_t theta[fgklayernumber];
4201 Double_t phi[fgklayernumber];
4202 Double_t psi0[fgklayernumber];
4203 Double_t deltapsi[fgklayernumber];
4204 TVector3* mountingsupportedgevector[fgklayernumber];
4205 for(Int_t i=0; i<fgklayernumber; i++){
4206 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4207 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
60e55aee 4208 * (TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
9b0c60ab 4209 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4210 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4211 / kssdlayladdernumber[i])));
4212 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]/fgkMountingBlockSupportRadius[i]);
4213 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4214 mountingsupportedgevector[i] = new TVector3();
60e55aee 4215 mountingsupportedgevector[i]->SetX(-0.5*fgkSSDMountingBlockLength[0]);
4216 mountingsupportedgevector[i]->SetY(fgkMountingBlockSupportRadius[i]*TMath::Sqrt(
4217 (1.-mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])*
4218 (1.+mountingsupportedgevector[i]->X()/fgkMountingBlockSupportRadius[i])));
9b0c60ab 4219 psi0[i] = 0.5*TMath::Pi()-phi[i];
4220 deltapsi[i] = (theta[i]+phi[i])/nedges;
4221 }
4222 TVector3** vertex[fgklayernumber];
4223 TList* vertexlist[fgklayernumber];
4224 Int_t indexedge[fgklayernumber] = {0,0};
4225 for(Int_t i=0; i<fgklayernumber; i++){
4226 vertex[i] = new TVector3*[nedges+1];
4227 vertexlist[i] = new TList();
4228 }
4229 for(Int_t i=0; i<fgklayernumber; i++){
4230 for(Int_t j=0; j<nedges+1; j++){
4231 vertex[i][j] = new TVector3(fgkMountingBlockSupportRadius[i]*TMath::Cos(psi0[i]+j*deltapsi[i]),
4232 fgkMountingBlockSupportRadius[i]*TMath::Sin(psi0[i]+j*deltapsi[i]));
4233 if(vertex[i][j]->X()>mountingsupportedgevector[i]->X()) indexedge[i]++;
4234 vertexlist[i]->Add(vertex[i][j]);
4235 }
4236 vertexlist[i]->AddAt(mountingsupportedgevector[i],indexedge[i]);
4237 }
4238 Double_t** xsidevertex = new Double_t*[fgklayernumber];
4239 Double_t** ysidevertex = new Double_t*[fgklayernumber];
4240 Double_t** xcentervertex = new Double_t*[fgklayernumber];
4241 Double_t** ycentervertex = new Double_t*[fgklayernumber];
4242 Double_t** xsidelowervertex = new Double_t*[fgklayernumber];
4243 Double_t** ysidelowervertex = new Double_t*[fgklayernumber];
4244 Double_t** xcenterlowervertex = new Double_t*[fgklayernumber];
4245 Double_t** ycenterlowervertex = new Double_t*[fgklayernumber];
4246 for(Int_t i=0; i<fgklayernumber; i++){
4247 xsidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4248 ysidevertex[i] = new Double_t[vertexlist[i]->GetSize()+2];
4249 xcentervertex[i] = new Double_t[indexedge[i]+3];
4250 ycentervertex[i] = new Double_t[indexedge[i]+3];
4251 xsidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4252 ysidelowervertex[i] = new Double_t[vertexlist[i]->GetSize()+1];
4253 xcenterlowervertex[i] = new Double_t[indexedge[i]+3];
4254 ycenterlowervertex[i] = new Double_t[indexedge[i]+3];
4255 for(Int_t j=0; j<vertexlist[i]->GetSize(); j++){
4256 xsidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4257 ((TVector3*)vertexlist[i]->At(j))->X();
4258 ysidevertex[i][j!=vertexlist[i]->GetSize()-1?j+3:0] =
4259 ((TVector3*)vertexlist[i]->At(j))->Y();
4260 xsidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->X();
4261 ysidelowervertex[i][j] = ((TVector3*)vertexlist[i]->At(vertexlist[i]->GetSize()-1-j))->Y();
4262 if(j<indexedge[i]+1){
4263 xcentervertex[i][j!=indexedge[i]?j+3:0] =
4264 ((TVector3*)vertexlist[i]->At(j))->X();
4265 ycentervertex[i][j!=indexedge[i]?j+3:0] =
4266 ((TVector3*)vertexlist[i]->At(j))->Y();
4267 xcenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->X();
4268 ycenterlowervertex[i][j+1] = ((TVector3*)vertexlist[i]->At(indexedge[i]-j))->Y();
4269 }
4270 }
4271 xsidevertex[i][1] = xsidevertex[i][0];
4272 ysidevertex[i][1] = fgkMountingBlockSupportRadius[i];
4273 xsidevertex[i][2] = xsidevertex[i][3];
4274 ysidevertex[i][2] = fgkMountingBlockSupportRadius[i];
4275 xcentervertex[i][1] = xcentervertex[i][0];
4276 ycentervertex[i][1] = fgkMountingBlockSupportRadius[i];
4277 xcentervertex[i][2] = xcentervertex[i][3];
4278 ycentervertex[i][2] = fgkMountingBlockSupportRadius[i];
4279 xsidelowervertex[i][vertexlist[i]->GetSize()] = xsidelowervertex[i][vertexlist[i]->GetSize()-1];
4280 ysidelowervertex[i][vertexlist[i]->GetSize()] = ysidelowervertex[i][0];
4281 xcenterlowervertex[i][0] = xcenterlowervertex[i][1];
4282 ycenterlowervertex[i][0] = ysidevertex[i][0];
4283 xcenterlowervertex[i][indexedge[i]+2] = xsidelowervertex[i][vertexlist[i]->GetSize()];
4284 ycenterlowervertex[i][indexedge[i]+2] = ycenterlowervertex[i][0];
4285 }
4286 /////////////////////////////////////////////////////////////
4287 // Building the Arc Structure of Ladder Supports
4288 /////////////////////////////////////////////////////////////
4289 TGeoXtru* sidemountingblocksupportshape[fgklayernumber];
4290 TGeoXtru* centermountingsupportshape[fgklayernumber];
4291 TGeoXtru* sideladdersupportpieceshape[fgklayernumber];
4292 TGeoXtru* centerladdersupportpieceshape[fgklayernumber];
4293 TGeoVolume* sidemountingblocksupport[fgklayernumber];
4294 TGeoVolume* centermountingblocksupport[fgklayernumber];
4295 TGeoVolume* sideladdersupportpiece[fgklayernumber];
4296 TGeoVolume* centerladdersupportpiece[fgklayernumber];
a3f8715e 4297 char sidemountingblockname[100];
4298 char centermountingblockname[100];
4299 char sideladdersupportpiecename[100];
4300 char centerladdersupportpiecename[100];
9b0c60ab 4301 for(Int_t i=0; i<fgklayernumber; i++){
4302 sprintf(sidemountingblockname,"MountingBlockSupportSideLay%dArc",i+5);
4303 sprintf(centermountingblockname,"MountingBlockSupportCenterLay%dArc",i+5);
4304 sprintf(sideladdersupportpiecename,"SideLadderSupportPieceLay%d",i+5);
4305 sprintf(centerladdersupportpiecename,"CenterLadderSupportPieceLay%d",i+5);
4306 sidemountingblocksupportshape[i] = new TGeoXtru(2);
4307 sidemountingblocksupportshape[i]->DefinePolygon(vertexlist[i]->GetSize()+2,
4308 xsidevertex[i],ysidevertex[i]);
4309 sidemountingblocksupportshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4310 -fgkMountingBlockSupportWidth[0]);
4311 sidemountingblocksupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4312 sidemountingblocksupport[i] = new TGeoVolume(sidemountingblockname,
4313 sidemountingblocksupportshape[i],
4314 fSSDAlCoolBlockMedium);
4315 sidemountingblocksupport[i]->SetLineColor(9);
4316 centermountingsupportshape[i] = new TGeoXtru(2);
4317 centermountingsupportshape[i]->DefinePolygon(indexedge[i]+3,
4318 xcentervertex[i],ycentervertex[i]);
4319 centermountingsupportshape[i]->DefineSection(0,0.);
4320 centermountingsupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4321 -fgkMountingBlockSupportWidth[0]);
160835d5 4322
9b0c60ab 4323 centermountingblocksupport[i] = new TGeoVolume(centermountingblockname,
4324 centermountingsupportshape[i],
4325 fSSDAlCoolBlockMedium);
4326 centermountingblocksupport[i]->SetLineColor(9);
4327 sideladdersupportpieceshape[i] = new TGeoXtru(2);
4328 sideladdersupportpieceshape[i]->DefinePolygon(vertexlist[i]->GetSize()+1,
4329 xsidelowervertex[i],ysidelowervertex[i]);
4330 sideladdersupportpieceshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4331 -fgkMountingBlockSupportWidth[0]);
4332 sideladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4333 sideladdersupportpiece[i] = new TGeoVolume(sideladdersupportpiecename,
4334 sideladdersupportpieceshape[i],
e21cdd03 4335 fSSDCarbonFiberMedium);
9b0c60ab 4336 sideladdersupportpiece[i]->SetLineColor(fColorAl);
4337 centerladdersupportpieceshape[i] = new TGeoXtru(2);
4338 centerladdersupportpieceshape[i]->DefinePolygon(indexedge[i]+3,
4339 xcenterlowervertex[i],ycenterlowervertex[i]);
4340 centerladdersupportpieceshape[i]->DefineSection(0,0.0);
4341 centerladdersupportpieceshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]
4342 -fgkMountingBlockSupportWidth[0]);
4343 centerladdersupportpiece[i] = new TGeoVolume(centerladdersupportpiecename,
4344 centerladdersupportpieceshape[i],
e21cdd03 4345 fSSDCarbonFiberMedium);
9b0c60ab 4346 centerladdersupportpiece[i]->SetLineColor(fColorAl);
4347 }
4348 /////////////////////////////////////////////////////////////
4349 // Building the Up Structure of Ladder Supports
4350 /////////////////////////////////////////////////////////////
4351 TGeoBBox** mountingblocksupportboxupshape[fgklayernumber];
4352 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxupshape[i] = new TGeoBBox*[2];
4353 TGeoBBox** mountingblocksupportboxdownshape[fgklayernumber];
4354 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdownshape[i] = new TGeoBBox*[2];
4355 TGeoVolume** mountingblocksupportboxdown[fgklayernumber];
4356 //////////////////////////////////////////////////////////
4357 // Setting the volume for TGeoXtru Mounting Block Piece
4358 //////////////////////////////////////////////////////////
4359 TGeoVolume** mountingblocksupportboxup[fgklayernumber];
4360 TGeoXtru* mountingblockpiecedownshape[fgklayernumber];
4361 TGeoVolume* mountingblockpiecedown[fgklayernumber];
4362 TGeoXtru* mountingblockpieceupshape[fgklayernumber];
4363 TGeoVolume* mountingblockpieceup[fgklayernumber];
4364 Double_t mountingblockpieceupxvertex[fgklayernumber][8];
4365 Double_t mountingblockpieceupyvertex[fgklayernumber][8];
4366 Double_t mountingblockpiecedownxvertex[fgklayernumber][8];
4367 Double_t mountingblockpiecedownyvertex[fgklayernumber][8];
a3f8715e 4368 char mountingblockpiecedownname[100];
4369 char mountingblockpieceupname[100];
9b0c60ab 4370 for(Int_t i=0; i<fgklayernumber; i++){
4371 ///////////////////////////
4372 // Mounting Block Down Vertex
4373 ///////////////////////////
4374 mountingblockpiecedownshape[i] = new TGeoXtru(2);
4375 sprintf(mountingblockpiecedownname,"MountingBlockPieceDownLay%d",i+5);
4376 mountingblockpiecedownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4377 mountingblockpiecedownyvertex[i][0] = fgkMountingBlockSupportRadius[i]
160835d5 4378 + fgkMountingBlockSupportDownHeight
4379 - fgkSSDLadderVerticalDisalignment;
9b0c60ab 4380 mountingblockpiecedownxvertex[i][1] = mountingblockpiecedownxvertex[i][0];
4381 mountingblockpiecedownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4382 + fgkSSDMountingBlockHeight[1]
4383 - 0.5*fgkCoolingTubeSupportHeight
0fb26117 4384 - fgkSSDModuleCoolingBlockToSensor;
9b0c60ab 4385 mountingblockpiecedownxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4386 mountingblockpiecedownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4387 mountingblockpiecedownxvertex[i][3] = mountingblockpiecedownxvertex[i][2];
4388 mountingblockpiecedownyvertex[i][3] = mountingblockpiecedownyvertex[i][0];
4389 mountingblockpiecedownxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4390 mountingblockpiecedownyvertex[i][4] = mountingblockpiecedownyvertex[i][0];
4391 mountingblockpiecedownxvertex[i][5] = mountingblockpiecedownxvertex[i][4];
4392 mountingblockpiecedownyvertex[i][5] = mountingblockpiecedownyvertex[i][4]
4393 + fgkSSDMountingBlockHeight[2]
4394 - fgkSSDMountingBlockHeight[0];
4395 mountingblockpiecedownxvertex[i][6] = -mountingblockpiecedownxvertex[i][4];
4396 mountingblockpiecedownyvertex[i][6] = mountingblockpiecedownyvertex[i][5];
4397 mountingblockpiecedownxvertex[i][7] = mountingblockpiecedownxvertex[i][6];
4398 mountingblockpiecedownyvertex[i][7] = mountingblockpiecedownyvertex[i][0];
4399 mountingblockpiecedownshape[i]->DefinePolygon(8,mountingblockpiecedownxvertex[i],
4400 mountingblockpiecedownyvertex[i]);
4401 mountingblockpiecedownshape[i]->DefineSection(0,0.0);
4402 mountingblockpiecedownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4403 mountingblockpiecedown[i] = new TGeoVolume(mountingblockpiecedownname,
e21cdd03 4404 mountingblockpiecedownshape[i],fSSDMountingBlockMedium);
9b0c60ab 4405 mountingblockpiecedown[i]->SetLineColor(fColorG10);
160835d5 4406
9b0c60ab 4407 ///////////////////////////
4408 // Mounting Block Up Vertex
4409 ///////////////////////////
4410 mountingblockpieceupshape[i] = new TGeoXtru(2);
4411 sprintf(mountingblockpieceupname,"MountingBlockPieceUpLay%d",i+5);
4412 mountingblockpieceupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0];
4413 mountingblockpieceupyvertex[i][0] = fgkMountingBlockSupportRadius[i]
160835d5 4414 + fgkMountingBlockSupportUpHeight[i]
4415 - fgkSSDLadderVerticalDisalignment;
9b0c60ab 4416 mountingblockpieceupxvertex[i][1] = mountingblockpieceupxvertex[i][0];
4417 mountingblockpieceupyvertex[i][1] = mountingblockpieceupyvertex[i][0]
4418 + fgkSSDMountingBlockHeight[1]
4419 - 0.5*fgkCoolingTubeSupportHeight
0fb26117 4420 - fgkSSDModuleCoolingBlockToSensor;
9b0c60ab 4421 mountingblockpieceupxvertex[i][2] = 0.5*fgkSSDMountingBlockLength[0];
4422 mountingblockpieceupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4423 mountingblockpieceupxvertex[i][3] = mountingblockpieceupxvertex[i][2];
4424 mountingblockpieceupyvertex[i][3] = mountingblockpieceupyvertex[i][0];
4425 mountingblockpieceupxvertex[i][4] = 0.5*fgkSSDMountingBlockLength[1];
4426 mountingblockpieceupyvertex[i][4] = mountingblockpieceupyvertex[i][0];
4427 mountingblockpieceupxvertex[i][5] = mountingblockpieceupxvertex[i][4];
4428 mountingblockpieceupyvertex[i][5] = mountingblockpieceupyvertex[i][4]
4429 + fgkSSDMountingBlockHeight[2]
4430 - fgkSSDMountingBlockHeight[0];
4431 mountingblockpieceupxvertex[i][6] = -mountingblockpieceupxvertex[i][4];
4432 mountingblockpieceupyvertex[i][6] = mountingblockpieceupyvertex[i][5];
4433 mountingblockpieceupxvertex[i][7] = mountingblockpieceupxvertex[i][6];
4434 mountingblockpieceupyvertex[i][7] = mountingblockpieceupyvertex[i][0];
160835d5 4435
9b0c60ab 4436 mountingblockpieceupshape[i]->DefinePolygon(8,mountingblockpieceupxvertex[i],
4437 mountingblockpieceupyvertex[i]);
4438 mountingblockpieceupshape[i]->DefineSection(0,0.0);
4439 mountingblockpieceupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4440 mountingblockpieceup[i] = new TGeoVolume(mountingblockpieceupname,
e21cdd03 4441 mountingblockpieceupshape[i],fSSDMountingBlockMedium);
9b0c60ab 4442 mountingblockpieceup[i]->SetLineColor(fColorG10);
4443 }
4444 ///////////////////////////////////////////////////////////////////
4445 // Setting the volume for TGeoXtru Mounting Block Support Trapezoid
4446 ///////////////////////////////////////////////////////////////////
4447 TGeoXtru* mountingblocksupportrapezoidownshape[fgklayernumber];
4448 TGeoXtru* mountingblocksupportrapezoidupshape[fgklayernumber];
4449 TGeoVolume* mountingblocksupportrapezoidown[fgklayernumber];
4450 TGeoVolume* mountingblocksupportrapezoidup[fgklayernumber];
4451 Double_t mountingblocksupportrapezoidownxvertex[fgklayernumber][5];
4452 Double_t mountingblocksupportrapezoidownyvertex[fgklayernumber][5];
4453 Double_t mountingblocksupportrapezoidupxvertex[fgklayernumber][5];
4454 Double_t mountingblocksupportrapezoidupyvertex[fgklayernumber][5];
a3f8715e 4455 char mountingblocksupportrapezoidowname[100];
4456 char mountingblocksupportrapezoidupname[100];
9b0c60ab 4457 Double_t scalefactor = 3./4.;
4458 for(Int_t i=0; i<fgklayernumber; i++){
4459 ////////////////////////////////////////////
4460 // Mounting Block Support Down Trapezoid Vertex
4461 ////////////////////////////////////////////
4462 mountingblocksupportrapezoidownshape[i] = new TGeoXtru(2);
4463 mountingblocksupportrapezoidownxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4464 - mountingsupportedge[i];
4465 mountingblocksupportrapezoidownyvertex[i][0] = mountingblockpiecedownyvertex[i][0];
4466 mountingblocksupportrapezoidownxvertex[i][1] =
4467 mountingblocksupportrapezoidownxvertex[i][0];
4468 mountingblocksupportrapezoidownyvertex[i][1] = mountingblockpiecedownyvertex[i][0]
4469 + scalefactor*(mountingblockpiecedownyvertex[i][1]
4470 - mountingblockpiecedownyvertex[i][0]);
4471 mountingblocksupportrapezoidownxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4472 mountingblocksupportrapezoidownyvertex[i][2] = mountingblockpiecedownyvertex[i][1];
4473 mountingblocksupportrapezoidownxvertex[i][3] = mountingblockpiecedownxvertex[i][0];
4474 mountingblocksupportrapezoidownyvertex[i][3] = mountingblocksupportrapezoidownyvertex[i][2];
4475 mountingblocksupportrapezoidownxvertex[i][4] = mountingblocksupportrapezoidownxvertex[i][3];
4476 mountingblocksupportrapezoidownyvertex[i][4] = mountingblocksupportrapezoidownyvertex[i][0];
160835d5 4477
9b0c60ab 4478 mountingblocksupportrapezoidownshape[i]->DefinePolygon(5,mountingblocksupportrapezoidownxvertex[i],
4479 mountingblocksupportrapezoidownyvertex[i]);
4480 mountingblocksupportrapezoidownshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4481 -fgkMountingBlockSupportWidth[0]);
4482 mountingblocksupportrapezoidownshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4483 sprintf(mountingblocksupportrapezoidowname,"MountingBlockSuppTrapezoidDownLay%d",i+5);
4484 mountingblocksupportrapezoidown[i] = new TGeoVolume(mountingblocksupportrapezoidowname,
e21cdd03 4485 mountingblocksupportrapezoidownshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4486 mountingblocksupportrapezoidown[i]->SetLineColor(9);
4487 ////////////////////////////////////////////
4488 // Mounting Block Support Up Trapezoid Vertex
4489 ////////////////////////////////////////////
4490 mountingblocksupportrapezoidupshape[i] = new TGeoXtru(2);
4491 mountingblocksupportrapezoidupxvertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4492 - mountingsupportedge[i];
4493 mountingblocksupportrapezoidupyvertex[i][0] = mountingblockpieceupyvertex[i][0];
4494 mountingblocksupportrapezoidupxvertex[i][1] =
4495 mountingblocksupportrapezoidupxvertex[i][0];
4496 mountingblocksupportrapezoidupyvertex[i][1] =
4497 mountingblockpieceupyvertex[i][0]
4498 + scalefactor*(mountingblockpieceupyvertex[i][1]
4499 - mountingblockpieceupyvertex[i][0]);
4500 mountingblocksupportrapezoidupxvertex[i][2] = -0.5*fgkSSDSensorWidth;
4501 mountingblocksupportrapezoidupyvertex[i][2] = mountingblockpieceupyvertex[i][1];
4502 mountingblocksupportrapezoidupxvertex[i][3] = mountingblockpieceupxvertex[i][0];
4503 mountingblocksupportrapezoidupyvertex[i][3] = mountingblocksupportrapezoidupyvertex[i][2];
4504 mountingblocksupportrapezoidupxvertex[i][4] = mountingblocksupportrapezoidupxvertex[i][3];
4505 mountingblocksupportrapezoidupyvertex[i][4] = mountingblocksupportrapezoidupyvertex[i][0];
160835d5 4506
9b0c60ab 4507 mountingblocksupportrapezoidupshape[i]->DefinePolygon(5,mountingblocksupportrapezoidupxvertex[i],
4508 mountingblocksupportrapezoidupyvertex[i]);
4509 mountingblocksupportrapezoidupshape[i]->DefineSection(0,fgkMountingBlockSupportWidth[1]
4510 -fgkMountingBlockSupportWidth[0]);
4511 mountingblocksupportrapezoidupshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4512 sprintf(mountingblocksupportrapezoidupname,"MountingBlockSuppTrapezoidUpLay%d",i+5);
4513 mountingblocksupportrapezoidup[i] = new TGeoVolume(mountingblocksupportrapezoidupname,
e21cdd03 4514 mountingblocksupportrapezoidupshape[i],fSSDCarbonFiberMedium);
9b0c60ab 4515 mountingblocksupportrapezoidup[i]->SetLineColor(9);
4516 }
4517 ///////////////////////////////////////////////////////////////////
4518 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxdown[i] = new TGeoVolume*[3];
4519 for(Int_t i=0; i<fgklayernumber; i++) mountingblocksupportboxup[i] = new TGeoVolume*[3];
4520 Double_t boxoriginup[fgklayernumber][2][3];
4521 Double_t boxorigindown[fgklayernumber][2][3];
a3f8715e 4522 char mountingblocksupportboxdownname[100];
4523 char mountingblocksupportboxupname[100];
9b0c60ab 4524 TGeoRotation* mountingblocksupportrot = new TGeoRotation();
4525 mountingblocksupportrot->SetAngles(90.,180.,-90);
4526 TGeoRotation* globalrefladdersupportrot = new TGeoRotation();
4527 globalrefladdersupportrot->SetAngles(0.,90.,0.);
4528 TGeoHMatrix* laddersupportmatrix[2];
4529 laddersupportmatrix[0] = new TGeoHMatrix(*globalrefladdersupportrot);
4530 laddersupportmatrix[1] = new TGeoHMatrix((*globalrefladdersupportrot)*(*mountingblocksupportrot));
4531 /////////////////////////////////////////////////////////////
4532 // Creating Mother Volume for Containment
4533 /////////////////////////////////////////////////////////////
4534 Double_t *xmothervertex[fgklayernumber];
4535 Double_t *ymothervertex[fgklayernumber];
4536 for(Int_t i=0; i<fgklayernumber; i++){
4537 xmothervertex[i] = new Double_t[8];
4538 ymothervertex[i] = new Double_t[8];
4539 }
4540 TGeoXtru* downmotherladdersupportshape[fgklayernumber];
4541 TGeoVolume* downmotherladdersupport[fgklayernumber];
4542 TGeoXtru* upmotherladdersupportshape[fgklayernumber];
160835d5 4543 TGeoVolume* upmotherladdersupport[fgklayernumber];
a3f8715e 4544 char upmotheladdersupportname[100];
4545 char downmotheladdersupportname[100];
9b0c60ab 4546 for(Int_t i=0; i<fgklayernumber; i++){
4547 xmothervertex[i][0] = -0.5*fgkSSDMountingBlockLength[0]
4548 - mountingsupportedge[i];
4549 ymothervertex[i][0] = -fgkMountingBlockSupportWidth[1];
4550 xmothervertex[i][1] = xmothervertex[i][0];
4551 ymothervertex[i][1] = -fgkMountingBlockSupportWidth[1]
4552 + fgkMountingBlockSupportWidth[0];
4553 xmothervertex[i][2] = -0.5*fgkSSDMountingBlockLength[0];
4554 ymothervertex[i][2] = ymothervertex[i][1];
4555 xmothervertex[i][3] = xmothervertex[i][2];
4556 ymothervertex[i][3] = -ymothervertex[i][0];
4557 xmothervertex[i][4] = -xmothervertex[i][0];
4558 ymothervertex[i][4] = ymothervertex[i][3];
4559 xmothervertex[i][5] = xmothervertex[i][4];
4560 ymothervertex[i][5] = -ymothervertex[i][1];
4561 xmothervertex[i][6] = -xmothervertex[i][2];
4562 ymothervertex[i][6] = ymothervertex[i][5];
4563 xmothervertex[i][7] = xmothervertex[i][6];
4564 ymothervertex[i][7] = ymothervertex[i][0];
160835d5 4565
9b0c60ab 4566 sprintf(downmotheladdersupportname,"LadderSupportDownLay%d",i+5);
4567 sprintf(upmotheladdersupportname,"LadderSupportUpLay%d",i+5);
160835d5 4568
4569 downmotherladdersupportshape[i] = new TGeoXtru(2);
9b0c60ab 4570 downmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4571 downmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
160835d5 4572 downmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
9b0c60ab 4573 + fgkMountingBlockSupportDownHeight
4574 + fgkSSDMountingBlockHeight[1]
4575 - 0.5*fgkCoolingTubeSupportHeight
160835d5 4576 - fgkSSDModuleCoolingBlockToSensor
4577 - fgkSSDLadderVerticalDisalignment);
4578
4579// - fgkSSDModuleVerticalDisalignment);
4580 //downmotherladdersupport[i] = new TGeoVolumeAssembly(downmotheladdersupportname);
4581
4582 downmotherladdersupport[i] = new TGeoVolume(downmotheladdersupportname,
4583 downmotherladdersupportshape[i],fSSDAir);
9b0c60ab 4584 upmotherladdersupportshape[i] = new TGeoXtru(2);
4585 upmotherladdersupportshape[i]->DefinePolygon(8,xmothervertex[i],ymothervertex[i]);
4586 upmotherladdersupportshape[i]->DefineSection(0,ysidevertex[i][0]);
4587 upmotherladdersupportshape[i]->DefineSection(1,ysidevertex[i][1]
4588 + fgkMountingBlockSupportUpHeight[i]
4589 + fgkSSDMountingBlockHeight[1]
4590 - 0.5*fgkCoolingTubeSupportHeight
160835d5 4591 - fgkSSDModuleCoolingBlockToSensor
4592 - fgkSSDLadderVerticalDisalignment);
4593
4594 upmotherladdersupport[i] = new TGeoVolume(upmotheladdersupportname,
4595 upmotherladdersupportshape[i],fSSDAir);
9b0c60ab 4596 }
4597 for(Int_t i=0; i<fgklayernumber; i++){
4598 /////////////////////////
4599 // Setting the box origin
4600 /////////////////////////
4601 boxorigindown[i][0][0] = -0.5*mountingsupportedge[i];
4602 boxorigindown[i][0][1] = fgkMountingBlockSupportRadius[i]
160835d5 4603 + 0.5*fgkMountingBlockSupportDownHeight
4604 - 0.5*fgkSSDLadderVerticalDisalignment;
9b0c60ab 4605 boxorigindown[i][0][2] = fgkMountingBlockSupportWidth[1]
4606 - 0.5*fgkMountingBlockSupportWidth[0];
4607
4608 boxorigindown[i][1][0] = 0.0;
4609 boxorigindown[i][1][1] = boxorigindown[i][0][1];
4610 boxorigindown[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4611 - fgkMountingBlockSupportWidth[0]);
4612
4613 boxoriginup[i][0][0] = -0.5*mountingsupportedge[i];
4614 boxoriginup[i][0][1] = fgkMountingBlockSupportRadius[i]
160835d5 4615 + 0.5*fgkMountingBlockSupportUpHeight[i]
4616 - 0.5*fgkSSDLadderVerticalDisalignment;
9b0c60ab 4617 boxoriginup[i][0][2] = fgkMountingBlockSupportWidth[1]
4618 - 0.5*fgkMountingBlockSupportWidth[0];
4619
4620 boxoriginup[i][1][0] = 0.0;
160835d5 4621 boxoriginup[i][1][1] = boxoriginup[i][0][1];
9b0c60ab 4622 boxoriginup[i][1][2] = 0.5*(fgkMountingBlockSupportWidth[1]
4623 - fgkMountingBlockSupportWidth[0]);
4624
4625 /////////////////////////
4626 // Setting the boxes
4627 /////////////////////////
4628 mountingblocksupportboxdownshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4629 + fgkSSDMountingBlockLength[0]),
160835d5 4630 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4631 0.5*fgkMountingBlockSupportWidth[0],
4632 boxorigindown[i][0]);
160835d5 4633 mountingblocksupportboxdownshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
4634 0.5*fgkMountingBlockSupportDownHeight - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4635 0.5*(fgkMountingBlockSupportWidth[1]
4636 - fgkMountingBlockSupportWidth[0]),
4637 boxorigindown[i][1]);
4638
4639 mountingblocksupportboxupshape[i][0] = new TGeoBBox(0.5*(mountingsupportedge[i]
4640 + fgkSSDMountingBlockLength[0]),
160835d5 4641 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4642 0.5*fgkMountingBlockSupportWidth[0],
4643 boxoriginup[i][0]);
160835d5 4644
9b0c60ab 4645 mountingblocksupportboxupshape[i][1] = new TGeoBBox(0.5*fgkSSDMountingBlockLength[0],
160835d5 4646 0.5*fgkMountingBlockSupportUpHeight[i] - 0.5*fgkSSDLadderVerticalDisalignment,
9b0c60ab 4647 0.5*(fgkMountingBlockSupportWidth[1]
4648 - fgkMountingBlockSupportWidth[0]),
4649 boxoriginup[i][1]);
4650 ///////////////////////////////////////
160835d5 4651 // Adding the Volumes to Mother Volume
9b0c60ab 4652 ///////////////////////////////////////
4653 for(Int_t j=0; j<2; j++){
4654 sprintf(mountingblocksupportboxdownname,"MountingBlockSuppDownLay%dBox%d",i+5,j+1);
4655 sprintf(mountingblocksupportboxupname,"MountingBlockSuppUpLay%dBox%d",i+5,j+1);
4656 mountingblocksupportboxdown[i][j] = new TGeoVolume(mountingblocksupportboxdownname,
4657 mountingblocksupportboxdownshape[i][j],
e21cdd03 4658 fSSDCarbonFiberMedium);
9b0c60ab 4659 mountingblocksupportboxup[i][j] = new TGeoVolume(mountingblocksupportboxupname,
4660 mountingblocksupportboxupshape[i][j],
e21cdd03 4661 fSSDCarbonFiberMedium);
9b0c60ab 4662 mountingblocksupportboxdown[i][j]->SetLineColor(9);
4663 mountingblocksupportboxup[i][j]->SetLineColor(9);
4664 for(Int_t k=0; k<2; k++){
4665 downmotherladdersupport[i]->AddNode(mountingblocksupportboxdown[i][j],k+1,laddersupportmatrix[k]);
160835d5 4666 upmotherladdersupport[i]->AddNode(mountingblocksupportboxup[i][j],k+1,laddersupportmatrix[k]);
9b0c60ab 4667 }
4668 }
4669 for(Int_t k=0; k<2; k++){
4670 downmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
4671 downmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4672 downmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4673 downmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
160835d5 4674 downmotherladdersupport[i]->AddNode(mountingblockpiecedown[i],k+1,laddersupportmatrix[k]);
9b0c60ab 4675 downmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidown[i],k+1,laddersupportmatrix[k]);
4676 upmotherladdersupport[i]->AddNode(centermountingblocksupport[i],k+1,laddersupportmatrix[k]);
160835d5 4677 upmotherladdersupport[i]->AddNode(sidemountingblocksupport[i],k+1,laddersupportmatrix[k]);
4678 upmotherladdersupport[i]->AddNode(sideladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4679 upmotherladdersupport[i]->AddNode(centerladdersupportpiece[i],k+1,laddersupportmatrix[k]);
4680 upmotherladdersupport[i]->AddNode(mountingblockpieceup[i],k+1,laddersupportmatrix[k]);
4681 upmotherladdersupport[i]->AddNode(mountingblocksupportrapezoidup[i],k+1,laddersupportmatrix[k]);
9b0c60ab 4682 }
4683 }
4684 TList* laddersupportlist = new TList();
4685 laddersupportlist->Add(downmotherladdersupport[0]);
4686 laddersupportlist->Add(upmotherladdersupport[0]);
4687 laddersupportlist->Add(downmotherladdersupport[1]);
4688 laddersupportlist->Add(upmotherladdersupport[1]);
4689 /////////////////////////////////////////////////////////////
4690 // Deallocating memory
4691 /////////////////////////////////////////////////////////////
4692 for(Int_t i=0; i<fgklayernumber; i++){
4693 for(Int_t j=0; j<nedges+1; j++)
4694 delete vertex[i][j];
4695 delete mountingsupportedgevector[i];
4696 delete [] vertex[i];
4697 delete vertexlist[i];
4698 delete [] xsidevertex[i];
4699 delete [] ysidevertex[i];
4700 delete [] xcentervertex[i];
4701 delete [] ycentervertex[i];
4702 delete [] xsidelowervertex[i];
4703 delete [] ysidelowervertex[i];
4704 delete [] xcenterlowervertex[i];
4705 delete [] ycenterlowervertex[i];
7b208ef4 4706 delete [] xmothervertex[i];
4707 delete [] ymothervertex[i];
9b0c60ab 4708 }
3e008bd7 4709 delete [] xsidevertex;
4710 delete [] ysidevertex;
4711 delete [] xcentervertex;
4712 delete [] ycentervertex;
4713 delete [] xsidelowervertex;
4714 delete [] ysidelowervertex;
4715 delete [] xcenterlowervertex;
4716 delete [] ycenterlowervertex;
9b0c60ab 4717 delete globalrefladdersupportrot;
4718 delete mountingblocksupportrot;
4719 /////////////////////
4720 return laddersupportlist;
4721}
4722 ////////////////////////////////////////////////////////////////////////////////
4723void AliITSv11GeometrySSD::SetLadderSupport(Int_t nedges){
4724//////////////////////////////////////////
4725// Method Generating Ladder Support Ring
4726//////////////////////////////////////////
4727 if(!fCreateMaterials) CreateMaterials();
4728 if(!fTransformationMatrices) CreateTransformationMatrices();
4729 if(!fBasicObjects) CreateBasicObjects();
4730 fLay5LadderSupportRing = new TGeoVolumeAssembly("Lay5LadderSupportRing");
4731 fLay6LadderSupportRing = new TGeoVolumeAssembly("Lay6LadderSupportRing");
4732 const Int_t kssdlayladdernumber[fgklayernumber] =
4733 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
4734 Double_t mountingsupportedge[fgklayernumber];
4735 Double_t mountingblockratio[fgklayernumber];
4736 Double_t theta[fgklayernumber];
4737 Double_t phi[fgklayernumber];
4738 for(Int_t i=0; i<fgklayernumber; i++){
4739 mountingblockratio[i] = fgkSSDMountingBlockLength[0]/fgkMountingBlockSupportRadius[i];
4740 mountingsupportedge[i] = 0.5*fgkMountingBlockSupportRadius[i]
60e55aee 4741 *(TMath::Sqrt((2.-mountingblockratio[i])*(2.+mountingblockratio[i]))
9b0c60ab 4742 * TMath::Sin(2.0*TMath::Pi()/kssdlayladdernumber[i])
4743 - mountingblockratio[i]*(1.0+TMath::Cos(2.0*TMath::Pi()
4744 / kssdlayladdernumber[i])));
4745 theta[i] = TMath::ASin(0.5*mountingblockratio[i]+mountingsupportedge[i]
4746 / fgkMountingBlockSupportRadius[i]);
4747 phi[i] = TMath::ASin(0.5*mountingblockratio[i]);
4748 }
4749 TGeoRotation* globalrot = new TGeoRotation();
4750 globalrot->SetAngles(0.,-90.,0.);
4751 TGeoRotation** laddersupportrot[fgklayernumber];
4752 TGeoHMatrix** laddersupportmatrix[fgklayernumber];
4753 for(Int_t i=0; i<fgklayernumber; i++){
4754 laddersupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
4755 laddersupportmatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
4756 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
4757 laddersupportrot[i][j] = new TGeoRotation();
4758 laddersupportrot[i][j]->SetAngles(j*(phi[i]+theta[i])*TMath::RadToDeg(),0.,0.);
4759 switch(i){
4760 case 0: //Ladder of Layer5
4761 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4762 fLay5LadderSupportRing->AddNode(j%2==0?fLay5LadderSupport[0]:fLay5LadderSupport[1],j+1,
4763 laddersupportmatrix[i][j]);
4764 break;
4765 case 1: //Ladder of Layer6
4766 laddersupportmatrix[i][j] = new TGeoHMatrix((*laddersupportrot[i][j])*(*globalrot));
4767 fLay6LadderSupportRing->AddNode(j%2==0?fLay6LadderSupport[0]:fLay6LadderSupport[1],j+1,
4768 laddersupportmatrix[i][j]);
4769 break;
4770 }
4771 }
4772 }
4773 /////////////////////////////////////////////////////////////
4774 // Creating Lower Ladder Support
4775 /////////////////////////////////////////////////////////////
4776 TVector3** ringsupportvertex[fgklayernumber];
4777 Double_t angle = 360./nedges;
4778 for(Int_t i=0; i<fgklayernumber; i++){
4779 ringsupportvertex[i] = new TVector3*[2*kssdlayladdernumber[i]+3+nedges];
4780 ringsupportvertex[i][0] = new TVector3(0.,fgkMountingBlockSupportRadius[i]
4781 * TMath::Cos(theta[i]));
4782 ringsupportvertex[i][1] = new TVector3(-0.5*fgkSSDMountingBlockLength[0]
4783 - mountingsupportedge[i],
4784 ringsupportvertex[i][0]->Y());
4785 ringsupportvertex[i][2] = new TVector3(0.5*fgkSSDMountingBlockLength[0],
4786 ringsupportvertex[i][1]->Y());
4787 ringsupportvertex[i][2]->RotateZ(theta[i]+phi[i]);
4788 for(Int_t j=1; j<kssdlayladdernumber[i]; j++){
4789 ringsupportvertex[i][2*j+1] = new TVector3(*ringsupportvertex[i][1]);
4790 ringsupportvertex[i][2*j+1]->RotateZ(j*(theta[i]+phi[i]));
4791 ringsupportvertex[i][2*j+2] = new TVector3(*ringsupportvertex[i][2]);
4792 ringsupportvertex[i][2*j+2]->RotateZ(j*(theta[i]+phi[i]));
4793 }
4794 ringsupportvertex[i][2*kssdlayladdernumber[i]+1] = new TVector3(*ringsupportvertex[i][0]);
4795 for(Int_t j=0; j<nedges+1; j++){
4796 ringsupportvertex[i][2*kssdlayladdernumber[i]+2+j] =
cd2243fb 4797 new TVector3((ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*CosD(90.0-j*angle),
4798 (ringsupportvertex[i][0]->Y()-fgkLadderSupportHeight)*SinD(90.0-j*angle));
9b0c60ab 4799 }
4800 }
4801 Double_t **xmothervertex = new Double_t*[fgklayernumber];
4802 Double_t **ymothervertex = new Double_t*[fgklayernumber];
4803 for(Int_t i=0; i<fgklayernumber; i++){
4804 xmothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4805 ymothervertex[i] = new Double_t[2*kssdlayladdernumber[i]+3+nedges];
4806 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++){
4807 xmothervertex[i][j] = ringsupportvertex[i][j]->X();
4808 ymothervertex[i][j] = ringsupportvertex[i][j]->Y();
4809 }
4810 }
0e8760e5 4811////////////////////////////////////////////////////////////////////////////////
4812// Start Corrections 13/06/08
4813////////////////////////////////////////////////////////////////////////////////
a3f8715e 4814 char lowerladderpconsupportname[100];
0e8760e5 4815 TGeoPcon* lowerladderpconsupportshape[fgklayernumber];
4816 TGeoVolume* lowerladderpconsupport[fgklayernumber];
4817 Double_t lowerladderpconezsection[2] = {0.,fgkMountingBlockSupportWidth[1]};
4818 Double_t lowerladderpconradiusmax[fgklayernumber];
4819 Double_t lowerladderpconradiusmin[fgklayernumber];
4820 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4821 lowerladdersupportrot->SetAngles(90.,180.,-90);
4822 for(Int_t i=0; i<fgklayernumber; i++){
4823 lowerladderpconradiusmax[i] = fgkMountingBlockSupportRadius[i]
4824 * TMath::Cos(theta[i]);
cd2243fb 4825 lowerladderpconradiusmin[i] = lowerladderpconradiusmax[i]-fgkLadderSupportHeight;
0e8760e5 4826 }
4827 for(Int_t i=0; i<fgklayernumber; i++){
4828/////////////////////////// Modified Version ?///////////////////
4829 lowerladderpconsupportshape[i] = new TGeoPcon(0.,360.,2);
4830 for(Int_t j=0; j<2; j++) lowerladderpconsupportshape[i]->DefineSection(j,
4831 lowerladderpconezsection[j],lowerladderpconradiusmin[i],
4832 lowerladderpconradiusmax[i]);
4833 sprintf(lowerladderpconsupportname,"LowerLadderPConSupportNameLay%d",i+5);
4834 lowerladderpconsupport[i] = new TGeoVolume(lowerladderpconsupportname,lowerladderpconsupportshape[i],fSSDSupportRingAl);
4835 lowerladderpconsupport[i]->SetLineColor(fColorAl);
4836 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],1);
4837 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladderpconsupport[i],2,lowerladdersupportrot);
4838 }
4839////////////////////////////////////////////////////////////////////////////////
4840// End Corrections 13/06/08
4841////////////////////////////////////////////////////////////////////////////////
4842 /*char lowerladdersupportname[30];
9b0c60ab 4843 TGeoXtru* lowerladdersupportshape[fgklayernumber];
4844 TGeoVolume* lowerladdersupport[fgklayernumber];
4845 TGeoRotation* lowerladdersupportrot = new TGeoRotation();
4846 lowerladdersupportrot->SetAngles(90.,180.,-90);
4847 for(Int_t i=0; i<fgklayernumber; i++){
4848 lowerladdersupportshape[i] = new TGeoXtru(2);
4849 lowerladdersupportshape[i]->DefinePolygon(2*kssdlayladdernumber[i]+3+nedges,
4850 xmothervertex[i],ymothervertex[i]);
4851 lowerladdersupportshape[i]->DefineSection(0,0.);
4852 lowerladdersupportshape[i]->DefineSection(1,fgkMountingBlockSupportWidth[1]);
4853 sprintf(lowerladdersupportname,"LowerLadderSupportNameLay%d",i+5);
4854 lowerladdersupport[i] = new TGeoVolume(lowerladdersupportname,
4855 lowerladdersupportshape[i],fSSDSupportRingAl);
4856 lowerladdersupport[i]->SetLineColor(fColorAl);
4857 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],1);
4858 (i==0 ? fLay5LadderSupportRing: fLay6LadderSupportRing)->AddNode(lowerladdersupport[i],2,lowerladdersupportrot);
0e8760e5 4859 }*/
9b0c60ab 4860 /////////////////////////////////////////////////////////////
4861 // Deallocating memory
4862 /////////////////////////////////////////////////////////////
4863 for(Int_t i=0; i<fgklayernumber; i++){
4864 for(Int_t j=0; j<2*kssdlayladdernumber[i]+3+nedges; j++)
4865 delete ringsupportvertex[i][j];
4866 delete [] ringsupportvertex[i];
4867 }
4868 for(Int_t i=0; i<fgklayernumber; i++){
4869 delete [] xmothervertex[i];
4870 delete [] ymothervertex[i];
4871 }
7b208ef4 4872 delete [] xmothervertex;
4873 delete [] ymothervertex;
9b0c60ab 4874 delete globalrot;
4875 for(Int_t i=0; i<fgklayernumber; i++){
4876 for(Int_t j=0; j<kssdlayladdernumber[i]; j++)
4877 delete laddersupportrot[i][j];
4878 delete [] laddersupportrot[i];
4879 }
4880 }
4881 ////////////////////////////////////////////////////////////////////////////////
4882 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoverPlate(){
4883 /////////////////////////////////////////////////////////////
4884 // Method generating Endcap CoverPlate
4885 /////////////////////////////////////////////////////////////
4886 // Holes Definition
4887 ///////////////////
4888 Int_t nendcapcoverplateholedges = 30;
4889 const Int_t kendcapcoverplatesmallholenumber[2] = {4,9};
4890 Double_t holesection[2] = {-0.5*fgkEndCapCoverPlateThickness,
4891 0.5*fgkEndCapCoverPlateThickness};
851c0ce3 4892 TGeoShape* endcapcoverplatesmallholeshape = GetHoleShape(fgkEndCapCoverPlateSmallHoleRadius,
9b0c60ab 4893 nendcapcoverplateholedges,holesection);
4894 TGeoVolume* endcapcoverplatesmallhole = new TGeoVolume("EndCapCoverPlateSmallHole",
e21cdd03 4895 endcapcoverplatesmallholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 4896 endcapcoverplatesmallhole->SetLineColor(6);
851c0ce3 4897 TGeoShape* endcapcoverplatebigholeshape = GetHoleShape(fgkEndCapCoverPlateBigHoleRadius,
9b0c60ab 4898 nendcapcoverplateholedges,holesection);
4899 TGeoVolume* endcapcoverplatebighole = new TGeoVolume("EndCapCoverPlateBigHole",
e21cdd03 4900 endcapcoverplatebigholeshape,fSSDAlCoolBlockMedium);
9b0c60ab 4901 endcapcoverplatebighole->SetLineColor(6);
4902 //////////////////////////
4903 // Screw Piece Definition
4904 //////////////////////////
4905 Double_t smallscrewangle = 360.0/nendcapcoverplateholedges;
4906 TGeoTube* endcapsmallscrewpieceshape = new TGeoTube(0.0,fgkEndCapCoverPlateSmallHoleRadius*
4907 CosD(0.5*smallscrewangle),
4908 0.5*fgkEndCapCoverPlateThickness);
4909 TGeoVolume* endcapsmallscrewpiece = new TGeoVolume("EndCapCoverPlateSmallScrewPiece",
4910 endcapsmallscrewpieceshape,
4911 fSSDCoolingTubePhynox);
4912 endcapsmallscrewpiece->SetLineColor(fColorPhynox);
4913 ///////////////////
4914 // Box Definition
4915 ///////////////////
4916 TGeoBBox* endcapcoverplateboxshape[4];
4917 TGeoVolume* endcapcoverplatebox[4];
4918 Double_t boxorigin[5][3];
4919 boxorigin[0][0] = 0.;
4920 boxorigin[0][1] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[2];
4921 boxorigin[0][2] = 0.;
4922
4923 boxorigin[1][0] = 0.5*fgkEndCapCoverPlateSmallHoleSeparation[0];
4924 boxorigin[1][1] = 4.*fgkEndCapCoverPlateSmallHoleSeparation[2];
4925 boxorigin[1][2] = 0.;
4926
4927 boxorigin[2][0] = 1.5*fgkEndCapCoverPlateSmallHoleSeparation[0]
4928 + fgkEndCapCoverPlateSmallHoleSeparation[1];
4929 boxorigin[2][1] = boxorigin[1][1];
4930 boxorigin[2][2] = 0.;
4931
4932 boxorigin[3][0] = fgkEndCapCoverPlateSmallHoleSeparation[0]
4933 + 0.5*fgkEndCapCoverPlateSmallHoleSeparation[1];
4934 boxorigin[3][1] = boxorigin[1][1];
4935 boxorigin[3][2] = 0.;
4936
4937 endcapcoverplateboxshape[0] = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4938 0.5*(fgkEndCapCoverPlateSmallHoleSeparation[2]
4939 - 2.*fgkEndCapCoverPlateSmallHoleRadius),
4940 0.5*fgkEndCapCoverPlateThickness,boxorigin[0]);
4941
4942 endcapcoverplateboxshape[1] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4943 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4944 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4945 + fgkEndCapCoverPlateSmallHoleRadius,
4946 0.5*fgkEndCapCoverPlateThickness,boxorigin[1]);
4947
4948 endcapcoverplateboxshape[2] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[0]
4949 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4950 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4951 + fgkEndCapCoverPlateSmallHoleRadius,
4952 0.5*fgkEndCapCoverPlateThickness,boxorigin[2]);
4953
4954 endcapcoverplateboxshape[3] = new TGeoBBox(0.5*(fgkEndCapCoverPlateSmallHoleSeparation[1]
4955 -2.*fgkEndCapCoverPlateSmallHoleRadius),
4956 4.*fgkEndCapCoverPlateSmallHoleSeparation[2]
4957 + fgkEndCapCoverPlateSmallHoleRadius,
4958 0.5*fgkEndCapCoverPlateThickness,boxorigin[3]);
4959
4960 endcapcoverplatebox[0] = new TGeoVolume("EndCapCoverPlateBox1",endcapcoverplateboxshape[0],
e21cdd03 4961 fSSDAlCoolBlockMedium);
9b0c60ab 4962 endcapcoverplatebox[1] = new TGeoVolume("EndCapCoverPlateBox2",endcapcoverplateboxshape[1],
e21cdd03 4963 fSSDAlCoolBlockMedium);
9b0c60ab 4964 endcapcoverplatebox[2] = new TGeoVolume("EndCapCoverPlateBox3",endcapcoverplateboxshape[2],
e21cdd03 4965 fSSDAlCoolBlockMedium);
9b0c60ab 4966 endcapcoverplatebox[3] = new TGeoVolume("EndCapCoverPlateBox4",endcapcoverplateboxshape[3],
e21cdd03 4967 fSSDAlCoolBlockMedium);
9b0c60ab 4968 endcapcoverplatebox[0]->SetLineColor(6);
4969 endcapcoverplatebox[1]->SetLineColor(6);
4970 endcapcoverplatebox[2]->SetLineColor(6);
4971 endcapcoverplatebox[3]->SetLineColor(6);
4972 Double_t endcapfillingboxorigin[3] = {fgkEndCapCoverPlateSmallHoleSeparation[0],0.,0.};
4973 TGeoBBox* endcapfillingboxshape = new TGeoBBox(fgkEndCapCoverPlateSmallHoleRadius,
4974 fgkEndCapCoverPlateSmallHoleRadius,
4975 0.5*fgkEndCapCoverPlateThickness,
4976 endcapfillingboxorigin);
4977 TGeoVolume* endcapfillingbox = new TGeoVolume("EndCapFillingBox",endcapfillingboxshape,
e21cdd03 4978 fSSDAlCoolBlockMedium);
9b0c60ab 4979 endcapfillingbox->SetLineColor(6);
4980 ////////////////////////////
851c0ce3 4981 // Contour shape Definition
9b0c60ab 4982 ////////////////////////////
4983 const Int_t kcontourvertexnumber = 10;
4984 Double_t xcontourvertex[kcontourvertexnumber];
4985 Double_t ycontourvertex[kcontourvertexnumber];
4986 xcontourvertex[0] = -fgkEndCapCoverPlateLength[0];
4987 xcontourvertex[1] = xcontourvertex[0];
4988 xcontourvertex[2] = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
4989 xcontourvertex[3] = xcontourvertex[2];
4990 xcontourvertex[4] = -fgkEndCapCoverPlateSmallHoleRadius;
4991 xcontourvertex[5] = xcontourvertex[4];
4992 xcontourvertex[6] = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
4993 xcontourvertex[7] = xcontourvertex[6];
4994 xcontourvertex[8] = xcontourvertex[4];
4995 xcontourvertex[9] = xcontourvertex[8];
4996 ycontourvertex[0] = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
4997 - (kendcapcoverplatesmallholenumber[1]-1)
4998 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
4999 ycontourvertex[1] = (kendcapcoverplatesmallholenumber[1]-1)
5000 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5001 ycontourvertex[2] = ycontourvertex[1];
5002 ycontourvertex[3] = ycontourvertex[0];
5003 ycontourvertex[4] = ycontourvertex[3];
5004 ycontourvertex[5] = -fgkEndCapCoverPlateSmallHoleRadius;
5005 ycontourvertex[6] = ycontourvertex[5];
5006 ycontourvertex[7] = (kendcapcoverplatesmallholenumber[1]-1)
5007 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5008 + fgkEndCapCoverPlateSmallHoleRadius;
5009 ycontourvertex[8] = ycontourvertex[7];
5010 ycontourvertex[9] = ycontourvertex[0];
851c0ce3 5011
5012 Double_t xboxin, dxboxin, yboxin, dyboxin;
5013 Double_t xboxout, dxboxout, yboxout, dyboxout;
5014 Double_t coordmin, coordmax;
5015 coordmin = -fgkEndCapCoverPlateLength[0];
5016 coordmax = fgkEndCapCoverPlateLength[1]-xcontourvertex[0];
5017 xboxout = 0.5*(coordmin+coordmax);
5018 dxboxout = 0.5*(coordmax-coordmin);
5019 coordmin = -0.5*(fgkEndCapCoverPlateWidth[0]-fgkEndCapCoverPlateWidth[2]
5020 - (kendcapcoverplatesmallholenumber[1]-1)
5021 * fgkEndCapCoverPlateSmallHoleSeparation[2]);
5022 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
5023 * fgkEndCapCoverPlateSmallHoleSeparation[2]-ycontourvertex[0];
5024 yboxout = 0.5*(coordmin+coordmax);
5025 dyboxout = 0.5*(coordmax-coordmin);
5026 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
5027 coordmax = fgkEndCapCoverPlateLength[1]+fgkEndCapCoverPlateSmallHoleRadius;
5028 xboxin = 0.5*(coordmin+coordmax);
5029 dxboxin = 0.5*(coordmax-coordmin);
5030 coordmin = -fgkEndCapCoverPlateSmallHoleRadius;
5031 coordmax = (kendcapcoverplatesmallholenumber[1]-1)
5032 * fgkEndCapCoverPlateSmallHoleSeparation[2]
5033 + fgkEndCapCoverPlateSmallHoleRadius;
5034 yboxin = 0.5*(coordmin+coordmax);
5035 dyboxin = 0.5*(coordmax-coordmin);
5036 new TGeoBBox("EndCapCoverPlateContourBoxOut", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5037 TGeoTranslation *trendCapCoverPlateContourboxout = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut",
5038 xboxout, yboxout, 0.);
5039 trendCapCoverPlateContourboxout->RegisterYourself();
5040 new TGeoBBox("EndCapCoverPlateContourBoxIn", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5041 TGeoTranslation *trendCapCoverPlateContourboxin = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn",
5042 xboxin, yboxin, 0.);
5043 trendCapCoverPlateContourboxin->RegisterYourself();
5044 TGeoCompositeShape *contourshape = new TGeoCompositeShape("contourShape",
5045 "EndCapCoverPlateContourBoxOut:SSD_trEndCapCoverPlateContourBoxOut-EndCapCoverPlateContourBoxIn:SSD_trEndCapCoverPlateContourBoxIn");
5046
e21cdd03 5047 TGeoVolume* contour = new TGeoVolume("EndCapCoverPlateContour",contourshape,
5048 fSSDAlCoolBlockMedium);
9b0c60ab 5049 contour->SetLineColor(6);
5050 /////////////////////////////
851c0ce3 5051 // Hole Contour Shape Definition
9b0c60ab 5052 ////////////////////////////
851c0ce3 5053 coordmin = xcontourvertex[0];
5054 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5055 xboxout = 0.5*(coordmin+coordmax);
5056 dxboxout = 0.5*(coordmax-coordmin);
5057 coordmin = ycontourvertex[1];
5058 coordmax = ycontourvertex[1]+fgkEndCapCoverPlateWidth[2];
5059 yboxout = 0.5*(coordmin+coordmax);
5060 dyboxout = 0.5*(coordmax-coordmin);
5061 coordmin = xcontourvertex[0]+ 0.5*(fgkEndCapCoverPlateLength[2]
5062 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5063 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5064 xboxin = 0.5*(coordmin+coordmax);
5065 dxboxin = 0.5*(coordmax-coordmin);
5066 coordmin = ycontourvertex[1]+0.5*(fgkEndCapCoverPlateWidth[2]
5067 - 2.*fgkEndCapCoverPlateBigHoleRadius);;
5068 coordmax = coordmin +2.*fgkEndCapCoverPlateBigHoleRadius;
5069 yboxin = 0.5*(coordmin+coordmax);
5070 dyboxin = 0.5*(coordmax-coordmin);
5071 new TGeoBBox("EndCapCoverPlateContourBoxOut1", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5072 TGeoTranslation *trendCapCoverPlateContourboxout1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut1",
5073 xboxout, yboxout, 0.);
5074 trendCapCoverPlateContourboxout1->RegisterYourself();
5075 new TGeoBBox("EndCapCoverPlateContourBoxIn1", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5076 TGeoTranslation *trendCapCoverPlateContourboxin1 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn1",
5077 xboxin, yboxin, 0.);
5078 trendCapCoverPlateContourboxin1->RegisterYourself();
5079 TGeoCompositeShape *contourshape1 = new TGeoCompositeShape("contourShape1",
5080 "EndCapCoverPlateContourBoxOut1:SSD_trEndCapCoverPlateContourBoxOut1-EndCapCoverPlateContourBoxIn1:SSD_trEndCapCoverPlateContourBoxIn1");
5081
5082
5083 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5084 coordmax = coordmin+fgkEndCapCoverPlateLength[2];
5085 xboxout = 0.5*(coordmin+coordmax);
5086 dxboxout = 0.5*(coordmax-coordmin);
5087 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5088 - fgkEndCapCoverPlateWidth[0]);
5089 coordmax = ycontourvertex[0];
5090 yboxout = 0.5*(coordmin+coordmax);
5091 dyboxout = 0.5*(coordmax-coordmin);
5092 coordmin = xcontourvertex[0]+fgkEndCapCoverPlateLength[5]+ 0.5*(fgkEndCapCoverPlateLength[2]
5093 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5094 coordmax = coordmin + 2.*fgkEndCapCoverPlateBigHoleRadius;
5095 xboxin = 0.5*(coordmin+coordmax);
5096 dxboxin = 0.5*(coordmax-coordmin);
5097 coordmin = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5098 - fgkEndCapCoverPlateWidth[0])+0.5*(fgkEndCapCoverPlateWidth[1]
5099 - fgkEndCapCoverPlateWidth[0]
5100 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5101 coordmax = coordmin+2.*fgkEndCapCoverPlateBigHoleRadius;
5102 yboxin = 0.5*(coordmin+coordmax);
5103 dyboxin = 0.5*(coordmax-coordmin);
5104 new TGeoBBox("EndCapCoverPlateContourBoxOut2", dxboxout, dyboxout, 0.5*fgkEndCapCoverPlateThickness);
5105 TGeoTranslation *trendCapCoverPlateContourboxout2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxOut2",
5106 xboxout, yboxout, 0.);
5107 trendCapCoverPlateContourboxout2->RegisterYourself();
5108 new TGeoBBox("EndCapCoverPlateContourBoxIn2", dxboxin, dyboxin, 0.5*fgkEndCapCoverPlateThickness+0.01);
5109 TGeoTranslation *trendCapCoverPlateContourboxin2 = new TGeoTranslation("SSD_trEndCapCoverPlateContourBoxIn2",
5110 xboxin, yboxin, 0.);
5111 trendCapCoverPlateContourboxin2->RegisterYourself();
5112 TGeoCompositeShape *contourshape2 = new TGeoCompositeShape("contourShape2",
5113 "EndCapCoverPlateContourBoxOut2:SSD_trEndCapCoverPlateContourBoxOut2-EndCapCoverPlateContourBoxIn2:SSD_trEndCapCoverPlateContourBoxIn2");
5114
5115// const Int_t kholecontourvertexnumber = 10;
5116
9b0c60ab 5117 Double_t xholecontourvertex[2][kcontourvertexnumber];
5118 Double_t yholecontourvertex[2][kcontourvertexnumber];
5119 xholecontourvertex[0][0] = xcontourvertex[0];
5120 xholecontourvertex[0][1] = xholecontourvertex[0][0];
5121 xholecontourvertex[0][2] = xholecontourvertex[0][1]+fgkEndCapCoverPlateLength[2];
5122 xholecontourvertex[0][3] = xholecontourvertex[0][2];
5123 xholecontourvertex[0][4] = xholecontourvertex[0][0]
5124 + 0.5*(fgkEndCapCoverPlateLength[2]
5125 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5126 xholecontourvertex[0][5] = xholecontourvertex[0][4];
5127 xholecontourvertex[0][6] = xholecontourvertex[0][5]
5128 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5129 xholecontourvertex[0][7] = xholecontourvertex[0][6];
5130 xholecontourvertex[0][8] = xholecontourvertex[0][4];
5131 xholecontourvertex[0][9] = xholecontourvertex[0][8];
5132
5133 yholecontourvertex[0][0] = ycontourvertex[1];
5134 yholecontourvertex[0][1] = yholecontourvertex[0][0]+fgkEndCapCoverPlateWidth[2];
5135 yholecontourvertex[0][2] = yholecontourvertex[0][1];
5136 yholecontourvertex[0][3] = yholecontourvertex[0][0];
5137 yholecontourvertex[0][4] = yholecontourvertex[0][3];
5138 yholecontourvertex[0][5] = yholecontourvertex[0][4]+0.5*(fgkEndCapCoverPlateWidth[2]
5139 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5140 yholecontourvertex[0][6] = yholecontourvertex[0][5];
5141 yholecontourvertex[0][7] = yholecontourvertex[0][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5142 yholecontourvertex[0][8] = yholecontourvertex[0][7];
5143 yholecontourvertex[0][9] = yholecontourvertex[0][0];
5144
5145 xholecontourvertex[1][0] = xcontourvertex[0]+fgkEndCapCoverPlateLength[5];
5146 xholecontourvertex[1][1] = xholecontourvertex[1][0];
5147 xholecontourvertex[1][2] = xholecontourvertex[1][1]+fgkEndCapCoverPlateLength[2];
5148 xholecontourvertex[1][3] = xholecontourvertex[1][2];
5149 xholecontourvertex[1][4] = xholecontourvertex[1][0]
5150 + 0.5*(fgkEndCapCoverPlateLength[2]
5151 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5152 xholecontourvertex[1][5] = xholecontourvertex[1][4];
5153 xholecontourvertex[1][6] = xholecontourvertex[1][5]
5154 + 2.*fgkEndCapCoverPlateBigHoleRadius;
5155 xholecontourvertex[1][7] = xholecontourvertex[1][6];
5156 xholecontourvertex[1][8] = xholecontourvertex[1][4];
5157 xholecontourvertex[1][9] = xholecontourvertex[1][8];
5158
5159 yholecontourvertex[1][0] = ycontourvertex[0]-(fgkEndCapCoverPlateWidth[1]
5160 - fgkEndCapCoverPlateWidth[0]);
5161 yholecontourvertex[1][1] = ycontourvertex[0];
5162 yholecontourvertex[1][2] = yholecontourvertex[1][1];
5163 yholecontourvertex[1][3] = yholecontourvertex[1][0];
5164 yholecontourvertex[1][4] = yholecontourvertex[1][3];
5165 yholecontourvertex[1][5] = yholecontourvertex[1][4]+0.5*(fgkEndCapCoverPlateWidth[1]
5166 - fgkEndCapCoverPlateWidth[0]
5167 - 2.*fgkEndCapCoverPlateBigHoleRadius);
5168 yholecontourvertex[1][6] = yholecontourvertex[1][5];
5169 yholecontourvertex[1][7] = yholecontourvertex[1][6]+2.*fgkEndCapCoverPlateBigHoleRadius;
5170 yholecontourvertex[1][8] = yholecontourvertex[1][7];
5171 yholecontourvertex[1][9] = yholecontourvertex[1][0];
5172
9b0c60ab 5173 TGeoVolume* holecontour[2];
851c0ce3 5174 holecontour[0] = new TGeoVolume("EndCapCoverPlateContour1",contourshape1,
e21cdd03 5175 fSSDAlCoolBlockMedium);
9b0c60ab 5176 holecontour[0]->SetLineColor(6);
851c0ce3 5177 holecontour[1] = new TGeoVolume("EndCapCoverPlateContour2",contourshape2,
e21cdd03 5178 fSSDAlCoolBlockMedium);
9b0c60ab 5179 holecontour[1]->SetLineColor(6);
5180 TGeoTranslation* holecontourtrans = new TGeoTranslation(fgkEndCapCoverPlateLength[3]
5181 + fgkEndCapCoverPlateLength[2],0.,0.);
5182 TGeoTranslation* bigholetrans[3];
5183 bigholetrans[0] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius,
5184 yholecontourvertex[0][7]-fgkEndCapCoverPlateBigHoleRadius,0.0);
5185 bigholetrans[1] = new TGeoTranslation(xholecontourvertex[0][4]+fgkEndCapCoverPlateBigHoleRadius
5186 + fgkEndCapCoverPlateLength[4],yholecontourvertex[0][7]
5187 - fgkEndCapCoverPlateBigHoleRadius,0.0);
5188 bigholetrans[2] = new TGeoTranslation(xholecontourvertex[1][4]+fgkEndCapCoverPlateBigHoleRadius,
5189 yholecontourvertex[1][5]+fgkEndCapCoverPlateBigHoleRadius,0.0);
5190 /////////////////////////////////
5191 // Mother Volume Xtru Definition
5192 /////////////////////////////////
5193 const Int_t kmothervertexnumber = 12;
5194 Double_t xmothervertex[kmothervertexnumber];
5195 Double_t ymothervertex[kmothervertexnumber];
5196 xmothervertex[0] = xcontourvertex[0];
5197 xmothervertex[1] = xmothervertex[0];
5198 xmothervertex[2] = xmothervertex[1]+fgkEndCapCoverPlateLength[2];
5199 xmothervertex[3] = xmothervertex[2];
5200 xmothervertex[4] = xmothervertex[3]+fgkEndCapCoverPlateLength[3];
5201 xmothervertex[5] = xmothervertex[4];
5202 xmothervertex[6] = xmothervertex[5]+fgkEndCapCoverPlateLength[2];
5203 xmothervertex[7] = xmothervertex[6];
5204 xmothervertex[8] = xmothervertex[0]+fgkEndCapCoverPlateLength[5]
5205 + fgkEndCapCoverPlateLength[2];
5206 xmothervertex[9] = xmothervertex[8];
5207 xmothervertex[10] = xmothervertex[9]-fgkEndCapCoverPlateLength[2];
5208 xmothervertex[11] = xmothervertex[10];
5209
5210 ymothervertex[0] = ycontourvertex[0];
5211 ymothervertex[1] = ymothervertex[0]+fgkEndCapCoverPlateWidth[0];
5212 ymothervertex[2] = ymothervertex[1];
5213 ymothervertex[3] = ycontourvertex[1];
5214 ymothervertex[4] = ymothervertex[3];
5215 ymothervertex[5] = ymothervertex[1];
5216 ymothervertex[6] = ymothervertex[5];
5217 ymothervertex[7] = ymothervertex[0];
5218 ymothervertex[8] = ymothervertex[7];
5219 ymothervertex[9] = ymothervertex[8]
5220 - (fgkEndCapCoverPlateWidth[1]-fgkEndCapCoverPlateWidth[0]);
5221 ymothervertex[10] = ymothervertex[9];
5222 ymothervertex[11] = ymothervertex[8];
5223 TGeoXtru* mothercoverplateshape = new TGeoXtru(2);
5224 mothercoverplateshape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5225 mothercoverplateshape->DefineSection(0,-0.5*fgkEndCapCoverPlateThickness);
5226 mothercoverplateshape->DefineSection(1,+0.5*fgkEndCapCoverPlateThickness);
5227 TGeoVolume* mothercoverplate = new TGeoVolume("EndCapCoverPlateMother",mothercoverplateshape,fSSDAir);
5228 ////////////////////////////////////////
5229 // Adding Nodes
5230 ////////////////////////////////////////
5231// TGeoTranslation** endcapcoverplatesmallholetrans[kendcapcoverplatesmallholenumber[0]];
5232 TGeoTranslation*** endcapcoverplatesmallholetrans;
5233 endcapcoverplatesmallholetrans = new TGeoTranslation**[kendcapcoverplatesmallholenumber[0]];
5234 Double_t transx[4] = {0,
5235 fgkEndCapCoverPlateSmallHoleSeparation[0],
5236 fgkEndCapCoverPlateSmallHoleSeparation[0]
5237 + fgkEndCapCoverPlateSmallHoleSeparation[1],
5238 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
5239 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
5240 Int_t index = 0;
5241 for(Int_t i=0; i<kendcapcoverplatesmallholenumber[0]; i++){
5242 endcapcoverplatesmallholetrans[i] =
5243 new TGeoTranslation*[kendcapcoverplatesmallholenumber[1]];
5244 for(Int_t j=0; j<kendcapcoverplatesmallholenumber[1]; j++){
5245 index = kendcapcoverplatesmallholenumber[1]*i+j+1;
5246 endcapcoverplatesmallholetrans[i][j] =
5247 new TGeoTranslation(transx[i],
5248 j*fgkEndCapCoverPlateSmallHoleSeparation[2],0.);
5249 if(index!=10){
5250 mothercoverplate->AddNode(endcapcoverplatesmallhole,
5251 index,endcapcoverplatesmallholetrans[i][j]);
5252 mothercoverplate->AddNode(endcapsmallscrewpiece,
5253 index,endcapcoverplatesmallholetrans[i][j]);
5254 }
5255 if(j<kendcapcoverplatesmallholenumber[1]-1)
5256 mothercoverplate->AddNode(endcapcoverplatebox[0],
5257 index,endcapcoverplatesmallholetrans[i][j]);
5258 }
5259 }
5260 mothercoverplate->AddNode(endcapcoverplatebox[1],1);
5261 mothercoverplate->AddNode(endcapcoverplatebox[2],1);
5262 mothercoverplate->AddNode(endcapcoverplatebox[3],1);
5263 mothercoverplate->AddNode(endcapfillingbox,1);
5264 mothercoverplate->AddNode(endcapcoverplatebighole,1,bigholetrans[0]);
5265 mothercoverplate->AddNode(endcapcoverplatebighole,2,bigholetrans[1]);
5266 mothercoverplate->AddNode(endcapcoverplatebighole,3,bigholetrans[2]);
5267 mothercoverplate->AddNode(holecontour[0],1);
5268 mothercoverplate->AddNode(holecontour[0],2,holecontourtrans);
5269 mothercoverplate->AddNode(holecontour[1],1);
5270 mothercoverplate->AddNode(contour,1);
5271 /////////////////////////////////
5272 return mothercoverplate;
5273 }
5274 ////////////////////////////////////////////////////////////////////////////////
5275 TGeoVolume* AliITSv11GeometrySSD::GetEndCapCoolingTube(){
5276 /////////////////////////////////////////////////////////////
5277 // Getting EndCap Cooling Tube
5278 /////////////////////////////////////////////////////////////
5279 TGeoTorus* endcapcoolingtubetorushape[5];
5280 TGeoVolume* endcapcoolingtubetorus[5];
5281 TGeoTube* endcapcoolingtubeshape[4];
5282 TGeoVolume* endcapcoolingtube[4];
a3f8715e 5283 char endcapcoolingtubetorusname[100];
5284 char endcapcoolingtubename[100];
9b0c60ab 5285 TGeoTorus* endcapcoolingwatertubetorushape[5];
5286 TGeoVolume* endcapcoolingwatertubetorus[5];
5287 TGeoTube* endcapcoolingwatertubeshape[4];
5288 TGeoVolume* endcapcoolingwatertube[4];
a3f8715e 5289 char endcapcoolingwatertubetorusname[100];
5290 char endcapcoolingwatertubename[100];
9b0c60ab 5291 for(Int_t i=0; i<5; i++){
5292 sprintf(endcapcoolingtubetorusname,"EndCapCoolingTubeTorus%d",i+1);
5293 sprintf(endcapcoolingtubename,"EndCapCoolingTube%d",i+1);
5294 sprintf(endcapcoolingwatertubetorusname,"EndCapCoolingWaterTubeTorus%d",i+1);
5295 sprintf(endcapcoolingwatertubename,"EndCapCoolingWaterTube%d",i+1);
5296 if(i==3){
5297 endcapcoolingtubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5298 fgkEndCapCoolingTubeRadiusMin,
5299 fgkEndCapCoolingTubeRadiusMax,
5300 90.0,fgkEndCapCoolingTubeAngle[3]);
5301 endcapcoolingwatertubetorushape[i] = new TGeoTorus(fgkEndCapCoolingTubeAxialRadius[0],
5302 0.,fgkEndCapCoolingTubeRadiusMin,
5303 90.0,fgkEndCapCoolingTubeAngle[3]);
5304 }
5305 else{
5306 endcapcoolingtubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5307 :fgkEndCapCoolingTubeAxialRadius[1],
5308 fgkEndCapCoolingTubeRadiusMin,
5309 fgkEndCapCoolingTubeRadiusMax,
5310 0.,fgkEndCapCoolingTubeAngle[i]);
5311 endcapcoolingwatertubetorushape[i] = new TGeoTorus(i!=4?fgkEndCapCoolingTubeAxialRadius[0]
5312 :fgkEndCapCoolingTubeAxialRadius[1],
5313 0.,fgkEndCapCoolingTubeRadiusMin,
5314 0.,fgkEndCapCoolingTubeAngle[i]);
5315 }
5316 endcapcoolingtubetorus[i] = new TGeoVolume(endcapcoolingtubetorusname,
5317 endcapcoolingtubetorushape[i],
5318 fSSDCoolingTubePhynox);
5319 endcapcoolingwatertubetorus[i] = new TGeoVolume(endcapcoolingwatertubetorusname,
5320 endcapcoolingwatertubetorushape[i],
5321 fSSDCoolingTubeWater);
5322 endcapcoolingtubetorus[i]->SetLineColor(fColorPhynox);
5323 endcapcoolingwatertubetorus[i]->SetLineColor(fColorWater);
5324 if(i<4){
5325 endcapcoolingtubeshape[i] = new TGeoTube(fgkEndCapCoolingTubeRadiusMin,
5326 fgkEndCapCoolingTubeRadiusMax,
5327 0.5*fgkEndCapCoolingTubeLength[i]);
5328 endcapcoolingwatertubeshape[i] = new TGeoTube(0.,fgkEndCapCoolingTubeRadiusMin,
5329 0.5*fgkEndCapCoolingTubeLength[i]);
5330 endcapcoolingtube[i] = new TGeoVolume(endcapcoolingtubename,
5331 endcapcoolingtubeshape[i],fSSDCoolingTubePhynox);
5332 endcapcoolingwatertube[i] = new TGeoVolume(endcapcoolingwatertubename,
5333 endcapcoolingwatertubeshape[i],fSSDCoolingTubeWater);
5334 endcapcoolingtube[i]->SetLineColor(fColorPhynox);
5335 endcapcoolingwatertube[i]->SetLineColor(fColorWater);
5336 }
5337 }
5338 TGeoVolumeAssembly* endcapcoolingtubemother = new TGeoVolumeAssembly("MotherEndCapCoolingTube");
5339 /////////////////////////////////////////
5340 // Transformation for Volume Positioning
5341 /////////////////////////////////////////
5342 TGeoCombiTrans* coolingtubecombitrans[6];
5343 TGeoRotation* coolingtuberot[8];
5344 TGeoTranslation* coolingtubetrans[6];
5345 TGeoHMatrix* coolingtubematrix[4];
5346 TGeoCombiTrans* torustubecombitrans[4];
5347 TGeoRotation* torustuberot[7];
5348 TGeoTranslation* torustubetrans[4];
5349 TGeoHMatrix* torustubematrix[5];
5350 TGeoCombiTrans* coolingwatertubecombitrans[6];
5351 TGeoRotation* coolingwatertuberot[8];
5352 TGeoTranslation* coolingwatertubetrans[6];
5353 TGeoHMatrix* coolingwatertubematrix[4];
5354 TGeoCombiTrans* toruswatertubecombitrans[4];
5355 TGeoRotation* toruswatertuberot[7];
5356 TGeoTranslation* toruswatertubetrans[4];
5357 TGeoHMatrix* toruswatertubematrix[5];
5358 for(Int_t i=0; i<8; i++){
5359 if(i<6){
5360 coolingtubetrans[i] = new TGeoTranslation();
5361 coolingwatertubetrans[i] = new TGeoTranslation();
5362 }
5363 if(i<8){
5364 coolingtuberot[i] = new TGeoRotation();
5365 coolingwatertuberot[i] = new TGeoRotation();
5366 }
5367 if(i<4){
5368 torustubetrans[i] = new TGeoTranslation();
5369 toruswatertubetrans[i] = new TGeoTranslation();
5370 }
5371 if(i<7){
5372 torustuberot[i] = new TGeoRotation();
5373 toruswatertuberot[i] = new TGeoRotation();
5374 }
5375 }
5376 /////////////////////////////////////////
5377 // Transformation for Inox Volume Positioning
5378 /////////////////////////////////////////
5379 coolingtubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5380 -endcapcoolingtubeshape[0]->GetDz(),0.);
5381 coolingtuberot[0]->SetAngles(0.,90.,0.);
5382 coolingtubecombitrans[0] = new TGeoCombiTrans(*coolingtubetrans[0],
5383 *coolingtuberot[0]);
5384
5385 coolingtubetrans[1]->SetTranslation(0.,-endcapcoolingtubeshape[1]->GetDz(),0.);
5386 coolingtuberot[1]->SetAngles(0.,90.,0.);
5387 coolingtubecombitrans[1] = new TGeoCombiTrans(*coolingtubetrans[1],
5388 *coolingtuberot[1]);
5389
5390 coolingtubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5391 *CosD(fgkEndCapCoolingTubeAngle[0]),
5392 fgkEndCapCoolingTubeAxialRadius[0]
5393 *SinD(fgkEndCapCoolingTubeAngle[0]),
5394 0.);
5395 coolingtuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5396 coolingtubecombitrans[2] = new TGeoCombiTrans(*coolingtubetrans[2],
5397 *coolingtuberot[2]);
5398
5399 coolingtubematrix[0] = new TGeoHMatrix((*coolingtubecombitrans[2])
5400 * (*coolingtubecombitrans[1]));
5401
5402 torustubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5403 endcapcoolingtubeshape[1]->GetDz());
5404 torustuberot[0]->SetAngles(0.,90.,0.);
5405 torustubecombitrans[0] = new TGeoCombiTrans(*torustubetrans[0],*torustuberot[0]);
5406
5407 torustubematrix[0] = new TGeoHMatrix((*coolingtubematrix[0])*(*torustubecombitrans[0]));
5408
5409 coolingtubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5410 -endcapcoolingtubeshape[2]->GetDz(),0.);
5411 coolingtuberot[3]->SetAngles(0.,90.,0.);
5412 coolingtubecombitrans[3] = new TGeoCombiTrans(*coolingtubetrans[3],
5413 *coolingtuberot[3]);
5414 coolingtuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5415 coolingtubematrix[1] = new TGeoHMatrix((*coolingtuberot[4])*(*coolingtubecombitrans[3]));
5416 coolingtubematrix[1]->MultiplyLeft(torustubematrix[0]);
5417
5418 torustubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5419 endcapcoolingtubeshape[2]->GetDz());
5420 torustuberot[1]->SetAngles(0.,90.,0.);
5421 torustubecombitrans[1] = new TGeoCombiTrans(*torustubetrans[1],*torustuberot[1]);
5422 torustuberot[2]->SetAngles(180.,0.,0.);
5423 torustubematrix[2] = new TGeoHMatrix((*torustuberot[2])*(*torustubecombitrans[1]));
5424 torustubematrix[2]->MultiplyLeft(coolingtubematrix[1]);
5425
5426 torustubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5427 -fgkEndCapCoolingTubeAxialRadius[0]);
5428 torustuberot[3]->SetAngles(0.,90.,0.);
5429 torustubecombitrans[2] = new TGeoCombiTrans(*torustubetrans[2],*torustuberot[3]);
5430 torustuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5431 torustubematrix[3] = new TGeoHMatrix((*torustuberot[4])*(*torustubecombitrans[2]));
5432 torustubematrix[3]->MultiplyLeft(torustubematrix[2]);
5433
5434 coolingtubetrans[4]->SetTranslation(-endcapcoolingtubeshape[3]->GetDz(),
5435 fgkEndCapCoolingTubeAxialRadius[0],0.);
5436 coolingtuberot[5]->SetAngles(90.,90.,-90.);
5437 coolingtubecombitrans[4] = new TGeoCombiTrans(*coolingtubetrans[4],
5438 *coolingtuberot[5]);
5439 coolingtuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5440 coolingtubematrix[2] = new TGeoHMatrix((*coolingtuberot[6])*(*coolingtubecombitrans[4]));
5441 coolingtubematrix[2]->MultiplyLeft(torustubematrix[3]);
5442
5443 torustubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5444 endcapcoolingtubeshape[0]->GetDz());
5445 torustuberot[5]->SetAngles(0.,90.,0.);
5446 torustubecombitrans[3] = new TGeoCombiTrans(*torustubetrans[3],*torustuberot[5]);
5447 torustuberot[6]->SetAngles(-90.,0.,0.);
5448 torustubematrix[4] = new TGeoHMatrix((*torustuberot[6])*(*torustubecombitrans[3]));
5449 torustubematrix[4]->MultiplyLeft(coolingtubecombitrans[0]);
5450
5451 coolingtubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5452 endcapcoolingtubeshape[3]->GetDz(),0.);
5453 coolingtuberot[6]->SetAngles(0.,90.,0.);
5454 coolingtubecombitrans[5] = new TGeoCombiTrans(*coolingtubetrans[5],
5455 *coolingtuberot[6]);
5456 coolingtuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5457 coolingtubematrix[3] = new TGeoHMatrix((*coolingtuberot[7])*(*coolingtubecombitrans[5]));
5458 coolingtubematrix[3]->MultiplyLeft(torustubematrix[4]);
5459 /////////////////////////////////////////
5460 // Transformation for Water Volume Positioning
5461 /////////////////////////////////////////
5462 coolingwatertubetrans[0]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0],
5463 -endcapcoolingwatertubeshape[0]->GetDz(),0.);
5464 coolingwatertuberot[0]->SetAngles(0.,90.,0.);
5465 coolingwatertubecombitrans[0] = new TGeoCombiTrans(*coolingwatertubetrans[0],
5466 *coolingwatertuberot[0]);
5467
5468 coolingwatertubetrans[1]->SetTranslation(0.,-endcapcoolingwatertubeshape[1]->GetDz(),0.);
5469 coolingwatertuberot[1]->SetAngles(0.,90.,0.);
5470 coolingwatertubecombitrans[1] = new TGeoCombiTrans(*coolingwatertubetrans[1],
5471 *coolingwatertuberot[1]);
5472
5473 coolingwatertubetrans[2]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[0]
5474 *CosD(fgkEndCapCoolingTubeAngle[0]),
5475 fgkEndCapCoolingTubeAxialRadius[0]
5476 *SinD(fgkEndCapCoolingTubeAngle[0]),
5477 0.);
5478 coolingwatertuberot[2]->SetAngles(fgkEndCapCoolingTubeAngle[0]-180.,0.,0.);
5479 coolingwatertubecombitrans[2] = new TGeoCombiTrans(*coolingwatertubetrans[2],
5480 *coolingwatertuberot[2]);
5481
5482 coolingwatertubematrix[0] = new TGeoHMatrix((*coolingwatertubecombitrans[2])
5483 * (*coolingwatertubecombitrans[1]));
5484
5485 toruswatertubetrans[0]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5486 endcapcoolingwatertubeshape[1]->GetDz());
5487 toruswatertuberot[0]->SetAngles(0.,90.,0.);
5488 toruswatertubecombitrans[0] = new TGeoCombiTrans(*toruswatertubetrans[0],
5489 *toruswatertuberot[0]);
5490
5491 toruswatertubematrix[0] = new TGeoHMatrix((*coolingwatertubematrix[0])
5492 * (*toruswatertubecombitrans[0]));
5493
5494 coolingwatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],
5495 -endcapcoolingwatertubeshape[2]->GetDz(),0.);
5496 coolingwatertuberot[3]->SetAngles(0.,90.,0.);
5497 coolingwatertubecombitrans[3] = new TGeoCombiTrans(*coolingwatertubetrans[3],
5498 *coolingwatertuberot[3]);
5499 coolingwatertuberot[4]->SetAngles(-180.+fgkEndCapCoolingTubeAngle[1],0.,0.);
5500 coolingwatertubematrix[1] = new TGeoHMatrix((*coolingwatertuberot[4])
5501 * (*coolingwatertubecombitrans[3]));
5502 coolingwatertubematrix[1]->MultiplyLeft(toruswatertubematrix[0]);
5503
5504 toruswatertubetrans[1]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[0],0.,
5505 endcapcoolingwatertubeshape[2]->GetDz());
5506 toruswatertuberot[1]->SetAngles(0.,90.,0.);
5507 toruswatertubecombitrans[1] = new TGeoCombiTrans(*toruswatertubetrans[1],
5508 *toruswatertuberot[1]);
5509 toruswatertuberot[2]->SetAngles(180.,0.,0.);
5510 toruswatertubematrix[2] = new TGeoHMatrix((*toruswatertuberot[2])
5511 * (*toruswatertubecombitrans[1]));
5512 toruswatertubematrix[2]->MultiplyLeft(coolingwatertubematrix[1]);
5513
5514 toruswatertubetrans[2]->SetTranslation(0.,fgkEndCapCoolingTubeAxialRadius[0],
5515 -fgkEndCapCoolingTubeAxialRadius[0]);
5516 toruswatertuberot[3]->SetAngles(0.,90.,0.);
5517 toruswatertubecombitrans[2] = new TGeoCombiTrans(*toruswatertubetrans[2],
5518 *toruswatertuberot[3]);
5519 toruswatertuberot[4]->SetAngles(fgkEndCapCoolingTubeAngle[2]-90.,0.,0.);
5520 toruswatertubematrix[3] = new TGeoHMatrix((*toruswatertuberot[4])
5521 * (*toruswatertubecombitrans[2]));
5522 toruswatertubematrix[3]->MultiplyLeft(toruswatertubematrix[2]);
5523
5524 coolingwatertubetrans[4]->SetTranslation(-endcapcoolingwatertubeshape[3]->GetDz(),
5525 fgkEndCapCoolingTubeAxialRadius[0],0.);
5526 coolingwatertuberot[5]->SetAngles(90.,90.,-90.);
5527 coolingwatertubecombitrans[4] = new TGeoCombiTrans(*coolingwatertubetrans[4],
5528 *coolingwatertuberot[5]);
5529 coolingwatertuberot[6]->SetAngles(fgkEndCapCoolingTubeAngle[3],0.,0.);
5530 coolingwatertubematrix[2] = new TGeoHMatrix((*coolingwatertuberot[6])
5531 * (*coolingwatertubecombitrans[4]));
5532 coolingwatertubematrix[2]->MultiplyLeft(toruswatertubematrix[3]);
5533
5534 toruswatertubetrans[3]->SetTranslation(-fgkEndCapCoolingTubeAxialRadius[1],0.,
5535 endcapcoolingwatertubeshape[0]->GetDz());
5536 toruswatertuberot[5]->SetAngles(0.,90.,0.);
5537 toruswatertubecombitrans[3] = new TGeoCombiTrans(*toruswatertubetrans[3],
5538 *toruswatertuberot[5]);
5539 toruswatertuberot[6]->SetAngles(-90.,0.,0.);
5540 toruswatertubematrix[4] = new TGeoHMatrix((*toruswatertuberot[6])
5541 * (*toruswatertubecombitrans[3]));
5542 toruswatertubematrix[4]->MultiplyLeft(coolingwatertubecombitrans[0]);
5543
5544 coolingwatertubetrans[5]->SetTranslation(fgkEndCapCoolingTubeAxialRadius[1],
5545 endcapcoolingwatertubeshape[3]->GetDz(),0.);
5546 coolingwatertuberot[6]->SetAngles(0.,90.,0.);
5547 coolingwatertubecombitrans[5] = new TGeoCombiTrans(*coolingwatertubetrans[5],
5548 *coolingwatertuberot[6]);
5549 coolingwatertuberot[7]->SetAngles(fgkEndCapCoolingTubeAngle[4],0.,0.);
5550 coolingwatertubematrix[3] = new TGeoHMatrix((*coolingwatertuberot[7])
5551 * (*coolingwatertubecombitrans[5]));
5552 coolingwatertubematrix[3]->MultiplyLeft(toruswatertubematrix[4]);
5553 /////////////////////////////////////////
5554 // Positioning Volumes
5555 /////////////////////////////////////////
5556 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[0],1);
5557 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[0],1);
5558
5559 endcapcoolingtubemother->AddNode(endcapcoolingtube[0],1,coolingtubecombitrans[0]);
5560 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[0],1,coolingwatertubecombitrans[0]);
5561
5562 endcapcoolingtubemother->AddNode(endcapcoolingtube[1],1,coolingtubematrix[0]);
5563 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[1],1,coolingwatertubematrix[0]);
5564
5565 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[1],1,torustubematrix[0]);
5566 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[1],1,toruswatertubematrix[0]);
5567
5568 endcapcoolingtubemother->AddNode(endcapcoolingtube[2],1,coolingtubematrix[1]);
5569 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[2],1,coolingwatertubematrix[1]);
5570
5571 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[2],1,torustubematrix[2]);
5572 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[2],1,toruswatertubematrix[2]);
5573
5574 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[3],1,torustubematrix[3]);
5575 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[3],1,toruswatertubematrix[3]);
5576
5577 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],1,coolingtubematrix[2]);
5578 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],1,coolingwatertubematrix[2]);
5579
5580 endcapcoolingtubemother->AddNode(endcapcoolingtubetorus[4],1,torustubematrix[4]);
5581 endcapcoolingtubemother->AddNode(endcapcoolingwatertubetorus[4],1,toruswatertubematrix[4]);
5582
5583 endcapcoolingtubemother->AddNode(endcapcoolingtube[3],2,coolingtubematrix[3]);
5584 endcapcoolingtubemother->AddNode(endcapcoolingwatertube[3],2,coolingwatertubematrix[3]);
5585 /////////////////////////////////////////////////////////////
5586 // Deallocating memory
5587 /////////////////////////////////////////////////////////////
5588 for(Int_t i=0; i<8; i++){
5589 if(i<6){
5590 delete coolingtubetrans[i];
5591 delete coolingwatertubetrans[i];
5592 if(i!=0){
5593 delete coolingtubecombitrans[i];
5594 delete coolingwatertubecombitrans[i];
5595 }
5596 }
5597 if(i<8){
5598 delete coolingtuberot[i];
5599 delete coolingwatertuberot[i];
5600 }
5601 if(i<4){
5602 delete torustubetrans[i];
5603 delete toruswatertubetrans[i];
5604 delete torustubecombitrans[i];
5605 delete toruswatertubecombitrans[i];
5606 }
5607 if(i<7){
5608 delete torustuberot[i];
5609 delete toruswatertuberot[i];
5610 }
5611 }
5612 /////////////////////////////////////////////////////////////
5613 return endcapcoolingtubemother;
5614 }
5615 ////////////////////////////////////////////////////////////////////////////////
5616 TGeoVolume* AliITSv11GeometrySSD::GetEndCapSideCover() const {
5617 /////////////////////////////////////////////////////////////
5618 // Getting EndCap Cover Side
5619 /////////////////////////////////////////////////////////////
5620 const Int_t kendcapcoverholenumber[2] = {7,5};
5621 const Int_t kvertexnumber = 15;
5622 Double_t xvertex[kvertexnumber], yvertex[kvertexnumber];
5623 xvertex[0] = 0.0;
5624 xvertex[1] = xvertex[0];
5625 xvertex[2] = fgkEndCapSideCoverLength[0];
5626 xvertex[3] = fgkEndCapSideCoverLength[1];
5627 xvertex[4] = xvertex[3];
5628 xvertex[5] = fgkEndCapSideCoverLength[2];
5629 xvertex[6] = xvertex[5];
5630 xvertex[7] = xvertex[2];
5631 xvertex[8] = xvertex[7];
5632 xvertex[9] = xvertex[6]-fgkEndCapSideCoverLength[0];
5633 xvertex[10] = xvertex[9];
5634 xvertex[11] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[1]
5635 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[1]-1)
5636 * fgkEndCapSideCoverLength[4];
5637 xvertex[12] = xvertex[11];
5638 xvertex[13] = xvertex[5]-fgkEndCapSideCoverLength[0]-kendcapcoverholenumber[0]
5639 * fgkEndCapSideCoverLength[3]-(kendcapcoverholenumber[0]-1)
5640 * fgkEndCapSideCoverLength[4];
5641 xvertex[14] = xvertex[13];
5642 yvertex[0] = 0.0;
5643 yvertex[1] = fgkEndCapSideCoverWidth[0];
5644 yvertex[2] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[2];
5645 yvertex[3] = yvertex[2];
5646 yvertex[4] = fgkEndCapSideCoverWidth[1];
5647 yvertex[5] = yvertex[4];
5648 yvertex[6] = yvertex[0];
5649 yvertex[7] = yvertex[6];
5650 yvertex[8] = fgkEndCapSideCoverWidth[6];
5651 yvertex[9] = yvertex[8];
5652 yvertex[10] = fgkEndCapSideCoverWidth[1]-fgkEndCapSideCoverWidth[3];
5653 yvertex[11] = yvertex[10];
5654 yvertex[12] = yvertex[9]+2.*fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4];
5655 yvertex[13] = yvertex[12];
5656 yvertex[14] = yvertex[6];
851c0ce3 5657 TGeoXtru* endcapsidecovershapeout = new TGeoXtru(2);
5658 endcapsidecovershapeout->SetName("endcapsidecovershapeout");
5659 endcapsidecovershapeout->DefinePolygon(7,xvertex,yvertex);
5660 endcapsidecovershapeout->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5661 endcapsidecovershapeout->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5662 TGeoXtru* endcapsidecovershapein = new TGeoXtru(2);
5663 endcapsidecovershapein->SetName("endcapsidecovershapein");
5664 endcapsidecovershapein->DefinePolygon(6,&xvertex[8],&yvertex[8]);
5665 endcapsidecovershapein->DefineSection(0,-0.5*fgkEndCapSideCoverThickness-0.01);
5666 endcapsidecovershapein->DefineSection(1,0.5*fgkEndCapSideCoverThickness+0.01);
5667
5668
5669 TGeoCompositeShape* endcapsidecovershape = new TGeoCompositeShape("endcapsidecovershape", "endcapsidecovershapeout-endcapsidecovershapein");
9b0c60ab 5670 TGeoVolume* endcapsidecover = new TGeoVolume("EndCapSideCover",
5671 endcapsidecovershape,fSSDCoolingTubePhynox);
5672 endcapsidecover->SetLineColor(fColorPhynox);
5673 ////////////////////////////////////////////
5674 // Defininition of Mother Volume
5675 ////////////////////////////////////////////
5676 const Int_t kmothervertexnumber = 7;
5677 Double_t xmothervertex[kmothervertexnumber];
5678 Double_t ymothervertex[kmothervertexnumber];
5679 for(Int_t i=0; i<kmothervertexnumber; i++){
5680 xmothervertex[i] = xvertex[i];
5681 ymothervertex[i] = yvertex[i];
5682 }
5683 TGeoXtru* endcapsidecovermothershape = new TGeoXtru(2);
5684 endcapsidecovermothershape->DefinePolygon(kmothervertexnumber,xmothervertex,ymothervertex);
5685 endcapsidecovermothershape->DefineSection(0,-0.5*fgkEndCapSideCoverThickness);
5686 endcapsidecovermothershape->DefineSection(1,0.5*fgkEndCapSideCoverThickness);
5687 TGeoVolume* endcapsidecovermother = new TGeoVolume("EndCapSideCoverMother",
5688 endcapsidecovermothershape,fSSDAir);
5689 ////////////////////////////////////////////
5690 endcapsidecovermother->AddNode(endcapsidecover,1);
5691 TGeoBBox* endcapsidecoverboxshape[4];
5692 endcapsidecoverboxshape[0] = new TGeoBBox(0.5*(kendcapcoverholenumber[0]*fgkEndCapSideCoverLength[3]
5693 + (kendcapcoverholenumber[0]-1)*fgkEndCapSideCoverLength[4]),
5694 0.5*fgkEndCapSideCoverLength[4],
5695 0.5*fgkEndCapSideCoverThickness);
5696 endcapsidecoverboxshape[1] = new TGeoBBox(0.5*(kendcapcoverholenumber[1]*fgkEndCapSideCoverLength[3]
5697 + (kendcapcoverholenumber[1]-1)*fgkEndCapSideCoverLength[4]),
5698 0.5*(fgkEndCapSideCoverWidth[4]-2.*fgkEndCapSideCoverWidth[5]
5699 - fgkEndCapSideCoverLength[4]),
5700 0.5*fgkEndCapSideCoverThickness);
5701 endcapsidecoverboxshape[2] = new TGeoBBox(endcapsidecoverboxshape[1]->GetDX(),
5702 0.5*fgkEndCapSideCoverLength[4],
5703 0.5*fgkEndCapSideCoverThickness);
5704 endcapsidecoverboxshape[3] = new TGeoBBox(0.5*fgkEndCapSideCoverLength[4],
5705 0.5*fgkEndCapSideCoverWidth[5],
5706 0.5*fgkEndCapSideCoverThickness);
5707 TGeoVolume* endcapsidecoverbox[4];
5708 endcapsidecoverbox[0] = new TGeoVolume("EndCapSideCoverBox1",endcapsidecoverboxshape[0],fSSDCoolingTubePhynox);
5709 endcapsidecoverbox[1] = new TGeoVolume("EndCapSideCoverBox2",endcapsidecoverboxshape[1],fSSDCoolingTubePhynox);
5710 endcapsidecoverbox[2] = new TGeoVolume("EndCapSideCoverBox3",endcapsidecoverboxshape[2],fSSDCoolingTubePhynox);
5711 endcapsidecoverbox[3] = new TGeoVolume("EndCapSideCoverBox4",endcapsidecoverboxshape[3],fSSDCoolingTubePhynox);
5712 for(Int_t i=0; i<4; i++) endcapsidecoverbox[i]->SetLineColor(fColorPhynox);
5713// TGeoTranslation* endcapsidecoverboxtrans[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5714 TGeoTranslation** endcapsidecoverboxtrans;
5715 endcapsidecoverboxtrans = new TGeoTranslation*[3+2*(kendcapcoverholenumber[0]-1)+2*(kendcapcoverholenumber[1]-1)];
5716 endcapsidecoverboxtrans[0] = new TGeoTranslation(endcapsidecoverboxshape[0]->GetDX()
5717 + fgkEndCapSideCoverLength[0],
5718 endcapsidecoverboxshape[0]->GetDY()
5719 + yvertex[9]+fgkEndCapSideCoverWidth[5],0.);
5720 endcapsidecoverboxtrans[1] = new TGeoTranslation(endcapsidecoverboxshape[1]->GetDX()
5721 + xvertex[11],
5722 endcapsidecoverboxshape[1]->GetDY()
5723 + yvertex[12],0.);
5724 endcapsidecoverboxtrans[2] = new TGeoTranslation(endcapsidecoverboxshape[2]->GetDX()
5725 + xvertex[11],
5726 endcapsidecoverboxshape[2]->GetDY()
5727 + yvertex[12]
5728 + 2.*endcapsidecoverboxshape[1]->GetDY()
5729 + fgkEndCapSideCoverWidth[5],0.);
5730 endcapsidecovermother->AddNode(endcapsidecoverbox[0],1,endcapsidecoverboxtrans[0]);
5731 endcapsidecovermother->AddNode(endcapsidecoverbox[1],1,endcapsidecoverboxtrans[1]);
5732 endcapsidecovermother->AddNode(endcapsidecoverbox[2],1,endcapsidecoverboxtrans[2]);
5733 for(Int_t i=0; i<2; i++)
5734 for(Int_t j=0; j<kendcapcoverholenumber[0]-1; j++){
5735 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3] =
5736 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+fgkEndCapSideCoverLength[0]
5737 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5738 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5739 +i*(fgkEndCapSideCoverWidth[5]+fgkEndCapSideCoverLength[4]),0.0);
5740 endcapsidecovermother->AddNode(endcapsidecoverbox[3],i*(kendcapcoverholenumber[0]-1)+j+1,
5741 endcapsidecoverboxtrans[i*(kendcapcoverholenumber[0]-1)+j+3]);
5742 }
5743 for(Int_t i=0; i<2; i++)
5744 for(Int_t j=0; j<kendcapcoverholenumber[1]-1; j++){
5745 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j] =
5746 new TGeoTranslation(endcapsidecoverboxshape[3]->GetDX()+xvertex[12]
5747 +(j+1)*fgkEndCapSideCoverLength[3]+j*fgkEndCapSideCoverLength[4],
5748 endcapsidecoverboxshape[3]->GetDY()+fgkEndCapSideCoverWidth[6]
5749 +fgkEndCapSideCoverWidth[4]+i*(fgkEndCapSideCoverWidth[5]
5750 +fgkEndCapSideCoverLength[4]),0.0);
5751 endcapsidecovermother->AddNode(endcapsidecoverbox[3],
5752 2*(kendcapcoverholenumber[0]-1)+3+i*(kendcapcoverholenumber[1]-1)+j,
5753 endcapsidecoverboxtrans[2*(kendcapcoverholenumber[0]-1)+3
5754 +i*(kendcapcoverholenumber[1]-1)+j]);
5755 }
5756 return endcapsidecovermother;
5757 }
5758 ////////////////////////////////////////////////////////////////////////////////
5759 TGeoVolume** AliITSv11GeometrySSD::GetEndCapCards() const {
5760 ////////////////////////////////////////////////////////////////////////////////
5761 // Method returning Interface Card A, Interface Card B, Supply Card
5762 ////////////////////////////////////////////////////////////////////////////////
5763 /////////////////////
5764 // Supply Card
5765 /////////////////////
5766 // Electronic Board Back Al Plane
5767 const Int_t kelectboardbackvertexnumber = 8;
5768 Double_t xelectboardback[kelectboardbackvertexnumber];
5769 Double_t yelectboardback[kelectboardbackvertexnumber];
5770 xelectboardback[0] = 0.0;
5771 xelectboardback[1] = xelectboardback[0];
5772 xelectboardback[2] = fgkEndCapCardElectBoardBackLength[0];
5773 xelectboardback[3] = xelectboardback[2];
5774 xelectboardback[4] = xelectboardback[3]-fgkEndCapCardElectBoardBackLength[1];
5775 xelectboardback[5] = xelectboardback[4];
5776 xelectboardback[6] = fgkEndCapCardElectBoardBackLength[1];
5777 xelectboardback[7] = xelectboardback[6];
5778
5779 yelectboardback[0] = 0.0;
5780 yelectboardback[1] = fgkEndCapCardElectBoardBackWidth[0];
5781 yelectboardback[2] = yelectboardback[1];
5782 yelectboardback[3] = yelectboardback[0];
5783 yelectboardback[4] = yelectboardback[3];
5784 yelectboardback[5] = yelectboardback[4]+fgkEndCapCardElectBoardBackWidth[1];
5785 yelectboardback[6] = yelectboardback[5];
5786 yelectboardback[7] = yelectboardback[4];
5787 TGeoXtru* electboardbackshape = new TGeoXtru(2);
5788 electboardbackshape->DefinePolygon(kelectboardbackvertexnumber,
5789 xelectboardback,yelectboardback);
5790 electboardbackshape->DefineSection(0,0.0);
5791 electboardbackshape->DefineSection(1,fgkEndCapCardElectBoardBackThickness);
5792 TGeoVolume* electboardback = new TGeoVolume("EndCapCardElectBoardBackPlane",
5793 electboardbackshape,fSSDSupportRingAl);
5794 electboardback->SetLineColor(fColorAl);
5795 // Electronic Board Kapton Layer
5796 const Int_t kelectlayervertexnumber = 8;
5797 Double_t xelectlayer[kelectlayervertexnumber];
5798 Double_t yelectlayer[kelectlayervertexnumber];
5799 xelectlayer[0] = fgkEndCapCardElectBoardBackLength[0]-fgkEndCapCardElectBoardLength;
5800 xelectlayer[1] = xelectlayer[0];
5801 xelectlayer[2] = fgkEndCapCardElectBoardLength;
5802 xelectlayer[3] = xelectlayer[2];
5803 for(Int_t i=4; i<kelectlayervertexnumber; i++) xelectlayer[i] = xelectboardback[i];
5804
5805 yelectlayer[0] = 0.0;
5806 yelectlayer[1] = fgkEndCapCardElectBoardLayerWidth[0];
5807 yelectlayer[2] = yelectlayer[1];
5808 yelectlayer[3] = yelectlayer[0];
5809 yelectlayer[4] = yelectlayer[3];
5810 yelectlayer[5] = yelectlayer[4]+fgkEndCapCardElectBoardLayerWidth[1];
5811 yelectlayer[6] = yelectlayer[5];
5812 yelectlayer[7] = yelectlayer[4];
5813 TGeoXtru* electlayershape = new TGeoXtru(2);
5814 electlayershape->DefinePolygon(kelectlayervertexnumber,xelectlayer,yelectlayer);
5815 electlayershape->DefineSection(0,0.0);
5816 electlayershape->DefineSection(1,fgkEndCapCardElectBoardLayerThickness);
5817 TGeoVolume* electlayer = new TGeoVolume("EndCapCardElectBoardLayer",
5818 electlayershape,fSSDKaptonFlexMedium);
5819 electlayer->SetLineColor(fColorKapton);
5820 // JMD Connector Female
5821 const Int_t kjmdconnectorvertexnumber = 6;
5822 Double_t xjmdconnectorvertex[kjmdconnectorvertexnumber];
5823 Double_t yjmdconnectorvertex[kjmdconnectorvertexnumber];
5824 xjmdconnectorvertex[0] = 0.0;
5825 xjmdconnectorvertex[1] = xjmdconnectorvertex[0];
5826 xjmdconnectorvertex[2] = fgkEndCapCardJMDConnectorLength[1];
5827 xjmdconnectorvertex[3] = xjmdconnectorvertex[2];
5828 xjmdconnectorvertex[4] = fgkEndCapCardJMDConnectorLength[0];
5829 xjmdconnectorvertex[5] = xjmdconnectorvertex[4];
5830
5831 yjmdconnectorvertex[0] = 0.0;
5832 yjmdconnectorvertex[1] = fgkEndCapCardJMDConnectorWidth[0];
5833 yjmdconnectorvertex[2] = yjmdconnectorvertex[1];
5834 yjmdconnectorvertex[3] = yjmdconnectorvertex[2]+fgkEndCapCardJMDConnectorWidth[1];
5835 yjmdconnectorvertex[4] = yjmdconnectorvertex[3];
5836 yjmdconnectorvertex[5] = yjmdconnectorvertex[0];
5837 TGeoXtru* jmdconnectorshape = new TGeoXtru(2);
5838 jmdconnectorshape->DefinePolygon(kjmdconnectorvertexnumber,xjmdconnectorvertex,
5839 yjmdconnectorvertex);
5840 jmdconnectorshape->DefineSection(0,0.0);
5841 jmdconnectorshape->DefineSection(1,fgkEndCapCardJMDConnectorThickness);
5842 TGeoVolume* jmdconnector = new TGeoVolume("EndCapCardJMDConnector",
5843 jmdconnectorshape,fSSDMountingBlockMedium);
5844 jmdconnector->SetLineColor(fColorG10);
5845 // Top Cable Connector
5846 const Int_t kcableconnectorvertexnumber = 8;
5847 Double_t xconnectorvertex[kcableconnectorvertexnumber];
5848 Double_t yconnectorvertex[kcableconnectorvertexnumber];
5849 xconnectorvertex[0] = 0.0;
5850 xconnectorvertex[1] = xconnectorvertex[0];
5851 xconnectorvertex[2] = xconnectorvertex[1]+fgkEndCapCardCableConnectorLength[1];
5852 xconnectorvertex[3] = xconnectorvertex[2];
5853 xconnectorvertex[4] = fgkEndCapCardCableConnectorLength[0]
5854 - fgkEndCapCardCableConnectorLength[2];
5855 xconnectorvertex[5] = xconnectorvertex[4];
5856 xconnectorvertex[6] = fgkEndCapCardCableConnectorLength[0];
5857 xconnectorvertex[7] = xconnectorvertex[6];
5858
5859 yconnectorvertex[0] = 0.0;
5860 yconnectorvertex[1] = fgkEndCapCardCableConnectorWidth[0];
5861 yconnectorvertex[2] = yconnectorvertex[1];
5862 yconnectorvertex[3] = fgkEndCapCardCableConnectorWidth[1];
5863 yconnectorvertex[4] = yconnectorvertex[3];
5864 yconnectorvertex[5] = yconnectorvertex[1];
5865 yconnectorvertex[6] = yconnectorvertex[5];
5866 yconnectorvertex[7] = yconnectorvertex[0];
5867 TGeoXtru* cableconnectorshape = new TGeoXtru(2);
5868 cableconnectorshape->DefinePolygon(kcableconnectorvertexnumber,xconnectorvertex,
5869 yconnectorvertex);
5870 cableconnectorshape->DefineSection(0,0.0);
5871 cableconnectorshape->DefineSection(1,fgkEndCapCardCableConnectorThickness);
5872 TGeoVolume* cableconnector = new TGeoVolume("EndCapCardTopCableConnector",
5873 cableconnectorshape,fSSDMountingBlockMedium);
5874 cableconnector->SetLineColor(fColorG10);
5875 // Strip Connection
5876 TGeoBBox* endcapstripconnectionshape =
5877 new TGeoBBox(0.5*fgkEndCapStripConnectionLength,
5878 0.5*fgkEndCapStripConnectionThickness,
5879 0.5*fgkEndCapStripConnectionWidth);
5880 TGeoVolume* endcapstripconnection = new TGeoVolume("EndCapStripConnection",
5881 endcapstripconnectionshape,
5882 fSSDSupportRingAl);
5883 endcapstripconnection->SetLineColor(fColorAl);
5884 // Interface Card B
5885 const Int_t kcardBvertexnumber = 12;
5886 Double_t xcardBvertexnumber[kcardBvertexnumber];
5887 Double_t ycardBvertexnumber[kcardBvertexnumber];
5888
5889 xcardBvertexnumber[0] = 0.0;
5890 xcardBvertexnumber[1] = xcardBvertexnumber[0];
5891 xcardBvertexnumber[2] = xcardBvertexnumber[1]+fgkEndCapInterfaceCardBLength[0];
5892 xcardBvertexnumber[3] = xcardBvertexnumber[2];
5893 xcardBvertexnumber[4] = xcardBvertexnumber[1];
5894 xcardBvertexnumber[5] = xcardBvertexnumber[4];
5895 xcardBvertexnumber[6] = xcardBvertexnumber[5]+fgkEndCapInterfaceCardBLength[1];
5896 xcardBvertexnumber[7] = xcardBvertexnumber[6];
5897 xcardBvertexnumber[8] = xcardBvertexnumber[7]-fgkEndCapInterfaceCardBLength[0];
5898 xcardBvertexnumber[9] = xcardBvertexnumber[8];
5899 xcardBvertexnumber[10] = xcardBvertexnumber[7];
5900 xcardBvertexnumber[11] = xcardBvertexnumber[10];
5901
5902 ycardBvertexnumber[0] = 0.0;
5903 ycardBvertexnumber[1] = fgkEndCapInterfaceCardBWidth[0];
5904 ycardBvertexnumber[2] = ycardBvertexnumber[1];
5905 ycardBvertexnumber[3] = ycardBvertexnumber[2]+fgkEndCapInterfaceCardBWidth[1];
5906 ycardBvertexnumber[4] = ycardBvertexnumber[3];
5907 ycardBvertexnumber[5] = ycardBvertexnumber[4]+fgkEndCapInterfaceCardBWidth[2];
5908 ycardBvertexnumber[6] = ycardBvertexnumber[5];
5909 ycardBvertexnumber[7] = ycardBvertexnumber[4];
5910 ycardBvertexnumber[8] = ycardBvertexnumber[7];
5911 ycardBvertexnumber[9] = ycardBvertexnumber[1];
5912 ycardBvertexnumber[10] = ycardBvertexnumber[9];
5913 ycardBvertexnumber[11] = ycardBvertexnumber[0];
5914
5915 TGeoXtru* interfacecardBshape = new TGeoXtru(2);
5916 interfacecardBshape->DefinePolygon(kcardBvertexnumber,xcardBvertexnumber,ycardBvertexnumber);
5917 interfacecardBshape->DefineSection(0,0.);
5918 interfacecardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness);
5919 TGeoVolume* interfacecardB = new TGeoVolume("EndCapInterfaceCardB",interfacecardBshape,
5920 fSSDMountingBlockMedium);
5921 interfacecardB->SetLineColor(46);
5922 // Interface Card B Electronic Board
5923 const Int_t kelectboardcardBvertexnumber = 14;
5924 Double_t xelectboardcardBvertex[kelectboardcardBvertexnumber];
5925 Double_t yelectboardcardBvertex[kelectboardcardBvertexnumber];
5926
5927 xelectboardcardBvertex[0] = xcardBvertexnumber[0]+fgkEndCapInterfaceCardBLength[2];
5928 xelectboardcardBvertex[1] = xelectboardcardBvertex[0];
5929 xelectboardcardBvertex[2] = xelectboardcardBvertex[1]+fgkEndCapInterfaceCardBLength[3];
5930 xelectboardcardBvertex[3] = xelectboardcardBvertex[2];
5931 xelectboardcardBvertex[4] = xelectboardcardBvertex[3]+fgkEndCapInterfaceCardBLength[4];
5932 xelectboardcardBvertex[5] = xelectboardcardBvertex[4];
5933 xelectboardcardBvertex[6] = xelectboardcardBvertex[5]+fgkEndCapInterfaceCardBLength[5];
5934 xelectboardcardBvertex[7] = xelectboardcardBvertex[6];
5935 xelectboardcardBvertex[8] = xelectboardcardBvertex[7]+8.0*fgkEndCapInterfaceCardBLength[4];
5936 xelectboardcardBvertex[9] = xelectboardcardBvertex[8];
5937 xelectboardcardBvertex[10] = xelectboardcardBvertex[9]+fgkEndCapInterfaceCardBLength[6];
5938 xelectboardcardBvertex[11] = xelectboardcardBvertex[10];
5939 xelectboardcardBvertex[12] = xelectboardcardBvertex[11]-9.0*fgkEndCapInterfaceCardBLength[4];
5940 xelectboardcardBvertex[13] = xelectboardcardBvertex[12];
5941
5942 yelectboardcardBvertex[0] = ycardBvertexnumber[0]+fgkEndCapInterfaceCardBWidth[1];
5943 yelectboardcardBvertex[1] = yelectboardcardBvertex[0]+fgkEndCapInterfaceCardBWidth[3];
5944 yelectboardcardBvertex[2] = yelectboardcardBvertex[1];
5945 yelectboardcardBvertex[3] = yelectboardcardBvertex[2]+fgkEndCapInterfaceCardBWidth[3];
5946 yelectboardcardBvertex[4] = yelectboardcardBvertex[3];
5947 yelectboardcardBvertex[5] = yelectboardcardBvertex[2];
5948 yelectboardcardBvertex[6] = yelectboardcardBvertex[5];
5949 yelectboardcardBvertex[7] = yelectboardcardBvertex[6]+fgkEndCapInterfaceCardBWidth[4];
5950 yelectboardcardBvertex[8] = yelectboardcardBvertex[7];
5951 yelectboardcardBvertex[9] = yelectboardcardBvertex[8]-fgkEndCapInterfaceCardBWidth[3];
5952 yelectboardcardBvertex[10] = yelectboardcardBvertex[9];
5953 yelectboardcardBvertex[11] = yelectboardcardBvertex[10]-fgkEndCapInterfaceCardBWidth[3];
5954 yelectboardcardBvertex[12] = yelectboardcardBvertex[11];
5955 yelectboardcardBvertex[13] = yelectboardcardBvertex[0];
5956
5957 TGeoXtru* electboardcardBshape = new TGeoXtru(2);
5958 electboardcardBshape->DefinePolygon(kelectboardcardBvertexnumber,
5959 xelectboardcardBvertex,yelectboardcardBvertex);
5960 electboardcardBshape->DefineSection(0,fgkEndCapInterfaceCardBThickness);
5961 electboardcardBshape->DefineSection(1,fgkEndCapInterfaceCardBThickness
5962 + fgkEndCapInterfaceElectBoardCardBThickness);
5963 TGeoVolume* electboardcardB = new TGeoVolume("EndCapInterfaceElectBoardCardB",electboardcardBshape,
5964 fSSDSupportRingAl);
5965 electboardcardB->SetLineColor(fColorAl);
5966 // Generating Stiffener 2
5967 TGeoBBox* endcapstiffenershape = new TGeoBBox(0.5*fgkEndCapStiffenerWidth,
5968 0.5*fgkEndCapStiffenerThickness,
5969 0.5*fgkEndCapStiffenerLength);
5970 TGeoVolume* endcapstiffener = new TGeoVolume("EndCapStiffener",endcapstiffenershape,fSSDSupportRingAl);
5971 endcapstiffener->SetLineColor(fColorAl);
5972 // Generating Mother Interface Card B Container
5973 const Int_t kinterfacecardBmothervertexnumber = 10;
5974 Double_t xinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5975 Double_t yinterfacecardBmothervertex[kinterfacecardBmothervertexnumber];
5976
5977 xinterfacecardBmothervertex[0] = 0.0;
5978 xinterfacecardBmothervertex[1] = xinterfacecardBmothervertex[0];
5979 xinterfacecardBmothervertex[2] = xinterfacecardBmothervertex[1]
5980 + fgkEndCapInterfaceCardBThickness;
5981 xinterfacecardBmothervertex[3] = xinterfacecardBmothervertex[2];
5982 xinterfacecardBmothervertex[4] = xinterfacecardBmothervertex[3]
5983 + fgkEndCapInterfaceElectBoardCardBThickness;
5984 xinterfacecardBmothervertex[5] = xinterfacecardBmothervertex[4];
5985 xinterfacecardBmothervertex[6] = xinterfacecardBmothervertex[3];
5986 xinterfacecardBmothervertex[7] = xinterfacecardBmothervertex[6];
5987 xinterfacecardBmothervertex[8] = xinterfacecardBmothervertex[7]
5988 + fgkEndCapCardJMDConnectorLength[0];
5989 xinterfacecardBmothervertex[9] = xinterfacecardBmothervertex[8];
5990
5991 yinterfacecardBmothervertex[0] = 0.0;
5992 yinterfacecardBmothervertex[1] = fgkEndCapInterfaceCardBWidth[0]
5993 + fgkEndCapInterfaceCardBWidth[1]
5994 + fgkEndCapInterfaceCardBWidth[2];
5995 yinterfacecardBmothervertex[2] = yinterfacecardBmothervertex[1];
5996 yinterfacecardBmothervertex[3] = yelectboardcardBvertex[3];
5997 yinterfacecardBmothervertex[4] = yinterfacecardBmothervertex[3];
5998 yinterfacecardBmothervertex[5] = yelectboardcardBvertex[11];
5999 yinterfacecardBmothervertex[6] = yinterfacecardBmothervertex[5];
6000 yinterfacecardBmothervertex[7] = fgkEndCapCardElectBoardLayerWidth[1]
6001 + fgkEndCapCardJMDConnectorWidth[0]
6002 + fgkEndCapCardJMDConnectorWidth[1];
6003 yinterfacecardBmothervertex[8] = yinterfacecardBmothervertex[7];
6004 yinterfacecardBmothervertex[9] = yinterfacecardBmothervertex[0];
6005 TGeoXtru* interfacecardBmothershape = new TGeoXtru(2);
6006 interfacecardBmothershape->DefinePolygon(kinterfacecardBmothervertexnumber,
6007 xinterfacecardBmothervertex,
6008 yinterfacecardBmothervertex);
6009 interfacecardBmothershape->DefineSection(0,-1.e-15);
6010 interfacecardBmothershape->DefineSection(1,fgkEndCapInterfaceCardBLength[1]);
6011 TGeoVolume* interfacecardBmother = new TGeoVolume("EndCapInterfaceCardBMother",
6012 interfacecardBmothershape,fSSDAir);
6013 electboardcardB->SetLineColor(fColorAl);
6014 // Positioning Volumes Mother Interface Card B Container
6015 TGeoRotation* interfacecardBrot = new TGeoRotation();
6016 TGeoTranslation* interfacecardBtrans = new TGeoTranslation();
6017 interfacecardBrot->SetAngles(90.,-90.,-90.);
6018 interfacecardBtrans->SetTranslation(fgkEndCapInterfaceCardBThickness,0.,0.);
6019 TGeoCombiTrans* interfacecardBcombitrans = new TGeoCombiTrans(*interfacecardBtrans,*interfacecardBrot);
6020 TGeoRotation* electboardcardBrot = new TGeoRotation();
6021 TGeoTranslation* electboardcardBtrans = new TGeoTranslation();
6022 electboardcardBrot->SetAngles(90.,90.,-90.);
6023 electboardcardBtrans->SetTranslation(0.,0.,fgkEndCapInterfaceCardBLength[1]);
6024 TGeoCombiTrans* electboardcardBcombitrans =
6025 new TGeoCombiTrans(*electboardcardBtrans,*electboardcardBrot);
6026 interfacecardBmother->AddNode(interfacecardB,1,interfacecardBcombitrans);
6027 interfacecardBmother->AddNode(electboardcardB,1,electboardcardBcombitrans);
6028 TGeoRotation* jmdconnectorcardBrot = new TGeoRotation();
6029 jmdconnectorcardBrot->SetAngles(90.,180.,-90.);
6030 TGeoTranslation* jmdconnectorcardBtrans[3];
6031 TGeoCombiTrans* jmdconnectorcardBcombitrans[3];
6032 for(Int_t i=0; i<3; i++){
6033 jmdconnectorcardBtrans[i] = new TGeoTranslation(fgkEndCapInterfaceCardBThickness
6034 + fgkEndCapCardJMDConnectorLength[0],
6035 fgkEndCapCardElectBoardLayerWidth[1],
6036 0.5*fgkEndCapCardJMDConnectorThickness
6037 + 0.5*(fgkEndCapInterfaceCardBLength[1]
6038 - 2.*fgkEndCapInterfaceCardBJMDConnectorSeparation)
6039 + i *fgkEndCapInterfaceCardBJMDConnectorSeparation);
6040 jmdconnectorcardBcombitrans[i] = new TGeoCombiTrans(*jmdconnectorcardBtrans[i],
6041 *jmdconnectorcardBrot);
6042 interfacecardBmother->AddNode(jmdconnector,i+1,jmdconnectorcardBcombitrans[i]);
6043 }
6044 // Mother Supply Card Container
6045 TGeoVolumeAssembly* mothersupplycard = new TGeoVolumeAssembly("EndCapCardMotherSupply");
6046 // Interface Card Container
6047 TGeoVolumeAssembly* motherinterfacecardcontainer = new TGeoVolumeAssembly("EndCapMotherInterfaceCardA");
6048 // Placing Volumes in Mother Supply Card Container
6049 // JMD Connector Positioning
6050 TGeoTranslation* jmdconnectortrans[2];
6051 for(Int_t i=0; i<2; i++) jmdconnectortrans[i] = new TGeoTranslation();
6052 jmdconnectortrans[0]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[1],
6053 fgkEndCapCardElectBoardBackLength[0]
6054 - fgkEndCapCardJMDConnectorThickness
6055 - fgkEndCapCardJMDConnectorToLayer);
6056 TGeoRotation* jmdconnectorot = new TGeoRotation();
6057 jmdconnectortrans[1]->SetTranslation(fgkEndCapCardElectBoardBackThickness
6058 + 2.*fgkEndCapCardJMDConnectorLength[0]
6059 + 2.*fgkEndCapCardElectBoardLayerThickness,
6060 fgkEndCapCardElectBoardLayerWidth[1],
6061 fgkEndCapCardJMDConnectorThickness
6062 + fgkEndCapCardJMDConnectorToLayer);
6063 jmdconnectorot->SetAngles(90.,180.,-90);
6064 TGeoCombiTrans* jmdconnectorcombitrans = new TGeoCombiTrans(*jmdconnectortrans[1],
6065 * jmdconnectorot);
6066 mothersupplycard->AddNode(jmdconnector,1,jmdconnectortrans[0]);
6067 mothersupplycard->AddNode(jmdconnector,2,jmdconnectorcombitrans);
6068 // Top Cable Connector Placing
6069 TGeoRotation* cableconnectorot[2];
6070 for(Int_t i=0; i<2; i++) cableconnectorot[i] = new TGeoRotation();
6071 TGeoTranslation* cableconnectortrans[3];
6072 for(Int_t i=0; i<3; i++) cableconnectortrans[i] = new TGeoTranslation();
6073 cableconnectorot[0]->SetAngles(90.,0.,0.);
6074 cableconnectorot[1]->SetAngles(0.,-90.,0.);
6075 cableconnectortrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0],0.,0.);
6076 TGeoCombiTrans* cableconnectorcombitrans = new TGeoCombiTrans(*cableconnectortrans[0],
6077 *cableconnectorot[0]);
6078 TGeoHMatrix* cableconnectormatrix[2];
6079 for(Int_t i=0; i<2; i++) cableconnectormatrix[i] =
6080 new TGeoHMatrix((*cableconnectorot[1])
6081 *(*cableconnectorcombitrans));
6082 cableconnectortrans[1]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6083 - fgkEndCapCardCableConnectorThickness,
6084 fgkEndCapCardCableConnectorLength[0]
6085 + fgkEndCapCardCableConnectorToLayer);
6086 cableconnectortrans[2]->SetTranslation(0.,fgkEndCapCardElectBoardLayerWidth[0]
6087 - 2.*fgkEndCapCardCableConnectorThickness
6088 - fgkEndCapCardCableConnectorDistance,
6089 fgkEndCapCardCableConnectorLength[0]
6090 + fgkEndCapCardCableConnectorToLayer);
6091 for(Int_t i=0; i<2; i++){
6092 cableconnectormatrix[i]->MultiplyLeft(cableconnectortrans[i+1]);
6093 mothersupplycard->AddNode(cableconnector,i+1,cableconnectormatrix[i]);
6094 }
6095 TGeoRotation* electboardbackrot = new TGeoRotation();
6096 TGeoTranslation* electboardbacktrans = new TGeoTranslation();
6097 electboardbackrot->SetAngles(90.,-90.,-90.);
6098 electboardbacktrans->SetTranslation(fgkEndCapCardElectBoardBackThickness
6099 + fgkEndCapCardJMDConnectorLength[0]
6100 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6101 TGeoCombiTrans* electboardbackcombitrans = new TGeoCombiTrans(*electboardbacktrans,
6102 *electboardbackrot);
6103 mothersupplycard->AddNode(electboardback,1,electboardbackcombitrans);
6104 // Electronic Board Kapton Layer Positioning
6105 TGeoRotation* electlayerrot = new TGeoRotation();
6106 TGeoTranslation* electlayertrans[2];
6107 TGeoCombiTrans* electlayercombitrans[2];
6108 for(Int_t i=0; i<2; i++) electlayertrans[i] = new TGeoTranslation();
6109 electlayerrot->SetAngles(90.,-90.,-90.);
6110 electlayertrans[0]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6111 + fgkEndCapCardElectBoardLayerThickness,0.,0.);
6112 electlayertrans[1]->SetTranslation(fgkEndCapCardJMDConnectorLength[0]
6113 + 2.*fgkEndCapCardElectBoardLayerThickness
6114 + fgkEndCapCardElectBoardBackThickness,0.,0.);
6115 for(Int_t i=0; i<2; i++){
6116 electlayercombitrans[i] = new TGeoCombiTrans(*electlayertrans[i],*electlayerrot);
6117 mothersupplycard->AddNode(electlayer,i+1,electlayercombitrans[i]);
6118 }
6119 // Placing Volumes in Mother Interface Card Container
6120 motherinterfacecardcontainer->AddNode(jmdconnector,1,jmdconnectorcombitrans);
6121 motherinterfacecardcontainer->AddNode(electboardback,1,electboardbackcombitrans);
6122 for(Int_t i=0; i<2; i++){
6123 motherinterfacecardcontainer->AddNode(electlayer,i+1,electlayercombitrans[i]);
6124 }
6125 /////////////////////////////////////////////////////////////
6126 // Generation of Card Interface Container
6127 /////////////////////////////////////////////////////////////
6128 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6129 - fgkEndCapCardJMDConnectorLength[0]
6130 - fgkEndCapInterfaceCardBThickness
6131 - 9.*fgkEndCapStripConnectionThickness
6132 - 8.*fgkEndCapCardElectBoardBackThickness;
6133 const Int_t kcardinterfacecontainervertexnumber = 14;
6134 Double_t xcardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6135 Double_t ycardinterfacecontainervertex[kcardinterfacecontainervertexnumber];
6136 xcardinterfacecontainervertex[0] =-6.5*fgkEndCapCardElectBoardBackThickness
6137 - 7.0*fgkEndCapStripConnectionThickness;
6138 xcardinterfacecontainervertex[1] = xcardinterfacecontainervertex[0];
6139 xcardinterfacecontainervertex[2] = xcardinterfacecontainervertex[1]
6140 + fgkEndCapStripConnectionThickness
6141 - fgkEndCapCardElectBoardLayerThickness
6142 - fgkEndCapCardCableConnectorWidth[0];
6143 xcardinterfacecontainervertex[3] = xcardinterfacecontainervertex[2];
6144 xcardinterfacecontainervertex[4] = xcardinterfacecontainervertex[1];
6145 xcardinterfacecontainervertex[5] = xcardinterfacecontainervertex[4];
6146 xcardinterfacecontainervertex[6] = 1.5*fgkEndCapCardElectBoardBackThickness
6147 + 2.0*fgkEndCapStripConnectionThickness;
6148 xcardinterfacecontainervertex[7] = xcardinterfacecontainervertex[6];
6149 xcardinterfacecontainervertex[8] = xcardinterfacecontainervertex[7]
6150 + fgkEndCapInterfaceCardBThickness;
6151 xcardinterfacecontainervertex[9] = xcardinterfacecontainervertex[8];
6152 xcardinterfacecontainervertex[10] = xcardinterfacecontainervertex[9]
6153 + fgkEndCapInterfaceElectBoardCardBThickness;
6154 xcardinterfacecontainervertex[11] = xcardinterfacecontainervertex[10];
6155 xcardinterfacecontainervertex[12] = xcardinterfacecontainervertex[11]
6156 - fgkEndCapInterfaceElectBoardCardBThickness
6157 + fgkEndCapCardJMDConnectorLength[0]
6158 + stiffenertransx+fgkEndCapStiffenerWidth;
6159 xcardinterfacecontainervertex[13] = xcardinterfacecontainervertex[12];
6160
6161 ycardinterfacecontainervertex[0] = 0.;
6162 ycardinterfacecontainervertex[1] = fgkEndCapCardElectBoardLayerWidth[1]
6163 + fgkEndCapCardJMDConnectorWidth[0]
6164 + fgkEndCapCardJMDConnectorWidth[1];
6165 ycardinterfacecontainervertex[2] = ycardinterfacecontainervertex[1];
6166 ycardinterfacecontainervertex[3] = fgkEndCapCardElectBoardBackWidth[0]
6167 - fgkEndCapStripConnectionWidth;
6168 ycardinterfacecontainervertex[4] = ycardinterfacecontainervertex[3];
6169 ycardinterfacecontainervertex[5] = fgkEndCapCardElectBoardBackWidth[0];
6170 ycardinterfacecontainervertex[6] = ycardinterfacecontainervertex[5];
6171 ycardinterfacecontainervertex[7] = fgkEndCapInterfaceCardBWidth[0]
6172 + fgkEndCapInterfaceCardBWidth[1]
6173 + fgkEndCapInterfaceCardBWidth[2];
6174 ycardinterfacecontainervertex[8] = ycardinterfacecontainervertex[7];
6175 ycardinterfacecontainervertex[9] = yelectboardcardBvertex[3];
6176 ycardinterfacecontainervertex[10] = ycardinterfacecontainervertex[9];
6177 ycardinterfacecontainervertex[11] = ycardinterfacecontainervertex[1];
6178 ycardinterfacecontainervertex[12] = ycardinterfacecontainervertex[11];
6179 ycardinterfacecontainervertex[13] = ycardinterfacecontainervertex[0];
6180
6181 TGeoXtru* interfacecardmothershape = new TGeoXtru(2);
6182 interfacecardmothershape->DefinePolygon(kcardinterfacecontainervertexnumber,
6183 xcardinterfacecontainervertex,
6184 ycardinterfacecontainervertex);
6185 interfacecardmothershape->DefineSection(0,-1.e-15-0.5*(fgkEndCapStiffenerLength
6186 - fgkEndCapCardElectBoardBackLength[0]));
6187 interfacecardmothershape->DefineSection(1,0.5*(fgkEndCapStiffenerLength
6188 + fgkEndCapCardElectBoardBackLength[0]));
6189 TGeoVolume** cardinterfacecontainer;
6190 cardinterfacecontainer = new TGeoVolume*[4];
6191 cardinterfacecontainer[0] = new TGeoVolume("EndCapCardsContainerLayer5Sx",
6192 interfacecardmothershape,fSSDAir);
6193 cardinterfacecontainer[1] = new TGeoVolume("EndCapCardsContainerLayer5Dx",
6194 interfacecardmothershape,fSSDAir);
6195 cardinterfacecontainer[2] = new TGeoVolume("EndCapCardsContainerLayer6Sx",
6196 interfacecardmothershape,fSSDAir);
6197 cardinterfacecontainer[3] = new TGeoVolume("EndCapCardsContainerLayer6Dx",
6198 interfacecardmothershape,fSSDAir);
6199 /////////////////////////////////
6200 // cardinterfacecontainer[0]: Card Container End Cap Layer 5 Bellegarde Side
6201 // cardinterfacecontainer[1]: Card Container End Cap Layer 5 Gex Side
6202 // cardinterfacecontainer[2]: Card Container End Cap Layer 6 Bellegarde Side
6203 // cardinterfacecontainer[3]: Card Container End Cap Layer 6 Gex Side
6204 /////////////////////////////////
6205 TGeoRotation* endcapstripconnectionrot[2];
6206 for(Int_t i=0; i<2; i++) endcapstripconnectionrot[i] = new TGeoRotation();
6207 endcapstripconnectionrot[0]->SetAngles(0.,90.,0.);
6208 endcapstripconnectionrot[1]->SetAngles(90.,90.,-90.);
6209 TGeoHMatrix* endcapstripconnectionmatrix = new TGeoHMatrix((*endcapstripconnectionrot[1])
6210 * (*endcapstripconnectionrot[0]));
6211 TGeoTranslation* endcapstripconnectiontrans = new TGeoTranslation();
6212 endcapstripconnectiontrans->SetTranslation(-endcapstripconnectionshape->GetDY()
6213 -0.5*fgkEndCapCardElectBoardBackThickness,
6214 fgkEndCapCardElectBoardBackWidth[0]
6215 -endcapstripconnectionshape->GetDZ(),
6216 0.5*fgkEndCapCardElectBoardBackLength[0]);
6217 endcapstripconnectionmatrix->MultiplyLeft(endcapstripconnectiontrans);
6218 TGeoTranslation* cardinterfacetrans[9];
6219 TGeoHMatrix* cardinterfacematrix[9];
6220 for(Int_t i=0; i<7; i++){
6221 cardinterfacetrans[i] = new TGeoTranslation(-i*(fgkEndCapStripConnectionThickness
6222 + fgkEndCapCardElectBoardBackThickness),
6223 0.0,0.0);
6224 cardinterfacematrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6225 * (*endcapstripconnectionmatrix));
6226 }
6227 cardinterfacetrans[7] = new TGeoTranslation((fgkEndCapStripConnectionThickness
6228 + fgkEndCapCardElectBoardBackThickness),
6229 0.0,0.0);
6230 cardinterfacematrix[7] = new TGeoHMatrix((*cardinterfacetrans[7])
6231 * (*endcapstripconnectionmatrix));
6232 cardinterfacetrans[8] = new TGeoTranslation(2.*(fgkEndCapStripConnectionThickness
6233 + fgkEndCapCardElectBoardBackThickness),
6234 0.0,0.0);
6235 cardinterfacematrix[8] = new TGeoHMatrix((*cardinterfacetrans[8])
6236 * (*endcapstripconnectionmatrix));
6237
6238 for(Int_t i=0; i<4; i++){
6239 cardinterfacecontainer[i]->AddNode(endcapstripconnection,1,
6240 cardinterfacematrix[7]);
6241 cardinterfacecontainer[i]->AddNode(endcapstripconnection,2,
6242 cardinterfacematrix[8]);
6243 }
6244 TGeoTranslation* mothersupplycardtrans =
6245 new TGeoTranslation(-0.5*(fgkEndCapCardElectBoardBackThickness
6246 + 2.*fgkEndCapCardJMDConnectorLength[0]
6247 + 2.*fgkEndCapCardElectBoardLayerThickness),0.0,0.0);
6248 TGeoHMatrix* mothersupplycardmatrix[7];
6249 Int_t index[4] = {1,1,1,1};
6250 for(Int_t i=0; i<7; i++){
6251 mothersupplycardmatrix[i] = new TGeoHMatrix((*cardinterfacetrans[i])
6252 * (*mothersupplycardtrans));
6253 for(Int_t j=0; j<4; j++){
6254 switch(j){
6255 case 0: //Layer5 EndCap Left Side
6256 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6257 cardinterfacematrix[i]);
6258 if(i!=0){
6259 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6260 mothersupplycardmatrix[i]);
6261 index[j]++;
6262
6263 }
6264 break;
6265 case 1: //Layer5 EndCap Rigth Side
6266 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6267 cardinterfacematrix[i]);
6268 if(i>0&&i<6){
6269 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6270 mothersupplycardmatrix[i]);
6271 index[j]++;
6272 }
6273 break;
6274 case 2: //Layer6 EndCap Left Side
6275 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6276 cardinterfacematrix[i]);
6277 if(i!=6){
6278 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6279 mothersupplycardmatrix[i]);
6280 index[j]++;
6281 }
6282 break;
6283 case 3: //Layer6 EndCap Right Side
6284 cardinterfacecontainer[j]->AddNode(endcapstripconnection,i+3,
6285 cardinterfacematrix[i]);
6286 cardinterfacecontainer[j]->AddNode(mothersupplycard,index[j],
6287 mothersupplycardmatrix[i]);
6288 index[j]++;
6289 break;
6290 }
6291 }
6292 }
6293 // Positioning Interface
6294 TGeoTranslation* motherinterfacecardtrans =
6295 new TGeoTranslation( -fgkEndCapCardJMDConnectorLength[0]
6296 +0.5*fgkEndCapCardElectBoardBackThickness
6297 -fgkEndCapCardElectBoardLayerThickness
6298 +fgkEndCapStripConnectionThickness,0.,0.);
6299 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(
6300 motherinterfacecardcontainer,i+1,motherinterfacecardtrans);
6301 // Positioning Interface Card B
6302 TGeoTranslation* interfacecardBmothertrans =
6303 new TGeoTranslation(0.5 * fgkEndCapCardElectBoardBackThickness
6304 + 2.*fgkEndCapStripConnectionThickness
6305 + fgkEndCapCardElectBoardBackThickness,0.,
6306 -0.5 * (fgkEndCapInterfaceCardBLength[1]
6307 - fgkEndCapCardElectBoardBackLength[0]));
6308 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(interfacecardBmother,1,
6309 interfacecardBmothertrans);
6310 // Positioning Stiffener
6311 TGeoTranslation* endcapstiffenertrans =
6312 new TGeoTranslation(1.5*fgkEndCapCardElectBoardBackThickness
6313 + 2.0*fgkEndCapStripConnectionThickness
6314 + fgkEndCapInterfaceCardBThickness
6315 + fgkEndCapCardJMDConnectorLength[0]
6316 + stiffenertransx
6317 + endcapstiffenershape->GetDX(),endcapstiffenershape->GetDY(),
6318 endcapstiffenershape->GetDZ()
6319 - 0.5*(fgkEndCapStiffenerLength
6320 - fgkEndCapCardElectBoardBackLength[0]));
6321 for(Int_t i=0; i<4; i++) cardinterfacecontainer[i]->AddNode(endcapstiffener,1,endcapstiffenertrans);
6322 /////////////////////////////////////////////////////////////
6323 // Deallocating memory
6324 /////////////////////////////////////////////////////////////
6325 delete interfacecardBrot;
6326 delete interfacecardBtrans;
6327 delete electboardcardBtrans;
6328 delete electboardcardBrot;
6329 delete jmdconnectorcardBrot;
6330 for(Int_t i=0; i<3; i++) delete jmdconnectorcardBtrans[i];
6331 delete jmdconnectorot;
6332 delete jmdconnectortrans[1];
6333 for(Int_t i=0; i<2; i++) delete cableconnectorot[i];
6334 delete cableconnectorcombitrans;
6335 delete electboardbacktrans;
6336 delete electboardbackrot;
6337 delete electlayerrot;
6338 for(Int_t i=0; i<2; i++) delete electlayertrans[i];
6339 for(Int_t i=0; i<2; i++) delete endcapstripconnectionrot[i];
6340 delete mothersupplycardtrans;
6341 for(Int_t i=0; i<7; i++) delete cardinterfacetrans[i];
6342 /////////////////////////////////////////////////////////////
6343 return cardinterfacecontainer;
6344 }
6345 ////////////////////////////////////////////////////////////////////////////////
6346 TGeoVolume** AliITSv11GeometrySSD::GetEndCapAssembly(){
6347 /////////////////////////////////////////////////////////////
6348 // Method returning EndCap Mother Volume
6349 /////////////////////////////////////////////////////////////
6350 const Int_t kendcapcoverplatesmallholenumber = 9;
6351 Double_t endcapmotherorigin[3];
6352 endcapmotherorigin[0] = -fgkEndCapCoverPlateLength[0]
6353 + 0.5 *(fgkEndCapCoverPlateLength[3]
6354 + 2.0 * fgkEndCapCoverPlateLength[2]);
6355 endcapmotherorigin[1] = - 0.5 * (fgkEndCapCoverPlateWidth[0]
6356 - fgkEndCapCoverPlateWidth[2]
6357 - (kendcapcoverplatesmallholenumber-1)
6358 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6359 + 0.5*(fgkEndCapSideCoverLength[2]
6360 + fgkEndCapCoverPlateWidth[1]
6361 - fgkEndCapCoverPlateWidth[0])
6362 - (fgkEndCapCoverPlateWidth[1]
6363 - fgkEndCapCoverPlateWidth[0]);
6364 endcapmotherorigin[2] = 0.5*fgkEndCapCoverPlateThickness
6365 + 2.*fgkEndCapCoolingTubeRadiusMax
6366 - 0.5*(2.*fgkEndCapCoolingTubeRadiusMax
6367 + fgkEndCapSideCoverWidth[1]
6368 + fgkEndCapSideCoverThickness
6369 + fgkEndCapKaptonFoilThickness);
6370 TGeoBBox* endcapmothershape = new TGeoBBox(0.5*(fgkEndCapCoverPlateLength[3]
6371 + 2.0* fgkEndCapCoverPlateLength[2]
6372 + 2.0* fgkEndCapSideCoverThickness),
6373 0.5* (fgkEndCapSideCoverLength[2]
6374 + fgkEndCapCoverPlateWidth[1]
6375 - fgkEndCapCoverPlateWidth[0]),
6376 0.5* (2.*fgkEndCapCoolingTubeRadiusMax
6377 + fgkEndCapSideCoverWidth[1]
6378 + fgkEndCapSideCoverThickness
6379 + fgkEndCapKaptonFoilThickness),
6380 endcapmotherorigin);
6381 TGeoVolume** endcapassembly;
6382 endcapassembly = new TGeoVolume*[4];
6383 endcapassembly[0] = new TGeoVolume("EndCapContainerLayer5Sx",
6384 endcapmothershape,fSSDAir);
6385 endcapassembly[1] = new TGeoVolume("EndCapContainerLayer5Dx",
6386 endcapmothershape,fSSDAir);
6387 endcapassembly[2] = new TGeoVolume("EndCapContainerLayer6Sx",
6388 endcapmothershape,fSSDAir);
6389 endcapassembly[3] = new TGeoVolume("EndCapContainerLayer6Dx",
6390 endcapmothershape,fSSDAir);
6391 /////////////////////////////////
6392 // endcapassembly[0]: Container End Cap Layer 5 Bellegarde Side
6393 // endcapassembly[1]: Container End Cap Layer 5 Gex Side
6394 // endcapassembly[2]: Container End Cap Layer 6 Bellegarde Side
6395 // endcapassembly[3]: Container End Cap Layer 6 Gex Side
6396 /////////////////////////////////
6397 /////////////////////////////////////////////////////
6398 // Placing Endcap Cover Plate
6399 /////////////////////////////////////////////////////
6400 TGeoVolume* endcapcoverplate = GetEndCapCoverPlate();
6401 TGeoRotation* endcapcoverplaterot = new TGeoRotation();
6402 endcapcoverplaterot->SetAngles(90.0,180.0,-90.0);
6403 TGeoCombiTrans* endcapcoverplatecombitrans =
6404 new TGeoCombiTrans(-0.5*fgkEndCapCoverPlateLength[1],0.,0.,
6405 endcapcoverplaterot);
6406 TGeoTranslation* endcapcoverplatetrans =
6407 new TGeoTranslation(1.5*fgkEndCapCoverPlateLength[1],0.,0.);
6408 TGeoHMatrix* endcapcoverplatematrix =
6409 new TGeoHMatrix((*endcapcoverplatetrans)
6410 * (*endcapcoverplatecombitrans));
6411 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoverplate,1,endcapcoverplatematrix);
6412 /////////////////////////////////////////////////////
6413 // Placing Endcap Side Cover
6414 /////////////////////////////////////////////////////
6415 TGeoVolume* endcapsidecover = GetEndCapSideCover();
6416 TGeoRotation* endcapsidecoverot[2];
6417 TGeoCombiTrans* endcapsidecovercombitrans[3];
6418 for(Int_t i=0; i<2; i++) endcapsidecoverot[i] = new TGeoRotation();
6419 endcapsidecoverot[0]->SetAngles(-90.,0.,0.);
6420 endcapsidecovercombitrans[0] = new TGeoCombiTrans(0.0,
6421 - 0.5*(fgkEndCapCoverPlateWidth[0]
6422 - fgkEndCapCoverPlateWidth[2]
6423 - (kendcapcoverplatesmallholenumber-1)
6424 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6425 + 0.*fgkEndCapCoverPlateWidth[0]
6426 + fgkEndCapSideCoverLength[2],
6427 0.5*(fgkEndCapSideCoverThickness
6428 + fgkEndCapCoverPlateThickness)
6429 - 0.5*fgkEndCapCoverPlateThickness,
6430 endcapsidecoverot[0]);
6431 endcapsidecoverot[1]->SetAngles(90.,-90.,-90.);
6432 endcapsidecovercombitrans[1] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0],0.0,
6433 0.5*fgkEndCapCoverPlateThickness
6434 -fgkEndCapSideCoverWidth[1],
6435 endcapsidecoverot[1]);
6436 endcapsidecovercombitrans[2] = new TGeoCombiTrans(-fgkEndCapCoverPlateLength[0]
6437 +fgkEndCapCoverPlateLength[3]
6438 +2.*fgkEndCapCoverPlateLength[2]
6439 +fgkEndCapSideCoverThickness,0.0,
6440 0.5*fgkEndCapCoverPlateThickness
6441 -fgkEndCapSideCoverWidth[1],
6442 endcapsidecoverot[1]);
6443 TGeoHMatrix* endcapsidecovermatrix[2];
6444 for(Int_t i=0; i<2; i++){
6445 endcapsidecovermatrix[i] = new TGeoHMatrix((*endcapsidecovercombitrans[i+1])
6446 * (*endcapsidecovercombitrans[0]));
6447 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapsidecover,i+1,
6448 endcapsidecovermatrix[i]);
6449 }
6450 /////////////////////////////////////////////////////
6451 // Placing Endcap Cooling Tube
6452 /////////////////////////////////////////////////////
6453 TGeoVolume* endcapcoolingtube = GetEndCapCoolingTube();
6454 TGeoRotation* endcapcoolingtuberot = new TGeoRotation();
6455 endcapcoolingtuberot->SetAngles(0.,180.,0.);
6456 TGeoCombiTrans* endcapccolingtubecombitrans
6457 = new TGeoCombiTrans(-0.5*(fgkEndCapCoolingTubeAxialRadius[0]
6458 + fgkEndCapCoolingTubeAxialRadius[1])
6459 + fgkEndCapCoverPlateLength[0]+fgkEndCapCoverPlateLength[1]
6460 - fgkEndCapCoolingTubeToCoverSide,
6461 fgkEndCapCoolingTubeAxialRadius[0],fgkEndCapCoolingTubeRadiusMax
6462 + 0.5*fgkEndCapCoverPlateThickness,endcapcoolingtuberot);
6463 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcoolingtube,1,
6464 endcapccolingtubecombitrans);
6465 /////////////////////////////////////////////////////
6466 // Placing Screws
6467 /////////////////////////////////////////////////////
6468 Double_t screwcoverplateradius[2] = {fgkEndCapCoverPlateScrewRadiusMax,
6469 fgkEndCapCoverPlateScrewRadiusMin};
6470 Int_t screwcoverplatedgesnumber[2] = {20,20};
6471 Double_t screwcoverplatesection[2] = {0.5*fgkEndCapCoverPlateThickness,
6472 fgkEndCapCoverPlateThickness
6473 + fgkEndCapCoolingTubeRadiusMax};
851c0ce3 6474 TGeoShape* screwcoverplateshape = GetScrewShape(screwcoverplateradius,
9b0c60ab 6475 screwcoverplatedgesnumber,
6476 screwcoverplatesection);
6477 TGeoVolume* screwcoverplate = new TGeoVolume("EndCapScrewCoverPlate",
6478 screwcoverplateshape,
6479 fSSDCoolingTubePhynox);
6480 screwcoverplate->SetLineColor(12);
6481 Double_t transx[4] = {0,
6482 fgkEndCapCoverPlateSmallHoleSeparation[0],
6483 fgkEndCapCoverPlateSmallHoleSeparation[0]
6484 + fgkEndCapCoverPlateSmallHoleSeparation[1],
6485 2.*fgkEndCapCoverPlateSmallHoleSeparation[0]
6486 + fgkEndCapCoverPlateSmallHoleSeparation[1]};
6487 const Int_t kendcapcoverplatescrewnumber[2] = {4,9};
6488// TGeoTranslation** endcapcoverplatescrewtrans[kendcapcoverplatescrewnumber[0]];
6489 TGeoTranslation*** endcapcoverplatescrewtrans;
6490 endcapcoverplatescrewtrans = new TGeoTranslation**[kendcapcoverplatescrewnumber[0]];
6491 Int_t index = 0;
6492 for(Int_t i=0; i<kendcapcoverplatescrewnumber[0]; i++){
6493 endcapcoverplatescrewtrans[i] =
6494 new TGeoTranslation*[kendcapcoverplatescrewnumber[1]];
6495 for(Int_t j=0; j<kendcapcoverplatescrewnumber[1]; j++){
6496 index = kendcapcoverplatescrewnumber[1]*i+j+1;
6497 if(index==1||index==9||index==28||index==36){
6498 endcapcoverplatescrewtrans[i][j] =
6499 new TGeoTranslation(transx[i],
6500 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6501 fgkEndCapSideCoverThickness);
6502 }
6503 else{
6504 endcapcoverplatescrewtrans[i][j] =
6505 new TGeoTranslation(transx[i],
6506 j*fgkEndCapCoverPlateSmallHoleSeparation[2],
6507 0.);
6508 }
6509 if(index!=19)
6510 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(screwcoverplate,index,
6511 endcapcoverplatescrewtrans[i][j]);
6512 }
6513 }
6514 /////////////////////////////////////////////////////
6515 // Placing Cover Plate Clips
6516 /////////////////////////////////////////////////////
6517 TGeoBBox* endcapcoverplateclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateClipLength,
6518 0.5*fgkEndCapCoverPlateClipWidth,
6519 0.5*fgkEndCapSideCoverThickness);
6520 TGeoVolume* endcapcoverplateclip = new TGeoVolume("EndCapCoverPlateUpClip",
6521 endcapcoverplateclipshape,
6522 fSSDCoolingTubePhynox);
6523 TGeoBBox* endcapcoverplatedownclipshape = new TGeoBBox(0.5*fgkEndCapCoverPlateDownClipLength,
6524 0.5*fgkEndCapCoverPlateDownClipWidth,
6525 0.5*fgkEndCapSideCoverThickness);
6526 TGeoVolume* endcapcoverplatedownclip = new TGeoVolume("EndCapCoverPlateDownClip",
6527 endcapcoverplatedownclipshape,
6528 fSSDCoolingTubePhynox);
6529 TGeoTranslation* endcapcoverplatecliptrans[4];
6530 endcapcoverplatecliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6531 - fgkEndCapCoverPlateLength[0]
6532 - fgkEndCapSideCoverThickness,
6533 0.0,
6534 0.5*(fgkEndCapSideCoverThickness
6535 + fgkEndCapCoverPlateThickness));
6536 endcapcoverplatecliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6537 - fgkEndCapCoverPlateLength[0]
6538 - fgkEndCapSideCoverThickness,
6539 (kendcapcoverplatescrewnumber[1]-1)
6540 * fgkEndCapSideCoverWidth[5],
6541 0.5*(fgkEndCapSideCoverThickness
6542 + fgkEndCapCoverPlateThickness));
6543 endcapcoverplatecliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6544 - fgkEndCapCoverPlateLength[0]
6545 + fgkEndCapCoverPlateLength[1]
6546 + 2.*fgkEndCapCoverPlateLength[0]
6547 - fgkEndCapCoverPlateClipLength
6548 + fgkEndCapSideCoverThickness,
6549 0.0,
6550 0.5*(fgkEndCapSideCoverThickness
6551 + fgkEndCapCoverPlateThickness));
6552 endcapcoverplatecliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateClipLength
6553 - fgkEndCapCoverPlateLength[0]
6554 + fgkEndCapCoverPlateLength[1]
6555 + 2.*fgkEndCapCoverPlateLength[0]
6556 - fgkEndCapCoverPlateClipLength
6557 + fgkEndCapSideCoverThickness,
6558 (kendcapcoverplatescrewnumber[1]-1)
6559 * fgkEndCapSideCoverWidth[5],
6560 0.5*(fgkEndCapSideCoverThickness
6561 + fgkEndCapCoverPlateThickness));
6562 endcapcoverplateclip->SetLineColor(fColorPhynox);
6563 endcapcoverplatedownclip->SetLineColor(fColorPhynox);
6564 for(Int_t i=0; i<4; i++)
6565 for(Int_t j=0; j<4; j++) endcapassembly[j]->AddNode(endcapcoverplateclip,i+1,
6566 endcapcoverplatecliptrans[i]);
6567 TGeoTranslation* endcapcoverplatedowncliptrans[4];
6568 endcapcoverplatedowncliptrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6569 - fgkEndCapCoverPlateLength[0]
6570 - fgkEndCapSideCoverThickness,
6571 0.5*(fgkEndCapCoverPlateDownClipWidth
6572 - fgkEndCapCoverPlateClipWidth),
6573 0.5*(fgkEndCapSideCoverThickness
6574 + fgkEndCapCoverPlateThickness)
6575 - fgkEndCapSideCoverWidth[1]
6576 - fgkEndCapSideCoverThickness);
6577 endcapcoverplatedowncliptrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6578 - fgkEndCapCoverPlateLength[0]
6579 - fgkEndCapSideCoverThickness,
6580 0.5*(fgkEndCapCoverPlateDownClipWidth
6581 - fgkEndCapCoverPlateClipWidth)
6582 + fgkEndCapSideCoverLength[2]
6583 - fgkEndCapCoverPlateDownClipWidth,
6584 0.5*(fgkEndCapSideCoverThickness
6585 + fgkEndCapCoverPlateThickness)
6586 - fgkEndCapSideCoverWidth[1]
6587 - fgkEndCapSideCoverThickness);
6588 endcapcoverplatedowncliptrans[2] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6589 - fgkEndCapCoverPlateLength[0]
6590 + fgkEndCapSideCoverThickness
6591 + fgkEndCapCoverPlateLength[1]
6592 + 2.0*fgkEndCapCoverPlateLength[0]
6593 - fgkEndCapCoverPlateDownClipLength,
6594 0.5*(fgkEndCapCoverPlateDownClipWidth
6595 - fgkEndCapCoverPlateClipWidth),
6596 0.5*(fgkEndCapSideCoverThickness
6597 + fgkEndCapCoverPlateThickness)
6598 - fgkEndCapSideCoverWidth[1]
6599 - fgkEndCapSideCoverThickness);
6600 endcapcoverplatedowncliptrans[3] = new TGeoTranslation(0.5*fgkEndCapCoverPlateDownClipLength
6601 - fgkEndCapCoverPlateLength[0]
6602 + fgkEndCapSideCoverThickness
6603 + fgkEndCapCoverPlateLength[1]
6604 + 2.0*fgkEndCapCoverPlateLength[0]
6605 - fgkEndCapCoverPlateDownClipLength,
6606 0.5*(fgkEndCapCoverPlateDownClipWidth
6607 - fgkEndCapCoverPlateClipWidth)
6608 + fgkEndCapSideCoverLength[2]
6609 - fgkEndCapCoverPlateDownClipWidth,
6610 0.5*(fgkEndCapSideCoverThickness
6611 + fgkEndCapCoverPlateThickness)
6612 - fgkEndCapSideCoverWidth[1]
6613 - fgkEndCapSideCoverThickness);
6614 for(Int_t i=0; i<4; i++)
6615 for(Int_t k=0; k<4; k++) endcapassembly[k]->AddNode(endcapcoverplatedownclip,i+1,
6616 endcapcoverplatedowncliptrans[i]);
6617 /////////////////////////////////////////////////////
6618 // Placing Kapton Foil
6619 /////////////////////////////////////////////////////
6620 TGeoBBox* endcapkaptonfoilshape = new TGeoBBox(0.5*fgkEndCapKaptonFoilLength,
6621 0.5*fgkEndCapKaptonFoilWidth,
6622 0.5*fgkEndCapKaptonFoilThickness);
6623 TGeoVolume* endcapkaptonfoil = new TGeoVolume("EndCapKaptonFoil",
6624 endcapkaptonfoilshape,
6625 fSSDKaptonFlexMedium);
6626 endcapkaptonfoil->SetLineColor(8);
6627 TGeoTranslation* endcapkaptonfoiltrans = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6628 0.5*fgkEndCapKaptonFoilWidth
6629 - 0.5*fgkEndCapCoverPlateClipWidth,
6630 0.5*fgkEndCapCoverPlateThickness
6631 - 0.5*fgkEndCapKaptonFoilThickness
6632 - fgkEndCapSideCoverWidth[1]
6633 - fgkEndCapSideCoverThickness);
6634 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapkaptonfoil,1,endcapkaptonfoiltrans);
6635 /////////////////////////////////////////////////////////////
6636 // Placing Electronic Tubes
6637 /////////////////////////////////////////////////////////////
6638 Double_t endcapeffectivecableswidth[2] = {fgkEndCapKaptonFoilWidth
6639 - fgkEndCapInterfaceCardBThickness
6640 - 9.*fgkEndCapStripConnectionThickness
6641 - 8.*fgkEndCapCardElectBoardBackThickness,
6642 fgkEndCapKaptonFoilWidth
6643 - fgkEndCapInterfaceCardBThickness
6644 - 9.*fgkEndCapStripConnectionThickness
6645 - 8.*fgkEndCapCardElectBoardBackThickness
6646 - fgkEndCapInterfaceElectBoardCardBThickness};
6647 TGeoVolume* endcapeffectivecables[2];
6648 endcapeffectivecables[0] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6649 fgkEndCapEffectiveCableRadiusMax,
6650 endcapeffectivecableswidth[0],
6651 10,"EndCapEffectiveCables1");
6652 endcapeffectivecables[1] = GetEndCapEffectiveCables(fgkEndCapEffectiveCableRadiusMin,
6653 fgkEndCapEffectiveCableRadiusMax,
6654 endcapeffectivecableswidth[1],
6655 25,"EndCapEffectiveCables2");
6656 TGeoRotation* endcapeffectivecablesrot = new TGeoRotation();
6657 TGeoTranslation* endcapeffectivecablestrans[2];
6658 endcapeffectivecablestrans[0] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6659 - 0.5*endcapeffectivecableswidth[0]
6660 - 0.5*(fgkEndCapCoverPlateWidth[0]
6661 - fgkEndCapCoverPlateWidth[2]
6662 - (kendcapcoverplatesmallholenumber-1)
6663 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6664 + fgkEndCapSideCoverLength[2],
6665 - 0.5*fgkEndCapCoverPlateThickness
6666 - (fgkEndCapCardElectBoardBackWidth[0]
6667 - fgkEndCapInterfaceCardBWidth[0]
6668 - fgkEndCapInterfaceCardBWidth[1]));
6669 endcapeffectivecablestrans[1] = new TGeoTranslation(0.5*fgkEndCapCoverPlateLength[1],
6670 - 0.5*endcapeffectivecableswidth[1]
6671 - 0.5*(fgkEndCapCoverPlateWidth[0]
6672 - fgkEndCapCoverPlateWidth[2]
6673 - (kendcapcoverplatesmallholenumber-1)
6674 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6675 + fgkEndCapSideCoverLength[2],
6676 - 0.5*fgkEndCapCoverPlateThickness
6677 - (fgkEndCapCardElectBoardBackWidth[0]
6678 - fgkEndCapInterfaceCardBWidth[0])
6679 - 0.5*fgkEndCapInterfaceCardBWidth[2]);
6680 endcapeffectivecablesrot->SetAngles(0.,90.,0.);
6681 TGeoCombiTrans* endcapeffectivecablescombitrans[2];
6682 endcapeffectivecablescombitrans[0] = new TGeoCombiTrans(*endcapeffectivecablestrans[0],
6683 *endcapeffectivecablesrot);
6684 endcapeffectivecablescombitrans[1] = new TGeoCombiTrans(*endcapeffectivecablestrans[1],
6685 *endcapeffectivecablesrot);
47f8de53 6686// for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[0],1,
6687// endcapeffectivecablescombitrans[0]);
9b0c60ab 6688 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapeffectivecables[1],1,
6689 endcapeffectivecablescombitrans[1]);
6690 /////////////////////////////////////////////////////////////
6691 // Placing End Cap Cards
6692 /////////////////////////////////////////////////////////////
6693 TGeoVolume** endcapcards = GetEndCapCards();
6694 TGeoRotation* endcapcardsrot[2];
6695 for(Int_t i=0; i<2; i++) endcapcardsrot[i] = new TGeoRotation();
6696 endcapcardsrot[0]->SetAngles(90.,0.,0.);
6697 TGeoTranslation* endcapcardstrans[2];
6698 endcapcardstrans[0] = new TGeoTranslation(0.,0.,0.5*(fgkEndCapInterfaceCardBLength[1]
6699 - fgkEndCapCardElectBoardBackLength[0]));
6700 TGeoCombiTrans* endcapcardscombitrans = new TGeoCombiTrans(*endcapcardstrans[0],*endcapcardsrot[0]);
6701 endcapcardsrot[1]->SetAngles(90.,90.,-90.);
6702 TGeoHMatrix* endcapcardsmatrix[2];
6703 endcapcardsmatrix[0] = new TGeoHMatrix((*endcapcardsrot[1])*(*endcapcardscombitrans));
6704 Double_t stiffenertransx = fgkEndCapKaptonFoilWidth-fgkEndCapStiffenerWidth
6705 - fgkEndCapCardJMDConnectorLength[0]
6706 - fgkEndCapInterfaceCardBThickness
6707 - 9.*fgkEndCapStripConnectionThickness
6708 - 8.*fgkEndCapCardElectBoardBackThickness;
6709 endcapcardstrans[1] = new TGeoTranslation(-0.5*fgkEndCapStiffenerLength
6710 - fgkEndCapCoverPlateLength[0]
6711 + 0.5 * (fgkEndCapCoverPlateLength[3]
6712 + 2.0 * fgkEndCapCoverPlateLength[2]),
6713 - stiffenertransx-fgkEndCapStiffenerWidth
6714 - fgkEndCapCardJMDConnectorLength[0]
6715 - fgkEndCapInterfaceCardBThickness
6716 - 2.0 * fgkEndCapStripConnectionThickness
6717 - 1.5 * fgkEndCapInterfaceCardBThickness
6718 - 0.5 * (fgkEndCapCoverPlateWidth[0]
6719 - fgkEndCapCoverPlateWidth[2]
6720 - (kendcapcoverplatesmallholenumber-1)
6721 * fgkEndCapCoverPlateSmallHoleSeparation[2])
6722 + fgkEndCapKaptonFoilWidth,
6723 0.5*fgkEndCapCoverPlateThickness
6724 - fgkEndCapSideCoverWidth[1]);
6725 endcapcardsmatrix[1] = new TGeoHMatrix((*endcapcardstrans[1])*(*endcapcardsmatrix[0]));
6726 for(Int_t i=0; i<4; i++) endcapassembly[i]->AddNode(endcapcards[i],1,endcapcardsmatrix[1]);
6727 /////////////////////////////////////////////////////////////
6728 // Deallocating memory
6729 /////////////////////////////////////////////////////////////
6730 delete endcapcoverplaterot;
6731 delete endcapcoverplatecombitrans;
6732 delete endcapcoverplatetrans;
6733 for(Int_t i=0; i<3; i++){
6734 delete endcapsidecovercombitrans[i];
6735 if(i<2) delete endcapsidecoverot[i];
6736 }
6737 for(Int_t i=0; i<2; i++) delete endcapcardsrot[i];
6738 for(Int_t i=0; i<2; i++) delete endcapcardstrans[i];
6739 delete endcapcardsmatrix[0];
6740 return endcapassembly;
6741 }
6742 ////////////////////////////////////////////////////////////////////////////////
6743 TGeoVolume* AliITSv11GeometrySSD::GetEndCapEffectiveCables(Double_t radiusmin,
6744 Double_t radiusmax,
6745 Double_t width,
6746 Int_t ncables,
a6e0ebfe 6747 const char* volname){
9b0c60ab 6748 /////////////////////////////////////////////////////////////
6749 // Generating EndCap High Voltage Tubes
6750 /////////////////////////////////////////////////////////////
6751 Double_t effectiveinneradius = TMath::Sqrt(ncables)*radiusmin;
60e55aee 6752 Double_t effectiveouteradius = TMath::Sqrt(effectiveinneradius*effectiveinneradius+(radiusmax-radiusmin)*(radiusmax-radiusmin));
6753
9b0c60ab 6754 TGeoTube* effectiveinnertubeshape = new TGeoTube(0.,effectiveinneradius,0.5*width);
6755 TGeoTube* effectiveoutertubeshape = new TGeoTube(effectiveinneradius,
6756 effectiveouteradius,0.5*width);
6757 TGeoVolume* effectiveinnertube = new TGeoVolume("EffectiveEndCapInnerTube",
6758 effectiveinnertubeshape,
6759 fSSDStiffenerConnectorMedium);
6760 effectiveinnertube->SetLineColor(41);
6761 TGeoVolume* effectiveoutertube = new TGeoVolume("EffectiveEndCapOuterTube",
6762 effectiveoutertubeshape,
6763 fSSDKaptonChipCableMedium);
6764 effectiveoutertube->SetLineColor(39);
6765 TGeoTube* effectivemothertubeshape = new TGeoTube(0.,effectiveouteradius,0.5*width);
6766 TGeoVolume* effectivemothertube = new TGeoVolume(volname,effectivemothertubeshape,fSSDAir);
6767 effectivemothertube->AddNode(effectiveinnertube,1);
6768 effectivemothertube->AddNode(effectiveoutertube,1);
6769 return effectivemothertube;
6770 }
6771 ////////////////////////////////////////////////////////////////////////////////
6772 TGeoVolume** AliITSv11GeometrySSD::EndCapSupport(){
6773 /////////////////////////////////////////////////////////////
6774 // Generating EndCap Support Layer 5 and Layer 6
6775 /////////////////////////////////////////////////////////////
6776 const Int_t knedges = 5;
6777 ///////////////////////////////////////////////
6778 // Setting the vertices for TGeoXtru Up Volume
6779 ///////////////////////////////////////////////
6780 const Int_t klayernumber = 2;
6781 Double_t xupvertex[klayernumber][knedges+3];
6782 Double_t yupvertex[klayernumber][knedges+3];
6783 Double_t upedgeangle[klayernumber] = {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
6784 Double_t middledgeangle[klayernumber] = {0.0,0.0};
6785 Double_t middlepsi[klayernumber] = {0.0,0.0};
6786 for(Int_t i=0; i<klayernumber; i++){
6787 xupvertex[i][0] = -fgkEndCapSupportMiddleRadius[i]*SinD(0.5*upedgeangle[i]);
6788 xupvertex[i][1] = -0.5*fgkEndCapSupportLength[i];
6789 xupvertex[i][2] = -xupvertex[i][1];
6790 xupvertex[i][3] = -xupvertex[i][0];
6791
6792 yupvertex[i][0] = fgkEndCapSupportMiddleRadius[i]*CosD(0.5*upedgeangle[i]);
6793 yupvertex[i][1] = 0.5*fgkEndCapSupportLength[i]/TanD(0.5*upedgeangle[i]);
6794 yupvertex[i][2] = yupvertex[i][1];
6795 yupvertex[i][3] = yupvertex[i][0];
6796
6797 middledgeangle[i] = upedgeangle[i]/knedges;
6798 middlepsi[i] = 90.0-0.5*upedgeangle[i];
6799 for(Int_t j=1; j<knedges; j++){
6800 xupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*CosD(middlepsi[i]+j*middledgeangle[i]);
6801 yupvertex[i][j+3] = fgkEndCapSupportMiddleRadius[i]*SinD(middlepsi[i]+j*middledgeangle[i]);
6802 }
6803 }
6804 ////////////////////////////////////
6805 // Generating Up TGeoXtru
6806 ////////////////////////////////////
6807 TGeoXtru* upendcapsupportshape[klayernumber];
6808 TGeoVolume* upendcapsupport[klayernumber];
a3f8715e 6809 char upendcapsupportname[100];
9b0c60ab 6810 for(Int_t i=0; i<klayernumber; i++){
6811 upendcapsupportshape[i] = new TGeoXtru(2);
6812 sprintf(upendcapsupportname,"UpEndCapSupportPieceLayer%i",i+5);
6813 upendcapsupportshape[i]->DefinePolygon(knedges+3,xupvertex[i],yupvertex[i]);
6814 upendcapsupportshape[i]->DefineSection(0,0.);
6815 upendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6816 upendcapsupport[i] = new TGeoVolume(upendcapsupportname,upendcapsupportshape[i],
e21cdd03 6817 fSSDSupportRingAl);
9b0c60ab 6818 upendcapsupport[i]->SetLineColor(5);
6819 }
6820 ///////////////////////////////////////////////
6821 // Setting the vertices for TGeoXtru Down Volume
6822 ///////////////////////////////////////////////
6823 Double_t xdownvertex[klayernumber][2*(knedges+1)];
6824 Double_t ydownvertex[klayernumber][2*(knedges+1)];
6825 for(Int_t i=0; i<klayernumber; i++){
6826 xdownvertex[i][0] = -fgkEndCapSupportLowRadius[i]*SinD(0.5*upedgeangle[i]);
6827 xdownvertex[i][1] = xupvertex[i][0];
6828 ydownvertex[i][0] = fgkEndCapSupportLowRadius[i]*CosD(0.5*upedgeangle[i]);
6829 ydownvertex[i][1] = yupvertex[i][0];
6830 for(Int_t j=0; j<knedges; j++){
6831 xdownvertex[i][j+2] = xupvertex[i][knedges+2-j];
6832 ydownvertex[i][j+2] = yupvertex[i][knedges+2-j];
6833 }
6834 for(Int_t j=0; j<knedges; j++){
6835 xdownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6836 * CosD(middlepsi[i]+j*middledgeangle[i]);
6837 ydownvertex[i][knedges+j+2] = fgkEndCapSupportLowRadius[i]
6838 * SinD(middlepsi[i]+j*middledgeangle[i]);
6839 }
6840 }
6841 ////////////////////////////////////
6842 // Generating Down TGeoXtru
6843 ////////////////////////////////////
6844 TGeoXtru* downendcapsupportshape[klayernumber];
6845 TGeoVolume* downendcapsupport[klayernumber];
a3f8715e 6846 char downendcapsupportname[100];
9b0c60ab 6847 for(Int_t i=0; i<klayernumber; i++){
6848 downendcapsupportshape[i] = new TGeoXtru(2);
6849 sprintf(downendcapsupportname,"DownEndCapSupportPieceLayer%i",i+5);
6850 downendcapsupportshape[i] = new TGeoXtru(2);
6851 downendcapsupportshape[i]->DefinePolygon(2*(knedges+1),xdownvertex[i],ydownvertex[i]);
6852 if(i==0){
6853 downendcapsupportshape[i]->DefineSection(0,0.);
6854 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportLowWidth[i]);
6855 }
6856 else{
6857 downendcapsupportshape[i]->DefineSection(0,fgkEndCapSupportHighWidth
6858 - fgkEndCapSupportLowWidth[i]);
6859 downendcapsupportshape[i]->DefineSection(1,fgkEndCapSupportHighWidth);
6860 }
6861 downendcapsupport[i] = new TGeoVolume(downendcapsupportname,
e21cdd03 6862 downendcapsupportshape[i],fSSDSupportRingAl);
9b0c60ab 6863 downendcapsupport[i]->SetLineColor(5);
6864 }
6865 ///////////////////////////////////////////////
6866 // Setting TGeoPgon Volume
6867 ///////////////////////////////////////////////
6868 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6869 fgkSSDLay6LadderNumber};
6870 TGeoPgon* endcapsupportmothershape[klayernumber];
6871 TGeoVolume** endcapsupportmother;
6872 endcapsupportmother = new TGeoVolume*[klayernumber];
a3f8715e 6873 char endcapsupportmothername[100];
9b0c60ab 6874 for(Int_t i=0; i<klayernumber; i++){
6875 endcapsupportmothershape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
6876 sprintf(endcapsupportmothername,"EndCapSupportMotherLayer%i",i+5);
6877 endcapsupportmothershape[i]->DefineSection(0,0.,ydownvertex[i][0],yupvertex[i][1]);
6878 endcapsupportmothershape[i]->DefineSection(1,fgkEndCapSupportHighWidth,
6879 ydownvertex[i][0],yupvertex[i][1]);
6880 endcapsupportmother[i] = new TGeoVolume(endcapsupportmothername,endcapsupportmothershape[i],
e21cdd03 6881 fSSDAir);
9b0c60ab 6882 }
6883 ////////////////////////////////////
6884 TGeoRotation** endcapsupportrot[klayernumber];
6885 for(Int_t i=0; i<2; i++){
6886 endcapsupportrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
6887 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6888 endcapsupportrot[i][j] = new TGeoRotation();
6889 endcapsupportrot[i][j]->SetAngles(j*upedgeangle[i],0.,0.);
6890 endcapsupportmother[i]->AddNode(upendcapsupport[i],j+1,endcapsupportrot[i][j]);
6891 endcapsupportmother[i]->AddNode(downendcapsupport[i],j+1,endcapsupportrot[i][j]);
6892 }
6893 }
6894 return endcapsupportmother;
6895 }
6896 ////////////////////////////////////////////////////////////////////////////////
6897 void AliITSv11GeometrySSD::SetEndCapSupportAssembly(){
6898 /////////////////////////////////////////////////////////////
6899 // Setting End Cap Support Layer 5 and 6.
6900 /////////////////////////////////////////////////////////////
6901 const Int_t kendcapcoverplatesmallholenumber = 9;
6902 const Int_t klayernumber = 2;
6903 const Int_t kssdlayladdernumber[klayernumber] = {fgkSSDLay5LadderNumber,
6904 fgkSSDLay6LadderNumber};
6905 Double_t upedgeangle[klayernumber] = {360.0/kssdlayladdernumber[0],
6906 360.0/kssdlayladdernumber[1]};
6907 TGeoVolume** endcapsupport = EndCapSupport();
6908 TGeoVolume** endcapassembly = GetEndCapAssembly();
6909 TGeoPgon* endcapsupportshape[klayernumber];
6910 Double_t* radiusmin[klayernumber];
6911 Double_t* radiusmax[klayernumber];
6912 for(Int_t i=0; i<klayernumber; i++){
6913 endcapsupportshape[i] = (TGeoPgon*)endcapsupport[i]->GetShape();
6914 radiusmin[i] = endcapsupportshape[i]->GetRmin();
6915 radiusmax[i] = endcapsupportshape[i]->GetRmax();
6916 }
6917 TGeoBBox* endcapassemblyshape = (TGeoBBox*)endcapassembly[0]->GetShape();
6918 Double_t endcapassemblycenter[3] = {endcapassemblyshape->GetDX(),
6919 endcapassemblyshape->GetDY(),
6920 endcapassemblyshape->GetDZ()};
6921 ///////////////////////////////////////////////
6922 // Setting TGeoPgon Volume for Mother Container
6923 ///////////////////////////////////////////////
6924 TGeoPgon* endcapsupportsystemshape[klayernumber];
a3f8715e 6925 char endcapsupportsystemothername[100];
9b0c60ab 6926 for(Int_t i=0; i<klayernumber; i++){
6927 endcapsupportsystemshape[i] = new TGeoPgon(0.0,360.0,kssdlayladdernumber[i],2);
6928 sprintf(endcapsupportsystemothername,"EndCapSupportSystemLayer%i",i+5);
6929 endcapsupportsystemshape[i]->DefineSection(0,-(fgkEndCapCoverPlateWidth[1]
6930 - fgkEndCapCoverPlateWidth[0]),*radiusmin[i],
6931 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6932 +2.*endcapassemblycenter[2])
6933 /CosD(0.5*upedgeangle[i]));
6934 endcapsupportsystemshape[i]->DefineSection(1,2.*endcapassemblycenter[1]
6935 -(fgkEndCapCoverPlateWidth[1]
6936 - fgkEndCapCoverPlateWidth[0]),
6937 *radiusmin[i],
6938 (*radiusmax[i]*CosD(0.5*upedgeangle[i])
6939 +2.*endcapassemblycenter[2])
6940 /CosD(0.5*upedgeangle[i]));
6941 }
e5bf64ae 6942 fgkEndCapSupportSystem = new TGeoVolume*[4];
9b0c60ab 6943 fgkEndCapSupportSystem[0] = new TGeoVolume("EndCapSupportSystemLayer5Sx",
6944 endcapsupportsystemshape[0],fSSDAir);
6945 fgkEndCapSupportSystem[1] = new TGeoVolume("EndCapSupportSystemLayer5Dx",
6946 endcapsupportsystemshape[0],fSSDAir);
6947 fgkEndCapSupportSystem[2] = new TGeoVolume("EndCapSupportSystemLayer6Sx",
6948 endcapsupportsystemshape[1],fSSDAir);
6949 fgkEndCapSupportSystem[3] = new TGeoVolume("EndCapSupportSystemLayer6Dx",
6950 endcapsupportsystemshape[1],fSSDAir);
6951 ///////////////////////////////////////////////
6952 TGeoTranslation* endcapassemblytrans[klayernumber];
6953 for(Int_t i=0; i<klayernumber; i++)
6954 endcapassemblytrans[i] = new TGeoTranslation(-fgkEndCapCoverPlateLength[0]
6955 - fgkEndCapSideCoverThickness
6956 + endcapassemblycenter[0],
6957 - 0.5*fgkEndCapCoverPlateThickness
6958 - 2.0*fgkEndCapCoolingTubeRadiusMax
6959 + 2.0*endcapassemblycenter[2]
6960 + 0.5*fgkEndCapSupportLength[i]
6961 / TanD(0.5*upedgeangle[i]),
6962 0.5*(fgkEndCapCoverPlateWidth[0]
6963 - fgkEndCapCoverPlateWidth[2]
6964 - (kendcapcoverplatesmallholenumber-1)
6965 * fgkEndCapCoverPlateSmallHoleSeparation[2]));
6966 TGeoRotation** endcapassemblyrot[klayernumber];
6967 TGeoHMatrix** endcapassemblymatrix[klayernumber];
6968 for(Int_t i=0; i<klayernumber; i++){
6969 endcapassemblyrot[i] = new TGeoRotation*[kssdlayladdernumber[i]+2];
6970 endcapassemblymatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]+2];
6971 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++) endcapassemblyrot[i][j] = new TGeoRotation();
6972 endcapassemblyrot[i][0]->SetAngles(0.,-90.,0.);
6973 endcapassemblyrot[i][1]->SetAngles(90.,180.,-90.);
6974 endcapassemblymatrix[i][0] = new TGeoHMatrix((*endcapassemblyrot[i][1])*(*endcapassemblyrot[i][0]));
6975 endcapassemblymatrix[i][1] = new TGeoHMatrix((*endcapassemblytrans[i])*(*endcapassemblymatrix[i][0]));
6976 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
6977 endcapassemblyrot[i][j+2]->SetAngles(j*upedgeangle[i],0.,0.);
6978 endcapassemblymatrix[i][j+2] = new TGeoHMatrix((*endcapassemblyrot[i][j+2])*(*endcapassemblymatrix[i][1]));
6979 }
6980 }
6981 TGeoTranslation* lay6endcapassemblytrans = new TGeoTranslation(0.,0.,
6982 fgkEndCapKaptonFoilWidth-fgkEndCapSupportHighWidth);
6983 for(Int_t i=0; i<2*klayernumber; i++){
6984 for(Int_t j=0; j<(i<2? kssdlayladdernumber[0]:kssdlayladdernumber[1]); j++){
6985 fgkEndCapSupportSystem[i]->AddNode(endcapassembly[i],j+1,i<2?endcapassemblymatrix[0][j+2]:
6986 endcapassemblymatrix[1][j+2]);
6987 }
6988 fgkEndCapSupportSystem[i]->AddNode(i<2?endcapsupport[0]:endcapsupport[1],1,i<2?0:lay6endcapassemblytrans);
6989 }
6990 /////////////////////////////////////////////////////////////
6991 // Deallocating memory
6992 /////////////////////////////////////////////////////////////
6993 for(Int_t i=0; i<klayernumber; i++){
6994 for(Int_t j=0; j<kssdlayladdernumber[i]+2; j++){
6995 delete endcapassemblyrot[i][j];
6996 }
7b208ef4 6997 delete [] endcapassemblyrot[i];
9b0c60ab 6998 delete endcapassemblymatrix[i][0];
6999 delete endcapassemblymatrix[i][1];
7000 }
7001 /////////////////////////////////////////////////////////////
7002 }
7003 void AliITSv11GeometrySSD::EndCapSupportSystemLayer5(TGeoVolume* moth){
7004 /////////////////////////////////////////////////////////////
7005 // Setting End Cap Support + End Cap Assembly of Layer 5.
7006 /////////////////////////////////////////////////////////////
7007 if (! moth) {
160835d5 7008 AliError("Can't insert end cap support of layer5, mother is null!\n");
9b0c60ab 7009 return;
7010 };
e5bf64ae 7011 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7012 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7013 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7014 fgkEndCapSupportCenterLay5ITSPosition
7015 + fgkEndCapSupportCenterLay5Position
7016 - fgkEndCapSideCoverLength[2]);
7017 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7018 fgkEndCapSideCoverLength[2]
7019 - fgkEndCapSupportCenterLay5Position
7020 - fgkEndCapSupportCenterLay5ITSPosition);
7021 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7022 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7023 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7024 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7025 moth->AddNode(fgkEndCapSupportSystem[0],1,endcapsupportsystemITSCentertrans[0]);
7026 moth->AddNode(fgkEndCapSupportSystem[1],1,endcapsupportsystemITSCentercombitrans);
7027 /////////////////////////////////////////////////////////////
7028 // Deallocating memory
7029 /////////////////////////////////////////////////////////////
7030 delete endcapsupportsystemrot;
7031 delete endcapsupportsystemITSCentertrans[1];
7032 }
7033 /////////////////////////////////////////////////////////////
7034 void AliITSv11GeometrySSD::EndCapSupportSystemLayer6(TGeoVolume* moth){
7035 /////////////////////////////////////////////////////////////
7036 // Setting End Cap Support + End Cap Assembly of Layer 6.
7037 /////////////////////////////////////////////////////////////
7038 if (! moth) {
160835d5 7039 AliError("Can't insert end cap support of layer6, mother is null!\n");
9b0c60ab 7040 return;
7041 };
e5bf64ae 7042 if(!fgkEndCapSupportSystem) SetEndCapSupportAssembly();
9b0c60ab 7043 TGeoTranslation* endcapsupportsystemITSCentertrans[2];
7044 endcapsupportsystemITSCentertrans[0] = new TGeoTranslation(0.,0.,
7045 fgkEndCapSupportCenterLay6ITSPosition
7046 + fgkEndCapSupportCenterLay6Position
7047 - fgkEndCapSideCoverLength[2]);
7048 endcapsupportsystemITSCentertrans[1] = new TGeoTranslation(0.,0.,
7049 fgkEndCapSideCoverLength[2]
7050 - fgkEndCapSupportCenterLay6Position
7051 - fgkEndCapSupportCenterLay6ITSPosition);
7052 TGeoRotation* endcapsupportsystemrot = new TGeoRotation();
7053 endcapsupportsystemrot->SetAngles(90.,180.,-90.);
7054 TGeoCombiTrans* endcapsupportsystemITSCentercombitrans =
7055 new TGeoCombiTrans(*endcapsupportsystemITSCentertrans[1],*endcapsupportsystemrot);
7056 moth->AddNode(fgkEndCapSupportSystem[2],1,endcapsupportsystemITSCentertrans[0]);
7057 moth->AddNode(fgkEndCapSupportSystem[3],1,endcapsupportsystemITSCentercombitrans);
7058 /////////////////////////////////////////////////////////////
7059 // Deallocating memory
7060 /////////////////////////////////////////////////////////////
7061 delete endcapsupportsystemrot;
7062 delete endcapsupportsystemITSCentertrans[1];
7063 }
7064 ////////////////////////////////////////////////////////////////////////////////
7065 void AliITSv11GeometrySSD::LadderSupportLayer5(TGeoVolume* moth){
7066 /////////////////////////////////////////////////////////////
7067 // Setting Ladder Support of Layer 5.
7068 /////////////////////////////////////////////////////////////
7069 if (! moth) {
160835d5 7070 AliError("Can't insert ladder lupport of layer5, mother is null!\n");
9b0c60ab 7071 return;
7072 };
7073 if(!fLay5LadderSupportRing) SetLadderSupport(100);
7074 fMotherVol = moth;
7075 TGeoTranslation* centerITSRingSupportLay5trans[2];
7076 for(Int_t i=0; i<2; i++){
7077 centerITSRingSupportLay5trans[i] =
7078 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay5Position);
7079 moth->AddNode(fLay5LadderSupportRing,i+1,centerITSRingSupportLay5trans[i]);
7080 }
7081 }
7082 ////////////////////////////////////////////////////////////////////////////////
7083 void AliITSv11GeometrySSD::LadderSupportLayer6(TGeoVolume* moth){
7084 /////////////////////////////////////////////////////////////
7085 // Setting Ladder Support of Layer 6.
7086 /////////////////////////////////////////////////////////////
7087 if (! moth) {
160835d5 7088 AliError("Can't insert ladder lupport of layer6, mother is null!\n");
9b0c60ab 7089 return;
7090 };
7091 if(!fLay6LadderSupportRing) SetLadderSupport(100);
7092 fMotherVol = moth;
7093 TGeoTranslation* centerITSRingSupportLay6trans[2];
7094 for(Int_t i=0; i<2; i++){
7095 centerITSRingSupportLay6trans[i] =
7096 new TGeoTranslation(0.,0.,TMath::Power(-1.,i)*fgkLadderSupportRingLay6Position);
7097 moth->AddNode(fLay6LadderSupportRing,i+1,centerITSRingSupportLay6trans[i]);
7098 }
7099 }
7100 ////////////////////////////////////////////////////////////////////////////////
47f8de53 7101 void AliITSv11GeometrySSD::SSDCone(TGeoVolume* moth){
7102 /////////////////////////////////////////////////////////////
7103 // Setting Ladder Support of Layer 6.
7104 /////////////////////////////////////////////////////////////
7105 if (! moth) {
160835d5 7106 AliError("Can't insert SSD Cone, mother is null!\n");
47f8de53 7107 return;
7108 };
7109 if(!fSSDCone) SetSSDCone();
7110 TGeoTranslation* ssdconetrans = new TGeoTranslation(0.,0.,0.5*fgkSSDCentralSupportLength
7111 + fgkSSDCentralAL3SupportLength);
7112 moth->AddNode(fSSDCone,1,ssdconetrans);
7113}
7114 ////////////////////////////////////////////////////////////////////////////////
7115 void AliITSv11GeometrySSD::SetSSDCone(){
7116 /////////////////////////////////////////////////////////////
7117 // Method generating SSDCone
7118 /////////////////////////////////////////////////////////////
7119 if(!fCreateMaterials) CreateMaterials();
7120 fSSDCone = new TGeoVolumeAssembly("ITSssdCone");
7121 Double_t ssdpconesectionradiusmax[16];
7122 Double_t ssdpconesectionradiusmin[16];
7123 Double_t ssdpconezsection[16];
7124 TGeoPcon* ssdpconelittleholeshape[8];
7125 TGeoVolume* ssdpconelittlehole[8];
7126 ssdpconezsection[0] = (fgkSSDPConeZLength[0]-fgkSSDPConeZLength[1]);
7127 ssdpconesectionradiusmin[0] = fgkSSDLowerPConeRadius;
7128 ssdpconesectionradiusmax[0] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7129 / SinD(fgkSSDPConeAngle)
7130 + ssdpconesectionradiusmin[0];
7131 ssdpconesectionradiusmin[1] = fgkSSDPConeLittleHoleRadius
7132 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7133 / SinD(fgkSSDPConeAngle);
7134 ssdpconesectionradiusmax[1] = fgkSSDPConeLittleHoleRadius;
7135 ssdpconezsection[1] = (ssdpconesectionradiusmin[1]-ssdpconesectionradiusmin[0])
7136 * TanD(fgkSSDPConeAngle)+ssdpconezsection[0];
7137 ssdpconelittleholeshape[0] = new TGeoPcon(0.,360.,2);
7138 for(Int_t i=0; i<2;i++) ssdpconelittleholeshape[0]->DefineSection(i,ssdpconezsection[i],
7139 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7140 ssdpconelittlehole[0] = new TGeoVolume("SSDConeLittleHole1",ssdpconelittleholeshape[0],fSSDCarbonFiberMedium);
7141 ssdpconelittlehole[0]->SetLineColor(4);
7142 /////////////////////////////////////////////////////////////
7143 ssdpconezsection[2] = ssdpconezsection[1];
7144 ssdpconesectionradiusmin[2] = ssdpconesectionradiusmin[1];
7145 ssdpconesectionradiusmax[2] = ssdpconesectionradiusmax[1];
7146 ssdpconesectionradiusmin[3] = fgkSSDPConeLittleHoleRadius+fgkSSDPConeLittleHoleLength
7147 - ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7148 / SinD(fgkSSDPConeAngle);
7149 ssdpconesectionradiusmax[3] = ssdpconezsection[0]*CosD(fgkSSDPConeAngle)
7150 / SinD(fgkSSDPConeAngle)+ssdpconesectionradiusmin[3];
7151 ssdpconezsection[3] = (ssdpconesectionradiusmin[3]-ssdpconesectionradiusmin[2])
7152 * TanD(fgkSSDPConeAngle)+ssdpconezsection[2];
7153 Double_t ssdpconelittleholeangle = fgkSSDPConeLittleHoleLength/fgkSSDPConeLittleHoleRadius
7154 * TMath::RadToDeg();
7155 ssdpconelittleholeshape[1] = new TGeoPcon(30.+0.5*ssdpconelittleholeangle,
7156 60.-ssdpconelittleholeangle,2);
7157 for(Int_t i=2;i<4;i++) ssdpconelittleholeshape[1]->DefineSection(i-2,ssdpconezsection[i],
7158 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7159 ssdpconelittlehole[1] = new TGeoVolume("SSDConeLittleHole2",ssdpconelittleholeshape[1],fSSDCarbonFiberMedium);
7160 ssdpconelittlehole[1]->SetLineColor(4);
7161 TGeoRotation* ssdconelittleholerot[6];
7162 for(Int_t i=0; i<6; i++){
7163 ssdconelittleholerot[i] = new TGeoRotation();
7164 ssdconelittleholerot[i]->SetAngles(i*60,0.,0.);
7165 }
7166 /////////////////////////////////////////////////////////////
7167 ssdpconezsection[4] = ssdpconezsection[3];
7168 ssdpconesectionradiusmin[4] = ssdpconesectionradiusmin[3];
7169 ssdpconesectionradiusmax[4] = ssdpconesectionradiusmax[3];
7170 ssdpconesectionradiusmin[5] = fgkSSDConeMiddleRadius-ssdpconezsection[0]
7171 * CosD(fgkSSDPConeAngle)
7172 / SinD(fgkSSDPConeAngle);
7173 ssdpconesectionradiusmax[5] = fgkSSDConeMiddleRadius;
7174 ssdpconezsection[5] = (ssdpconesectionradiusmin[5]-ssdpconesectionradiusmin[4])
7175 * TanD(fgkSSDPConeAngle)+ssdpconezsection[4];
7176 ssdpconelittleholeshape[2] = new TGeoPcon(0.,360.,2);
7177 for(Int_t i=4; i<6;i++) ssdpconelittleholeshape[2]->DefineSection(i-4,ssdpconezsection[i],
7178 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7179 ssdpconelittlehole[2] = new TGeoVolume("SSDConeLittleHole3",ssdpconelittleholeshape[2],fSSDCarbonFiberMedium);
7180 ssdpconelittlehole[2]->SetLineColor(4);
7181 ///////////////////////////////////////////////////
7182 ssdpconezsection[6] = ssdpconezsection[5];
7183 ssdpconesectionradiusmin[6] = ssdpconesectionradiusmin[5];
7184 ssdpconesectionradiusmax[6] = ssdpconesectionradiusmax[5];
7185 ssdpconesectionradiusmin[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength
7186 -ssdpconezsection[0]
7187 * CosD(fgkSSDPConeAngle)
7188 / SinD(fgkSSDPConeAngle);
7189 ssdpconesectionradiusmax[7] = fgkSSDConeMiddleRadius+fgkSSDPConeMiddleLength;
7190 ssdpconezsection[7] = (ssdpconesectionradiusmin[7]-ssdpconesectionradiusmin[6])
7191 * TanD(fgkSSDPConeAngle)+ssdpconezsection[6];
7192 Double_t ssdpconemiddleholeangle = fgkSSDPConeMiddleWidth/fgkSSDConeMiddleRadius
7193 * TMath::RadToDeg();
7194 ssdpconelittleholeshape[3] = new TGeoPcon(22.5+0.5*ssdpconemiddleholeangle,
7195 45.-ssdpconemiddleholeangle,2);
7196 for(Int_t i=6;i<8;i++) ssdpconelittleholeshape[3]->DefineSection(i-6,ssdpconezsection[i],
7197 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7198 ssdpconelittlehole[3] = new TGeoVolume("SSDConeLittleHole4",ssdpconelittleholeshape[3],fSSDCarbonFiberMedium);
7199 ssdpconelittlehole[3]->SetLineColor(4);
7200 TGeoRotation* ssdconemiddleholerot[8];
7201 for(Int_t i=0; i<8; i++){
7202 ssdconemiddleholerot[i] = new TGeoRotation();
7203 ssdconemiddleholerot[i]->SetAngles(i*45,0.,0.);
7204 }
7205 /////////////////////////////////////////////////////////////
7206 ssdpconezsection[8] = ssdpconezsection[7];
7207 ssdpconesectionradiusmin[8] = ssdpconesectionradiusmin[7];
7208 ssdpconesectionradiusmax[8] = ssdpconesectionradiusmax[7];
7209 ssdpconesectionradiusmin[9] = fgkSSDPConeUpRadius-ssdpconezsection[0]
7210 * CosD(fgkSSDPConeAngle)
7211 / SinD(fgkSSDPConeAngle);
7212 ssdpconesectionradiusmax[9] = fgkSSDPConeUpRadius;
7213 ssdpconezsection[9] = (ssdpconesectionradiusmin[9]-ssdpconesectionradiusmin[8])
7214 * TanD(fgkSSDPConeAngle)+ssdpconezsection[8];
7215 ssdpconelittleholeshape[4] = new TGeoPcon(0.,360.,2);
7216 for(Int_t i=8; i<10;i++) ssdpconelittleholeshape[4]->DefineSection(i-8,ssdpconezsection[i],
7217 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7218 ssdpconelittlehole[4] = new TGeoVolume("SSDConeLittleHole5",ssdpconelittleholeshape[4],fSSDCarbonFiberMedium);
7219 ssdpconelittlehole[4]->SetLineColor(4);
7220 /////////////////////////////////////////////////////////////
7221 Double_t ssdconetrapezoidheight = fgkSSDPConeUpMaxRadius-fgkSSDPConeUpRadius;
7222 Double_t ssdconetrapezoidbasis = fgkSSDPConeTrapezoidBasis-2.0
7223 * (0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)
7224 - 0.5*ssdconetrapezoidheight/(fgkSSDPConeUpMaxRadius
7225 - 0.5*ssdconetrapezoidheight)*(0.5*fgkSSDPConeTrapezoidBasis
7226 - 0.5*ssdconetrapezoidheight/TanD(fgkSSDPConeTrapezoidAngle)));
7227 Double_t ssdconetrapezoidsection = (2.0*TMath::Pi()*fgkSSDPConeUpMaxRadius-8.0*ssdconetrapezoidbasis)/8.;
7228 Double_t ssdpconetrapezoidsectionangle = ssdconetrapezoidsection/fgkSSDPConeUpMaxRadius
7229 * TMath::RadToDeg();
7230 ssdpconezsection[10] = ssdpconezsection[9];
7231 ssdpconesectionradiusmin[10] = ssdpconesectionradiusmin[9];
7232 ssdpconesectionradiusmax[10] = ssdpconesectionradiusmax[9];
7233 ssdpconesectionradiusmin[11] = fgkSSDPConeUpMaxRadius-ssdpconezsection[0]
7234 * CosD(fgkSSDPConeAngle)
7235 / SinD(fgkSSDPConeAngle);
7236 ssdpconesectionradiusmax[11] = fgkSSDPConeUpMaxRadius;
7237 ssdpconezsection[11] = (ssdpconesectionradiusmin[11]-ssdpconesectionradiusmin[10])
7238 * TanD(fgkSSDPConeAngle)+ssdpconezsection[10];
7239 ssdpconelittleholeshape[5] = new TGeoPcon(90.-0.5*ssdpconetrapezoidsectionangle,
7240 ssdpconetrapezoidsectionangle,2);
7241 for(Int_t i=10;i<12;i++) ssdpconelittleholeshape[5]->DefineSection(i-10,ssdpconezsection[i],
7242 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7243 ssdpconelittlehole[5] = new TGeoVolume("SSDConeLittleHole6",ssdpconelittleholeshape[5],fSSDCarbonFiberMedium);
7244 ssdpconelittlehole[5]->SetLineColor(4);
7245 TGeoRotation* ssdconeupradiusrot[8];
7246 for(Int_t i=0; i<8; i++){
7247 ssdconeupradiusrot[i] = new TGeoRotation();
7248 ssdconeupradiusrot[i]->SetAngles(i*45,0.,0.);
7249 }
7250 /////////////////////////////////////////////////////////////
7251 ssdpconezsection[12] = ssdpconezsection[11];
7252 ssdpconezsection[13] = ssdpconezsection[12]+fgkSSDPConeRadiusWidth;
7253 ssdpconesectionradiusmin[12] = ssdpconesectionradiusmin[11];
7254 ssdpconesectionradiusmax[12] = fgkSSDPConeExternalRadius;
7255 ssdpconesectionradiusmin[13] = ssdpconesectionradiusmin[12];
7256 ssdpconesectionradiusmax[13] = fgkSSDPConeExternalRadius;
7257 ssdpconelittleholeshape[6] = new TGeoPcon(0.,360.,2);
7258 for(Int_t i=12; i<14;i++) ssdpconelittleholeshape[6]->DefineSection(i-12,ssdpconezsection[i],
7259 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7260 ssdpconelittlehole[6] = new TGeoVolume("SSDConeLittleHole7",ssdpconelittleholeshape[6],fSSDCarbonFiberMedium);
7261 ssdpconelittlehole[6]->SetLineColor(4);
7262 /////////////////////////////////////////////////////////////
7263 ssdpconezsection[14] = 0.0;
7264 ssdpconezsection[15] = ssdpconezsection[0];
7265 ssdpconesectionradiusmin[14] = ssdpconesectionradiusmin[0];
7266 ssdpconesectionradiusmax[14] = ssdpconesectionradiusmin[14];
7267 ssdpconesectionradiusmin[15] = ssdpconesectionradiusmin[0];
7268 ssdpconesectionradiusmax[15] = ssdpconesectionradiusmax[0];
7269 ssdpconelittleholeshape[7] = new TGeoPcon(0.,360.,2);
7270 for(Int_t i=14; i<16;i++) ssdpconelittleholeshape[7]->DefineSection(i-14,ssdpconezsection[i],
7271 ssdpconesectionradiusmin[i],ssdpconesectionradiusmax[i]);
7272 ssdpconelittlehole[7] = new TGeoVolume("SSDConeLittleHole8",ssdpconelittleholeshape[7],fSSDCarbonFiberMedium);
7273 ssdpconelittlehole[7]->SetLineColor(4);
7274 /////////////////////////////////////////////////////////////
7275 TGeoTube* ssdtubeconeshape[2];
7276 TGeoVolume* ssdtubecone[2];
7277 TGeoTranslation* ssdtubeconetrans[2];
7278 ssdtubeconeshape[0] = new TGeoTube(fgkSSDPConeUpMiddleRadius,
7279 fgkSSDPConeExternalRadius,
7280 0.5*(fgkSSDPConeLength-ssdpconezsection[13]));
7281 ssdtubeconeshape[1] = new TGeoTube(fgkSSDPConeDownRadius,ssdpconesectionradiusmin[0],
7282 0.5*ssdpconezsection[0]);
7283 ssdtubecone[0] = new TGeoVolume("SSDConeTube1",ssdtubeconeshape[0],fSSDSupportRingAl);
7284 ssdtubecone[1] = new TGeoVolume("SSDConeTube2",ssdtubeconeshape[1],fSSDSupportRingAl);
7285 ssdtubeconetrans[0] = new TGeoTranslation(0.,0.,
7286 0.5*(fgkSSDPConeLength-ssdpconezsection[13])
7287 + ssdpconezsection[13]);
7288 ssdtubeconetrans[1] = new TGeoTranslation(0.,0.,0.5*ssdpconezsection[0]);
7289 ssdtubecone[0]->SetLineColor(4);
7290 ssdtubecone[1]->SetLineColor(4);
7291 /////////////////////////////////////////////////////////////
7292 // Mother Volume Container
7293 /////////////////////////////////////////////////////////////
7294 Double_t ssdconemotherradiusmin[8];
7295 Double_t ssdconemotherradiusmax[8];
7296 Double_t ssdconemothersection[8];
7297 ssdconemotherradiusmin[0] = fgkSSDPConeDownRadius;
7298 ssdconemotherradiusmax[0] = ssdpconesectionradiusmin[0];
7299 ssdconemotherradiusmin[1] = fgkSSDPConeDownRadius;
7300 ssdconemotherradiusmax[1] = ssdpconesectionradiusmax[0];
7301 ssdconemotherradiusmin[2] = ssdpconesectionradiusmin[0];
7302 ssdconemotherradiusmax[2] = ssdpconesectionradiusmax[0];
7303 ssdconemotherradiusmin[3] = ssdpconesectionradiusmin[11];
7304 ssdconemotherradiusmax[3] = ssdpconesectionradiusmax[11];
7305 ssdconemotherradiusmin[4] = ssdpconesectionradiusmin[12];
7306 ssdconemotherradiusmax[4] = ssdpconesectionradiusmax[12];
7307 ssdconemotherradiusmin[5] = ssdpconesectionradiusmin[13];
7308 ssdconemotherradiusmax[5] = ssdpconesectionradiusmax[13];
7309 ssdconemotherradiusmin[6] = fgkSSDPConeUpMiddleRadius;
7310 ssdconemotherradiusmax[6] = fgkSSDPConeExternalRadius;
7311 ssdconemotherradiusmin[7] = fgkSSDPConeUpMiddleRadius;
7312 ssdconemotherradiusmax[7] = fgkSSDPConeExternalRadius;
7313 ssdconemothersection[0] = 0.0;
7314 ssdconemothersection[1] = ssdpconezsection[0];
7315 ssdconemothersection[2] = ssdpconezsection[0];
7316 ssdconemothersection[3] = ssdpconezsection[11];
7317 ssdconemothersection[4] = ssdpconezsection[11];
7318 ssdconemothersection[5] = ssdpconezsection[13];
7319 ssdconemothersection[6] = ssdpconezsection[13];
7320 ssdconemothersection[7] = fgkSSDPConeLength;
7321 TGeoPcon* ssdconemothershape = new TGeoPcon(0.,360,8);
7322 for(Int_t i=0; i<8; i++) ssdconemothershape->DefineSection(i,ssdconemothersection[i],
7323 ssdconemotherradiusmin[i],ssdconemotherradiusmax[i]);
7324 TGeoVolume* ssdconemother = new TGeoVolume("SSDMotherCone",ssdconemothershape,fSSDAir);
7325 /////////////////////////////////////////////////////////////
7326 //Placing the Volumes into Mother
7327 /////////////////////////////////////////////////////////////
7328 ssdconemother->AddNode(ssdpconelittlehole[0],1);
7329 for(Int_t i=0; i<6; i++){
7330 ssdconemother->AddNode(ssdpconelittlehole[1],i+1,ssdconelittleholerot[i]);
7331 }
7332 ssdconemother->AddNode(ssdpconelittlehole[2],1);
7333 for(Int_t i=0; i<8; i++){
7334 ssdconemother->AddNode(ssdpconelittlehole[3],i+1,ssdconemiddleholerot[i]);
7335 }
7336 ssdconemother->AddNode(ssdpconelittlehole[4],1);
7337 for(Int_t i=0; i<8; i++){
7338 ssdconemother->AddNode(ssdpconelittlehole[5],i+1,ssdconeupradiusrot[i]);
7339 }
7340 ssdconemother->AddNode(ssdpconelittlehole[6],1);
7341 ssdconemother->AddNode(ssdpconelittlehole[7],1);
7342 ssdconemother->AddNode(ssdtubecone[0],1,ssdtubeconetrans[0]);
7343 ssdconemother->AddNode(ssdtubecone[1],1,ssdtubeconetrans[1]);
7344 /////////////////////////////////////////////////////////////
7345 // ITS General Support
7346 /////////////////////////////////////////////////////////////
7347 TGeoTube* ssdcentralsupportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7348 fgkSSDCentralSupportRadius,0.5*fgkSSDCentralSupportLength);
7349 TGeoVolume* ssdcentralsupport = new TGeoVolume("SSDCentralSupport",ssdcentralsupportshape,fSSDRohaCellCone);
7350 TGeoTranslation* ssdcentralsupportrans = new TGeoTranslation(0.,0.,-0.5*fgkSSDCentralSupportLength
7351 - fgkSSDCentralAL3SupportLength);
7352 ssdcentralsupport->SetLineColor(4);
7353 fSSDCone->AddNode(ssdcentralsupport,1,ssdcentralsupportrans);
7354 TGeoTube* ssdcentralal3supportshape = new TGeoTube(fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth,
7355 fgkSSDCentralSupportRadius,0.25*fgkSSDCentralAL3SupportLength);
7356 TGeoVolume* ssdcentralal3support = new TGeoVolume("SSDCentralAl3Support",ssdcentralal3supportshape,fSSDSupportRingAl);
7357 TGeoTranslation* ssdcentralal3supportrans[3];
7358 ssdcentralal3supportrans[0] = new TGeoTranslation(0.,0.,-0.75*fgkSSDCentralAL3SupportLength);
7359 ssdcentralal3supportrans[1] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7360 - 1.25*fgkSSDCentralAL3SupportLength);
7361 ssdcentralal3support->SetLineColor(4);
7362 fSSDCone->AddNode(ssdcentralal3support,1,ssdcentralal3supportrans[0]);
7363 fSSDCone->AddNode(ssdcentralal3support,2,ssdcentralal3supportrans[1]);
7364 TGeoPcon* ssdpconcentralal3shape = new TGeoPcon(0.,360.,2);
7365 Double_t ssdpconcentralradiusmin[2];
7366 Double_t ssdpconcentralradiusmax[2];
7367 Double_t ssdpconcentralsection[2];
7368 ssdpconcentralradiusmin[0] = fgkSSDCentralSupportRadius-fgkSSDCentralSupportWidth;
7369 ssdpconcentralradiusmin[1] = fgkSSDCentralSupportRadius-fgkSSDCentralAL3SupportWidth;
7370 ssdpconcentralradiusmax[0] = fgkSSDCentralSupportRadius;
7371 ssdpconcentralradiusmax[1] = fgkSSDCentralSupportRadius;
7372 ssdpconcentralsection[0] = -0.5*fgkSSDCentralAL3SupportLength;
7373 ssdpconcentralsection[1] = 0.;
7374 for(Int_t i=0; i<2;i++) ssdpconcentralal3shape->DefineSection(i,ssdpconcentralsection[i],
7375 ssdpconcentralradiusmin[i],ssdpconcentralradiusmax[i]);
7376 TGeoVolume* ssdpconcentralal3 = new TGeoVolume("SSDPConeCentralAl3",ssdpconcentralal3shape,fSSDSupportRingAl);
7377 ssdpconcentralal3->SetLineColor(4);
7378 fSSDCone->AddNode(ssdpconcentralal3,1);
7379 TGeoRotation* ssdcentralal3supportrot = new TGeoRotation();
7380 ssdcentralal3supportrot->SetAngles(90.,180,-90.);
7381 ssdcentralal3supportrans[2] = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7382 -2.*fgkSSDCentralAL3SupportLength);
7383 TGeoCombiTrans* ssdcentralal3supporcombitrans = new TGeoCombiTrans(*ssdcentralal3supportrans[2],
7384 *ssdcentralal3supportrot);
7385 fSSDCone->AddNode(ssdpconcentralal3,2,ssdcentralal3supporcombitrans);
7386 TGeoRotation* ssdconemotherot = new TGeoRotation();
7387 ssdconemotherot->SetAngles(90.,180.,-90.);
7388 TGeoTranslation* ssdconemothertrans = new TGeoTranslation(0.,0.,-fgkSSDCentralSupportLength
7389 -2.*fgkSSDCentralAL3SupportLength);
7390 TGeoCombiTrans* ssdconemothercombitrans = new TGeoCombiTrans(*ssdconemothertrans,*ssdconemotherot);
7391 fSSDCone->AddNode(ssdconemother,1);
7392 fSSDCone->AddNode(ssdconemother,2,ssdconemothercombitrans);
7393 /////////////////////////////////////////////////////////////
7394 // Deallocating memory
7395 /////////////////////////////////////////////////////////////
7396 delete ssdcentralal3supportrot;
7397 delete ssdcentralal3supportrans[2];
7398 delete ssdconemotherot;
7399 delete ssdconemothertrans;
7400 /////////////////////////////////////////////////////////////
7401 }
fcfbdd23 7402 ////////////////////////////////////////////////////////////////////////////////
7403 void AliITSv11GeometrySSD::SSDCables(TGeoVolume* moth){
7404 /////////////////////////////////////////////////////////////
7405 // Setting SSD Cables
7406 /////////////////////////////////////////////////////////////
7407 if (! moth) {
160835d5 7408 AliError("Can't insert SSD Cables, mother is null!\n");
fcfbdd23 7409 return;
7410 };
7411 TGeoVolume* ssdcables = SetSSDCables();
7412 moth->AddNode(ssdcables,1);
7413}
47f8de53 7414 ////////////////////////////////////////////////////////////////////////////////
7415 TGeoVolume* AliITSv11GeometrySSD::SetSSDCables(){
7416 /////////////////////////////////////////////////////////////
7417 // Method generating SSDCables
7418 /////////////////////////////////////////////////////////////
7419 // SSD Layer 5 Cables
7420 //////////////////////////////////////////////////////////////////////////////////////////////////
7421 TGeoVolumeAssembly* ssdcablesmother = new TGeoVolumeAssembly("SSDCables");
7422 Double_t ssdcablelayvertical = 0.05; // Internal variables to control overlapping with SDD cables
fcfbdd23 7423 Double_t ssdcablelaylateral = 0.55; // Internal variables to control overlapping with SDD cables
47f8de53 7424 Double_t ssdcablesfactor = 0.5; // Internal variables to control overlapping with SDD cables
7425 //////////////////////////////////////////////////////////////////////////////////////////////////
7426 Double_t ssdcableslay5rigthsideradiusmin = fgkEndCapSupportMiddleRadius[0]+fgkSSDCablesLay5TubeRadiusMin;
7427 Double_t ssdcableslay5endconedistance = (ssdcableslay5rigthsideradiusmin
7428 - fgkSSDLowerPConeRadius)
7429 * TanD(fgkSSDPConeAngle);
7430 Double_t ssdcableslay5startconedistance = fgkEndCapSupportCenterLay5ITSPosition
7431 + fgkEndCapSupportCenterLay5Position
7432 - 0.5*fgkSSDCentralSupportLength-fgkSSDCentralAL3SupportLength;
7433 Double_t ssdcablelay5rightsidelength = ssdcableslay5endconedistance
7434 - ssdcableslay5startconedistance;
7435 ssdcablelay5rightsidelength *= ssdcablesfactor;
7436 Double_t ssdcableslay5rightsideradiusmax = ssdcableslay5rigthsideradiusmin+fgkSSDCablesLay5RightSideHeight;
7437 TGeoTube* ssdcablelay5rightubeshape = new TGeoTube(ssdcableslay5rigthsideradiusmin,
7438 ssdcableslay5rightsideradiusmax,
7439 0.5*ssdcablelay5rightsidelength);
7440 TGeoVolume* ssdcablelay5righttube = new TGeoVolume("SSDCableLay5RightSideTube",
7441 ssdcablelay5rightubeshape,
7442 fSSDCopper);
7443 ssdcablelay5righttube->SetLineColor(9);
7444 TGeoTranslation* ssdcablelay5rightrans =
7445 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay5ITSPosition
7446 + fgkEndCapSupportCenterLay5Position
7447 + 0.5*ssdcablelay5rightsidelength);
7448 ////////////////////////////////////
7449 // Double_t cablescapacity[20];
7450 // cablescapacity[0] = ssdcablelay5rightubeshape->Capacity();
7451 ////////////////////////////////////
7452 ssdcablesmother->AddNode(ssdcablelay5righttube,1,ssdcablelay5rightrans);
7453 ////////////////////////////////////
7454 // TGeoPCone Volumes
7455 ///////////////////////////////////
7456 TGeoPcon* ssdcableslay5pconshape[3];
7457 TGeoVolume* ssdcableslay5pcon[3];
7458 ssdcableslay5pconshape[0] = new TGeoPcon(0.,360.,2);
7459 Double_t ssdcableslay5pconzsection[6];
7460 Double_t ssdcableslay5pconrmin[6];
7461 Double_t ssdcableslay5pconrmax[6];
7462 ssdcableslay5pconrmin[0] = ssdcablelay5rightubeshape->GetRmin();
7463 ssdcableslay5pconrmax[0] = ssdcablelay5rightubeshape->GetRmax();
7464 ssdcableslay5pconrmin[1] = fgkSSDPConeUpRadius*(1.0+ssdcablelayvertical);
7465 ssdcableslay5pconrmax[1] = ssdcableslay5pconrmin[1]+fgkSSDCablesLay5RightSideHeight;
7466 ssdcableslay5pconzsection[0] = fgkEndCapSupportCenterLay5ITSPosition
7467 + fgkEndCapSupportCenterLay5Position
7468 + 2.*ssdcablelay5rightubeshape->GetDz();
7469 ssdcableslay5pconzsection[1] = 0.5*fgkSSDCentralSupportLength
7470 + fgkSSDCentralAL3SupportLength
7471 + (fgkSSDPConeUpRadius-fgkSSDLowerPConeRadius)
7472 * TanD(fgkSSDPConeAngle);
7473 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[0]->DefineSection(i,ssdcableslay5pconzsection[i],
7474 ssdcableslay5pconrmin[i],ssdcableslay5pconrmax[i]);
7475 ssdcableslay5pcon[0] = new TGeoVolume("SSDCableLay5RightSidePCon1",
7476 ssdcableslay5pconshape[0],fSSDCopper);
7477 ssdcableslay5pcon[0]->SetLineColor(9);
7478 ssdcablesmother->AddNode(ssdcableslay5pcon[0],1);
7479////////////////////////////////////
7480// cablescapacity[1] = ssdcableslay5pconshape[0]->Capacity();
7481////////////////////////////////////
7482 ssdcableslay5pconzsection[2] = ssdcableslay5pconzsection[1];
7483 ssdcableslay5pconzsection[3] = 0.5*fgkSSDCentralSupportLength
7484 + fgkSSDCentralAL3SupportLength
7485 + 0.25*TanD(fgkSSDPConeAngle)*(fgkSSDPConeUpMaxRadius
7486 + 3.*fgkSSDPConeUpRadius-4.*fgkSSDLowerPConeRadius);
7487 Double_t ssdcableangle = (fgkSSDPConeTrapezoidBasis-2.*(fgkSSDPConeUpMaxRadius
7488 - fgkSSDPConeUpRadius)/TanD(fgkSSDPConeTrapezoidAngle))
7489 / fgkSSDPConeUpRadius*TMath::RadToDeg()*2;
7490 ssdcableslay5pconshape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7491 ssdcableangle,2);
7492 ssdcableslay5pconrmin[2] = ssdcableslay5pconrmin[1];
7493 ssdcableslay5pconrmax[2] = ssdcableslay5pconrmax[1];
7494 ssdcableslay5pconrmin[3] = 0.25*(fgkSSDPConeUpMaxRadius+3.*fgkSSDPConeUpRadius
7495 - 4.*fgkSSDLowerPConeRadius)+fgkSSDLowerPConeRadius;
7496 ssdcableslay5pconrmin[3]*=(1.0+ssdcablelayvertical);
7497 ssdcableslay5pconrmax[3] = ssdcableslay5pconrmin[3]+fgkSSDCablesLay5RightSideHeight;
7498 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[1]->DefineSection(i,ssdcableslay5pconzsection[i+2],
7499 ssdcableslay5pconrmin[i+2],ssdcableslay5pconrmax[i+2]);
7500 ssdcableslay5pcon[1] = new TGeoVolume("SSDCableLay5RightSidePCon2",ssdcableslay5pconshape[1],fSSDCopper);
7501 ssdcableslay5pcon[1]->SetLineColor(9);
7502 ////////////////////////////////////
7503 ssdcableslay5pconshape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7504 ssdcableangle,2);
7505 ssdcableslay5pconrmin[4] = ssdcableslay5pconrmin[3];
7506 ssdcableslay5pconrmax[4] = ssdcableslay5pconrmax[3];
7507 ssdcableslay5pconrmin[5] = ssdcableslay5pconrmin[4];
7508 ssdcableslay5pconrmax[5] = ssdcableslay5pconrmax[4];
7509 ssdcableslay5pconzsection[4] = ssdcableslay5pconzsection[3];
7510 ssdcableslay5pconzsection[5] = (ssdcableslay5pconrmin[5]-fgkSSDLowerPConeRadius)
7511 * TanD(fgkSSDPConeAngle)
7512 + 0.5*fgkSSDCentralSupportLength
7513 + fgkSSDCentralAL3SupportLength;
7514 ssdcableslay5pconzsection[5]-= ssdcablelaylateral;
7515 for(Int_t i=0; i<2;i++) ssdcableslay5pconshape[2]->DefineSection(i,ssdcableslay5pconzsection[i+4],
7516 ssdcableslay5pconrmin[i+4],ssdcableslay5pconrmax[i+4]);
7517 ssdcableslay5pcon[2] = new TGeoVolume("SSDCableLay5RightSidePCon3",ssdcableslay5pconshape[2],fSSDCopper);
7518 ssdcableslay5pcon[2]->SetLineColor(9);
7519////////////////////////////////////
7520 TGeoRotation* ssdcableslay5pconrot[4];
7521 for(Int_t i=0; i<4; i++){
7522 ssdcableslay5pconrot[i] = new TGeoRotation();
7523 ssdcableslay5pconrot[i]->SetAngles(90.0*i,0.,0.);
7524 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+1,ssdcableslay5pconrot[i]);
7525 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+1,ssdcableslay5pconrot[i]);
7526 }
7527 ////////////////////////////////////
7528 //cablescapacity[2] = 4.0*ssdcableslay5pconshape[1]->Capacity();
7529 //cablescapacity[3] = 4.0*ssdcableslay5pconshape[2]->Capacity();
7530 ////////////////////////////////////
7531 // Positioning Left SSD Cables Part
7532 ////////////////////////////////////
7533 TGeoTranslation* ssdcablesLay5RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7534 - 0.5*ssdcablelay5rightsidelength
7535 - fgkEndCapSupportCenterLay5Position
7536 - fgkEndCapSupportCenterLay5ITSPosition);
7537 ssdcablesmother->AddNode(ssdcablelay5righttube,2,ssdcablesLay5RightTubeToLeftrans);
7538 TGeoRotation* ssdcablesLay5RightPConToLeftRot = new TGeoRotation();
7539 ssdcablesLay5RightPConToLeftRot->SetAngles(90.,180.,-90);
7540 ssdcablesmother->AddNode(ssdcableslay5pcon[0],2,ssdcablesLay5RightPConToLeftRot);
7541 TGeoHMatrix* ssdcablesLay5RightPConToLeftMatrix[4];
7542 for(Int_t i=0; i<4; i++){ ssdcablesLay5RightPConToLeftMatrix[i] =
7543 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconrot[i]));
7544 ssdcablesmother->AddNode(ssdcableslay5pcon[1],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7545 ssdcablesmother->AddNode(ssdcableslay5pcon[2],i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7546 }
7547 ////////////////////////////////////
7548 //cablescapacity[4] = ssdcablelay5rightubeshape->Capacity();
7549 //cablescapacity[5] = ssdcableslay5pconshape[0]->Capacity();
7550 //cablescapacity[6] = 4.*ssdcableslay5pconshape[1]->Capacity();
7551 //cablescapacity[7] = 4.*ssdcableslay5pconshape[2]->Capacity();
7552 /////////////////////////////////////////////////////////////
7553 // Water Tubes Layer 5
7554 /////////////////////////
7555 TGeoTube* ssdcablelay5rightubewatershape = new TGeoTube(ssdcableslay5rightsideradiusmax,
7556 ssdcableslay5rightsideradiusmax
7557 + fgkSSDCablesLay5RightSideWaterHeight,
7558 0.5*ssdcablelay5rightsidelength);
7559 TGeoVolume* ssdcablelay5rightwatertube = new TGeoVolume("SSDCableLay5RightSideWaterTube",
7560 ssdcablelay5rightubewatershape,
7561 fSSDCoolingTubeWater);
7562 ssdcablelay5rightwatertube->SetLineColor(7);
7563 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,1,ssdcablelay5rightrans);
7564 ssdcablesmother->AddNode(ssdcablelay5rightwatertube,2,ssdcablesLay5RightTubeToLeftrans);
7565 ////////////////////////////////////
7566 // TGeoPCone Water Volumes Layer
7567 ///////////////////////////////////
7568 TGeoPcon* ssdcableslay5pconwatershape[3];
7569 TGeoVolume* ssdcableslay5pconwater[3];
7570 ssdcableslay5pconwatershape[0] = new TGeoPcon(0.,360.,2);
7571 Double_t ssdcableslay5pconwaterzsection[6];
7572 Double_t ssdcableslay5pcwateronrmin[6];
7573 Double_t ssdcableslay5pconwaterrmax[6];
7574 ssdcableslay5pcwateronrmin[0] = ssdcableslay5pconrmax[0];
7575 ssdcableslay5pconwaterrmax[0] = ssdcableslay5pcwateronrmin[0]
7576 + fgkSSDCablesLay5RightSideWaterHeight;
7577 ssdcableslay5pcwateronrmin[1] = ssdcableslay5pconrmax[1];
7578 ssdcableslay5pconwaterrmax[1] = ssdcableslay5pcwateronrmin[1]
7579 + fgkSSDCablesLay5RightSideWaterHeight;
7580 ssdcableslay5pconwaterzsection[0] = ssdcableslay5pconzsection[0];
7581 ssdcableslay5pconwaterzsection[1] = ssdcableslay5pconzsection[1];
7582 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[0]->DefineSection(i,ssdcableslay5pconwaterzsection[i],
7583 ssdcableslay5pcwateronrmin[i],ssdcableslay5pconwaterrmax[i]);
7584 ssdcableslay5pconwater[0] = new TGeoVolume("SSDCableLay5RightSidePConWater1",
7585 ssdcableslay5pconwatershape[0],fSSDCoolingTubeWater);
7586 ssdcableslay5pconwater[0]->SetLineColor(7);
7587 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],1);
7588 ssdcablesmother->AddNode(ssdcableslay5pconwater[0],2,ssdcablesLay5RightPConToLeftRot);
7589////////////////////////////////////
7590 ssdcableslay5pconwaterzsection[2] = ssdcableslay5pconzsection[2];
7591 ssdcableslay5pconwaterzsection[3] = ssdcableslay5pconzsection[3];
7592 ssdcableslay5pconwatershape[1] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7593 ssdcableangle,2);
7594 ssdcableslay5pcwateronrmin[2] = ssdcableslay5pconrmax[1];
7595 ssdcableslay5pconwaterrmax[2] = ssdcableslay5pcwateronrmin[2]
7596 + fgkSSDCablesLay5RightSideWaterHeight;
7597 ssdcableslay5pcwateronrmin[3] = ssdcableslay5pconrmax[3];
7598 ssdcableslay5pconwaterrmax[3] = ssdcableslay5pcwateronrmin[3]
7599 + fgkSSDCablesLay5RightSideWaterHeight;
7600 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[1]->DefineSection(i,ssdcableslay5pconwaterzsection[i+2],
7601 ssdcableslay5pcwateronrmin[i+2],ssdcableslay5pconwaterrmax[i+2]);
7602 ssdcableslay5pconwater[1] = new TGeoVolume("SSDCableLay5RightSidePConWater2",
7603 ssdcableslay5pconwatershape[1],fSSDCoolingTubeWater);
7604 ssdcableslay5pconwater[1]->SetLineColor(7);
7605////////////////////////////////////
7606 ssdcableslay5pconwatershape[2] = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7607 ssdcableangle,2);
7608 ssdcableslay5pcwateronrmin[4] = ssdcableslay5pconrmax[3];
7609 ssdcableslay5pconwaterrmax[4] = ssdcableslay5pcwateronrmin[4]
7610 + fgkSSDCablesLay5RightSideWaterHeight;
7611 ssdcableslay5pcwateronrmin[5] = ssdcableslay5pconrmax[4];
7612 ssdcableslay5pconwaterrmax[5] = ssdcableslay5pcwateronrmin[4]
7613 + fgkSSDCablesLay5RightSideWaterHeight;
7614 ssdcableslay5pconwaterzsection[4] = ssdcableslay5pconzsection[4];
7615 ssdcableslay5pconwaterzsection[5] = ssdcableslay5pconzsection[5];
7616 for(Int_t i=0; i<2;i++) ssdcableslay5pconwatershape[2]->DefineSection(i,ssdcableslay5pconwaterzsection[i+4],
7617 ssdcableslay5pcwateronrmin[i+4],ssdcableslay5pconwaterrmax[i+4]);
7618 ssdcableslay5pconwater[2] = new TGeoVolume("SSDCableLay5RightSidePConWater3",
7619 ssdcableslay5pconwatershape[2],fSSDCoolingTubeWater);
7620 ssdcableslay5pconwater[2]->SetLineColor(7);
7621////////////////////////////////////
7622 TGeoRotation* ssdcableslay5pconwaterot[4];
7623 TGeoHMatrix* ssdcablesLay5RightPConWaterToLeftMatrix[4];
7624 for(Int_t i=0; i<4; i++){
7625 ssdcableslay5pconwaterot[i] = new TGeoRotation();
7626 ssdcableslay5pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7627 ssdcablesLay5RightPConWaterToLeftMatrix[i] =
7628 new TGeoHMatrix((*ssdcablesLay5RightPConToLeftRot)*(*ssdcableslay5pconwaterot[i]));
7629 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+1,ssdcableslay5pconwaterot[i]);
7630 ssdcablesmother->AddNode(ssdcableslay5pconwater[1],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7631 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+1,ssdcableslay5pconwaterot[i]);
7632 ssdcablesmother->AddNode(ssdcableslay5pconwater[2],i+5,ssdcablesLay5RightPConWaterToLeftMatrix[i]);
7633 }
7634 /////////////////////////
7635 // SSD Layer 6 Cables
7636 /////////////////////////
7637 Double_t ssdcableslay6rigthsideradiusmin = fgkEndCapSupportMiddleRadius[1]+fgkSSDCablesLay6TubeRadiusMin;
7638 Double_t ssdcablelay6rightsidelength = 2.*ssdcablelay5rightsidelength;
7639 Double_t ssdcableslay6rightsideradiusmax = ssdcableslay6rigthsideradiusmin+fgkSSDCablesLay6RightSideHeight;
7640 TGeoTube* ssdcablelay6rightubeshape = new TGeoTube(ssdcableslay6rigthsideradiusmin,
7641 ssdcableslay6rightsideradiusmax,
7642 0.5*ssdcablelay6rightsidelength);
7643 TGeoVolume* ssdcablelay6righttube = new TGeoVolume("SSDCableLay6RightSideTube",
7644 ssdcablelay6rightubeshape,
7645 fSSDCopper);
7646 ssdcablelay6righttube->SetLineColor(9);
7647 TGeoTranslation* ssdcablelay6rightrans =
7648 new TGeoTranslation(0.,0.,fgkEndCapSupportCenterLay6ITSPosition
7649 + fgkEndCapSupportCenterLay6Position
7650 + 0.5*ssdcablelay6rightsidelength);
7651 TGeoTranslation* ssdcablesLay6RightTubeToLeftrans = new TGeoTranslation(0.,0.,
7652 - 0.5*ssdcablelay6rightsidelength
7653 - fgkEndCapSupportCenterLay6Position
7654 - fgkEndCapSupportCenterLay6ITSPosition);
7655 ssdcablesmother->AddNode(ssdcablelay6righttube,1,ssdcablelay6rightrans);
7656 ssdcablesmother->AddNode(ssdcablelay6righttube,2,ssdcablesLay6RightTubeToLeftrans);
7657 ////////////////////////////////////
7658 //cablescapacity[8] = 2.*ssdcablelay6rightubeshape->Capacity();
7659 ////////////////////////////////////
7660 TGeoPcon* ssdcableslay6pconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7661 ssdcableangle,2);
7662 TGeoVolume* ssdcableslay6pcon;
7663 Double_t ssdcableslay6pconrmin[2];
7664 Double_t ssdcableslay6pconrmax[2];
7665 Double_t ssdcableslay6pconzsection[2];
7666 ssdcableslay6pconrmin[0] = ssdcableslay6rigthsideradiusmin;
7667 ssdcableslay6pconrmax[0] = ssdcableslay6rightsideradiusmax;
7668 ssdcableslay6pconrmin[1] = ssdcableslay6pconrmin[0];
7669 ssdcableslay6pconrmax[1] = ssdcableslay6pconrmax[0];
7670 ssdcableslay6pconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7671 + fgkEndCapSupportCenterLay6Position
7672 + ssdcablelay6rightsidelength;
7673 ssdcableslay6pconzsection[1] = ssdcableslay5pconwaterzsection[5];
7674 for(Int_t i=0; i<2;i++) ssdcableslay6pconshape->DefineSection(i,ssdcableslay6pconzsection[i],
7675 ssdcableslay6pconrmin[i],ssdcableslay6pconrmax[i]);
7676 ssdcableslay6pcon = new TGeoVolume("SSDCableLay6RightSidePCon",
7677 ssdcableslay6pconshape,fSSDCopper);
7678 ssdcableslay6pcon->SetLineColor(9);
7679 for(Int_t i=0; i<4; i++){
7680 ssdcablesmother->AddNode(ssdcableslay6pcon,i+1,ssdcableslay5pconrot[i]);
7681 ssdcablesmother->AddNode(ssdcableslay6pcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7682 }
7683 ////////////////////////////////////
7684 //cablescapacity[9] = 8.*ssdcableslay6pconshape->Capacity();
7685 /////////////////////////
7686 // Water Tubes Layer 6
7687 /////////////////////////
7688 TGeoTube* ssdcablelay6righwatertubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax,
7689 ssdcableslay6rightsideradiusmax
7690 + fgkSSDCablesLay5RightSideWaterHeight,
7691 0.5*ssdcablelay6rightsidelength);
7692 TGeoVolume* ssdcablelay6rightwatertube = new TGeoVolume("SSDCableLay6RightSideWaterTube",
7693 ssdcablelay6righwatertubeshape,
7694 fSSDCoolingTubeWater);
7695 ssdcablelay6rightwatertube->SetLineColor(7);
7696 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,1,ssdcablelay6rightrans);
7697 ssdcablesmother->AddNode(ssdcablelay6rightwatertube,2,ssdcablesLay6RightTubeToLeftrans);
7698 TGeoPcon* ssdcableslay6waterpconshape = new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,
7699 ssdcableangle,2);
7700 TGeoVolume* ssdcableslay6waterpcon;
7701 Double_t ssdcableslay6waterpconrmin[2];
7702 Double_t ssdcableslay6waterpconrmax[2];
7703 Double_t ssdcableslay6waterpconzsection[2];
7704 ssdcableslay6waterpconrmin[0] = ssdcableslay6rightsideradiusmax;
7705 ssdcableslay6waterpconrmax[0] = ssdcableslay6rightsideradiusmax
7706 + fgkSSDCablesLay5RightSideWaterHeight;
7707 ssdcableslay6waterpconrmin[1] = ssdcableslay6waterpconrmin[0];
7708 ssdcableslay6waterpconrmax[1] = ssdcableslay6waterpconrmax[0];
7709 ssdcableslay6waterpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7710 + fgkEndCapSupportCenterLay6Position
7711 + ssdcablelay6rightsidelength;
7712 ssdcableslay6waterpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7713 for(Int_t i=0; i<2;i++) ssdcableslay6waterpconshape->DefineSection(i,ssdcableslay6waterpconzsection[i],
7714 ssdcableslay6waterpconrmin[i],ssdcableslay6waterpconrmax[i]);
7715 ssdcableslay6waterpcon = new TGeoVolume("SSDCableLay6RightSideWaterPCon",
7716 ssdcableslay6waterpconshape,fSSDCoolingTubeWater);
7717 ssdcableslay6waterpcon->SetLineColor(7);
7718 TGeoRotation* ssdcableslay6pconwaterot[4];
7719 TGeoRotation* ssdcablesLay6RightPConToLeftRot = new TGeoRotation();
7720 ssdcablesLay6RightPConToLeftRot->SetAngles(90.,180.,-90);
7721 TGeoHMatrix* ssdcablesLay6RightPConToLeftMatrix[4];
7722 for(Int_t i=0; i<4; i++){
7723 ssdcableslay6pconwaterot[i] = new TGeoRotation();
7724 ssdcableslay6pconwaterot[i]->SetAngles(90.0*i+45.0,0.,0.);
7725 ssdcablesLay6RightPConToLeftMatrix[i] = new TGeoHMatrix((*ssdcablesLay6RightPConToLeftRot)
7726 * (*ssdcableslay6pconwaterot[i]));
7727 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+1,ssdcableslay6pconwaterot[i]);
7728 ssdcablesmother->AddNode(ssdcableslay6waterpcon,i+5,ssdcablesLay6RightPConToLeftMatrix[i]);
7729 }
7730 ////////////////////////////////////////
7731 // From ITS Ring to Patch Panel3-RB26
7732 ////////////////////////////////////////
7733 Double_t ssdcablepatchpanel3BB26radiusmin[2];
7734 Double_t ssdcablepatchpanel3BB26radiusmax[2];
7735 Double_t ssdcablepatchpanel3RB26zsection[2];
cd2243fb 7736 ssdcablepatchpanel3BB26radiusmin[0] = ssdcableslay5pconrmin[3]-0.5*fgkSSDPatchPanelHeight+2.8;
47f8de53 7737 ssdcablepatchpanel3BB26radiusmax[0] = ssdcablepatchpanel3BB26radiusmin[0]
7738 + fgkSSDCablesLay5RightSideHeight
cd2243fb 7739 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
47f8de53 7740 ssdcablepatchpanel3BB26radiusmin[1] = fgkSSDPatchPanel2RB26Radius;
7741 ssdcablepatchpanel3BB26radiusmax[1] = ssdcablepatchpanel3BB26radiusmin[1]
7742 + 0.*fgkSSDCablesLay5RightSideHeight
cd2243fb 7743 + 0.*fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
47f8de53 7744 ssdcablepatchpanel3RB26zsection[0] = 0.5*fgkSSDCentralSupportLength
7745 + fgkSSDCentralAL3SupportLength
7746 + fgkSSDPConeZLength[0];
7747 ssdcablepatchpanel3RB26zsection[1] = fgkSSDPatchPanel2RB26ITSDistance;
7748 TGeoPcon* ssdcablepatchpanel3RB26pconshape =
7749 new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
7750 - 0.5*ssdcableangle,ssdcableangle,2);
7751 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB26pconshape->DefineSection(i,ssdcablepatchpanel3RB26zsection[i],
7752 ssdcablepatchpanel3BB26radiusmin[i],ssdcablepatchpanel3BB26radiusmax[i]);
7753 TGeoVolume* ssdcablepatchpanel3RB26pcon = new TGeoVolume("SSDCablePatchPanel3RB26",
7754 ssdcablepatchpanel3RB26pconshape,fSSDCopper);
7755 ssdcablepatchpanel3RB26pcon->SetLineColor(9);
85f741d8 7756 TGeoRotation* ssdcablepatchpanel3B26rot[4];
47f8de53 7757 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B26rot[i] = new TGeoRotation();
67446e8a 7758 ssdcablepatchpanel3B26rot[0]->SetAngles(0.0,0.0,0.0);
47f8de53 7759 ssdcablepatchpanel3B26rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB26Angle[0]
67446e8a 7760 + fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
7761 ssdcablepatchpanel3B26rot[2]->SetAngles(180.0,0.0,0.0);
47f8de53 7762 ssdcablepatchpanel3B26rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB26Angle[0]
67446e8a 7763 + fgkSSDCablesPatchPanel2RB26Angle[1]+6.0,0.0,0.0);
47f8de53 7764 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB26pcon,i+1,ssdcablepatchpanel3B26rot[i]);
7765 ////////////////////////////////////
7766 //cablescapacity[10] = 4.*ssdcablepatchpanel3RB26pconshape->Capacity();
7767 ////////////////////////////////////////
7768 // ITS Ring Cables RB26 Part
7769 ////////////////////////////////////////
7770 Double_t ssdcableitsring3BB26pconzsection[2];
7771 Double_t ssdcableitsring3BB26pconrmin[2];
7772 Double_t ssdcableitsring3BB26pconrmax[2];
7773 ssdcableitsring3BB26pconzsection[0] = 0.5*fgkSSDCentralSupportLength
7774 + fgkSSDCentralAL3SupportLength
7775 + (4.0/5.0)*fgkSSDPConeZLength[0];
7776 ssdcableitsring3BB26pconzsection[1] = ssdcablepatchpanel3RB26zsection[0];
cd2243fb 7777 ssdcableitsring3BB26pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeight;
47f8de53 7778 ssdcableitsring3BB26pconrmax[0] = ssdcableitsring3BB26pconrmin[0]
7779 + fgkSSDCablesLay5RightSideHeight
cd2243fb 7780 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
47f8de53 7781 ssdcableitsring3BB26pconrmin[1] = ssdcablepatchpanel3BB26radiusmin[0];
7782 ssdcableitsring3BB26pconrmax[1] = ssdcablepatchpanel3BB26radiusmax[0];
7783 TGeoPcon* ssdcableitsring3BB26pconshape[4];
7784 ssdcableitsring3BB26pconshape[0] = new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB26Angle[0]
7785 - 0.5*ssdcableangle,ssdcableangle
7786 + (fgkSSDCablesPatchPanel2RB26Angle[0]
7787 - fgkSSDCableAngle),2);
7788 ssdcableitsring3BB26pconshape[1] = new TGeoPcon(90.0+fgkSSDCablesPatchPanel2RB26Angle[1]
7789 - 0.5*ssdcableangle,ssdcableangle
7790 + 3.0*fgkSSDCableAngle
7791 - fgkSSDCablesPatchPanel2RB26Angle[1],2);
7792 ssdcableitsring3BB26pconshape[2] = new TGeoPcon(270-fgkSSDCablesPatchPanel2RB26Angle[0]
7793 - 0.5*ssdcableangle,ssdcableangle
7794 - fgkSSDCableAngle
7795 + fgkSSDCablesPatchPanel2RB26Angle[0],2);
7796 ssdcableitsring3BB26pconshape[3] = new TGeoPcon(270.0+fgkSSDCablesPatchPanel2RB26Angle[1]
7797 - 0.5*ssdcableangle,ssdcableangle
7798 + 3.0*fgkSSDCableAngle
7799 - fgkSSDCablesPatchPanel2RB26Angle[1],2);
7800 for(Int_t i=0;i<4;i++)
7801 for(Int_t j=0; j<2; j++) ssdcableitsring3BB26pconshape[i]->DefineSection(j,ssdcableitsring3BB26pconzsection[j],
7802 ssdcableitsring3BB26pconrmin[j],
7803 ssdcableitsring3BB26pconrmax[j]);
7804 TGeoVolume* ssdcableitsring3BB26pcon[4];
7805 ssdcableitsring3BB26pcon[0] = new TGeoVolume("SSDCableITSRing3RB26Part1",
7806 ssdcableitsring3BB26pconshape[0],fSSDCopper);
7807 ssdcableitsring3BB26pcon[1] = new TGeoVolume("SSDCableITSRing3RB26Part2",
7808 ssdcableitsring3BB26pconshape[1],fSSDCopper);
7809 ssdcableitsring3BB26pcon[2] = new TGeoVolume("SSDCableITSRing3RB26Part3",
7810 ssdcableitsring3BB26pconshape[2],fSSDCopper);
7811 ssdcableitsring3BB26pcon[3] = new TGeoVolume("SSDCableITSRing3RB26Part4",
7812 ssdcableitsring3BB26pconshape[3],fSSDCopper);
7813 for(Int_t i=0;i<4;i++){
7814 ssdcableitsring3BB26pcon[i]->SetLineColor(9);
5ef8864c 7815 ssdcablesmother->AddNode(ssdcableitsring3BB26pcon[i],1);
47f8de53 7816}
7817 ////////////////////////////////////
7818 //cablescapacity[11] = ssdcableitsring3BB26pconshape[0]->Capacity()
7819 // + ssdcableitsring3BB26pconshape[1]->Capacity()
7820 // + ssdcableitsring3BB26pconshape[2]->Capacity()
7821 // + ssdcableitsring3BB26pconshape[3]->Capacity();
7822 ////////////////////////////////////////
7823 // From ITS Ring to Patch Panel2-RB24
7824 ////////////////////////////////////////
7825 Double_t ssdcablepatchpanel3BB24radiusmin[2];
7826 Double_t ssdcablepatchpanel3BB24radiusmax[2];
7827 Double_t ssdcablepatchpanel3RB24zsection[2];
7828 ssdcablepatchpanel3BB24radiusmin[0] = ssdcablepatchpanel3BB26radiusmin[0];
7829 ssdcablepatchpanel3BB24radiusmax[0] = ssdcablepatchpanel3BB26radiusmax[0];
7830 ssdcablepatchpanel3BB24radiusmin[1] = fgkSSDPatchPanel2RB24Radius;
7831 ssdcablepatchpanel3BB24radiusmax[1] = ssdcablepatchpanel3BB24radiusmin[1]
7832 + 0.*fgkSSDCablesLay5RightSideHeight
7833 + 0.*fgkSSDCablesLay6RightSideHeight
cd2243fb 7834 + 0.5*fgkSSDPatchPanelHeight;
47f8de53 7835 ssdcablepatchpanel3RB24zsection[0] = -0.5*fgkSSDCentralSupportLength
7836 - fgkSSDCentralAL3SupportLength
7837 - fgkSSDPConeZLength[0];
7838 ssdcablepatchpanel3RB24zsection[1] = -fgkSSDPatchPanel2RB24ITSDistance;
7839 TGeoPcon* ssdcablepatchpanel3RB24pconshape =
7840 new TGeoPcon(90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
7841 - 0.5*ssdcableangle,ssdcableangle,2);
7842 for(Int_t i=0; i<2;i++) ssdcablepatchpanel3RB24pconshape->DefineSection(i,ssdcablepatchpanel3RB24zsection[i],
7843 ssdcablepatchpanel3BB24radiusmin[i],ssdcablepatchpanel3BB24radiusmax[i]);
7844 TGeoVolume* ssdcablepatchpanel3RB24pcon = new TGeoVolume("SSDCablePatchPanel3RB24",
7845 ssdcablepatchpanel3RB24pconshape,
7846 fSSDCopper);
7847 ssdcablepatchpanel3RB24pcon->SetLineColor(9);
85f741d8 7848 TGeoRotation* ssdcablepatchpanel3B24rot[4];
47f8de53 7849 for(Int_t i=0; i<4; i++) ssdcablepatchpanel3B24rot[i] = new TGeoRotation();
67446e8a 7850 ssdcablepatchpanel3B24rot[0]->SetAngles(-6.0,0.0,0.0);
47f8de53 7851 ssdcablepatchpanel3B24rot[1]->SetAngles(fgkSSDCablesPatchPanel2RB24Angle[0]
7852 + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
67446e8a 7853 ssdcablepatchpanel3B24rot[2]->SetAngles(174.0,0.0,0.0);
47f8de53 7854 ssdcablepatchpanel3B24rot[3]->SetAngles(180.0+fgkSSDCablesPatchPanel2RB24Angle[0]
7855 + fgkSSDCablesPatchPanel2RB24Angle[1],0.0,0.0);
7856 for(Int_t i=0; i<4; i++) ssdcablesmother->AddNode(ssdcablepatchpanel3RB24pcon,i+1,ssdcablepatchpanel3B24rot[i]);
7857 ////////////////////////////////////
7858 //cablescapacity[12] = 4.*ssdcablepatchpanel3RB24pconshape->Capacity();
7859 ////////////////////////////////////////
7860 // ITS Ring Cables RB24 Part
7861 ////////////////////////////////////////
7862 Double_t ssdcableitsring3BB24pconzsection[2];
7863 Double_t ssdcableitsring3BB24pconrmin[2];
7864 Double_t ssdcableitsring3BB24pconrmax[2];
7865 ssdcableitsring3BB24pconzsection[0] = -ssdcableitsring3BB26pconzsection[0];
7866 ssdcableitsring3BB24pconzsection[1] = ssdcablepatchpanel3RB24zsection[0];
cd2243fb 7867 ssdcableitsring3BB24pconrmin[0] = fgkSSDPConeUpRadius-0.5*fgkSSDPatchPanelHeight;
47f8de53 7868 ssdcableitsring3BB24pconrmax[0] = ssdcableitsring3BB24pconrmin[0]
7869 + fgkSSDCablesLay5RightSideHeight
cd2243fb 7870 + fgkSSDCablesLay6RightSideHeight+0.5*fgkSSDPatchPanelHeight;
47f8de53 7871 ssdcableitsring3BB24pconrmin[1] = ssdcablepatchpanel3BB24radiusmin[0];
7872 ssdcableitsring3BB24pconrmax[1] = ssdcablepatchpanel3BB24radiusmax[0];
7873 TGeoPcon* ssdcableitsring3BB24pconshape[4];
7874 ssdcableitsring3BB24pconshape[0] = new TGeoPcon(fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7875 + (90.0-fgkSSDCablesPatchPanel2RB24Angle[1]
7876 - fgkSSDCableAngle),2);
7877 ssdcableitsring3BB24pconshape[1] = new TGeoPcon(90.0+fgkSSDCableAngle-0.5*ssdcableangle,
7878 ssdcableangle-fgkSSDCableAngle
7879 + fgkSSDCablesPatchPanel2RB24Angle[0],2);
7880 ssdcableitsring3BB24pconshape[2] = new TGeoPcon(180.0+fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle
7881 - fgkSSDCableAngle
7882 + 90.0-fgkSSDCablesPatchPanel2RB24Angle[1],2);
5ef8864c 7883 ssdcableitsring3BB24pconshape[3] = new TGeoPcon(270.0+fgkSSDCableAngle-0.5*ssdcableangle,
47f8de53 7884 ssdcableangle-fgkSSDCableAngle
7885 + fgkSSDCablesPatchPanel2RB24Angle[0],2);
7886 for(Int_t i=0;i<4;i++)
7887 for(Int_t j=0; j<2; j++) ssdcableitsring3BB24pconshape[i]->DefineSection(j,ssdcableitsring3BB24pconzsection[j],
7888 ssdcableitsring3BB24pconrmin[j],
7889 ssdcableitsring3BB24pconrmax[j]);
7890 TGeoVolume* ssdcableitsring3BB24pcon[4];
7891 ssdcableitsring3BB24pcon[0] = new TGeoVolume("SSDCableITSRing3RB24Part1",
7892 ssdcableitsring3BB24pconshape[0],fSSDCopper);
7893 ssdcableitsring3BB24pcon[1] = new TGeoVolume("SSDCableITSRing3RB24Part2",
7894 ssdcableitsring3BB24pconshape[1],fSSDCopper);
7895 ssdcableitsring3BB24pcon[2] = new TGeoVolume("SSDCableITSRing3RB24Part3",
7896 ssdcableitsring3BB24pconshape[2],fSSDCopper);
7897 ssdcableitsring3BB24pcon[3] = new TGeoVolume("SSDCableITSRing3RB24Part4",
7898 ssdcableitsring3BB24pconshape[3],fSSDCopper);
7899 for(Int_t i=0;i<4;i++){
7900 ssdcableitsring3BB24pcon[i]->SetLineColor(9);
5ef8864c 7901 ssdcablesmother->AddNode(ssdcableitsring3BB24pcon[i],1);
47f8de53 7902}
7903 ////////////////////////////////////
7904 //cablescapacity[13] = ssdcableitsring3BB24pconshape[0]->Capacity()
7905 // + ssdcableitsring3BB24pconshape[1]->Capacity()
7906 // + ssdcableitsring3BB24pconshape[2]->Capacity()
7907 // + ssdcableitsring3BB24pconshape[3]->Capacity();
7908 ////////////////////////////////////
7909 // Volumes for Material Budget
7910 ////////////////////////////////////
7911 TGeoTube* ssdcablelay6materialbudgetubeshape = new TGeoTube(ssdcableslay6rightsideradiusmax
7912 + fgkSSDCablesLay5RightSideWaterHeight,
7913 ssdcableslay6rightsideradiusmax
7914 + fgkSSDCablesLay5RightSideWaterHeight
7915 + fgkSSDCableMaterialBudgetHeight,0.5*ssdcablelay6rightsidelength);
7916 TGeoVolume* ssdcablelay6materialbudgetube = new TGeoVolume("SSDCableLay6MaterialBudgetTube",
7917 ssdcablelay6materialbudgetubeshape,
7918 fSSDCopper);
7919 ssdcablelay6materialbudgetube->SetLineColor(9);
7920 ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,1,ssdcablelay6rightrans);
7921 ssdcablesmother->AddNode(ssdcablelay6materialbudgetube,2,ssdcablesLay6RightTubeToLeftrans);
7922
7923 TGeoPcon* ssdcablelay6materialbudgetpconshape =
7924 new TGeoPcon(90.0-fgkSSDCableAngle-0.5*ssdcableangle,ssdcableangle,2);
7925 TGeoVolume* ssdcablelay6materialbudgetpcon;
7926 Double_t ssdcablelay6materialbudgetpconrmin[2];
7927 Double_t ssdcablelay6materialbudgetpconrmax[2];
7928 Double_t ssdcablelay6materialbudgetpconzsection[2];
7929 ssdcablelay6materialbudgetpconrmin[0] = ssdcableslay6rightsideradiusmax
7930 + fgkSSDCablesLay5RightSideWaterHeight;
7931 ssdcablelay6materialbudgetpconrmax[0] = ssdcablelay6materialbudgetpconrmin[0]
7932 + fgkSSDCableMaterialBudgetHeight;
7933 ssdcablelay6materialbudgetpconrmin[1] = ssdcablelay6materialbudgetpconrmin[0];
7934 ssdcablelay6materialbudgetpconrmax[1] = ssdcablelay6materialbudgetpconrmax[0];
7935 ssdcablelay6materialbudgetpconzsection[0] = fgkEndCapSupportCenterLay6ITSPosition
7936 + fgkEndCapSupportCenterLay6Position
7937 + ssdcablelay6rightsidelength;
7938 ssdcablelay6materialbudgetpconzsection[1] = ssdcableslay5pconwaterzsection[5];
7939 for(Int_t i=0; i<2;i++) ssdcablelay6materialbudgetpconshape->DefineSection(i,
7940 ssdcablelay6materialbudgetpconzsection[i],
7941 ssdcablelay6materialbudgetpconrmin[i],
7942 ssdcablelay6materialbudgetpconrmax[i]);
7943 ssdcablelay6materialbudgetpcon = new TGeoVolume("SSDCableLay6MaterialBudgetPCon",
7944 ssdcablelay6materialbudgetpconshape,fSSDCopper);
7945 ssdcablelay6materialbudgetpcon->SetLineColor(9);
7946 for(Int_t i=0; i<4; i++){
7947 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+1,ssdcableslay5pconrot[i]);
7948 ssdcablesmother->AddNode(ssdcablelay6materialbudgetpcon,i+5,ssdcablesLay5RightPConToLeftMatrix[i]);
7949 }
7950////////////////////////////////////
7951 /* cablescapacity[14] = 2.*ssdcablelay6materialbudgetubeshape->Capacity();
7952 cablescapacity[15] = 2.*ssdcablelay6materialbudgetpconshape->Capacity();
7953 Double_t ssdcablesvolume = 0.0;
7954 for(Int_t i=0;i<16;i++) ssdcablesvolume+=cablescapacity[i];
7955 std::cout << ssdcablesvolume << std::endl;*/
7956 return ssdcablesmother;
7957 }
7958 ////////////////////////////////////////////////////////////////////////////////
d7599219 7959TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
b671cde1 7960 Double_t height, const char* shapename, Int_t isign) const{
44285dfa 7961 /////////////////////////////////////////////////////////////
7962 // Method generating an Arb shape
7963 /////////////////////////////////////////////////////////////
7964 const Int_t kvertexnumber = 8;
7965 const Int_t ktransvectnumber = 2;
b671cde1 7966 TVector3 vertex[kvertexnumber];
7967 TVector3 transvector[2];
7968 for(Int_t i=0; i<ktransvectnumber; i++) transvector[i].SetY(width[i]);
44285dfa 7969 /////////////////////////////////////////////////////////////
d7599219 7970 //Setting the vertices for TGeoArb8
44285dfa 7971 /////////////////////////////////////////////////////////////
b671cde1 7972 vertex[0] = *vertexpos[0];
7973 vertex[1] = *vertexpos[1];
7974 vertex[2] = vertex[1];
7975 vertex[3] = vertex[0];
7976 vertex[4] = *vertexpos[2];
7977 vertex[5] = *vertexpos[3];
7978 vertex[6] = vertex[5];
7979 vertex[7] = vertex[4];
7980
7981 // NB: order of points is clockwise
7982 if (isign < 0) {
7983 vertex[2] -= transvector[0];
7984 vertex[3] -= transvector[0];
7985 vertex[6] -= transvector[1];
7986 vertex[7] -= transvector[1];
7987 }
7988 else {
7989 vertex[0] += transvector[0];
7990 vertex[1] += transvector[0];
7991 vertex[4] += transvector[1];
7992 vertex[5] += transvector[1];
7993 }
7994
44285dfa 7995 /////////////////////////////////////////////////////////////
7996 TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
b671cde1 7997 for(Int_t i = 0; i<kvertexnumber;i++) {
7998 arbshape->SetVertex(i,vertex[i].X(),vertex[i].Y());
7999 }
8000
44285dfa 8001 return arbshape;
d7599219 8002}
bf210566 8003///////////////////////////////////////////////////////////////////////////////
8004TGeoXtru* AliITSv11GeometrySSD::GetArcShape(Double_t phi, Double_t rmin,
8005 Double_t rmax, Int_t nedges, Double_t height){
8006 /////////////////////////////////////////////////////////////
8007 // Method generating Arc shape
8008 /////////////////////////////////////////////////////////////
8009 const Int_t kvertexnumber = 2*nedges+2;
8010 TGeoXtru* arcshape = new TGeoXtru(2);
8011 TVector3** vertexposition[2];
8012 for(Int_t i=0; i<2; i++) vertexposition[i] = new TVector3*[nedges+1];
8013 Double_t angle = 0.;
8014 for(Int_t i=0; i<nedges+1; i++){
8015 angle = 90.+0.5*phi-i*(phi/nedges);
8016 vertexposition[0][i] = new TVector3(rmin*CosD(angle),rmin*SinD(angle));
8017 vertexposition[1][i] = new TVector3(rmax*CosD(angle),rmax*SinD(angle));
8018 }
8019 Double_t *xvertexpoints = new Double_t[kvertexnumber];
8020 Double_t *yvertexpoints = new Double_t[kvertexnumber];
8021 for(Int_t i=0; i<kvertexnumber; i++){
8022 if(i==0){ xvertexpoints[i] = vertexposition[0][i]->X(),
8023 yvertexpoints[i] = vertexposition[0][i]->Y();
8024 }
8025 else if(i>=1&&i<nedges+2)
8026 {
8027 xvertexpoints[i] = vertexposition[1][i-1]->X();
8028 yvertexpoints[i] = vertexposition[1][i-1]->Y();
8029 }
8030 else
8031 {
8032 xvertexpoints[i] = vertexposition[0][kvertexnumber-i]->X();
8033 yvertexpoints[i] = vertexposition[0][kvertexnumber-i]->Y();
8034 }
8035 }
8036 arcshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
8037 arcshape->DefineSection(0,-0.5*height);
8038 arcshape->DefineSection(1,0.5*height);
44285dfa 8039 /////////////////////////////////////////////////////////////
bf210566 8040 // Deallocating memory
44285dfa 8041 /////////////////////////////////////////////////////////////
bf210566 8042 for(Int_t i=0; i<2; i++){
8043 for(Int_t j=0; j<nedges+1; j++)
8044 delete vertexposition[i][j];
8045 delete [] vertexposition[i];
8046 }
8047 delete [] xvertexpoints;
8048 delete [] yvertexpoints;
8049 /////////////////////////////////////////////////////////////
8050 return arcshape;
d7599219 8051}
8052////////////////////////////////////////////////////////////////////////////////
851c0ce3 8053TGeoShape* AliITSv11GeometrySSD::GetScrewShape(Double_t* radius,Int_t* edgesnumber,Double_t* section) const {
9b0c60ab 8054 ///////////////////////////////////////////////////////////////////////
8055 // Method Generating the Screw Shape
8056 // radius[0]: outer radius
8057 // radius[1]: inner radius
8058 // edgesnumber[0]: outer number of edges
8059 // edgesnumber[1]: inner number of edges
8060 // section[0]: lower section position
8061 // section[1]: higher section position
8062 ///////////////////////////////////////////////////////////////////////
8063 Double_t outradius = radius[0];
8064 Double_t inradius = radius[1];
8065 Int_t outvertexnumber = edgesnumber[0];
8066 Int_t invertexnumber = edgesnumber[1];
851c0ce3 8067 Double_t* xscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8068 Double_t* yscrewvertex = new Double_t[outvertexnumber+invertexnumber];
8069 for(Int_t i=0; i<outvertexnumber; i++){
9b0c60ab 8070 xscrewvertex[i] = outradius*CosD(90.+i*360./outvertexnumber);
8071 yscrewvertex[i] = outradius*SinD(90.+i*360./outvertexnumber);
8072 }
851c0ce3 8073 for(Int_t i=0; i<invertexnumber; i++){
8074 xscrewvertex[outvertexnumber+i] = inradius*CosD(90.+i*360./invertexnumber);
8075 yscrewvertex[outvertexnumber+i] = inradius*SinD(90.+i*360./invertexnumber);
9b0c60ab 8076 }
851c0ce3 8077 TGeoXtru* screwshapeout = new TGeoXtru(2);
8078 screwshapeout->DefinePolygon(outvertexnumber,xscrewvertex,yscrewvertex);
8079 screwshapeout->DefineSection(0,section[0]);
8080 screwshapeout->DefineSection(1,section[1]);
8081 TGeoXtru* screwshapein = new TGeoXtru(2);
8082 screwshapein->DefinePolygon(invertexnumber,&xscrewvertex[outvertexnumber],&yscrewvertex[outvertexnumber]);
8083 screwshapein->DefineSection(0,section[0]-0.01); // make inner part bigger in Z
8084 screwshapein->DefineSection(1,section[1]+0.01); // safer when we subtract it
8085 TGeoSubtraction *snode = new TGeoSubtraction(screwshapeout, screwshapein);
8086 TGeoCompositeShape *screwshape = new TGeoCompositeShape("", snode);
8087
9b0c60ab 8088 delete [] xscrewvertex;
8089 delete [] yscrewvertex;
8090 return screwshape;
8091}
8092////////////////////////////////////////////////////////////////////////////////
851c0ce3 8093TGeoShape* AliITSv11GeometrySSD::GetHoleShape(Double_t radius, Int_t nedges, Double_t *section) const {
9b0c60ab 8094 ///////////////////////////////////////////////////////////////////////
8095 // Method Generating the Hole Shape
8096 // radius of the Hole
8097 // nedges: number of edges to approximate the circle
8098 ///////////////////////////////////////////////////////////////////////
851c0ce3 8099 Double_t* xholevertex = new Double_t[nedges];
8100 Double_t* yholevertex = new Double_t[nedges];
8101 Double_t z = 0.5*(section[0]+section[1]);
8102 Double_t dz = 0.5*(section[1]-section[0]);
8103 TGeoTranslation *tr = 0;
8104 if (TMath::Abs(z) > TGeoShape::Tolerance()) {
8105 tr = new TGeoTranslation(0.,0.,z);
8106 tr->RegisterYourself();
8107 }
8108 TGeoBBox *box = new TGeoBBox("",radius,radius,dz);
8109 for(Int_t i=0; i<nedges; i++){
8110 xholevertex[i] = radius*CosD(i*360./nedges);
8111 yholevertex[i] = radius*SinD(i*360./nedges);
9b0c60ab 8112 }
851c0ce3 8113 TGeoXtru* holeshapeout = new TGeoXtru(2);
8114 holeshapeout->DefinePolygon(nedges,xholevertex,yholevertex);
8115 holeshapeout->DefineSection(0,section[0]-0.01); // make subtracted part larger in Z
8116 holeshapeout->DefineSection(1,section[1]+0.01);
8117 TGeoSubtraction *snode = new TGeoSubtraction(box,holeshapeout,tr);
8118 TGeoCompositeShape *holeshape = new TGeoCompositeShape("", snode);
8119
9b0c60ab 8120 delete [] xholevertex;
8121 delete [] yholevertex;
8122 return holeshape;
8123}
8124////////////////////////////////////////////////////////////////////////////////
44285dfa 8125TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{
8126 /////////////////////////////////////////////////////////////
8127 // Given an axis specified by param, it gives the reflection of the point
8128 // respect to the axis
8129 /////////////////////////////////////////////////////////////
8130 TVector3* n = new TVector3(param[0],param[1],param[2]);
8131 Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
8132 TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
bf210566 8133 /////////////////////////////////////////////////////////////
8134 // Deallocating memory
8135 /////////////////////////////////////////////////////////////
8136 delete n;
8137 /////////////////////////////////////////////////////////////
44285dfa 8138 return reflectedvector;
d7599219 8139}
8140////////////////////////////////////////////////////////////////////////////////
bf210566 8141TGeoHMatrix* AliITSv11GeometrySSD::AddTranslationToHMatrix(TGeoHMatrix* ct,
d7599219 8142 Double_t dx,
8143 Double_t dy,
8144 Double_t dz) const{
44285dfa 8145 /////////////////////////////////////////////////////////////
d7599219 8146 // Add a dx,dy,dz translation to the initial TGeoCombiTrans
44285dfa 8147 /////////////////////////////////////////////////////////////
bf210566 8148 TGeoHMatrix* hmatrix = new TGeoHMatrix(*ct);
8149 const Double_t *vect = hmatrix->GetTranslation();
44285dfa 8150 Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
bf210566 8151 hmatrix->SetTranslation(newvect);
8152 TGeoHMatrix* matrix = new TGeoHMatrix(*hmatrix);
8153 delete hmatrix;
8154 return matrix;
d7599219 8155}
8156////////////////////////////////////////////////////////////////////////////////
d7599219 8157TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
44285dfa 8158 /////////////////////////////////////////////////////////////
8159 // Method returning the Medium type
8160 /////////////////////////////////////////////////////////////
a3f8715e 8161 char ch[100];
d7599219 8162 sprintf(ch, "ITS_%s",mediumName);
8163 TGeoMedium* medium = gGeoManager->GetMedium(ch);
8164 if (! medium)
160835d5 8165 AliError(Form("medium %s not found !\n", mediumName));
d7599219 8166 return medium;
8167}
8168////////////////////////////////////////////////////////////////////////////////
d7599219 8169void AliITSv11GeometrySSD::CreateMaterials(){
8170///////////////////////////////////
8171// This part has to be modified
8172///////////////////////////////////
8173 ///////////////////////////////////
8174 // Silicon for Sensor
8175 ///////////////////////////////////
bf210566 8176 fSSDSensorMedium = GetMedium("SI$");
d7599219 8177 ///////////////////////////////////
8178 // Silicon Mixture for Sensor
8179 ///////////////////////////////////
44285dfa 8180 fSSDChipMedium = GetMedium("SPD SI CHIP$");
8181 fSSDChipGlueMedium = GetMedium("EPOXY$");
d7599219 8182 ///////////////////////////////////
8183 // Stiffener Components Materials
8184 ///////////////////////////////////
bf210566 8185 fSSDStiffenerMedium = GetMedium("SDD C AL (M55J)$");
d7599219 8186 ///////////////////////////
8187 // Stiffener Connectors
8188 ///////////////////////////
bf210566 8189 fSSDStiffenerConnectorMedium = GetMedium("COPPER$");
d7599219 8190 ////////////////////////////////
8191 // Stiffener 0603-1812 Capacitor
8192 ////////////////////////////////
bf210566 8193 fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
8194 fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3$");
78e34526 8195 fSSDStiffenerCapacitorCapMedium = GetMedium("NiSn$");
d7599219 8196 ///////////////////////////
8197 // Stiffener Hybrid Wire
8198 ///////////////////////////
bf210566 8199 fSSDStiffenerHybridWireMedium = GetMedium("COPPER$");
d7599219 8200 ///////////////////////////
8201 // Al for Cooling Block
8202 ///////////////////////////
bf210566 8203 fSSDAlCoolBlockMedium = GetMedium("AL$");
d7599219 8204 //////////////////////////////////////////////////////
8205 // Kapton and Al for Chip Cable Flex and Ladder Cables
8206 //////////////////////////////////////////////////////
bf210566 8207 fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8208 fSSDAlTraceChipCableMedium = GetMedium("AL$");
8209 fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)$");
8210 fSSDAlTraceFlexMedium = GetMedium("AL$");
8211 fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)$");
8212 fSSDAlTraceLadderCableMedium = GetMedium("AL$");
d7599219 8213 /////////////////////////////////////////////////////////////////
8214 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
8215 //////////////////////////////////////////////////////////////////
44285dfa 8216 fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
d7599219 8217 /////////////////////////////////////////////////////////////////
8218 // G10 for Detector Leg, TubeHolder
8219 //////////////////////////////////////////////////////////////////
44285dfa 8220 fSSDTubeHolderMedium = GetMedium("G10FR4$");
8221 fSSDSensorSupportMedium = GetMedium("G10FR4$");
8222 fSSDMountingBlockMedium = GetMedium("G10FR4$");
8223 fSSDMountingBlockMedium = GetMedium("G10FR4$");
d7599219 8224 /////////////////////////////////////////////////////////////////
8225 // Water and Phynox for Cooling Tube
8226 //////////////////////////////////////////////////////////////////
bf210566 8227 fSSDCoolingTubeWater = GetMedium("WATER$");
44285dfa 8228 fSSDCoolingTubePhynox = GetMedium("INOX$");
bf210566 8229 /////////////////////////////////////////////////////////////////////
9b0c60ab 8230 // Material for Support Rings
8231 /////////////////////////////////////////////////////////////////////
8232 fSSDSupportRingAl = GetMedium("AL$");
47f8de53 8233 fSSDRohaCellCone = GetMedium("ROHACELL$");
9b0c60ab 8234 /////////////////////////////////////////////////////////////////////
bf210566 8235 fSSDAir = GetMedium("SDD AIR$");
47f8de53 8236 fSSDCopper = GetMedium("COPPER$");
78e34526 8237 fSSDSn = GetMedium("Sn$");
bf210566 8238 fCreateMaterials = kTRUE;
d7599219 8239}
8240/////////////////////////////////////////////////////////////////////