New AliITSMisAligner class. It replaces MakeITS...MisAlignment.C macros and class...
[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"
160835d5 41#include "Riostream.h"
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:
56const Double_t AliITSv11GeometrySSD::fgkSSDLadderVerticalDisalignment = 0.2*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;
bf210566 91//const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 3.315;
9acf2ecc 92const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 0.315*fgkmm;
93const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist = 2.500*fgkmm;
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;
97const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length = 4.600*fgkmm;
98const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width = 3.400*fgkmm;
bf210566 99const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height = 0.700*fgkmm; // multiplied by 0.5
9acf2ecc 100const Double_t AliITSv11GeometrySSD::fgkSSDWireLength = 30.000*fgkmm;
101const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius = 0.185*fgkmm;
bf210566 102const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2] =
103 {44.32*fgkmm, 0.33*fgkmm};
104const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation = 0.44*fgkmm;
105const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength = 2.16*fgkmm;
106const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth = 3.60*fgkmm;
d7599219 107const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight =
bf210566 108 0.25*fgkSSDStiffenerHeight;
109const Double_t AliITSv11GeometrySSD::fgkSSDConnectorAlHeight = 0.030*fgkmm;
110const Double_t AliITSv11GeometrySSD::fgkSSDConnectorNiHeight = 0.002*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] =
bf210566 119 {1.000*fgkmm, 0.120*fgkmm};
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;
d7599219 163/////////////////////////////////////////////////////////////////////////////////
164// SSD Module (lengths are in mm and angles in degrees)
165/////////////////////////////////////////////////////////////////////////////////
166const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2] =
bf210566 167 { 1.000*fgkmm, 3.900*fgkmm};
d7599219 168const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
9acf2ecc 169 45.600*fgkmm;
d7599219 170const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor =
9acf2ecc 171 5.075*fgkmm;
d7599219 172/////////////////////////////////////////////////////////////////////////////////
173// Sensor Support (lengths are in mm and angles in degrees)
174/////////////////////////////////////////////////////////////////////////////////
bf210566 175const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength =
176 5.800*fgkmm;
d7599219 177const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth =
bf210566 178 2.000*fgkmm;
d7599219 179const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
0fb26117 180 { 4.620*fgkmm-fgkSSDModuleVerticalDisalignment,
181 5.220*fgkmm-fgkSSDModuleVerticalDisalignment};
ca86fdb4 182//const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
183// { 4.520*fgkmm, 5.130*fgkmm};
bf210566 184const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] =
185 { 0.450*fgkmm, 0.450*fgkmm};
186const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition
187 = 0.5 * (fgkSSDModuleSensorSupportDistance
188 + fgkSSDSensorSideSupportThickness[0])
189 - fgkSSDSensorSideSupportLength;
d7599219 190const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength =
bf210566 191 5.250*fgkmm;
d7599219 192const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth =
bf210566 193 1.680*fgkmm;
194const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2]
195 = {fgkSSDSensorSideSupportHeight[0]
196 + fgkSSDSensorSideSupportThickness[0],
197 fgkSSDSensorSideSupportHeight[1]
198 + fgkSSDSensorSideSupportThickness[1]};
199const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2]
200 = {fgkSSDSensorSideSupportThickness[0],
201 fgkSSDSensorSideSupportThickness[1]};
d7599219 202const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition =
bf210566 203 19.000*fgkmm;
d7599219 204/////////////////////////////////////////////////////////////////////////////////
205// Chip Cables (lengths are in mm and angles in degrees)
206/////////////////////////////////////////////////////////////////////////////////
207const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2] =
bf210566 208 {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
d7599219 209const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4] =
bf210566 210 { 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
211 - (fgkSSDSensorSideSupportHeight[1]
212 - fgkSSDSensorSideSupportHeight[0])
0fb26117 213 - fgkSSDModuleVerticalDisalignment
bf210566 214 - fgkSSDCoolingBlockHoleCenter
215 - fgkSSDStiffenerHeight
216 - fgkSSDChipHeight-fgkSSDSensorHeight,
217 fgkSSDModuleCoolingBlockToSensor
0fb26117 218 - fgkSSDModuleVerticalDisalignment
bf210566 219 - fgkSSDCoolingBlockHoleCenter
220 - fgkSSDStiffenerHeight
221 - fgkSSDChipHeight-fgkSSDSensorHeight};
d7599219 222const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3] =
bf210566 223 { 11.000*fgkmm, 0.800*fgkmm, 0.600*fgkmm};
d7599219 224/////////////////////////////////////////////////////////////////////////////////
225// Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
226/////////////////////////////////////////////////////////////////////////////////
227const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
bf210566 228 3.820*fgkmm;
229//const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
230// 3.780;
d7599219 231const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth =
bf210566 232 fgkSSDSensorLength-fgkSSDSensorOverlap;
d7599219 233const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2] =
bf210566 234 { 0.86*fgkmm, 0.30*fgkmm};
d7599219 235const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2] =
bf210566 236 { 30.00, 90.00};
d7599219 237const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
bf210566 238 1.78*fgkmm;
d7599219 239/////////////////////////////////////////////////////////////////////////////////
240//Carbon Fiber Parameters (lengths are in mm and angles in degrees)
241/////////////////////////////////////////////////////////////////////////////////
bf210566 242const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength
243 = fgkSSDModuleSensorSupportDistance
244 - 2. * fgkCarbonFiberJunctionToSensorSupport;
245const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle = 60.00;
d7599219 246const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2] =
bf210566 247 { 0.751*fgkmm, 0.482*fgkmm};
248const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength =
249 1.630*fgkmm;
250const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth = 0.950*fgkmm;
251const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength
252 = fgkCarbonFiberTriangleLength
253 - 0.5*fgkCarbonFiberSupportTopEdgeDist[1]
254 / TMath::Cos(fgkCarbonFiberTriangleAngle
255 * TMath::DegToRad());
256const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength
257 = 0.5*(fgkCarbonFiberJunctionWidth
258 - fgkCarbonFiberSupportWidth)
259 - fgkCarbonFiberSupportTopEdgeDist[0]
260 - fgkCarbonFiberSupportWidth;
d7599219 261/////////////////////////////////////////////////////////////////////////////////
262// Carbon Fiber Lower Support Parameters (lengths are in mm)
263/////////////////////////////////////////////////////////////////////////////////
c40ebacc 264const Double_t AliITSv11GeometrySSD::fgkLowerSupportToSensorZ = 11.575*fgkmm;
d7599219 265const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
9acf2ecc 266 = 0.950*fgkmm;
d7599219 267const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
9acf2ecc 268 = 1.600*fgkmm;
d7599219 269const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
9acf2ecc 270 = 0.830*fgkmm;
d7599219 271const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
272 = 0.5*fgkCarbonFiberSupportWidth;
273const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
bf210566 274 = fgkCarbonFiberJunctionWidth
275 - 2. * (fgkCarbonFiberLowerSupportWidth
276 + fgkCarbonFiberLowerSupportVolumeSeparation);
d7599219 277const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
bf210566 278 = {fgkCarbonFiberLowerSupportWidth
279 + fgkCarbonFiberLowerSupportVolumeSeparation,
280 fgkCarbonFiberLowerSupportWidth
281 + fgkCarbonFiberLowerSupportVolumeSeparation
282 + fgkCarbonFiberLowerSupportTransverseWidth};
d7599219 283/////////////////////////////////////////////////////////////////////////////////
284// End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
285/////////////////////////////////////////////////////////////////////////////////
286const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
bf210566 287 {0.5 * (fgkSSDLay5LadderLength
288 - fgkSSDLay5SensorsNumber
289 * fgkCarbonFiberJunctionWidth
290 - fgkCarbonFiberLowerSupportWidth),
291 0.5 * (fgkSSDLay5LadderLength
292 - fgkSSDLay5SensorsNumber
293 * fgkCarbonFiberJunctionWidth
294 + fgkCarbonFiberLowerSupportWidth)};
d7599219 295const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
bf210566 296 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
297 fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
d7599219 298const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
bf210566 299 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
300 fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
9b0c60ab 301const Double_t AliITSv11GeometrySSD::fgkendladdercoolingsupportdistance[3] =
302 {15.0*fgkmm, 13.5*fgkmm, 14.5*fgkmm};
d7599219 303/////////////////////////////////////////////////////////////////////////////////
304// Cooling Tube Support (lengths are in mm and angles in degrees)
305/////////////////////////////////////////////////////////////////////////////////
bf210566 306const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax = 1.45*fgkmm;
d7599219 307const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
308 = fgkSSDCoolingBlockHoleRadius[0];
bf210566 309const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength = 8.55*fgkmm;
310const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight = 0.85*fgkmm;
311const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth = 2.00*fgkmm;
d7599219 312const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation =
bf210566 313 fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
314const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber =
315 11.70*fgkmm;
d7599219 316/////////////////////////////////////////////////////////////////////////////////
317// Cooling Tube (lengths are in mm and angles in degrees)
318/////////////////////////////////////////////////////////////////////////////////
bf210566 319const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax = fgkCoolingTubeSupportRmin;
320const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 0.96*fgkmm;
321const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
d7599219 322 fgkCarbonFiberJunctionWidth;
323const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
bf210566 324 fgkSSDModuleSensorSupportDistance
325 + fgkSSDCoolingBlockLength;
9b0c60ab 326const Double_t AliITSv11GeometrySSD::fgkMountingBlockToSensorSupport = 30.7*fgkmm;
d7599219 327/////////////////////////////////////////////////////////////////////////////////
328// SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
329/////////////////////////////////////////////////////////////////////////////////
330const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3] =
bf210566 331 { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
d7599219 332const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4] =
bf210566 333 { 4.0*fgkmm, 8.0*fgkmm, 5.0*fgkmm, 0.2*fgkmm};
d7599219 334const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth =
bf210566 335 20.0*fgkmm;
d7599219 336const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle =
bf210566 337 40.0;
d7599219 338const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight =
339 0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
340const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
bf210566 341 2.5*fgkmm;
d7599219 342const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2] =
bf210566 343 { 56.0*fgkmm, 12.0*fgkmm};
d7599219 344const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2] =
bf210566 345 { 5.0*fgkmm, 2.9*fgkmm};
d7599219 346const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius =
bf210566 347 1.0*fgkmm;
d7599219 348const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge =
bf210566 349 6.0*fgkmm;
d7599219 350const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth =
bf210566 351 4.0*fgkmm;
d7599219 352const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2] =
bf210566 353 { 1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
d7599219 354/////////////////////////////////////////////////////////////////////////////////
9b0c60ab 355// SSD Mounting Block Clip Parameters (lengths are in mm and angles in degrees)
356/////////////////////////////////////////////////////////////////////////////////
357const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipLength = 15.1*fgkmm;
358const Double_t AliITSv11GeometrySSD::fgkMountingBlockClipThickness = 0.3*fgkmm;
359const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewRadius = 1.6*fgkmm;
360const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibScrewPosition = 4.0*fgkmm;
361const Double_t AliITSv11GeometrySSD::fgkMountingBlockClibWidth = 9.0*fgkmm;
362/////////////////////////////////////////////////////////////////////////////////
363// SSD Mounting Block Support Parameters (lengths are in mm and angles in degrees)
364/////////////////////////////////////////////////////////////////////////////////
365const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportWidth[2] = {9.5*fgkmm,10.0*fgkmm};
366const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportDownHeight = 4.0*fgkmm;
367const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportRadius[2] = {fgkSSDLay5RadiusMin
368 - fgkSSDMountingBlockHeight[1]
369 + 0.5*fgkCoolingTubeSupportHeight
370 + fgkSSDModuleCoolingBlockToSensor
371 - fgkMountingBlockSupportDownHeight,
372 fgkSSDLay6RadiusMin
373 - fgkSSDMountingBlockHeight[1]
374 + 0.5*fgkCoolingTubeSupportHeight
375 + fgkSSDModuleCoolingBlockToSensor
376 - fgkMountingBlockSupportDownHeight};
377const Double_t AliITSv11GeometrySSD::fgkMountingBlockSupportUpHeight[2] = {fgkSSDLay5RadiusMax
378 - fgkSSDMountingBlockHeight[1]
379 + 0.5*fgkCoolingTubeSupportHeight
380 + fgkSSDModuleCoolingBlockToSensor
381 - fgkMountingBlockSupportRadius[0],
382 fgkSSDLay6RadiusMax
383 - fgkSSDMountingBlockHeight[1]
384 + 0.5*fgkCoolingTubeSupportHeight
385 + fgkSSDModuleCoolingBlockToSensor
386 - fgkMountingBlockSupportRadius[1]};
387const Double_t AliITSv11GeometrySSD::fgkLadderSupportHeigth = 10.0*fgkmm; // To be verified
388const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay5Position = 451.35*fgkmm;
389const Double_t AliITSv11GeometrySSD::fgkLadderSupportRingLay6Position = 510.00*fgkmm;
390/////////////////////////////////////////////////////////////////////////////////
391// SSD End Cap Cover Plate Parameters (lengths are in mm and angles in degrees)
392/////////////////////////////////////////////////////////////////////////////////
393const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleRadius = 1.25*fgkmm;
394const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateBigHoleRadius = 2.45*fgkmm;
395const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateThickness = 0.5*fgkmm;
396const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateSmallHoleSeparation[3] =
397 {16.5*fgkmm,22.0*fgkmm,7.*fgkmm};
398const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateLength[6] =
399 {7.*fgkmm,55.*fgkmm,8.0*fgkmm,53.*fgkmm,61.0*fgkmm,25.5*fgkmm};
400const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateWidth[3] =
401 {68.5*fgkmm,75.5*fgkmm,6.5*fgkmm};
402const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMin = 0.750*fgkmm;
403const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateScrewRadiusMax = 2.*fgkmm;
404const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipLength = 10.4*fgkmm;
405const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateClipWidth = 6.0*fgkmm;
406const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipLength = 5.7*fgkmm;
407const Double_t AliITSv11GeometrySSD::fgkEndCapCoverPlateDownClipWidth = 5.0*fgkmm;
408/////////////////////////////////////////////////////////////////////////////////
409// SSD End Cap Kapton Foil Parameters (lengths are in mm and angles in degrees)
410/////////////////////////////////////////////////////////////////////////////////
411const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilThickness = 0.4*fgkmm;
412const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilLength = 68.0*fgkmm;
413const Double_t AliITSv11GeometrySSD::fgkEndCapKaptonFoilWidth = 75.0*fgkmm;
414/////////////////////////////////////////////////////////////////////////////////
415// SSD End Cap Cooling Tube Parameters (lengths are in mm and angles in degrees)
416/////////////////////////////////////////////////////////////////////////////////
417const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAxialRadius[2] =
418 {10.5*fgkmm,9.25*fgkmm};
419const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMin = 1.3*fgkmm;
420const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeRadiusMax = 1.5*fgkmm;
421const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeAngle[5] =
422 {182.3,177.9,84.4,70.0,35.0};
423const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeLength[5] =
424 {49.5*fgkmm,41.7*fgkmm,47.6*fgkmm,5.0*fgkmm};
425const Double_t AliITSv11GeometrySSD::fgkEndCapCoolingTubeToCoverSide = 13.0*fgkmm;
426/////////////////////////////////////////////////////////////////////////////////
427// SSD End Cap Cover Side Parameters (lengths are in mm and angles in degrees)
428/////////////////////////////////////////////////////////////////////////////////
429const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverLength[5] = {3.5*fgkmm,
430 6.5*fgkmm,75.0*fgkmm,8.0*fgkmm,2.0*fgkmm};
431const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverWidth[7] = {30.9*fgkmm,
432 47.5*fgkmm,12.6*fgkmm,5.6*fgkmm,
433 20.0*fgkmm,7.0*fgkmm,5.9*fgkmm};
434const Double_t AliITSv11GeometrySSD::fgkEndCapSideCoverThickness = 0.4*fgkmm;
435/////////////////////////////////////////////////////////////////////////////////
436// SSD End Cap Cards Parameters (lengths are in mm and angles in degrees)
437/////////////////////////////////////////////////////////////////////////////////
438const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackLength[3] =
439 {62.0*fgkmm,21.87*fgkmm};
440const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackWidth[2] =
7708d5f3 441 {47.0*fgkmm,0.35*fgkmm};
9b0c60ab 442const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardBackThickness =
443 1.0*fgkmm;
444const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLength = 61.8*fgkmm;
445const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerWidth[2] =
446 {43.5*fgkmm, 0.70*fgkmm};
447const Double_t AliITSv11GeometrySSD::fgkEndCapCardElectBoardLayerThickness =
448 0.15*fgkmm;
449const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorThickness =
450 19.0*fgkmm;
451const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorLength[2] =
452 {4.80*fgkmm,1.1*fgkmm};
453const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorWidth[2] =
454 {3.3*fgkmm,1.10*fgkmm};
455const Double_t AliITSv11GeometrySSD::fgkEndCapCardJMDConnectorToLayer =
456 2.1*fgkmm;
457const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorLength[3] =
458 {5.2*fgkmm,3.5*fgkmm,1.2*fgkmm};
459const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorWidth[2] =
460 {1.9*fgkmm,0.15*fgkmm};
461const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorThickness =
462 19*fgkmm;
463const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorDistance =
464 1.0*fgkmm;
465const Double_t AliITSv11GeometrySSD::fgkEndCapCardCableConnectorToLayer =
466 3.6*fgkmm;
467const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionLength =
468 61.0*fgkmm;
469const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionThickness =
470 5.97*fgkmm;
471const Double_t AliITSv11GeometrySSD::fgkEndCapStripConnectionWidth = 3.0*fgkmm;
472const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBLength[7] =
473 {3.1*fgkmm,68.0*fgkmm,3.6*fgkmm,
474 1.9*fgkmm,2.5*fgkmm,14.2*fgkmm,1.5*fgkmm};
475const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBWidth[5] =
476 {17.0*fgkmm,10.0*fgkmm,5.9*fgkmm,6.4*fgkmm,3.9*fgkmm};
477const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBThickness =
478 1.0*fgkmm;
479const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceElectBoardCardBThickness
480 = 0.15*fgkmm;
481const Double_t AliITSv11GeometrySSD::fgkEndCapInterfaceCardBJMDConnectorSeparation =
482 20.0*fgkmm;
483const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerLength = 68.0*fgkmm;
484const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerWidth = 5.0*fgkmm;
485const Double_t AliITSv11GeometrySSD::fgkEndCapStiffenerThickness = 5.0*fgkmm;
486const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMin = 1.25*fgkmm; // To Be Checked
487const Double_t AliITSv11GeometrySSD::fgkEndCapEffectiveCableRadiusMax = 1.575*fgkmm; // To Be Checked
488/////////////////////////////////////////////////////////////////////////////////
489// SSD End Cap SupportLayer5/6 Side Parameters (lengths are in mm and angles in degrees)
490/////////////////////////////////////////////////////////////////////////////////
491const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLength[2] = {70.424*fgkmm,72.919*fgkmm};
492const Double_t AliITSv11GeometrySSD::fgkEndCapSupportMiddleRadius[2] = {377.0*fgkmm,437.0*fgkmm};
47f8de53 493const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowRadius[2] = {375.0*fgkmm,435.0*fgkmm};
9b0c60ab 494const Double_t AliITSv11GeometrySSD::fgkEndCapSupportHighWidth = 20.0*fgkmm;
495const Double_t AliITSv11GeometrySSD::fgkEndCapSupportLowWidth[2] = {3.0*fgkmm,3.0*fgkmm};
496const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5ITSPosition = 625.0*fgkmm;
497const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay5Position = 2.5*fgkmm;
498const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6ITSPosition = 635.0*fgkmm;
499const Double_t AliITSv11GeometrySSD::fgkEndCapSupportCenterLay6Position = 2.5*fgkmm;
500/////////////////////////////////////////////////////////////////////////////////
47f8de53 501// SSD Cone Parameters (lengths are in mm and angles in degrees)
502/////////////////////////////////////////////////////////////////////////////////
503const Double_t AliITSv11GeometrySSD::fgkSSDLowerPConeRadius = 296.5*fgkmm;
504const Double_t AliITSv11GeometrySSD::fgkSSDPConeAngle = 39.0;
fcfbdd23 505const Double_t AliITSv11GeometrySSD::fgkSSDPConeZLength[2] = {168.0*fgkmm,153.0*fgkmm};
47f8de53 506const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleRadius = 317.5*fgkmm;
507const Double_t AliITSv11GeometrySSD::fgkSSDPConeLittleHoleLength = 20.*fgkmm;
508const Double_t AliITSv11GeometrySSD::fgkSSDConeMiddleRadius = 350.*fgkmm;
509const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleLength = 30.*fgkmm;
510const Double_t AliITSv11GeometrySSD::fgkSSDPConeMiddleWidth = 40.*fgkmm;
511const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpRadius = 400.*fgkmm;
fcfbdd23 512const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMaxRadius = 459.*fgkmm;
47f8de53 513const Double_t AliITSv11GeometrySSD::fgkSSDPConeUpMiddleRadius = 472.5*fgkmm;
514const Double_t AliITSv11GeometrySSD::fgkSSDPConeDownRadius = 282.0*fgkmm;
515const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidAngle = 42.0;
516const Double_t AliITSv11GeometrySSD::fgkSSDPConeTrapezoidBasis = 200.0*fgkmm;
517const Double_t AliITSv11GeometrySSD::fgkSSDPConeExternalRadius = 492.5*fgkmm;
518const Double_t AliITSv11GeometrySSD::fgkSSDPConeRadiusWidth = 16.75*fgkmm;
fcfbdd23 519const Double_t AliITSv11GeometrySSD::fgkSSDPConeLength = 168.0*fgkmm;
47f8de53 520const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportLength = 1020.*fgkmm;
521const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportRadius = 297.5*fgkmm;
522const Double_t AliITSv11GeometrySSD::fgkSSDCentralSupportWidth = 6.28*fgkmm;
523const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportLength = 60.0*fgkmm;
524const Double_t AliITSv11GeometrySSD::fgkSSDCentralAL3SupportWidth = 2.5*fgkSSDCentralSupportWidth;
525/////////////////////////////////////////////////////////////////////////////////
526// SSD Cables Parameters (lengths are in mm and angles in degrees)
527/////////////////////////////////////////////////////////////////////////////////
528const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5TubeRadiusMin = 11.9*fgkmm;
529const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay6TubeRadiusMin = 11.9*fgkmm;
530const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5RightSideHeight = 7.*fgkmm; // to be fixed in order to reproduce material budget
531const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay6RightSideHeight = 7.*fgkmm; // to be fixed in order to reproduce material budget
532const Double_t AliITSv11GeometrySSD::fgkSSDCableAngle = 22.5;
533const Double_t AliITSv11GeometrySSD::fgkSSDCablesLay5RightSideWaterHeight = 2.5*fgkmm; // to be fixed in order to reproduce material budget
534const Double_t AliITSv11GeometrySSD::fgkSSDCablesPatchPanel2RB26Angle[2] = {25.0,53.2};
535const Double_t AliITSv11GeometrySSD::fgkSSDCablesPatchPanel2RB24Angle[2] = {23.0,53.6};
536const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26ITSDistance = 975.0*fgkmm;
537const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24ITSDistance = 1020.0*fgkmm;
538const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = 451.3*fgkmm;
539const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = 451.3*fgkmm;
540const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanelHeigth = 87.5*fgkmm;
541const Double_t AliITSv11GeometrySSD::fgkSSDCableMaterialBudgetHeight = 20.0*fgkmm;
542//const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB26Radius = fgkSSDPConeExternalRadius;
543//const Double_t AliITSv11GeometrySSD::fgkSSDPatchPanel2RB24Radius = fgkSSDPConeExternalRadius;
544/////////////////////////////////////////////////////////////////////////////////
44285dfa 545ClassImp(AliITSv11GeometrySSD)
546/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 547AliITSv11GeometrySSD::AliITSv11GeometrySSD():
548 AliITSv11Geometry(),
44285dfa 549 fSSDChipMedium(),
550 fSSDChipGlueMedium(),
551 fSSDStiffenerMedium(),
552 fSSDStiffenerConnectorMedium(),
553 fSSDStiffener0603CapacitorMedium(),
554 fSSDStiffener1812CapacitorMedium(),
555 fSSDStiffenerHybridWireMedium(),
556 fSSDKaptonFlexMedium(),
557 fSSDAlTraceFlexMedium(),
558 fSSDAlTraceLadderCableMedium(),
559 fSSDKaptonLadderCableMedium(),
560 fSSDKaptonChipCableMedium(),
561 fSSDAlTraceChipCableMedium(),
562 fSSDAlCoolBlockMedium(),
563 fSSDSensorMedium(),
564 fSSDSensorSupportMedium(),
565 fSSDCarbonFiberMedium(),
566 fSSDTubeHolderMedium(),
567 fSSDCoolingTubeWater(),
568 fSSDCoolingTubePhynox(),
9b0c60ab 569 fSSDSupportRingAl(),
44285dfa 570 fSSDMountingBlockMedium(),
47f8de53 571 fSSDRohaCellCone(),
bf210566 572 fSSDAir(),
47f8de53 573 fSSDCopper(),
bf210566 574 fCreateMaterials(kFALSE),
575 fTransformationMatrices(kFALSE),
576 fBasicObjects(kFALSE),
577 fcarbonfiberjunction(),
578 fcoolingtubesupport(),
579 fhybridmatrix(),
580 fssdcoolingblocksystem(),
581 fcoolingblocksystematrix(),
582 fssdstiffenerflex(),
583 fssdendflex(),
9b0c60ab 584 fendladdercoolingtubesupportmatrix(),
bf210566 585 fendladdermountingblock(),
9b0c60ab 586 fendladdermountingblockclip(),
bf210566 587 fSSDSensor5(),
588 fSSDSensor6(),
589 fSSDLayer5(),
590 fSSDLayer6(),
591 fMotherVol(),
9b0c60ab 592 fLay5LadderSupportRing(),
593 fLay6LadderSupportRing(),
e5bf64ae 594 fgkEndCapSupportSystem(),
47f8de53 595 fSSDCone(),
44285dfa 596 fColorCarbonFiber(4),
597 fColorRyton(5),
bf210566 598 fColorPhynox(14),
44285dfa 599 fColorSilicon(3),
bf210566 600 fColorAl(38),
44285dfa 601 fColorKapton(6),
602 fColorPolyhamide(5),
603 fColorStiffener(9),
bf210566 604 fColorEpoxy(30),
605 fColorWater(7),
606 fColorG10(41)
44285dfa 607{
608 ////////////////////////
609 // Standard constructor
610 ////////////////////////
44285dfa 611}
612/////////////////////////////////////////////////////////////////////////////////
613AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
9acf2ecc 614 AliITSv11Geometry(s.GetDebug()),
44285dfa 615 fSSDChipMedium(s.fSSDChipMedium),
616 fSSDChipGlueMedium(s.fSSDChipGlueMedium),
617 fSSDStiffenerMedium(s.fSSDStiffenerMedium),
618 fSSDStiffenerConnectorMedium(s.fSSDStiffenerConnectorMedium),
619 fSSDStiffener0603CapacitorMedium(s.fSSDStiffener0603CapacitorMedium),
620 fSSDStiffener1812CapacitorMedium(s.fSSDStiffener1812CapacitorMedium),
621 fSSDStiffenerHybridWireMedium(s.fSSDStiffenerHybridWireMedium),
622 fSSDKaptonFlexMedium(s.fSSDKaptonFlexMedium),
623 fSSDAlTraceFlexMedium(s.fSSDAlTraceFlexMedium),
624 fSSDAlTraceLadderCableMedium(s.fSSDAlTraceLadderCableMedium),
625 fSSDKaptonLadderCableMedium(s.fSSDKaptonLadderCableMedium),
626 fSSDKaptonChipCableMedium(s.fSSDKaptonChipCableMedium),
627 fSSDAlTraceChipCableMedium(s.fSSDAlTraceChipCableMedium),
628 fSSDAlCoolBlockMedium(s.fSSDAlCoolBlockMedium),
629 fSSDSensorMedium(s.fSSDSensorMedium),
630 fSSDSensorSupportMedium(s.fSSDSensorSupportMedium),
631 fSSDCarbonFiberMedium(s.fSSDCarbonFiberMedium),
632 fSSDTubeHolderMedium(s.fSSDTubeHolderMedium),
633 fSSDCoolingTubeWater(s.fSSDCoolingTubeWater),
634 fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox),
9b0c60ab 635 fSSDSupportRingAl(s.fSSDSupportRingAl),
44285dfa 636 fSSDMountingBlockMedium(s.fSSDMountingBlockMedium),
47f8de53 637 fSSDRohaCellCone(s.fSSDRohaCellCone),
bf210566 638 fSSDAir(s.fSSDAir),
47f8de53 639 fSSDCopper(s.fSSDCopper),
bf210566 640 fCreateMaterials(s.fCreateMaterials),
641 fTransformationMatrices(s.fTransformationMatrices),
642 fBasicObjects(s.fBasicObjects),
643 fcarbonfiberjunction(s.fcarbonfiberjunction),
644 fcoolingtubesupport(s.fcoolingtubesupport),
645 fhybridmatrix(s.fhybridmatrix),
646 fssdcoolingblocksystem(s.fssdcoolingblocksystem),
647 fcoolingblocksystematrix(s.fcoolingblocksystematrix),
648 fssdstiffenerflex(s.fssdstiffenerflex),
649 fssdendflex(s.fssdendflex),
9b0c60ab 650 fendladdercoolingtubesupportmatrix(s.fendladdercoolingtubesupportmatrix),
bf210566 651 fendladdermountingblock(s.fendladdermountingblock),
9b0c60ab 652 fendladdermountingblockclip(s.fendladdermountingblockclip),
bf210566 653 fSSDSensor5(s.fSSDSensor5),
654 fSSDSensor6(s.fSSDSensor6),
655 fSSDLayer5(s.fSSDLayer5),
656 fSSDLayer6(s.fSSDLayer6),
44285dfa 657 fMotherVol(s.fMotherVol),
9b0c60ab 658 fLay5LadderSupportRing(s.fLay5LadderSupportRing),
659 fLay6LadderSupportRing(s.fLay6LadderSupportRing),
e5bf64ae 660 fgkEndCapSupportSystem(s.fgkEndCapSupportSystem),
47f8de53 661 fSSDCone(s.fSSDCone),
44285dfa 662 fColorCarbonFiber(s.fColorCarbonFiber),
663 fColorRyton(s.fColorRyton),
664 fColorPhynox(s.fColorPhynox),
665 fColorSilicon(s.fColorSilicon),
666 fColorAl(s.fColorAl),
667 fColorKapton(s.fColorKapton),
668 fColorPolyhamide(s.fColorPolyhamide),
669 fColorStiffener(s.fColorStiffener),
bf210566 670 fColorEpoxy(s.fColorEpoxy),
671 fColorWater(s.fColorWater),
672 fColorG10(s.fColorG10)
44285dfa 673{
674 ////////////////////////
675 // Copy Constructor
676 ////////////////////////
d7599219 677}
678/////////////////////////////////////////////////////////////////////////////////
44285dfa 679AliITSv11GeometrySSD& AliITSv11GeometrySSD::
680operator=(const AliITSv11GeometrySSD &s){
681 ////////////////////////
682 // Assignment operator
683 ////////////////////////
684 this->~AliITSv11GeometrySSD();
685 new(this) AliITSv11GeometrySSD(s);
686 return *this;
687/*
688 if(&s == this) return *this;
689 fMotherVol = s.fMotherVol;
690 return *this;
691 */
692}
bf210566 693///////////////////////////////////////////////////////////////////////////////
694void AliITSv11GeometrySSD::CreateTransformationMatrices(){
695 ///////////////////////////////////////////////////////////////////////
696 // Method generating the trasformation matrix for the whole SSD Geometry
697 ///////////////////////////////////////////////////////////////////////
698 // Setting some variables for Carbon Fiber Supportmatrix creation
699 //////////////////////////////////////////////////////////////////////
700 Double_t carbonfibersupportxaxisEdgeproj = fgkCarbonFiberSupportEdgeLength
701 * CosD(fgkCarbonFiberJunctionAngle[0]);
702 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
703 + fgkCarbonFiberSupportTopEdgeDist[0]
704 + fgkCarbonFiberSupportWidth);
705 Double_t carbonfibersupportheight = carbonfibersupportxaxisEdgeproj
706 * TanD(fgkCarbonFiberJunctionAngle[0]);
707 TGeoRotation* carbonfiberot[3];
708 for(Int_t i=0; i<3; i++) carbonfiberot[i] = new TGeoRotation();
709 carbonfiberot[0]->SetAngles(0.0,180.0,0.0);
710 carbonfiberot[1]->SetAngles(90.,-fgkCarbonFiberTriangleAngle,-90.);
711 carbonfiberot[2]->SetRotation((*carbonfiberot[1])*(*carbonfiberot[0]));
712 Double_t transvector[3] = {fgkCarbonFiberTriangleLength
713 * CosD(fgkCarbonFiberTriangleAngle),0.,
714 - fgkCarbonFiberTriangleLength
715 * SinD(fgkCarbonFiberTriangleAngle)};
716 ///////////////////////////////////////////
717 //Setting Local Translations and Rotations:
718 ///////////////////////////////////////////
719 TGeoCombiTrans* localcarbonfibersupportmatrix[3];
720 localcarbonfibersupportmatrix[0] = new TGeoCombiTrans(0.0,0.0,
721 0.5*carbonfibersupportheight,NULL);
722 localcarbonfibersupportmatrix[1] = new TGeoCombiTrans(transvector[0],
723 2.*symmetryplaneposition+transvector[1],
724 transvector[2], carbonfiberot[2]);
725 localcarbonfibersupportmatrix[2] = new TGeoCombiTrans(*carbonfiberot[1]);
726 /////////////////////////////////////////////////////////////
727 // Carbon Fiber Support Transformations
728 /////////////////////////////////////////////////////////////
729 const Int_t kcarbonfibersupportmatrixnumber[2] = {2,3};
730 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++){
731 fcarbonfibersupportmatrix[i] = new TGeoHMatrix();
732 for(Int_t j=0; j<kcarbonfibersupportmatrixnumber[i]; j++)
733 fcarbonfibersupportmatrix[i]->MultiplyLeft(localcarbonfibersupportmatrix[i==0?2*j:j]);
734 }
735 /////////////////////////////////////////////////////////////
736 // Carbon Fiber Junction Transformation
737 /////////////////////////////////////////////////////////////
738 const Int_t kcarbonfiberjunctionmatrixnumber = 2;
739 TGeoCombiTrans** localcarbonfiberjunctionmatrix[fgkcarbonfiberjunctionumber];
740 TGeoRotation** localcarbonfiberjunctionrot[fgkcarbonfiberjunctionumber];
741 TGeoTranslation** localcarbonfiberjunctiontrans[fgkcarbonfiberjunctionumber];
742 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
743 localcarbonfiberjunctionmatrix[i] =
744 new TGeoCombiTrans*[kcarbonfiberjunctionmatrixnumber];
745 localcarbonfiberjunctionrot[i] =
746 new TGeoRotation*[kcarbonfiberjunctionmatrixnumber];
747 localcarbonfiberjunctiontrans[i] =
748 new TGeoTranslation*[kcarbonfiberjunctionmatrixnumber];
d7599219 749 }
bf210566 750 ///////////////////////
751 // Setting Translations
752 ///////////////////////
753 localcarbonfiberjunctiontrans[0][0] = new TGeoTranslation(0.,0.,0.);
754 localcarbonfiberjunctiontrans[1][0] =
755 new TGeoTranslation(fgkCarbonFiberTriangleLength,0.0,0.0);
756 localcarbonfiberjunctiontrans[2][0] =
757 new TGeoTranslation(fgkCarbonFiberTriangleLength
758 * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),
759 fgkCarbonFiberTriangleLength
760 * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad()),0.0);
761 localcarbonfiberjunctiontrans[0][1] =
762 new TGeoTranslation(0.0,0.5*fgkCarbonFiberJunctionWidth,0.0);
763 localcarbonfiberjunctiontrans[1][1] =
764 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
765 localcarbonfiberjunctiontrans[2][1] =
766 new TGeoTranslation(*localcarbonfiberjunctiontrans[0][1]);
767 ////////////////////
768 // Setting Rotations
769 ////////////////////
770 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
771 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++)
772 localcarbonfiberjunctionrot[i][j] = new TGeoRotation();
773 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++)
774 localcarbonfiberjunctionrot[i][0]->SetAngles(120.*i,0.0,0.0);
775 localcarbonfiberjunctionrot[0][1]->SetAngles(0.0,90.0,0.0);
776 localcarbonfiberjunctionrot[1][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
777 localcarbonfiberjunctionrot[2][1]->SetRotation(*localcarbonfiberjunctionrot[0][1]);
778 ////////////////////////////////////////
779 // Setting Carbon Fiber Junction matrix
780 ////////////////////////////////////////
781 for(Int_t i=0; i<fgkcarbonfiberjunctionumber; i++){
782 fcarbonfiberjunctionmatrix[i] = new TGeoHMatrix();
783 for(Int_t j=0; j<kcarbonfiberjunctionmatrixnumber; j++){
784 localcarbonfiberjunctionmatrix[i][j] =
785 new TGeoCombiTrans(*localcarbonfiberjunctiontrans[i][j],
786 *localcarbonfiberjunctionrot[i][j]);
787 fcarbonfiberjunctionmatrix[i]->MultiplyLeft(localcarbonfiberjunctionmatrix[i][j]);
788 }
d7599219 789 }
bf210566 790 /////////////////////////////////////////////////////////////
791 // Carbon Fiber Lower Support Transformations
792 /////////////////////////////////////////////////////////////
793 TGeoTranslation* localcarbonfiberlowersupportrans[2];
794 localcarbonfiberlowersupportrans[0] = new TGeoTranslation(0.0,
795 fgkCarbonFiberLowerSupportVolumePosition[1]
796 + fgkCarbonFiberLowerSupportVolumePosition[0],
797 0.0);
798 localcarbonfiberlowersupportrans[1] = new TGeoTranslation(0.0,
799 fgkCarbonFiberJunctionWidth
800 - fgkCarbonFiberLowerSupportWidth
801 - fgkCarbonFiberLowerSupportVolumePosition[0]
802 - fgkCarbonFiberLowerSupportVolumePosition[1],
803 - 0.5*fgkCarbonFiberLowerSupportHeight);
804 localcarbonfiberlowersupportrans[0]->Add(localcarbonfiberlowersupportrans[1]);
805 fcarbonfiberlowersupportrans[0] =
806 new TGeoTranslation(*localcarbonfiberlowersupportrans[0]);
807 fcarbonfiberlowersupportrans[1] =
808 new TGeoTranslation(*localcarbonfiberlowersupportrans[1]);
809 /////////////////////////////////////////////////////////////
810 // SSD Sensor Support Transformations
811 /////////////////////////////////////////////////////////////
812 const Int_t kssdsensorsupportmatrixnumber = 3;
813 TGeoCombiTrans** localssdsensorsupportmatrix[fgkssdsensorsupportnumber];
814 TGeoRotation** localssdsensorsupportrot[fgkssdsensorsupportnumber];
815 TGeoTranslation** localssdsensorsupportrans[fgkssdsensorsupportnumber];
816 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
817 localssdsensorsupportmatrix[i] =
818 new TGeoCombiTrans*[kssdsensorsupportmatrixnumber];
819 localssdsensorsupportrot[i] =
820 new TGeoRotation*[kssdsensorsupportmatrixnumber];
821 localssdsensorsupportrans[i] =
822 new TGeoTranslation*[kssdsensorsupportmatrixnumber];
d7599219 823 }
bf210566 824 ///////////////////////
825 // Setting Translations
826 ///////////////////////
827 localssdsensorsupportrans[0][0] = new TGeoTranslation(0.0,
828 0.5*fgkSSDSensorSideSupportWidth,
829 0.0);
830 localssdsensorsupportrans[1][0] =
831 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
832 localssdsensorsupportrans[2][0] =
833 new TGeoTranslation(*localssdsensorsupportrans[0][0]);
834 localssdsensorsupportrans[0][1] =
835 new TGeoTranslation(-0.5*fgkSSDSensorSideSupportWidth,
836 0.5*fgkSSDSensorSideSupportThickness[0],
837 0.0);
838 localssdsensorsupportrans[1][1] =
839 new TGeoTranslation(0.5*fgkSSDSensorSideSupportWidth,
840 - 0.5*fgkSSDSensorSideSupportThickness[0]
841 - fgkSSDModuleSensorSupportDistance,
842 0.0);
843 localssdsensorsupportrans[2][1] =
844 new TGeoTranslation(0.5*fgkSSDSensorCenterSupportThickness[0]
845 - fgkSSDSensorCenterSupportPosition,
846 0.5*fgkSSDSensorCenterSupportWidth
847 - 0.5*fgkSSDModuleSensorSupportDistance,
848 fgkSSDSensorCenterSupportThickness[0]);
849 localssdsensorsupportrans[0][2] =
850 new TGeoTranslation(fgkCarbonFiberTriangleLength
851 + fgkCarbonFiberJunctionToSensorSupport,
852 fgkCarbonFiberJunctionWidth
853 - 0.5*(fgkCarbonFiberLowerSupportWidth
854 + fgkSSDSensorCenterSupportLength
855 - fgkSSDSensorCenterSupportThickness[0])
856 - fgkSSDSensorCenterSupportPosition,
857 0.0);
858 localssdsensorsupportrans[1][2] =
859 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
860 localssdsensorsupportrans[2][2] =
861 new TGeoTranslation(*localssdsensorsupportrans[0][2]);
862 ////////////////////
863 // Setting Rotations
864 ////////////////////
865 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++)
866 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++)
867 localssdsensorsupportrot[i][j] = new TGeoRotation();
868 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
869 localssdsensorsupportrot[i][0]->SetAngles(0.0,90.0,0.0);
870 localssdsensorsupportrot[i][2]->SetAngles(-90.0,0.0,0.0);
d7599219 871 }
bf210566 872 localssdsensorsupportrot[0][1]->SetAngles(0.0,90.0,-90.0);
873 localssdsensorsupportrot[1][1]->SetAngles(180.0,90.0,-90.0);
874 localssdsensorsupportrot[2][1]->SetAngles(270.0,90.0,-90.0);
875 ////////////////////////////////////////
876 // SSD Sensor Support matrix
877 ////////////////////////////////////////
878 for(Int_t i=0; i<fgkssdsensorsupportnumber; i++){
879 fssdsensorsupportmatrix[i] = new TGeoHMatrix();
880 for(Int_t j=0; j<kssdsensorsupportmatrixnumber; j++){
881 localssdsensorsupportmatrix[i][j] =
882 new TGeoCombiTrans(*localssdsensorsupportrans[i][j],
883 *localssdsensorsupportrot[i][j]);
884 fssdsensorsupportmatrix[i]->MultiplyLeft(localssdsensorsupportmatrix[i][j]);
885 }
d7599219 886 }
44285dfa 887 /////////////////////////////////////////////////////////////
bf210566 888 // SSD Cooling Tube Support Transformations
44285dfa 889 /////////////////////////////////////////////////////////////
bf210566 890 const Int_t kcoolingtubesupportmatrixnumber = 2;
891 TGeoCombiTrans* localcoolingtubesupportmatrix[kcoolingtubesupportmatrixnumber];
892 TGeoTranslation* localcoolingtubesupportrans[kcoolingtubesupportmatrixnumber];
893 TGeoRotation* localcoolingtubesupportrot[kcoolingtubesupportmatrixnumber];
44285dfa 894 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
d7599219 895 /fgkCoolingTubeSupportRmax);
bf210566 896 localcoolingtubesupportrans[0] =
897 new TGeoTranslation(2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
d7599219 898 + 2.*(fgkCoolingTubeSupportLength
44285dfa 899 - fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
d7599219 900 + fgkCarbonFiberTriangleLength
bf210566 901 - 2.0*fgkCarbonFiberJunctionLength,0.0,0.0);
902 localcoolingtubesupportrans[1] =
903 new TGeoTranslation(fgkCarbonFiberJunctionLength
904 - (fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax),
905 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
906 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
907 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
908 - 0.5*(fgkCarbonFiberLowerSupportWidth
909 + fgkSSDSensorCenterSupportLength
910 - fgkSSDSensorCenterSupportThickness[0])
911 + 0.5*fgkSSDSensorLength,
912 - 0.5*fgkCoolingTubeSupportHeight);
913 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
914 localcoolingtubesupportrot[i] = new TGeoRotation();
915 localcoolingtubesupportrot[0]->SetAngles(180.0,0.0,0.0);
916 localcoolingtubesupportrot[1]->SetAngles(0.0,90.0,0.0);
917 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++)
918 localcoolingtubesupportmatrix[i] =
919 new TGeoCombiTrans(*localcoolingtubesupportrans[i],
920 *localcoolingtubesupportrot[i]);
921 fcoolingtubesupportmatrix[0] = new TGeoHMatrix(*localcoolingtubesupportmatrix[1]);
922 fcoolingtubesupportmatrix[1] = new TGeoHMatrix((*localcoolingtubesupportmatrix[1])*
923 (*localcoolingtubesupportmatrix[0]));
924 /////////////////////////////////////////////////////////////
9b0c60ab 925 // End Ladder SSD Cooling Tube Support Transformations
926 /////////////////////////////////////////////////////////////
927 TGeoTranslation** localendladdercooltubetrans[2];
928 localendladdercooltubetrans[0] = new TGeoTranslation*[4];
929 localendladdercooltubetrans[1] = new TGeoTranslation*[2];
930 for(Int_t i=0; i<4; i++) localendladdercooltubetrans[0][i] = new TGeoTranslation();
931 localendladdercooltubetrans[0][0]->SetTranslation(fgkCarbonFiberJunctionLength
932 - (fgkCoolingTubeSupportLength
933 - fgkCoolingTubeSupportRmax),
934 fgkEndLadderMountingBlockPosition[0]
935 - fgkendladdercoolingsupportdistance[0]
936 + 0.5*fgkCoolingTubeSupportWidth,
937 - 0.5*fgkCoolingTubeSupportHeight);
938 localendladdercooltubetrans[0][1]->SetTranslation(fgkCarbonFiberJunctionLength
939 - (fgkCoolingTubeSupportLength
940 - fgkCoolingTubeSupportRmax),
941 fgkEndLadderMountingBlockPosition[0]
942 + fgkendladdercoolingsupportdistance[1]
943 + 0.5*fgkCoolingTubeSupportWidth,
944 - 0.5*fgkCoolingTubeSupportHeight);
945 localendladdercooltubetrans[0][2]->SetTranslation(2*(fgkCoolingTubeSupportLength
946 - fgkCoolingTubeSupportRmax)
947 + fgkCarbonFiberTriangleLength
948 - 2.0*fgkCarbonFiberJunctionLength,
949 0.0,
950 0.0);
951 localendladdercooltubetrans[0][3]->SetTranslation(0.0,
952 fgkendladdercoolingsupportdistance[0]
953 + fgkendladdercoolingsupportdistance[1],
954 0.0);
955 for(Int_t i=0; i<2; i++) localendladdercooltubetrans[1][i] = new TGeoTranslation();
956 localendladdercooltubetrans[1][0]->SetTranslation(fgkCoolingTubeSupportRmax
957 + fgkCarbonFiberJunctionLength
958 - fgkCoolingTubeSupportLength,
959 fgkEndLadderCarbonFiberLowerJunctionLength[1]
960 - 0.5*fgkCoolingTubeSupportWidth
961 -fgkendladdercoolingsupportdistance[2],
962 - 0.5*fgkCoolingTubeSupportHeight);
963 localendladdercooltubetrans[1][1]->SetTranslation(fgkCarbonFiberTriangleLength
964 + fgkCoolingTubeSupportLength
965 - fgkCoolingTubeSupportRmax
966 - fgkCarbonFiberJunctionLength,
967 fgkEndLadderCarbonFiberLowerJunctionLength[1]
968 - 0.5*fgkCoolingTubeSupportWidth
969 - fgkendladdercoolingsupportdistance[2],
970 - 0.5*fgkCoolingTubeSupportHeight);
971 fendladdercoolingtubesupportmatrix = new TGeoHMatrix**[kcoolingtubesupportmatrixnumber];
972 fendladdercoolingtubesupportmatrix[0] = new TGeoHMatrix*[4];
973 fendladdercoolingtubesupportmatrix[1] = new TGeoHMatrix*[2];
974 fendladdercoolingtubesupportmatrix[0][0] = new TGeoHMatrix((*localendladdercooltubetrans[0][0])*
975 (*localcoolingtubesupportrot[1]));
976 fendladdercoolingtubesupportmatrix[0][1] = new TGeoHMatrix((*localendladdercooltubetrans[0][1])*
977 (*localcoolingtubesupportrot[1]));
978 fendladdercoolingtubesupportmatrix[0][2] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][0]);
979 fendladdercoolingtubesupportmatrix[0][2]->Multiply(localcoolingtubesupportrot[0]);
980 fendladdercoolingtubesupportmatrix[0][2]->MultiplyLeft(localendladdercooltubetrans[0][2]);
981 fendladdercoolingtubesupportmatrix[0][3] = new TGeoHMatrix(*fendladdercoolingtubesupportmatrix[0][2]);
982 fendladdercoolingtubesupportmatrix[0][3]->MultiplyLeft(localendladdercooltubetrans[0][3]);
983
984 fendladdercoolingtubesupportmatrix[1][0] =
985 new TGeoHMatrix((*localendladdercooltubetrans[1][0])
986 *(*localcoolingtubesupportrot[1]));
987 fendladdercoolingtubesupportmatrix[1][1] = new TGeoHMatrix(*localcoolingtubesupportrot[1]);
988 fendladdercoolingtubesupportmatrix[1][1]->Multiply(localcoolingtubesupportrot[0]);
989 fendladdercoolingtubesupportmatrix[1][1]->MultiplyLeft(localendladdercooltubetrans[1][1]);
990 /////////////////////////////////////////////////////////////
bf210566 991 // SSD Cooling Tube Transformations
992 /////////////////////////////////////////////////////////////
993 TGeoRotation* localcoolingtuberot = new TGeoRotation();
994 localcoolingtuberot->SetAngles(0.,90.,0.);
995 TGeoTranslation** localcoolingtubetrans[4];
996 TVector3** localcoolingtubevect[4];
997 for(Int_t i=0; i<4; i++){
998 localcoolingtubevect[i] = new TVector3*[2];
999 localcoolingtubetrans[i] = new TGeoTranslation*[2];
1000 fcoolingtubematrix[i] = new TGeoHMatrix*[2];
d7599219 1001 }
bf210566 1002 localcoolingtubevect[0][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
1003 -fgkCarbonFiberTriangleLength),
1004 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1005 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1006 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1007 - 0.5*(fgkCarbonFiberLowerSupportWidth
1008 + fgkSSDSensorCenterSupportLength
1009 - fgkSSDSensorCenterSupportThickness[0])+
1010 0.5*fgkSSDSensorLength-0.25*(fgkSSDSensorLength
1011 - 2.0*fgkSSDModuleStiffenerPosition[1]
1012 - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
1013 - 0.5*fgkCoolingTubeSupportWidth,
1014 - 0.5*fgkCoolingTubeSupportHeight);
1015 localcoolingtubevect[0][1] = new TVector3(localcoolingtubevect[0][0]->X(),
1016 localcoolingtubevect[0][0]->Y()+0.5*(fgkSSDSensorLength
1017 - 2.0*fgkSSDModuleStiffenerPosition[1]
1018 - 2.0*fgkSSDCoolingBlockWidth-fgkCoolingTubeSupportWidth)
1019 + fgkCoolingTubeSupportWidth,
1020 localcoolingtubevect[0][0]->Z());
1021 localcoolingtubevect[1][0] = new TVector3(-localcoolingtubevect[0][0]->X()
1022 + fgkCarbonFiberTriangleLength,
1023 localcoolingtubevect[0][0]->Y(),
1024 localcoolingtubevect[0][0]->Z());
1025 localcoolingtubevect[1][1] = new TVector3(-localcoolingtubevect[0][1]->X()
1026 + fgkCarbonFiberTriangleLength,
1027 localcoolingtubevect[0][1]->Y(),
1028 localcoolingtubevect[0][1]->Z());
1029 localcoolingtubevect[2][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
1030 - fgkCarbonFiberTriangleLength),
1031 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1032 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1033 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1034 - 0.5*(fgkCarbonFiberLowerSupportWidth
1035 + fgkSSDSensorCenterSupportLength
1036 - fgkSSDSensorCenterSupportThickness[0])
1037 + fgkSSDModuleStiffenerPosition[1]
1038 - 0.5*(fgkSSDModuleStiffenerPosition[1]-fgkSSDSensorOverlap),
1039 - 0.5*fgkCoolingTubeSupportHeight);
1040 localcoolingtubevect[2][1] = new TVector3(-localcoolingtubevect[2][0]->X()
1041 + fgkCarbonFiberTriangleLength,
1042 localcoolingtubevect[2][0]->Y(),
1043 localcoolingtubevect[2][0]->Z());
1044 localcoolingtubevect[3][0] = new TVector3(-0.5*(fgkCoolingTubeSeparation
1045 - fgkCarbonFiberTriangleLength),
1046 - (2.0*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1047 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1048 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1049 - 0.5*(fgkCarbonFiberLowerSupportWidth
1050 + fgkSSDSensorCenterSupportLength
1051 - fgkSSDSensorCenterSupportThickness[0])
1052 + fgkSSDSensorLength
1053 - 0.5*fgkSSDModuleStiffenerPosition[1],
1054 - 0.5*fgkCoolingTubeSupportHeight);
1055 localcoolingtubevect[3][1] = new TVector3(-localcoolingtubevect[3][0]->X()
1056 + fgkCarbonFiberTriangleLength,
1057 localcoolingtubevect[3][0]->Y(),
1058 - 0.5*fgkCoolingTubeSupportHeight);
1059 for(Int_t i=0; i<4; i++)
1060 for(Int_t j=0; j<2; j++){
1061 localcoolingtubetrans[i][j] =
1062 new TGeoTranslation(localcoolingtubevect[i][j]->X(),
1063 localcoolingtubevect[i][j]->Y(),
1064 localcoolingtubevect[i][j]->Z());
1065 fcoolingtubematrix[i][j] = new TGeoHMatrix((*localcoolingtubetrans[i][j])
1066 * (*localcoolingtuberot));
1067 }
1068 /////////////////////////////////////////////////////////////
9b0c60ab 1069 // SSD End Ladder Cooling Tube Transformations
1070 /////////////////////////////////////////////////////////////
1071 TGeoRotation* localendlladdercoolingtuberot = new TGeoRotation();
1072 localendlladdercoolingtuberot->SetAngles(0.,90.,0.);
1073 TGeoTranslation** localendlladdercoolingtubetrans[2];
1074 localendlladdercoolingtubetrans[0] = new TGeoTranslation*[6];
1075 localendlladdercoolingtubetrans[1] = new TGeoTranslation*[4];
1076 for(Int_t i=0; i<2; i++)
1077 for(Int_t j=0; j<(i==0?6:4); j++)
1078 localendlladdercoolingtubetrans[i][j] = new TGeoTranslation();
1079 localendlladdercoolingtubetrans[0][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1080 - fgkCoolingTubeSupportRmax)
1081 + fgkCarbonFiberJunctionLength,
1082 0.5*(fgkEndLadderMountingBlockPosition[0]
1083 - fgkendladdercoolingsupportdistance[0]),
1084 - 0.5*fgkCoolingTubeSupportHeight);
1085 localendlladdercoolingtubetrans[0][1]->SetTranslation((fgkCoolingTubeSupportLength
1086 - fgkCoolingTubeSupportRmax)
1087 - fgkCarbonFiberJunctionLength
1088 + fgkCarbonFiberTriangleLength,
1089 0.5*(fgkEndLadderMountingBlockPosition[0]
1090 - fgkendladdercoolingsupportdistance[0]),
1091 - 0.5*fgkCoolingTubeSupportHeight);
1092 localendlladdercoolingtubetrans[0][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1093 - fgkCoolingTubeSupportRmax)
1094 + fgkCarbonFiberJunctionLength,
1095 fgkEndLadderMountingBlockPosition[0]
1096 - fgkendladdercoolingsupportdistance[0]
1097 + 0.5*(fgkendladdercoolingsupportdistance[0]
1098 + fgkendladdercoolingsupportdistance[1]
1099 + fgkCoolingTubeSupportWidth),
1100 - 0.5*fgkCoolingTubeSupportHeight);
1101 localendlladdercoolingtubetrans[0][3]->SetTranslation((fgkCoolingTubeSupportLength
1102 - fgkCoolingTubeSupportRmax)
1103 - fgkCarbonFiberJunctionLength
1104 + fgkCarbonFiberTriangleLength,
1105 fgkEndLadderMountingBlockPosition[0]
1106 - fgkendladdercoolingsupportdistance[0]
1107 + 0.5*(fgkendladdercoolingsupportdistance[0]
1108 + fgkendladdercoolingsupportdistance[1]
1109 + fgkCoolingTubeSupportWidth),
1110 - 0.5*fgkCoolingTubeSupportHeight);
1111 localendlladdercoolingtubetrans[0][4]->SetTranslation(-(fgkCoolingTubeSupportLength
1112 - fgkCoolingTubeSupportRmax)
1113 + fgkCarbonFiberJunctionLength,
1114 fgkEndLadderCarbonFiberLowerJunctionLength[0]
1115 - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1116 - fgkEndLadderMountingBlockPosition[0]
1117 - fgkendladdercoolingsupportdistance[1]
1118 - fgkCoolingTubeSupportWidth),
1119 - 0.5*fgkCoolingTubeSupportHeight);
1120 localendlladdercoolingtubetrans[0][5]->SetTranslation((fgkCoolingTubeSupportLength
1121 - fgkCoolingTubeSupportRmax)
1122 - fgkCarbonFiberJunctionLength
1123 + fgkCarbonFiberTriangleLength,
1124 fgkEndLadderCarbonFiberLowerJunctionLength[0]
1125 - 0.50 * (fgkEndLadderCarbonFiberLowerJunctionLength[0]
1126 - fgkEndLadderMountingBlockPosition[0]
1127 - fgkendladdercoolingsupportdistance[1]
1128 - fgkCoolingTubeSupportWidth),
1129 - 0.5*fgkCoolingTubeSupportHeight);
1130 localendlladdercoolingtubetrans[1][0]->SetTranslation(-(fgkCoolingTubeSupportLength
1131 - fgkCoolingTubeSupportRmax)
1132 + fgkCarbonFiberJunctionLength,
1133 - 0.50 * (fgkMountingBlockToSensorSupport
1134 - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1135 - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1136 + fgkSSDSensorOverlap
1137 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1138 - fgkendladdercoolingsupportdistance[2]
1139 - fgkEndLadderMountingBlockPosition[1]
1140 - fgkCoolingTubeSupportWidth)
1141 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1142 - fgkendladdercoolingsupportdistance[2]
1143 - fgkCoolingTubeSupportWidth,
1144 - 0.5*fgkCoolingTubeSupportHeight);
1145 localendlladdercoolingtubetrans[1][1]->SetTranslation((fgkCoolingTubeSupportLength
1146 - fgkCoolingTubeSupportRmax)
1147 - fgkCarbonFiberJunctionLength
1148 + fgkCarbonFiberTriangleLength,
1149 - 0.50 * (fgkMountingBlockToSensorSupport
1150 - 0.50 * (fgkSSDFlexHoleWidth-fgkSSDSensorSideSupportWidth)
1151 - fgkSSDStiffenerWidth-fgkSSDModuleStiffenerPosition[1]
1152 + fgkSSDSensorOverlap
1153 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1154 - fgkendladdercoolingsupportdistance[2]
1155 - fgkEndLadderMountingBlockPosition[1]
1156 - fgkCoolingTubeSupportWidth)
1157 + fgkEndLadderCarbonFiberLowerJunctionLength[1]
1158 - fgkendladdercoolingsupportdistance[2]
1159 - fgkCoolingTubeSupportWidth,
1160 - 0.5*fgkCoolingTubeSupportHeight);
1161 localendlladdercoolingtubetrans[1][2]->SetTranslation(-(fgkCoolingTubeSupportLength
1162 - fgkCoolingTubeSupportRmax)
1163 + fgkCarbonFiberJunctionLength,
1164 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1165 - 0.5*fgkendladdercoolingsupportdistance[2],
1166 - 0.5*fgkCoolingTubeSupportHeight);
1167 localendlladdercoolingtubetrans[1][3]->SetTranslation((fgkCoolingTubeSupportLength
1168 - fgkCoolingTubeSupportRmax)
1169 - fgkCarbonFiberJunctionLength
1170 + fgkCarbonFiberTriangleLength,
1171 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1172 - 0.5*fgkendladdercoolingsupportdistance[2],
1173 - 0.5*fgkCoolingTubeSupportHeight);
1174 fendladdercoolingtubematrix[0] = new TGeoHMatrix*[6];
1175 fendladdercoolingtubematrix[1] = new TGeoHMatrix*[4];
1176 for(Int_t i=0; i<2; i++)
1177 for(Int_t j=0; j<(i==0?6:4); j++){
1178 fendladdercoolingtubematrix[i][j] = new TGeoHMatrix(*localendlladdercoolingtuberot);
1179 fendladdercoolingtubematrix[i][j]->MultiplyLeft(localendlladdercoolingtubetrans[i][j]);
1180 }
1181 /////////////////////////////////////////////////////////////
bf210566 1182 // SSD Hybrid Components Transformations
1183 /////////////////////////////////////////////////////////////
1184 const Int_t khybridmatrixnumber = 3;
1185 TGeoTranslation* localhybridtrans[khybridmatrixnumber];
1186 localhybridtrans[0] = new TGeoTranslation(0.5*fgkSSDStiffenerLength,
1187 0.5*fgkSSDStiffenerWidth,
1188 0.5*fgkSSDStiffenerHeight);
1189 localhybridtrans[1] = new TGeoTranslation(fgkSSDModuleStiffenerPosition[0],
1190 fgkSSDModuleStiffenerPosition[1],0.0);
1191
1192 localhybridtrans[2] = new TGeoTranslation(
1193 - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1194 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1195 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1196 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1197 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
1198 - fgkSSDSensorCenterSupportThickness[0]),
1199 - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
ca86fdb4 1200 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight
0fb26117 1201 - fgkSSDModuleVerticalDisalignment));
bf210566 1202 fhybridmatrix = new TGeoHMatrix();
1203 for(Int_t i=0; i<khybridmatrixnumber; i++) fhybridmatrix->MultiplyLeft(localhybridtrans[i]);
1204 /////////////////////////////////////////////////////////////
1205 // SSD Cooling Block Transformations
1206 /////////////////////////////////////////////////////////////
1207 const Int_t kcoolingblockmatrixnumber = 4;
1208 TGeoTranslation* localcoolingblocktrans[kcoolingblockmatrixnumber];
1209 localcoolingblocktrans[0] = new TGeoTranslation(-2.*(fgkCoolingTubeSupportRmax
1210 - fgkCoolingTubeSupportRmin),0.0,
1211 0.5*(fgkSSDCoolingBlockHoleCenter+fgkCoolingTubeRmax));
1212 localcoolingblocktrans[1] = new TGeoTranslation(0.5*fgkSSDStiffenerLength
1213 - 0.5*fgkSSDModuleSensorSupportDistance-fgkSSDCoolingBlockLength,
1214 0.0,fgkSSDStiffenerHeight);
1215 localcoolingblocktrans[2] = new TGeoTranslation(*localhybridtrans[1]);
1216 localcoolingblocktrans[3] = new TGeoTranslation(*localhybridtrans[2]);
1217 fcoolingblocksystematrix = new TGeoHMatrix();
1218 for(Int_t i=0; i<kcoolingblockmatrixnumber; i++)
1219 fcoolingblocksystematrix->MultiplyLeft(localcoolingblocktrans[i]);
1220 /////////////////////////////////////////////////////////////
1221 // SSD Stiffener Flex Transformations
1222 /////////////////////////////////////////////////////////////
1223 const Int_t klocalflexmatrixnumber = 4;
1224 TGeoCombiTrans** localflexmatrix[fgkflexnumber];
1225 for(Int_t i=0; i<fgkflexnumber; i++)
1226 localflexmatrix[i] = new TGeoCombiTrans*[klocalflexmatrixnumber];
1227 for(Int_t i=0; i<fgkflexnumber; i++)
1228 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1229 localflexmatrix[i][j] = new TGeoCombiTrans();
1230 Double_t ssdstiffenerseparation = fgkSSDSensorLength
1231 - 2.*fgkSSDModuleStiffenerPosition[1]
1232 - fgkSSDStiffenerWidth;
1233 localflexmatrix[0][0]->SetTranslation(-fgkSSDFlexLength[0]
1234 +0.5*fgkSSDStiffenerLength,
1235 0.5*fgkSSDStiffenerWidth,
1236 -0.5*fgkSSDStiffenerHeight
1237 -0.5*fgkSSDFlexHeight[0]);
1238 localflexmatrix[1][0]->SetTranslation(-(fgkSSDStiffenerLength-fgkSSDFlexLength[0])
1239 +0.5*fgkSSDStiffenerLength,ssdstiffenerseparation
1240 -0.5*fgkSSDStiffenerWidth,
1241 -0.5*fgkSSDStiffenerHeight
1242 -0.5*fgkSSDFlexHeight[0]);
1243 TGeoRotation* localflexrot = new TGeoRotation();
1244 localflexrot->SetAngles(180.,0.,0.);
1245 localflexmatrix[1][0]->SetRotation(localflexrot);
1246 for(Int_t i=0; i<fgkflexnumber; i++)
1247 for(Int_t j =1; j<klocalflexmatrixnumber; j++)
1248 localflexmatrix[i][j]->SetTranslation(*localhybridtrans[j-1]);
1249 for(Int_t i=0; i<fgkflexnumber; i++){
1250 fstiffenerflexmatrix[i] = new TGeoHMatrix();
1251 for(Int_t j =0; j<klocalflexmatrixnumber; j++)
1252 fstiffenerflexmatrix[i]->MultiplyLeft(localflexmatrix[i][j]);
d7599219 1253 }
bf210566 1254 /////////////////////////////////////////////////////////////
1255 // SSD End Flex Transformations
1256 /////////////////////////////////////////////////////////////
1257 TGeoRotation* localendflexrot = new TGeoRotation();
1258 localendflexrot->SetAngles(0.0,90.0,0.0);
1259 TGeoCombiTrans* localendflexmatrix = new TGeoCombiTrans();
1260 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
1261 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
1262 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1263 * TMath::DegToRad()*ssdflexradiusmax
1264 - fgkSSDFlexLength[2]-TMath::Pi()
0fb26117 1265 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1266 - 0.1*fgkSSDFlexFullLength;
bf210566 1267 Double_t trans = ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
1268 + (ssdflexradiusmax-fgkSSDStiffenerHeight)*SinD(2.*fgkSSDFlexAngle)
1269 + fgkSSDFlexLength[2];
1270 localendflexmatrix->SetTranslation(fgkSSDFlexLength[0]-trans,
1271 0.5*fgkSSDFlexWidth[0],
1272 2.*fgkSSDStiffenerHeight
1273 + 0.5*fgkSSDFlexHeight[0]);
1274 localendflexmatrix->SetRotation(localendflexrot);
1275 for(Int_t i=0; i<fgkflexnumber; i++)
1276 fendflexmatrix[i] = new TGeoHMatrix((*fstiffenerflexmatrix[i])*(*localendflexmatrix));
1277 /////////////////////////////////////////////////////////////
1278 // End Ladder Carbon Fiber Junction
1279 /////////////////////////////////////////////////////////////
1280 TGeoCombiTrans** localendladdercarbonfiberjunctionmatrix[fgkendlabbercarbonfiberjunctionumber];
1281 TGeoRotation** localendladdercarbonfiberjunctionrot[fgkendlabbercarbonfiberjunctionumber];
1282 TGeoTranslation** localendladdercarbonfiberjunctiontrans[fgkendlabbercarbonfiberjunctionumber];
1283 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1284 localendladdercarbonfiberjunctionmatrix[i]
1285 = new TGeoCombiTrans*[fgkendladdercabonfiberjunctionmatrixnumber];
1286 localendladdercarbonfiberjunctionrot[i]
1287 = new TGeoRotation*[fgkendladdercabonfiberjunctionmatrixnumber];
1288 localendladdercarbonfiberjunctiontrans[i]
1289 = new TGeoTranslation*[fgkendladdercabonfiberjunctionmatrixnumber];
1290 fendladdercarbonfiberjunctionmatrix[i]
1291 = new TGeoHMatrix*[fgkendladdercabonfiberjunctionmatrixnumber];
d7599219 1292 }
bf210566 1293 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1294 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1295 localendladdercarbonfiberjunctionrot[i][j] = new TGeoRotation();
1296 localendladdercarbonfiberjunctiontrans[i][j] = new TGeoTranslation();
1297 }
1298 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1299 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++)
1300 localendladdercarbonfiberjunctionrot[i][j]->SetAngles(120.*j,0.,0.);
1301 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1302 localendladdercarbonfiberjunctiontrans[i][1]->SetTranslation(fgkCarbonFiberTriangleLength,
1303 0.0,0.0);
1304 localendladdercarbonfiberjunctiontrans[i][2]->SetTranslation(fgkCarbonFiberTriangleLength
1305 * CosD(fgkCarbonFiberTriangleAngle),fgkCarbonFiberTriangleLength
1306 * SinD(fgkCarbonFiberTriangleAngle),
1307 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
1308 - fgkEndLadderCarbonFiberUpperJunctionLength[i]));
1309 }
1310 TGeoCombiTrans* localendladdercarbonfiberjunctionglobalmatrix[fgkendlabbercarbonfiberjunctionumber];
1311 TGeoRotation* localendladdercarbonfiberjunctionglobalrot[fgkendlabbercarbonfiberjunctionumber];
1312 TGeoTranslation* localendladdercarbonfiberjunctionglobaltrans[fgkendlabbercarbonfiberjunctionumber];
1313 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1314 localendladdercarbonfiberjunctionglobalrot[i] = new TGeoRotation();
1315 localendladdercarbonfiberjunctionglobaltrans[i] = new TGeoTranslation();
1316 localendladdercarbonfiberjunctionglobalrot[i]->SetAngles(0.0,90.0,0.0);
1317 localendladdercarbonfiberjunctionglobaltrans[i]->SetTranslation(0.0,
1318 0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],0.0);
1319 localendladdercarbonfiberjunctionglobalmatrix[i] =
1320 new TGeoCombiTrans(*localendladdercarbonfiberjunctionglobaltrans[i],
1321 *localendladdercarbonfiberjunctionglobalrot[i]);
1322 }
1323 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1324 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1325 localendladdercarbonfiberjunctionmatrix[i][j] =
1326 new TGeoCombiTrans(*localendladdercarbonfiberjunctiontrans[i][j],
1327 *localendladdercarbonfiberjunctionrot[i][j]);
1328 fendladdercarbonfiberjunctionmatrix[i][j] =
1329 new TGeoHMatrix((*localendladdercarbonfiberjunctionglobalmatrix[i])
1330 * (*localendladdercarbonfiberjunctionmatrix[i][j]));
1331 }
1332 /////////////////////////////////////////////////////////////
1333 // End Ladder Carbon Fiber Support
1334 /////////////////////////////////////////////////////////////
1335 TGeoTranslation* localendladdercarbonfibertrans[fgkendladdercarbonfibermatrixnumber];
1336 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++){
1337 localendladdercarbonfibertrans[i] = new TGeoTranslation();
1338 localendladdercarbonfibertrans[i]->SetTranslation(0.0,
1339 i==0 ? 0.0 :fgkCarbonFiberLowerSupportWidth,0.0);
1340 fendladdercarbonfibermatrix[i] = new TGeoHMatrix*[fgkcarbonfibersupportnumber];
1341 }
1342 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
1343 for(Int_t j=0; j<fgkcarbonfibersupportnumber; j++)
1344 fendladdercarbonfibermatrix[i][j] =
1345 new TGeoHMatrix((*localendladdercarbonfibertrans[i])
1346 *(*fcarbonfibersupportmatrix[j]));
1347 /////////////////////////////////////////////////////////////
1348 // End Ladder SSD Mounting Block
1349 /////////////////////////////////////////////////////////////
1350 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
9b0c60ab 1351 fendladdermountingblockcombitrans[i] = new TGeoCombiTrans();
1352 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1353 fendladdermountingblockcombitrans[i]->SetTranslation(- 0.25*(fgkSSDMountingBlockLength[0]
bf210566 1354 + fgkSSDMountingBlockLength[1])
1355 + 0.5*fgkCarbonFiberTriangleLength,
1356 fgkEndLadderMountingBlockPosition[i],
1357 - fgkSSDMountingBlockHeight[1]
1358 + 0.5*fgkSSDMountingBlockHeight[0]);
9b0c60ab 1359 TGeoRotation* endladdermountingblockrot = new TGeoRotation();
1360 endladdermountingblockrot->SetAngles(0.,90.,0.);
1361 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1362 fendladdermountingblockcombitrans[i]->SetRotation(*endladdermountingblockrot);
1363 /////////////////////////////////////////////////////////////
1364 // End Ladder SSD Mounting Block Clip Matrix
1365 /////////////////////////////////////////////////////////////
1366 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1367 fendladdermountingblockclipmatrix[i] = new TGeoHMatrix*[2];
1368
1369 TGeoRotation* localendladdercliprot = new TGeoRotation();
1370 TGeoTranslation* localendladdercliptrans = new TGeoTranslation();
1371 localendladdercliptrans->SetTranslation(-0.5*(fgkSSDMountingBlockLength[0]
1372 - fgkSSDMountingBlockLength[1])
1373 + fgkSSDMountingBlockLength[0],0.,0.);
1374 localendladdercliprot->SetAngles(90.,180.,-90.);
1375 TGeoCombiTrans* localendladderclipcombitrans =
1376 new TGeoCombiTrans(*localendladdercliptrans,*localendladdercliprot);
1377 for(Int_t i=0; i<fgkendladdermountingblocknumber; i++)
1378 for(Int_t j=0; j<2; j++){
1379 fendladdermountingblockclipmatrix[i][j] =
1380 new TGeoHMatrix(*fendladdermountingblockcombitrans[i]);
1381 if(j!=0) fendladdermountingblockclipmatrix[i][j]->Multiply(localendladderclipcombitrans);
1382 }
bf210566 1383 /////////////////////////////////////////////////////////////
1384 // End Ladder Carbon Fiber Lower Support
1385 /////////////////////////////////////////////////////////////
1386 for(Int_t i=0; i<fgkendladderlowersuppnumber; i++)
1387 fendladderlowersupptrans[i] =
1388 new TGeoTranslation(0.0,(1-i)*(fgkEndLadderMountingBlockPosition[i]
1389 + 0.5*fgkSSDMountingBlockWidth),
1390 - 0.5*fgkCarbonFiberLowerSupportHeight);
1391 fendladderlowersupptrans[2] = new TGeoTranslation(0.0,
1392 fgkCarbonFiberLowerSupportVolumePosition[1]
1393 + fgkCarbonFiberLowerSupportVolumePosition[0],
1394 0.0);
1395 fendladderlowersupptrans[2]->Add(fendladderlowersupptrans[1]);
1396 /////////////////////////////////////////////////////////////
1397 // Matrix for positioning Ladder into mother volume
1398 /////////////////////////////////////////////////////////////
1399 TGeoHMatrix** ladderglobalmatrix[fgkladdernumber];
1400 for(Int_t i=0; i<fgkladdernumber; i++)
1401 ladderglobalmatrix[i] = new TGeoHMatrix*[fgkladdernumber];
1402 TGeoRotation* localladdermotherrot = new TGeoRotation();
1403 localladdermotherrot->SetAngles(0.,90.,0.);
1404 TGeoTranslation* localladdermothertrans[fgkladdernumber];
1405 TGeoCombiTrans* localladdermothercombitrans[fgkladdernumber];
1406 for(Int_t i=0; i<fgkladdernumber; i++){
1407 localladdermothertrans[i] = new TGeoTranslation(0.,
1408 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
1409 + fgkEndLadderCarbonFiberLowerJunctionLength[0]
1410 + (i==0?fgkSSDLay5SensorsNumber:fgkSSDLay6SensorsNumber)
1411 * fgkCarbonFiberJunctionWidth,0.);
1412 localladdermothercombitrans[i] = new TGeoCombiTrans(*localladdermothertrans[i],
1413 *localladdermotherrot);
1414 ladderglobalmatrix[0][i] = new TGeoHMatrix(*localladdermothercombitrans[i]);
1415 ladderglobalmatrix[1][i] = new TGeoHMatrix(ladderglobalmatrix[0][i]->Inverse());
d7599219 1416 }
44285dfa 1417 /////////////////////////////////////////////////////////////
bf210566 1418 // Ladder Cables Matrices
44285dfa 1419 /////////////////////////////////////////////////////////////
44285dfa 1420 Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
d7599219 1421 + fgkSSDFlexHeight[1];
44285dfa 1422 Double_t ssdladdercabletransx[3];
1423 ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
bf210566 1424 * SinD(2.*fgkSSDFlexAngle)
1425 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1426 ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
1427 - ssdladdercabletransx[0]
bf210566 1428 / SinD(2.*fgkSSDFlexAngle))
1429 * CosD(fgkSSDFlexAngle);
44285dfa 1430 ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1431 * TMath::DegToRad()*ssdflexradiusmax
d7599219 1432 - fgkSSDFlexLength[2]-TMath::Pi()
1433 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
1434 - fgkSSDLadderCableWidth)
bf210566 1435 * CosD(2.*fgkSSDFlexAngle);
44285dfa 1436 Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
bf210566 1437 * TanD(2.*fgkSSDFlexAngle),
44285dfa 1438 ssdladdercabletransx[1]
bf210566 1439 * TanD(fgkSSDFlexAngle),
44285dfa 1440 ssdladdercabletransx[2]
bf210566 1441 * TanD(2.*fgkSSDFlexAngle)};
44285dfa 1442 TGeoRotation* localladdercablerot[3];
bf210566 1443 for(Int_t i=0; i<3; i++) localladdercablerot[i] = new TGeoRotation();
1444 localladdercablerot[0]->SetAngles(90.,0.,0.);
1445 localladdercablerot[1]->SetAngles(90.,60.,-90.);
44285dfa 1446 localladdercablerot[2]->SetRotation((*localladdercablerot[1])
1447 * (*localladdercablerot[0]));
1448 ////////////////////////////////////////////
1449 // LocalLadderCableCombiTransMatrix
1450 ////////////////////////////////////////////
1451 const Int_t klocalladdersidecablesnumber = 2;
1452 const Int_t klocalladdercombitransnumber = 5;
1453 TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
1454 for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
1455 localladdercablecombitransmatrix[i] =
1456 new TGeoCombiTrans*[klocalladdercombitransnumber];
1457 ///////////////////////////////////////////
1458 // Left Side Ladder Cables Transformations
1459 ///////////////////////////////////////////
1460 localladdercablecombitransmatrix[0][0] =
d7599219 1461 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
1462 0.,0.,NULL);
bf210566 1463 localladdercablecombitransmatrix[0][1] =
1464 new TGeoCombiTrans(-0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
1465 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
1466 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
1467 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
1468 - 0.5*(fgkCarbonFiberLowerSupportWidth
1469 + fgkSSDSensorCenterSupportLength
1470 - fgkSSDSensorCenterSupportThickness[0]),
1471 - (fgkSSDModuleCoolingBlockToSensor
1472 + 0.5*fgkCoolingTubeSupportHeight
1473 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]
1474 - fgkSSDChipHeight),NULL);
44285dfa 1475 localladdercablecombitransmatrix[0][2] =
d7599219 1476 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
1477 fgkSSDModuleStiffenerPosition[1],0.,0);
bf210566 1478 localladdercablecombitransmatrix[0][3] = new TGeoCombiTrans(
1479 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
1480 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1481 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1482 - fgkSSDStiffenerWidth,- 0.5*fgkSSDChipHeight,
1483 new TGeoRotation("",180.,0.,0.));
44285dfa 1484 localladdercablecombitransmatrix[0][4] =
1485 new TGeoCombiTrans(-ssdladdercabletransx[0]
1486 - ssdladdercabletransx[1]-ssdladdercabletransx[2]
d7599219 1487 + fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1488 0.,
1489 0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
1490 + fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
44285dfa 1491 + ssdladdercabletransz[0]-ssdladdercabletransz[1]
1492 + ssdladdercabletransz[2],localladdercablerot[2]);
1493 ///////////////////////////////////////////
1494 // Rigth Side Ladder Cables Transformations
1495 ///////////////////////////////////////////
bf210566 1496 TGeoCombiTrans* localladdercablessdmodulematrix =
1497 new TGeoCombiTrans(0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
1498 - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
1499 fgkSSDStiffenerWidth,
1500 - 0.5*fgkSSDFlexHeight[0],NULL);
44285dfa 1501 for(Int_t i=0; i<klocalladdercombitransnumber; i++)
1502 localladdercablecombitransmatrix[1][i] =
bf210566 1503 (i!=3 ? new TGeoCombiTrans(*localladdercablecombitransmatrix[0][i]):
1504 new TGeoCombiTrans(*localladdercablessdmodulematrix));
44285dfa 1505 ///////////////////////////////////////////
bf210566 1506 // Setting LadderCableHMatrix
44285dfa 1507 ///////////////////////////////////////////
bf210566 1508 Int_t beamaxistrans[2][3];
1509 beamaxistrans[0][0] = fgkSSDLay5SensorsNumber/2;
1510 beamaxistrans[0][1] = beamaxistrans[0][0]+1;
1511 beamaxistrans[0][2] = beamaxistrans[0][0]-1;
1512 beamaxistrans[1][0] = (fgkSSDLay6SensorsNumber-1)/2;
1513 beamaxistrans[1][1] = beamaxistrans[1][0]+1;
1514 beamaxistrans[1][2] = beamaxistrans[1][0];
1515 TGeoHMatrix** localladdercablehmatrix[fgkladdercablesnumber];
1516 TGeoRotation* laddercablerot = new TGeoRotation();
1517 TGeoTranslation* laddercabletrans = new TGeoTranslation();
1518 TGeoCombiTrans* laddercablecombitrans = new TGeoCombiTrans();
1519 Double_t* laddercabletransvector;
1520 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1521 localladdercablehmatrix[i] = new TGeoHMatrix*[klocalladdersidecablesnumber];
1522 fladdercablematrix[i] = new TGeoHMatrix*[fgkladdercablematrixnumber];
1523 }
1524 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1525 for(Int_t j=0; j<klocalladdersidecablesnumber; j++){
1526 localladdercablehmatrix[i][j] = new TGeoHMatrix();
1527 for(Int_t k=0; k<klocalladdercombitransnumber; k++){
1528 localladdercablehmatrix[i][j]->MultiplyLeft(
1529 localladdercablecombitransmatrix[j][klocalladdercombitransnumber-k-1]);
1530 }
1531 laddercablerot->SetMatrix(localladdercablehmatrix[i][j]->GetRotationMatrix());
1532 laddercabletransvector = localladdercablehmatrix[i][j]->GetTranslation();
1533 laddercabletrans->SetTranslation(laddercabletransvector[0],
44285dfa 1534 laddercabletransvector[1]
bf210566 1535 + (j==0 ? beamaxistrans[i][0] : 0.)
d7599219 1536 * fgkCarbonFiberJunctionWidth,
bf210566 1537 laddercabletransvector[2]);
1538 laddercablecombitrans->SetRotation(*laddercablerot);
1539 laddercablecombitrans->SetTranslation(*laddercabletrans);
1540 fladdercablematrix[i][j] = new TGeoHMatrix(*laddercablecombitrans);
1541 }
1542 fladdercablematrix[i][2] =
1543 AddTranslationToHMatrix(fladdercablematrix[i][1],0.,
1544 beamaxistrans[i][1]*fgkCarbonFiberJunctionWidth,0.);
1545 fladdercablematrix[i][3] =
1546 AddTranslationToHMatrix(fladdercablematrix[i][0],0.,
1547 beamaxistrans[i][2]*fgkCarbonFiberJunctionWidth,0.);
d7599219 1548 }
bf210566 1549 for(Int_t i=0; i<fgkladdercablesnumber; i++)
1550 for(Int_t j=0; j<klocalladdercombitransnumber-1; j++)
1551 fladdercablematrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1552 ///////////////////////////////////////////
1553 // Setting Ladder HMatrix
1554 ///////////////////////////////////////////
1555 Int_t ssdlaysensorsnumber[fgkladdernumber] = {fgkSSDLay5SensorsNumber,
1556 fgkSSDLay6SensorsNumber};
1557 for(Int_t i=0; i<fgkladdernumber; i++){
1558 fladdermatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1559 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1560 fladdermatrix[i][j] = new TGeoHMatrix();
1561 fladdermatrix[i][j]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1562 fladdermatrix[i][j]->SetDy(fgkCarbonFiberJunctionWidth*j);
1563 fladdermatrix[i][j]->MultiplyLeft(ladderglobalmatrix[1][i]);
1564 }
d7599219 1565 }
bf210566 1566 ///////////////////////////////////////////
1567 // Setting SSD Sensor Matrix
1568 ///////////////////////////////////////////
1569 TGeoCombiTrans* localssdsensorcombitrans[2];
1570 TGeoRotation* localssdsensorrot = new TGeoRotation();
1571 localssdsensorrot->SetAngles(0.,90.,0.);
1572 TGeoTranslation* localssdsensortrans[2];
1573 for(Int_t i=0; i<2; i++) localssdsensortrans[i] = new TGeoTranslation();
1574 localssdsensortrans[0]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
c40ebacc 1575 fgkCarbonFiberJunctionWidth
1576 - fgkCarbonFiberLowerSupportWidth
1577 - fgkLowerSupportToSensorZ,
bf210566 1578 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
0fb26117 1579 - fgkSSDModuleCoolingBlockToSensor
e21cdd03 1580 + (fgkSSDSensorSideSupportHeight[1]
0fb26117 1581 - fgkSSDSensorSideSupportHeight[0]));
bf210566 1582 localssdsensortrans[1]->SetTranslation(0.5*fgkCarbonFiberTriangleLength,
c40ebacc 1583 fgkCarbonFiberJunctionWidth
1584 - fgkCarbonFiberLowerSupportWidth
1585 - fgkLowerSupportToSensorZ,
bf210566 1586 0.5*fgkSSDSensorHeight-0.5*fgkCoolingTubeSupportHeight
0fb26117 1587 -fgkSSDModuleCoolingBlockToSensor);
bf210566 1588 for(Int_t i=0; i<2; i++)
1589 localssdsensorcombitrans[i] = new TGeoCombiTrans(*localssdsensortrans[i],
1590 *localssdsensorrot);
1591 for(Int_t i=0; i<fgkladdernumber; i++){
1592 fssdsensormatrix[i] = new TGeoHMatrix*[ssdlaysensorsnumber[i]];
1593 for(Int_t j=0; j<ssdlaysensorsnumber[i]; j++){
1594 switch(i){
1595 case 0: //Ladder of Layer5
1596 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1597 * ((j%2==0 ? *localssdsensorcombitrans[0] :
1598 *localssdsensorcombitrans[1])));
1599 break;
1600 case 1: //Ladder of Layer6
1601 fssdsensormatrix[i][j] = new TGeoHMatrix((*fladdermatrix[i][j])
1602 * ((j%2==0 ? *localssdsensorcombitrans[1] :
1603 *localssdsensorcombitrans[0])));
1604 break;
1605 }
1606 }
1607 }
1608 //////////////////////////
1609 // Setting SSD End Ladder
1610 //////////////////////////
1611 for(Int_t i=0; i<2; i++) fendladdersegmentmatrix[i] = new TGeoHMatrix*[2];
1612 for(Int_t i=0; i<2; i++){
1613 fendladdersegmentmatrix[0][i] = new TGeoHMatrix();
1614 fendladdersegmentmatrix[0][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1615 fendladdersegmentmatrix[0][i]->SetDy(fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber[i]);
1616 fendladdersegmentmatrix[0][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1617 fendladdersegmentmatrix[1][i] = new TGeoHMatrix();
1618 fendladdersegmentmatrix[1][i]->SetDx(-0.5*fgkCarbonFiberTriangleLength);
1619 fendladdersegmentmatrix[1][i]->RotateZ(180.0);
1620 fendladdersegmentmatrix[1][i]->MultiplyLeft(ladderglobalmatrix[1][i]);
1621 }
1622 /////////////////////////////////////////////////////
1623 // Setting the CombiTransformation to pass ITS center
1624 /////////////////////////////////////////////////////
1625 Double_t itscentertransz[fgklayernumber];
1626 itscentertransz[0] = fgkSSDLay5LadderLength
1627 - fgkLay5CenterITSPosition;
1628 itscentertransz[1] = fgkSSDLay6LadderLength
1629 - fgkLay6CenterITSPosition;
1630 Double_t itssensortransy = fgkSSDModuleCoolingBlockToSensor
1631 + 0.5*fgkCoolingTubeSupportHeight;
1632 TGeoRotation* itscenterrot[3];
1633 for(Int_t i=0; i<fgklayernumber; i++) itscenterrot[i] = new TGeoRotation();
1634 itscenterrot[0]->SetAngles(90.,180.,-90.);
1635 itscenterrot[1]->SetAngles(0.,90.,0.);
1636 itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
1637 TGeoCombiTrans* itscentercombitrans[fgklayernumber];
1638 for(Int_t i=0; i<fgklayernumber; i++)
1639 itscentercombitrans[i] = new TGeoCombiTrans(0.,
1640 itssensortransy,
1641 fgkEndLadderCarbonFiberLowerJunctionLength[1]
1642 - itscentertransz[i],itscenterrot[2]);
1643 TGeoRotation** locallayerrot[fgklayernumber];
1644 TGeoTranslation** locallayertrans[fgklayernumber];
1645 TGeoCombiTrans** locallayercombitrans[fgklayernumber];
1646 TGeoTranslation* localbeamaxistrans[fgklayernumber];
1647 localbeamaxistrans[0] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay5LadderLength
1648 - fgkLay5CenterITSPosition);
1649 localbeamaxistrans[1] = new TGeoTranslation(0.,0.,0.5*fgkSSDLay6LadderLength
1650 - fgkLay6CenterITSPosition);
1651 const Int_t kssdlayladdernumber[fgklayernumber] =
1652 {fgkSSDLay5LadderNumber,fgkSSDLay6LadderNumber};
1653 for(Int_t i=0; i<fgklayernumber; i++){
1654 locallayerrot[i] = new TGeoRotation*[kssdlayladdernumber[i]];
1655 locallayertrans[i] = new TGeoTranslation*[kssdlayladdernumber[i]];
1656 locallayercombitrans[i] = new TGeoCombiTrans*[kssdlayladdernumber[i]];
1657 flayermatrix[i] = new TGeoHMatrix*[kssdlayladdernumber[i]];
d7599219 1658 }
bf210566 1659 Double_t layerladderangleposition[fgklayernumber] =
1660 {360./fgkSSDLay5LadderNumber,360./fgkSSDLay6LadderNumber};
1661 Double_t layerradius = 0.;
1662 for(Int_t i=0; i<fgklayernumber; i++){
1663 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1664 switch(i){
1665 case 0: //Ladder of Layer5
1666 layerradius = (j%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
1667 break;
1668 case 1: //Ladder of Layer6
1669 layerradius = (j%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
1670 break;
1671 }
1672 locallayerrot[i][j] = new TGeoRotation();
1673 locallayertrans[i][j] = new TGeoTranslation();
1674 locallayerrot[i][j]->SetAngles(j*layerladderangleposition[i],0.,0.);
1675 locallayertrans[i][j]->SetTranslation(layerradius
1676 * CosD(90.0+j*layerladderangleposition[i]),
1677 layerradius
1678 * SinD(90.0+j*layerladderangleposition[i]),0.);
1679 locallayercombitrans[i][j] = new TGeoCombiTrans(*locallayertrans[i][j],
1680 *locallayerrot[i][j]);
1681 flayermatrix[i][j] = new TGeoHMatrix((*locallayercombitrans[i][j])*(*itscentercombitrans[i]));
1682 flayermatrix[i][j]->Multiply(ladderglobalmatrix[0][i]);
1683 flayermatrix[i][j]->MultiplyLeft(localbeamaxistrans[i]);
d7599219 1684 }
bf210566 1685 }
44285dfa 1686 /////////////////////////////////////////////////////////////
bf210566 1687 // Deallocating memory
44285dfa 1688 /////////////////////////////////////////////////////////////
bf210566 1689 for(Int_t i=0; i< kcarbonfibersupportmatrixnumber[1]; i++){
1690 delete carbonfiberot[i];
1691 delete localcarbonfibersupportmatrix[i];
d7599219 1692 }
bf210566 1693 for(Int_t i=0; i< fgkcarbonfiberjunctionumber; i++){
1694 for(Int_t j=0; j< kcarbonfiberjunctionmatrixnumber; j++){
1695 delete localcarbonfiberjunctionmatrix[i][j];
1696 delete localcarbonfiberjunctionrot[i][j];
1697 delete localcarbonfiberjunctiontrans[i][j];
1698 }
1699 delete [] localcarbonfiberjunctionmatrix[i];
1700 delete [] localcarbonfiberjunctionrot[i];
1701 delete [] localcarbonfiberjunctiontrans[i];
d7599219 1702 }
bf210566 1703 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1704 delete localcarbonfiberlowersupportrans[i];
1705 for(Int_t i=0; i< fgkssdsensorsupportnumber; i++){
1706 for(Int_t j=0; j< kssdsensorsupportmatrixnumber; j++){
1707 delete localssdsensorsupportmatrix[i][j];
1708 delete localssdsensorsupportrot[i][j];
1709 delete localssdsensorsupportrans[i][j];
1710 }
1711 delete [] localssdsensorsupportmatrix[i];
1712 delete [] localssdsensorsupportrot[i];
1713 delete [] localssdsensorsupportrans[i];
d7599219 1714 }
bf210566 1715 for(Int_t i=0; i<kcoolingtubesupportmatrixnumber; i++){
1716 delete localcoolingtubesupportmatrix[i];
1717 delete localcoolingtubesupportrot[i];
1718 delete localcoolingtubesupportrans[i];
1719 }
1720 for(Int_t i=0; i<4; i++){
1721 for(Int_t j=0; j<2; j++){
1722 delete localcoolingtubevect[i][j];
1723 delete localcoolingtubetrans[i][j];
1724 }
1725 delete [] localcoolingtubevect[i];
1726 delete [] localcoolingtubetrans[i];
1727 }
9b0c60ab 1728 delete endladdermountingblockrot;
bf210566 1729 for(Int_t i=0; i<khybridmatrixnumber; i++) delete localhybridtrans[i];
1730 for(Int_t i=0; i<kcoolingblockmatrixnumber; i++) delete localcoolingblocktrans[i];
1731 for(Int_t i=0; i<fgkflexnumber; i++){
1732 for(Int_t j=1; j<klocalflexmatrixnumber; j++)
1733 delete localflexmatrix[i][j];
1734 delete [] localflexmatrix[i];
1735 }
9b0c60ab 1736 delete localendlladdercoolingtuberot;
1737 for(Int_t i=0; i<2; i++){
1738 for(Int_t j=0; j<(i==0?6:4); j++)
1739 delete localendlladdercoolingtubetrans[i][j];
1740 delete [] localendlladdercoolingtubetrans[i];
1741 }
1742
bf210566 1743 delete localflexrot;
1744 delete localendflexrot;
1745 delete localendflexmatrix;
1746 for(Int_t i=0; i<fgkladdernumber; i++){
1747 delete localladdermothertrans[i];
1748 delete localladdermothercombitrans[i];
1749 }
1750 delete localladdermotherrot;
1751 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1752 for(Int_t j=0; j<fgkendladdercabonfiberjunctionmatrixnumber; j++){
1753 delete localendladdercarbonfiberjunctionmatrix[i][j];
1754 delete localendladdercarbonfiberjunctionrot[i][j];
1755 delete localendladdercarbonfiberjunctiontrans[i][j];
1756 }
1757 delete [] localendladdercarbonfiberjunctionmatrix[i];
1758 delete [] localendladdercarbonfiberjunctionrot[i];
1759 delete [] localendladdercarbonfiberjunctiontrans[i];
1760 delete localendladdercarbonfiberjunctionglobalrot[i];
1761 delete localendladdercarbonfiberjunctionglobaltrans[i];
1762 delete localendladdercarbonfiberjunctionglobalmatrix[i];
1763 }
9b0c60ab 1764 for(Int_t i=0; i<2; i++){
1765 for(Int_t j=0; j<(i==0?4:2); j++) delete localendladdercooltubetrans[i][j];
1766 delete [] localendladdercooltubetrans[i];
1767 }
1768 for(Int_t i=0; i<fgkendladdercarbonfibermatrixnumber; i++)
bf210566 1769 delete localendladdercarbonfibertrans[i];
1770 for(Int_t i=0; i<3; i++) delete localladdercablerot[i];
1771 for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
1772 for(Int_t j=0; j<klocalladdercombitransnumber; j++)
1773 delete localladdercablecombitransmatrix[i][j];
1774 delete []localladdercablecombitransmatrix[i];
1775 }
9b0c60ab 1776 delete localendladdercliprot;
1777 delete localendladdercliptrans;
bf210566 1778 for(Int_t i=0; i<fgkladdercablesnumber; i++){
1779 for(Int_t j=0; j<klocalladdersidecablesnumber; j++)
1780 delete localladdercablehmatrix[i][j];
1781 delete []localladdercablehmatrix[i];
1782 }
1783 delete laddercablerot;
1784 delete laddercabletrans;
1785 delete laddercablecombitrans;
1786 delete localladdercablessdmodulematrix;
1787 delete localssdsensorrot;
1788 for(Int_t i=0; i<2; i++){
1789 delete localssdsensortrans[i];
1790 delete localssdsensorcombitrans[i];
1791 }
1792 for(Int_t i=0; i<fgklayernumber; i++){
1793 for(Int_t j=0; j<kssdlayladdernumber[i]; j++){
1794 delete locallayerrot[i][j];
1795 delete locallayertrans[i][j];
1796 delete locallayercombitrans[i][j];
d7599219 1797 }
bf210566 1798 delete [] locallayerrot[i];
1799 delete [] locallayertrans[i];
1800 delete [] locallayercombitrans[i];
1801 delete localbeamaxistrans[i];
1802 }
1803 for(Int_t i=0; i<3; i++) delete itscenterrot[i];
1804 for(Int_t i=0; i<fgkladdernumber; i++){
1805 for(Int_t j=0; j<fgkladdernumber; j++)
1806 delete ladderglobalmatrix[i][j];
1807 delete [] ladderglobalmatrix[i];
1808 }
1809 /////////////////////////////////////////////////////////////
1810 fTransformationMatrices = kTRUE;
d7599219 1811}
bf210566 1812///////////////////////////////////////////////////////////////////////////////
1813void AliITSv11GeometrySSD::CreateBasicObjects(){
1814 /////////////////////////////////////////////////////////////
1815 // Method generating the Objects of SSD Geometry
44285dfa 1816 /////////////////////////////////////////////////////////////
bf210566 1817 // SSD Sensor
1818 ///////////////////////////////////
1819 SetSSDSensor();
1820 /////////////////////////////////////////////////////////////
1821 // Carbon Fiber Support
1822 /////////////////////////////////////////////////////////////
1823 TList* carbonfibersupportlist = GetCarbonFiberSupportList();
1824 for(Int_t i=0; i<fgkcarbonfibersupportnumber; i++)
1825 fcarbonfibersupport[i] = (TGeoVolume*)carbonfibersupportlist->At(i);
44285dfa 1826 /////////////////////////////////////////////////////////////
bf210566 1827 // Carbon Fiber Junction
44285dfa 1828 /////////////////////////////////////////////////////////////
ca86fdb4 1829 fcarbonfiberjunction = GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth-fgkSSDTolerance);
44285dfa 1830 /////////////////////////////////////////////////////////////
bf210566 1831 // Carbon Fiber Lower Support
44285dfa 1832 /////////////////////////////////////////////////////////////
bf210566 1833 TList* carbonfiberlowersupportlist = GetCarbonFiberLowerSupportList();
1834 for(Int_t i=0; i<fgkcarbonfiberlowersupportnumber; i++)
1835 fcarbonfiberlowersupport[i] = (TGeoVolume*)carbonfiberlowersupportlist->At(i);
d7599219 1836 /////////////////////////////
bf210566 1837 // SSD Sensor Support
d7599219 1838 /////////////////////////////
bf210566 1839 for(Int_t i=0; i<fgkvolumekind; i++) fssdsensorsupport[i] =
1840 new TGeoVolume*[fgkssdsensorsupportnumber];
1841 Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
1842 fgkSSDSensorSideSupportThickness[1]};
1843 for(Int_t i=0; i<fgkssdsensorsupportnumber-1; i++){
1844 fssdsensorsupport[0][i] = GetSSDSensorSupport(fgkSSDSensorSideSupportLength,
1845 fgkSSDSensorSideSupportHeight[i],
1846 fgkSSDSensorSideSupportWidth,
1847 sidesupporthickness);
1848 fssdsensorsupport[1][i] = GetSSDSensorSupport(fgkSSDSensorCenterSupportLength,
1849 fgkSSDSensorCenterSupportHeight[i],
1850 fgkSSDSensorCenterSupportWidth,
1851 sidesupporthickness);
1852 }
44285dfa 1853 /////////////////////////////////////////////////////////////
bf210566 1854 // SSD Cooling Tube Support
44285dfa 1855 /////////////////////////////////////////////////////////////
bf210566 1856 Int_t edgesnumber = 16;
1857 fcoolingtubesupport = GetCoolingTubeSupport(edgesnumber);
44285dfa 1858 /////////////////////////////////////////////////////////////
bf210566 1859 // SSD Hybrid
44285dfa 1860 /////////////////////////////////////////////////////////////
bf210566 1861 TList* ssdhybridcomponentslist = GetSSDHybridParts();
1862 for(Int_t i=0; i<fgkhybridcompnumber; i++)
1863 fssdhybridcomponent[i] = (TGeoVolume*)ssdhybridcomponentslist->At(i);
44285dfa 1864 /////////////////////////////////////////////////////////////
bf210566 1865 // SSD Cooling Block System
44285dfa 1866 /////////////////////////////////////////////////////////////
bf210566 1867 fssdcoolingblocksystem = GetCoolingBlockSystem();
1868 /////////////////////////////////////////////////////////////
1869 // SSD Cooling Tube
44285dfa 1870 /////////////////////////////////////////////////////////////
bf210566 1871 TList* coolingtubelist = GetCoolingTubeList();
1872 for(Int_t i=0; i<fgkcoolingtubenumber; i++)
1873 fcoolingtube[i] = (TGeoVolume*)coolingtubelist->At(i);
9b0c60ab 1874 for(Int_t i=0; i<fgkendladdercoolingtubenumber; i++)
1875 fendladdercoolingtube[i] =
1876 (TGeoVolume*)coolingtubelist->At(fgkcoolingtubenumber+i);
44285dfa 1877 /////////////////////////////////////////////////////////////
bf210566 1878 // SSD Flex
1879 /////////////////////////////////////////////////////////////
1880 fssdstiffenerflex = GetSSDStiffenerFlex();
1881 fssdendflex = GetSSDEndFlex();
1882 ///////////////////////////////////
1883 // End Ladder Carbon Fiber Junction
1884 ///////////////////////////////////
1885 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++)
1886 fendladdercarbonfiberjunction[i] =
1887 new TGeoVolume*[fgkendlabbercarbonfiberjunctionumber];
1888 for(Int_t i=0; i<fgkendlabbercarbonfiberjunctionumber; i++){
1889 fendladdercarbonfiberjunction[i][0] =
ca86fdb4 1890 GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]-fgkSSDTolerance);
bf210566 1891 fendladdercarbonfiberjunction[i][1] =
ca86fdb4 1892 GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]-fgkSSDTolerance);
d7599219 1893 }
bf210566 1894 ///////////////////////////////////
1895 // End Ladder Mounting Block
1896 ///////////////////////////////////
1897 fendladdermountingblock = GetSSDMountingBlock();
9b0c60ab 1898 ///////////////////////////////////
1899 // End Ladder Mounting Block
1900 ///////////////////////////////////
1901 fendladdermountingblockclip = GetMountingBlockClip();
1902 ///////////////////////////////////
1903 // Ladder Support
1904 ///////////////////////////////////
1905 TList* laddersupportlist = GetMountingBlockSupport(20);
1906 fLay5LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(0);
1907 fLay5LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(1);
1908 fLay6LadderSupport[0] = (TGeoVolume*)laddersupportlist->At(2);
1909 fLay6LadderSupport[1] = (TGeoVolume*)laddersupportlist->At(3);
44285dfa 1910 /////////////////////////////////////////////////////////////
bf210566 1911 // Deallocating memory
1912 /////////////////////////////////////////////////////////////
1913 delete carbonfibersupportlist;
1914 delete carbonfiberlowersupportlist;
1915 delete ssdhybridcomponentslist;
9b0c60ab 1916 delete laddersupportlist;
bf210566 1917 /////////////////////////////////////////////////////////////
1918 fBasicObjects = kTRUE;
d7599219 1919}
1920/////////////////////////////////////////////////////////////////////////////////
bf210566 1921void AliITSv11GeometrySSD::SetSSDSensor(){
1922 ////////////////////////////////////////////////////////////////
1923 // Method generating SSD Sensors: it sets the private variables
1924 // fSSDSensor5, fSSDSensor6
1925 ////////////////////////////////////////////////////////////////
1926 Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1927 Double_t ssdsensitivewidth = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1928 TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
1929 0.5*ssdsensitivewidth,
1930 0.5*fgkSSDSensorHeight,
1931 0.5*ssdsensitivelength);
1932 TGeoVolume* ssdsensorsensitiveLay5 =
02d4acf9 1933 new TGeoVolume(fgSSDsensitiveVolName5,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1934 TGeoVolume* ssdsensorsensitiveLay6 =
02d4acf9 1935 new TGeoVolume(fgSSDsensitiveVolName6,ssdsensorsensitiveshape,fSSDSensorMedium);
bf210566 1936 ssdsensorsensitiveLay5->SetLineColor(fColorSilicon);
1937 ssdsensorsensitiveLay6->SetLineColor(fColorSilicon);
1938 TGeoBBox* ssdsensorinsensitiveshape[2];
1939 ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
1940 0.5*fgkSSDSensorInsensitiveWidth,
1941 0.5*fgkSSDSensorHeight,
1942 0.5*fgkSSDSensorLength);
1943 ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
1944 0.5*ssdsensitivewidth,
1945 0.5*fgkSSDSensorHeight,
1946 0.5*fgkSSDSensorInsensitiveWidth);
1947 const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
1948 "SSDSensorInsensitive2"};
1949 TGeoVolume* ssdsensorinsensitive[2];
1950 for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1951 new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1952 fSSDSensorMedium);
1953 ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
1954 }
44285dfa 1955 /////////////////////////////////////////////////////////////
bf210566 1956 // Virtual Volume containing SSD Sensor
1957 /////////////////////////////////////////////////////////////
1958 TGeoBBox* virtualSSDSensorShape = new TGeoBBox("SSDSensorShape",
1959 0.5*fgkSSDSensorWidth,
1960 0.5*fgkSSDSensorHeight,
1961 0.5*fgkSSDSensorLength);
ef9451a3 1962 fSSDSensor5 = new TGeoVolume("ITSssdSensor5",virtualSSDSensorShape,
bf210566 1963 fSSDAir);
ef9451a3 1964 fSSDSensor6 = new TGeoVolume("ITSssdSensor6",virtualSSDSensorShape,
bf210566 1965 fSSDAir);
1966 /////////////////////////////////////////////////////////////
1967 for(Int_t i=0; i<4; i++){
1968 fSSDSensor5->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1969 ssdsensorinsensitive[1],i<2?1:2,
1970 new TGeoTranslation(
1971 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1972 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1973 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1974 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
1975 fSSDSensor6->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1976 ssdsensorinsensitive[1],i<2?1:2,
1977 new TGeoTranslation(
1978 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
1979 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[0]->GetDX()),0.,
1980 0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
1981 * (ssdsensorsensitiveshape->GetDZ()+ssdsensorinsensitiveshape[1]->GetDZ())));
d7599219 1982 }
bf210566 1983 fSSDSensor5->AddNode(ssdsensorsensitiveLay5,1);
1984 fSSDSensor6->AddNode(ssdsensorsensitiveLay6,1);
d7599219 1985}
bf210566 1986///////////////////////////////////////////////////////////////////////////////
1987TList* AliITSv11GeometrySSD::GetCarbonFiberSupportList(){
1988 /////////////////////////////////////////////////////////////
44285dfa 1989 // Method generating the Carbon Fiber Support
1990 /////////////////////////////////////////////////////////////
1991 const Int_t kvertexnumber = 4;
1992 const Int_t kshapesnumber = 2;
1993 TVector3** vertexposition[kshapesnumber];
1994 for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
1995 Double_t carbonfibersupportxaxisEdgeproj =
d7599219 1996 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
1997 * TMath::DegToRad());
44285dfa 1998 Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
d7599219 1999 / fgkCarbonFiberSupportXAxisLength);
2000 /////////////////////
2001 //Vertex Positioning
2002 ////////////////////
44285dfa 2003 vertexposition[0][0] = new TVector3();
2004 vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
d7599219 2005 fgkCarbonFiberSupportYAxisLength);
44285dfa 2006 vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
2007 carbonfibersupportxaxisEdgeproj
2008 * TMath::Tan(theta));
2009 vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
2010 - carbonfibersupportxaxisEdgeproj,
d7599219 2011 fgkCarbonFiberSupportYAxisLength
44285dfa 2012 - vertexposition[0][2]->Y());
d7599219 2013 ////////////////////////////////////////////////////
2014 //Setting the parameters for Isometry Transformation
2015 ////////////////////////////////////////////////////
44285dfa 2016 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
d7599219 2017 + fgkCarbonFiberSupportTopEdgeDist[0]
2018 + fgkCarbonFiberSupportWidth);
2019 Double_t* param = new Double_t[4];
44285dfa 2020 param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
2021 for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
160835d5 2022 new TVector3((GetReflection(vertexposition[0][j],param))->X(),
2023 (GetReflection(vertexposition[0][j],param))->Y());
a6e0ebfe 2024 const char* carbonfibersupportshapename[kshapesnumber] =
d7599219 2025 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
a6e0ebfe 2026 const char* carbonfibersupportname[kshapesnumber] =
bf210566 2027 {"CarbonFiberSupport1","CarbonFiberSupport2"};
44285dfa 2028 TGeoArb8* carbonfibersupportshape[kshapesnumber];
bf210566 2029 TGeoVolume* carbonfibersupport[kshapesnumber];
2030 TList* carbonfibersupportlist = new TList();
44285dfa 2031 Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
2032 Double_t carbonfibersupportheight =
2033 carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
d7599219 2034 *TMath::DegToRad());
bf210566 2035 for(Int_t i = 0; i< kshapesnumber; i++){
2036 carbonfibersupportshape[i] =
44285dfa 2037 GetArbShape(vertexposition[i],width,carbonfibersupportheight,
bf210566 2038 carbonfibersupportshapename[i],i==0 ? 1: -1);
2039 carbonfibersupport[i] = new TGeoVolume(carbonfibersupportname[i],
2040 carbonfibersupportshape[i],fSSDCarbonFiberMedium);
2041 carbonfibersupport[i]->SetLineColor(fColorCarbonFiber);
2042 carbonfibersupportlist->Add(carbonfibersupport[i]);
2043 }
2044 /////////////////////////////////////////////////////////////
2045 // Deallocating memory
2046 /////////////////////////////////////////////////////////////
2047 for(Int_t i=0; i< kshapesnumber; i++){
2048 for(Int_t j=0; j< kvertexnumber; j++)
2049 delete vertexposition[i][j];
2050 delete [] vertexposition[i];
2051 }
2052 delete [] param;
2053 /////////////////////////////////////////////////////////////
2054 return carbonfibersupportlist;
2055}
2056/////////////////////////////////////////////////////////////////////////////////
2057TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
2058 /////////////////////////////////////////////////////////////
2059 // Method generating SSD Carbon Fiber Junction
2060 /////////////////////////////////////////////////////////////
2061 const Int_t kvertexnumber = 6;
2062 TGeoXtru* carbonfiberjunctionshape = new TGeoXtru(2);
d4ff3e0a 2063 Double_t reflectionparam[4] = {TMath::Tan(fgkCarbonFiberJunctionAngle[0]
2064 * TMath::DegToRad()),-1.,0.,0.};
bf210566 2065 TVector3* vertex[kvertexnumber];
2066 vertex[0] = new TVector3();
2067 vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
2068 * TMath::Cos(fgkCarbonFiberJunctionAngle[0]
2069 * TMath::DegToRad()),
2070 fgkCarbonFiberJunctionEdge[0]
2071 * TMath::Sin(fgkCarbonFiberJunctionAngle[0]
2072 * TMath::DegToRad()));
2073 vertex[4] = new TVector3(fgkCarbonFiberJunctionLength,
2074 fgkCarbonFiberJunctionEdge[1]);
2075 vertex[5] = new TVector3(fgkCarbonFiberJunctionLength);
2076 vertex[1] = GetReflection(vertex[5],reflectionparam);
2077 vertex[2] = GetReflection(vertex[4],reflectionparam);
2078 Double_t xvertexpoints[6], yvertexpoints[6];
2079 for(Int_t i=0; i<kvertexnumber; i++)
2080 xvertexpoints[i] = vertex[i]->X(), yvertexpoints[i] = vertex[i]->Y();
2081 carbonfiberjunctionshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2082 carbonfiberjunctionshape->DefineSection(0,-0.5*width);
2083 carbonfiberjunctionshape->DefineSection(1,0.5*width);
2084 TGeoVolume* carbonfiberjunction = new TGeoVolume("CarbonFiberJunction",
2085 carbonfiberjunctionshape,fSSDCarbonFiberMedium);
2086 carbonfiberjunction->SetLineColor(fColorCarbonFiber);
2087 /////////////////////////////////////////////////////////////
2088 // Deallocating memory
2089 /////////////////////////////////////////////////////////////
2090 for (Int_t i=0; i<kvertexnumber; i++) delete vertex[i];
2091 /////////////////////////////////////////////////////////////
2092 return carbonfiberjunction;
d7599219 2093}
2094////////////////////////////////////////////////////////////////////////////////
bf210566 2095TList* AliITSv11GeometrySSD::GetCarbonFiberLowerSupportList(){
44285dfa 2096 /////////////////////////////////////////////////////////////
2097 // Method generating the Carbon Fiber Lower Support
2098 /////////////////////////////////////////////////////////////
2099 const Int_t kvertexnumber = 4;
2100 const Int_t kshapesnumber = 2;
2101 Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
d7599219 2102 fgkCarbonFiberLowerSupportWidth};
44285dfa 2103 TVector3** vertexposition[kshapesnumber];
2104 for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
2105 new TVector3*[kvertexnumber];
d7599219 2106 //First Shape Vertex Positioning
44285dfa 2107 vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
2108 vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
d7599219 2109 - fgkCarbonFiberLowerSupportLowerLenght);
44285dfa 2110 vertexposition[0][2] = new TVector3();
2111 vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
d7599219 2112 //Second Shape Vertex Positioning
44285dfa 2113 Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
d7599219 2114 - fgkCarbonFiberLowerSupportVolumePosition[0])
2115 / fgkCarbonFiberTriangleLength);
44285dfa 2116 vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
2117 vertexposition[0][0]->X()*TMath::Tan(theta)
d7599219 2118 + fgkCarbonFiberLowerSupportVolumePosition[0]);
44285dfa 2119 vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
2120 vertexposition[0][1]->X()*TMath::Tan(theta)
d7599219 2121 + fgkCarbonFiberLowerSupportVolumePosition[0]);
44285dfa 2122 vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
2123 vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
d7599219 2124 fgkCarbonFiberLowerSupportVolumePosition[1]);
a6e0ebfe 2125 const char* carbonfiberlowersupportshapename[kshapesnumber] =
d7599219 2126 {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
a6e0ebfe 2127 const char* carbonfiberlowersupportname[kshapesnumber] =
bf210566 2128 {"CarbonFiberLowerSupport1","CarbonFiberLowerSupport2"};
44285dfa 2129 TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
bf210566 2130 TGeoVolume* carbonfiberlowersupport[kshapesnumber];
2131 TList* carbonfiberlowersupportlist = new TList();
2132 for(Int_t i = 0; i< kshapesnumber; i++){
2133 carbonfiberlowersupportshape[i] =
44285dfa 2134 GetArbShape(vertexposition[i],width,
d7599219 2135 fgkCarbonFiberLowerSupportHeight,
bf210566 2136 carbonfiberlowersupportshapename[i]);
2137 carbonfiberlowersupport[i] = new TGeoVolume(carbonfiberlowersupportname[i],
2138 carbonfiberlowersupportshape[i],fSSDCarbonFiberMedium);
2139 carbonfiberlowersupport[i]->SetLineColor(fColorCarbonFiber);
2140 carbonfiberlowersupportlist->Add(carbonfiberlowersupport[i]);
2141 }
2142 /////////////////////////////////////////////////////////////
2143 // Deallocating memory
2144 /////////////////////////////////////////////////////////////
2145 for(Int_t i=0; i< kshapesnumber; i++){
2146 for(Int_t j=0; j< kvertexnumber; j++)
2147 delete vertexposition[i][j];
2148 delete [] vertexposition[i];
2149 }
2150 /////////////////////////////////////////////////////////////
2151 return carbonfiberlowersupportlist;
d7599219 2152}
bf210566 2153///////////////////////////////////////////////////////////////////////////////
2154TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Double_t length, Double_t height,
2155 Double_t width, Double_t* thickness)const{
44285dfa 2156 /////////////////////////////////////////////////////////////
bf210566 2157 // Method generating the Sensor Support
44285dfa 2158 /////////////////////////////////////////////////////////////
bf210566 2159 const Int_t kvertexnumber = 6;
2160 TGeoXtru* ssdsensorsupportshape = new TGeoXtru(2);
2161 TVector3* vertexposition[kvertexnumber];
2162 vertexposition[0] = new TVector3();
2163 vertexposition[1] = new TVector3(0.0,length);
2164 vertexposition[2] = new TVector3(thickness[1],vertexposition[1]->Y());
2165 vertexposition[3] = new TVector3(vertexposition[2]->X(),thickness[0]);
2166 vertexposition[4] = new TVector3(height,vertexposition[3]->Y());
2167 vertexposition[5] = new TVector3(vertexposition[4]->X());
2168 Double_t xvertexpoints[6], yvertexpoints[6];
2169 for(Int_t i=0; i<kvertexnumber; i++)
2170 xvertexpoints[i] = vertexposition[i]->X(),
2171 yvertexpoints[i] = vertexposition[i]->Y();
2172 ssdsensorsupportshape->DefinePolygon(kvertexnumber,xvertexpoints,yvertexpoints);
2173 ssdsensorsupportshape->DefineSection(0,-0.5*width);
2174 ssdsensorsupportshape->DefineSection(1,0.5*width);
2175 TGeoVolume* ssdsensorsupport = new TGeoVolume("SSDSensorSupport",
2176 ssdsensorsupportshape,fSSDSensorSupportMedium);
2177 /////////////////////////////////////////////////////////////
2178 // Deallocating memory
2179 /////////////////////////////////////////////////////////////
2180 for (Int_t i=0; i<kvertexnumber; i++)
2181 delete vertexposition[i];
2182 /////////////////////////////////////////////////////////////
2183 return ssdsensorsupport;
d7599219 2184}
2185////////////////////////////////////////////////////////////////////////////////
bf210566 2186TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(Int_t nedges){
44285dfa 2187 /////////////////////////////////////////////////////////////
2188 // Method generating the Cooling Tube Support
bf210566 2189 /////////////////////////////////////////////////////////////
2190 if(nedges%2!=0) nedges--;
2191 const Int_t kvertexnumber = nedges+5;
44285dfa 2192 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
d7599219 2193 / fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
bf210566 2194 Double_t angle = 90.+phi;
2195 Double_t psi = 90.-phi;
2196 ///////////////////////////////////////
2197 // Vertex Positioning for TGeoXTru
2198 ///////////////////////////////////////
2199 TVector3** vertexposition = new TVector3*[kvertexnumber];
2200 vertexposition[0] = new TVector3(fgkCoolingTubeSupportRmin*CosD(angle),
2201 fgkCoolingTubeSupportRmin*SinD(angle));
2202 vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax*CosD(angle),
2203 fgkCoolingTubeSupportRmax*SinD(angle));
44285dfa 2204 vertexposition[2] = new TVector3(vertexposition[1]->X(),
bf210566 2205 fgkCoolingTubeSupportRmax);
2206 vertexposition[3] = new TVector3(-vertexposition[1]->X(),
2207 fgkCoolingTubeSupportRmax);
2208 vertexposition[4] = new TVector3(-vertexposition[1]->X(),
2209 vertexposition[1]->Y());
2210 for(Int_t i=0; i<nedges; i++)
2211 vertexposition[i+5] =
2212 new TVector3(fgkCoolingTubeSupportRmin*CosD(psi+i*(2.*phi/nedges)),
2213 fgkCoolingTubeSupportRmin*SinD(psi+i*(2.*phi/nedges)));
2214 ///////////////////////////////////////////////////////////////////////
2215 // TGeoXTru Volume definition for Cooling Tube Support Arc Part
2216 ///////////////////////////////////////////////////////////////////////
2217 TGeoXtru* coolingtubesupportarcshape = new TGeoXtru(2);
2218 Double_t* xvertexpoints = new Double_t[kvertexnumber];
2219 Double_t* yvertexpoints = new Double_t[kvertexnumber];
2220 for(Int_t i=0; i<kvertexnumber; i++){
2221 xvertexpoints[i] = vertexposition[i]->X();
2222 yvertexpoints[i] = vertexposition[i]->Y();
2223 }
2224 coolingtubesupportarcshape->DefinePolygon(kvertexnumber,xvertexpoints,
2225 yvertexpoints);
2226 coolingtubesupportarcshape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2227 coolingtubesupportarcshape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2228 TGeoVolume* coolingtubesupportarc = new TGeoVolume("CoolingTubeSupportArc",
2229 coolingtubesupportarcshape,
2230 fSSDTubeHolderMedium);
2231 coolingtubesupportarc->SetLineColor(fColorG10);
2232 //////////////////////////////////////////////////////////////////////////
2233 // TGeoTubeSeg Volume definition for Cooling Tube Support TGeoTubeSeg Part
2234 //////////////////////////////////////////////////////////////////////////
2235 TGeoTubeSeg* coolingtubesupportsegshape =
2236 new TGeoTubeSeg(fgkCoolingTubeSupportRmin,
2237 fgkCoolingTubeSupportRmax,
2238 0.5*fgkCoolingTubeSupportWidth,
2239 phi,360-phi);
2240 TGeoVolume* coolingtubesupportseg = new TGeoVolume("CoolingTubeSupportSeg",
2241 coolingtubesupportsegshape,
2242 fSSDTubeHolderMedium);
2243 coolingtubesupportseg->SetLineColor(fColorG10);
2244 //////////////////////////////////////////////////////////////////////////
2245 // TGeoBBox Volume definition for Cooling Tube Support Box Part
2246 //////////////////////////////////////////////////////////////////////////
44285dfa 2247 Double_t* boxorigin = new Double_t[3];
bf210566 2248 Double_t boxlength = fgkCoolingTubeSupportLength-2.*fgkCoolingTubeSupportRmax;
2249 boxorigin[0] = fgkCoolingTubeSupportRmax+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2250 TGeoBBox* coolingtubesupportboxshape = new TGeoBBox(0.5*boxlength,
2251 0.5*fgkCoolingTubeSupportHeight,
2252 0.5*fgkCoolingTubeSupportWidth,boxorigin);
2253 TGeoVolume* coolingtubesupportbox = new TGeoVolume("CoolingTubeSupportBox",
2254 coolingtubesupportboxshape,fSSDTubeHolderMedium);
2255 coolingtubesupportbox->SetLineColor(fColorG10);
2256 //////////////////////////////////////////////////////////////////////////
2257 // Cooling Tube for Cooling Tube Support
2258 //////////////////////////////////////////////////////////////////////////
2259 TGeoXtru* coolingtubearcshape[2];
2260 coolingtubearcshape[0] = new TGeoXtru(2);
2261 Double_t* xvert = new Double_t[nedges+2];
2262 Double_t* yvert = new Double_t[nedges+2];
2263 Double_t ratio = fgkCoolingTubeRmin/fgkCoolingTubeSupportRmin;
2264 ////////////////////////////////////////
2265 // Positioning the vertices for TGeoXTru
2266 ////////////////////////////////////////
2267 xvert[0] = 0., yvert[0] = 0.;
2268 xvert[1] = vertexposition[0]->X()*ratio, yvert[1] = vertexposition[0]->Y()*ratio;
2269 for(Int_t i=0; i< nedges; i++)
2270 xvert[i+2] = vertexposition[kvertexnumber-i-1]->X()*ratio,
2271 yvert[i+2] = vertexposition[kvertexnumber-i-1]->Y()*ratio;
2272 ////////////////////////////////////////
2273 // Defining TGeoXTru PolyGone
2274 ////////////////////////////////////////
2275 coolingtubearcshape[0]->DefinePolygon(nedges+2,xvert,yvert);
2276 coolingtubearcshape[0]->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2277 coolingtubearcshape[0]->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2278 coolingtubearcshape[1] = GetArcShape(2.*phi,fgkCoolingTubeRmin,
2279 fgkCoolingTubeRmax,nedges,fgkCoolingTubeSupportWidth);
2280 TGeoVolume* coolingtubearc[2];
2281 coolingtubearc[0] = new TGeoVolume("CoolingTubeWaterArcPart",
2282 coolingtubearcshape[0],fSSDCoolingTubeWater);
2283 coolingtubearc[1] = new TGeoVolume("CoolingTubePhynoxArcPart",
2284 coolingtubearcshape[1],fSSDCoolingTubePhynox);
2285 coolingtubearc[0]->SetLineColor(fColorWater);
2286 coolingtubearc[1]->SetLineColor(fColorPhynox);
2287 ////////////////////////////////////////////
2288 // Defining TGeoTubeSeg Part of Cooling Tube
2289 ////////////////////////////////////////////
2290 TGeoTubeSeg* coolingtubesegshape[2];
2291 coolingtubesegshape[0] = new TGeoTubeSeg(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
2292 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2293 coolingtubesegshape[1] = new TGeoTubeSeg(0.,fgkCoolingTubeRmin,
2294 0.5*fgkCoolingTubeSupportWidth,phi,360-phi);
2295 TGeoVolume* coolingtubeseg[2];
2296 coolingtubeseg[0] = new TGeoVolume("CoolingTubePhynoxPart",
2297 coolingtubesegshape[0],fSSDCoolingTubePhynox);
2298 coolingtubeseg[1] = new TGeoVolume("CoolingTubeWaterPart",
2299 coolingtubesegshape[1],fSSDCoolingTubeWater);
2300 coolingtubeseg[0]->SetLineColor(fColorPhynox);
2301 coolingtubeseg[1]->SetLineColor(fColorWater);
2302 /////////////////////////////////////////////////////////////
2303 // Virtual Volume containing Cooling Tube Support
2304 /////////////////////////////////////////////////////////////
2305 TGeoXtru* virtualCoolingTubeSupportShape = new TGeoXtru(2);
2306 const Int_t kvirtualvertexnumber = 8;
2307 TVector3* virtualvertex[kvirtualvertexnumber];
2308 ////////////////////////////////////////
2309 // Positioning the vertices for TGeoXTru
2310 ////////////////////////////////////////
2311 virtualvertex[0] = new TVector3(-fgkCoolingTubeSupportRmax,-fgkCoolingTubeSupportRmax);
2312 virtualvertex[1] = new TVector3(virtualvertex[0]->X(),-virtualvertex[0]->Y());
2313 virtualvertex[2] = new TVector3(-virtualvertex[0]->X(),virtualvertex[1]->Y());
2314 virtualvertex[3] = new TVector3(virtualvertex[2]->X(),0.5*fgkCoolingTubeSupportHeight);
2315 virtualvertex[4] = new TVector3(virtualvertex[3]->X()+boxlength,virtualvertex[3]->Y());
2316 virtualvertex[5] = new TVector3(virtualvertex[4]->X(),-virtualvertex[4]->Y());
2317 virtualvertex[6] = new TVector3(virtualvertex[3]->X(),-virtualvertex[3]->Y());
2318 virtualvertex[7] = new TVector3(virtualvertex[2]->X(),-virtualvertex[2]->Y());
2319 Double_t xmothervertex[kvirtualvertexnumber], ymothervertex[kvirtualvertexnumber];
2320 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2321 xmothervertex[i] = virtualvertex[i]->X(),
2322 ymothervertex[i] = virtualvertex[i]->Y();
2323 ////////////////////////////////////////
2324 // Defining TGeoXTru PolyGone
2325 ////////////////////////////////////////
2326 virtualCoolingTubeSupportShape->DefinePolygon(kvirtualvertexnumber,xmothervertex,
2327 ymothervertex);
2328 virtualCoolingTubeSupportShape->DefineSection(0,-0.5*fgkCoolingTubeSupportWidth);
2329 virtualCoolingTubeSupportShape->DefineSection(1,0.5*fgkCoolingTubeSupportWidth);
2330 TGeoVolume* virtualcoolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2331 virtualCoolingTubeSupportShape,fSSDAir);
2332 ////////////////////////////////////////
2333 // Positioning Volumes in Virtual Volume
2334 ////////////////////////////////////////
2335 TGeoRotation* coolingtubesupportrot = new TGeoRotation();
2336 coolingtubesupportrot->SetAngles(-90.0,0.0,0.0);
2337 virtualcoolingtubesupport->AddNode(coolingtubesupportarc,1,coolingtubesupportrot);
2338 virtualcoolingtubesupport->AddNode(coolingtubesupportbox,1);
2339 virtualcoolingtubesupport->AddNode(coolingtubesupportseg,1);
2340 virtualcoolingtubesupport->AddNode(coolingtubearc[0],1,coolingtubesupportrot);
2341 virtualcoolingtubesupport->AddNode(coolingtubearc[1],1,coolingtubesupportrot);
2342 virtualcoolingtubesupport->AddNode(coolingtubeseg[0],1);
2343 virtualcoolingtubesupport->AddNode(coolingtubeseg[1],1);
2344 /////////////////////////////////////////////////////////////
2345 // Deallocating memory
2346 /////////////////////////////////////////////////////////////
2347 delete [] vertexposition;
3e008bd7 2348 delete [] xvertexpoints;
2349 delete [] yvertexpoints;
2350 delete [] xvert;
2351 delete [] yvert;
bf210566 2352 for(Int_t i=0; i< kvirtualvertexnumber; i++)
2353 delete virtualvertex[i];
2354 /////////////////////////////////////////////////////////////
2355 return virtualcoolingtubesupport;
d7599219 2356}
bf210566 2357/////////////////////////////////////////////////////////////////////////////////
2358TList* AliITSv11GeometrySSD::GetSSDHybridParts(){
2359 /////////////////////////////////////////////////////////////
2360 // Method generating List containing SSD Hybrid Components
2361 /////////////////////////////////////////////////////////////
2362 TList* ssdhybridlist = new TList();
2363 const Int_t kssdstiffenernumber = 2;
2364 Double_t ssdstiffenerseparation = fgkSSDSensorLength
2365 - 2.*fgkSSDModuleStiffenerPosition[1]
2366 - fgkSSDStiffenerWidth;
2367 Double_t ssdchipcablesradius[kssdstiffenernumber];
2368 for(Int_t i=0; i<kssdstiffenernumber; i++)
2369 ssdchipcablesradius[i] = 0.25*(fgkSSDChipCablesHeight[i+2]
2370 - fgkSSDChipCablesHeight[0]
2371 - fgkSSDChipCablesHeight[1]);
2372 /////////////////////////////////////////////////////////////
2373 // Mother Volumes Containers
2374 /////////////////////////////////////////////////////////////
2375 const Int_t kmothernumber = 2;
2376 const Int_t kmothervertexnumber = 12;
2377 Double_t xmothervertex[kmothernumber][kmothervertexnumber];
2378 Double_t ymothervertex[kmothernumber][kmothervertexnumber];
2379 ///////////////////////
2380 // Setting the vertices
2381 ///////////////////////
2382 xmothervertex[0][0] = -0.5*fgkSSDStiffenerLength;
2383 xmothervertex[0][1] = xmothervertex[0][0];
2384 xmothervertex[0][2] = fgkSSDFlexLength[0]-0.5*fgkSSDStiffenerLength;
2385 xmothervertex[0][3] = xmothervertex[0][2];
2386 xmothervertex[0][4] = xmothervertex[0][0];
2387 xmothervertex[0][5] = xmothervertex[0][4];
2388 xmothervertex[0][6] = -xmothervertex[0][0];
2389 xmothervertex[0][7] = xmothervertex[0][6];
2390 xmothervertex[0][8] = -xmothervertex[0][2];
2391 xmothervertex[0][9] = xmothervertex[0][8];
2392 xmothervertex[0][10] = xmothervertex[0][7];
2393 xmothervertex[0][11] = xmothervertex[0][10];
2394 for(Int_t i=0; i<kmothervertexnumber; i++) xmothervertex[1][i] = xmothervertex[0][i];
2395 for(Int_t i = 0; i<kmothernumber; i++){
2396 ymothervertex[i][0] = -(fgkSSDChipWidth-(0.5*fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist)
2397 + ssdchipcablesradius[i]+fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]);
2398 ymothervertex[i][1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexWidth[0];
2399 ymothervertex[i][2] = ymothervertex[i][1];
2400 ymothervertex[i][3] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth;
2401 ymothervertex[i][4] = ymothervertex[i][3];
2402 ymothervertex[i][5] = ymothervertex[i][4]+0.5*fgkSSDStiffenerWidth-ymothervertex[i][0];
2403 ymothervertex[i][6] = ymothervertex[i][5];
2404 ymothervertex[i][7] = 0.5*fgkSSDStiffenerWidth+fgkSSDFlexWidth[0];
2405 ymothervertex[i][8] = ymothervertex[i][7];
2406 ymothervertex[i][9] = 0.5*fgkSSDStiffenerWidth;
2407 ymothervertex[i][10] = ymothervertex[i][9];
2408 ymothervertex[i][11] = ymothervertex[i][0];
2409 }
2410 TGeoXtru* ssdhybridmothershape[kmothernumber];
ca86fdb4 2411// TGeoVolume* ssdhybridmother[kmothernumber];
2412 TGeoVolumeAssembly* ssdhybridmother[kmothernumber];
bf210566 2413 const char* ssdhybridmothername[kmothernumber] = {"SSDHybridMother1","SSDHybridMother2"};
2414 for(Int_t i=0; i<kmothernumber; i++){
2415 ssdhybridmothershape[i] = new TGeoXtru(2);
2416 ssdhybridmothershape[i]->DefinePolygon(kmothervertexnumber,xmothervertex[i],
2417 ymothervertex[i]);
2418 ssdhybridmothershape[i]->DefineSection(0,-0.5*fgkSSDStiffenerHeight-fgkSSDChipHeight
2419 -fgkSSDChipCablesHeight[i+2]);
2420 ssdhybridmothershape[i]->DefineSection(1, 0.5*fgkSSDStiffenerHeight);
ca86fdb4 2421// ssdhybridmother[i] = new TGeoVolume(ssdhybridmothername[i],ssdhybridmothershape[i],
2422// fSSDAir);
2423 ssdhybridmother[i] = new TGeoVolumeAssembly(ssdhybridmothername[i]);
bf210566 2424 }
2425 /////////////////////////////////////////////////////////////
2426 // SSD Stiffener
2427 /////////////////////////////////////////////////////////////
2428 TGeoBBox* ssdstiffenershape = new TGeoBBox("SSDStiffenerShape",
2429 0.5*fgkSSDStiffenerLength,
ca86fdb4 2430 0.5*(fgkSSDStiffenerWidth-fgkSSDTolerance),
bf210566 2431 0.5*fgkSSDStiffenerHeight);
2432 TGeoVolume* ssdstiffener = new TGeoVolume("SSDStiffener",ssdstiffenershape,
2433 fSSDStiffenerMedium);
2434 ssdstiffener->SetLineColor(fColorStiffener);
2435 TGeoTranslation* ssdstiffenertrans[kssdstiffenernumber];
2436 for(Int_t i=0; i<kssdstiffenernumber; i++)
2437 ssdstiffenertrans[i] = new TGeoTranslation(0.,i*ssdstiffenerseparation,0.);
2438 /////////////////////////////////////////////////////////////
2439 // SSD Chip System
2440 /////////////////////////////////////////////////////////////
2441 TList* ssdchipsystemlist = GetSSDChipSystem();
2442 Double_t ssdchipseparation = fgkSSDSensorLength
2443 - 2.*fgkSSDModuleStiffenerPosition[1]
2444 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
2445 - 0.5*fgkSSDChipWidth);
2446 Double_t ssdchipsystemlength = (fgkSSDChipNumber-1)*(fgkSSDChipLength
2447 + fgkSSDChipSeparationLength)+fgkSSDChipCablesLength[1];
2448 TGeoTranslation* ssdchipsystemtrans = new TGeoTranslation(0.5*fgkSSDChipCablesLength[1]
2449 - 0.5*ssdchipsystemlength,
2450 0.5*(ssdstiffenerseparation-ssdchipseparation),
2451 - 0.5*(fgkSSDChipHeight+fgkSSDStiffenerHeight));
2452////////////////////////////
2453// Capacitor 0603-2200 nF
2454///////////////////////////
2455 const Int_t knapacitor0603number = 5;
2456 TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
2457 0.5*fgkSSDCapacitor0603Length,
9f5fafaf 2458 0.5*(fgkSSDCapacitor0603Width),
bf210566 2459 0.5*fgkSSDCapacitor0603Height);
2460 TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
2461 fSSDStiffener0603CapacitorMedium);
2462 capacitor0603->SetLineColor(fColorAl);
2463 for(Int_t i=0; i<kmothernumber; i++){
2464 for(Int_t j=0; j<kssdstiffenernumber; j++){
2465 ssdhybridmother[i]->AddNode(ssdstiffener,j+1,ssdstiffenertrans[j]);
2466 for(Int_t k=1; k<knapacitor0603number+1; k++){
9f5fafaf 2467 ssdhybridmother[i]->AddNode(capacitor0603,knapacitor0603number*j+k,
2468 new TGeoTranslation((k-3.)/6*fgkSSDStiffenerLength,
2469 j*ssdstiffenerseparation
2470 + 0.5*((j==0? 1:-1)*fgkSSDStiffenerWidth
2471 + (j==0? -1:+1)*fgkSSDCapacitor0603Width),
2472 - 0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height)));
bf210566 2473 }
2474 }
2475 ssdhybridmother[i]->AddNode((TGeoVolume*)ssdchipsystemlist->At(i),i+1,ssdchipsystemtrans);
2476 ssdhybridlist->Add(ssdhybridmother[i]);
2477 }
2478/////////////////////////////////////////////////////////////
2479// Mother Volume Containing Capacitor Part
2480/////////////////////////////////////////////////////////////
2481 const Int_t kcapacitormothernumber = 8;
2482 Double_t xcapacitorvertex[kcapacitormothernumber];
2483 Double_t ycapacitorvertex[kcapacitormothernumber];
2484 ///////////////////////
2485 // Setting the vertices
2486 ///////////////////////
2487 xcapacitorvertex[0] = -fgkSSDConnectorPosition[0]+ssdstiffenershape->GetDX();
2488 xcapacitorvertex[1] = xcapacitorvertex[0];
2489 xcapacitorvertex[2] = 0.5*fgkSSDFlexHoleWidth;
2490 xcapacitorvertex[3] = xcapacitorvertex[2];
2491 xcapacitorvertex[4] = xcapacitorvertex[0];
2492 xcapacitorvertex[5] = xcapacitorvertex[0];
2493 xcapacitorvertex[6] = -xcapacitorvertex[0];
2494 xcapacitorvertex[7] = xcapacitorvertex[6];
2495 ycapacitorvertex[0] = -0.5*fgkSSDStiffenerWidth;
2496 ycapacitorvertex[1] = ssdstiffenerseparation-0.5*fgkSSDStiffenerWidth-fgkSSDFlexHoleLength;
2497 ycapacitorvertex[2] = ycapacitorvertex[1];
2498 ycapacitorvertex[3] = ycapacitorvertex[2]+fgkSSDFlexHoleLength;
2499 ycapacitorvertex[4] = ycapacitorvertex[3];
2500 ycapacitorvertex[5] = ycapacitorvertex[4]+fgkSSDStiffenerWidth;
2501 ycapacitorvertex[6] = ycapacitorvertex[5];
2502 ycapacitorvertex[7] = ycapacitorvertex[0];
2503 TGeoXtru* ssdhybridcapacitormothershape = new TGeoXtru(2);
2504 ssdhybridcapacitormothershape->DefinePolygon(kcapacitormothernumber,xcapacitorvertex,
2505 ycapacitorvertex);
2506 ssdhybridcapacitormothershape->DefineSection(0,0.5*fgkSSDStiffenerHeight);
2507 ssdhybridcapacitormothershape->DefineSection(1, 0.5*fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height);
ca86fdb4 2508// TGeoVolume* ssdhybridcapacitormother = new TGeoVolume("SSDHybridCapacitorMother",ssdhybridcapacitormothershape,
2509// fSSDAir);
2510 TGeoVolumeAssembly* ssdhybridcapacitormother = new TGeoVolumeAssembly("SSDHybridCapacitorMother");
bf210566 2511////////////////////////////
2512// Connector
2513///////////////////////////
2514 const Int_t kssdconnectornumber = 2;
2515 TGeoBBox* ssdconnectorshape[kssdconnectornumber];
2516 Double_t ssdAlconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorAlHeight)};
2517 Double_t ssdNiconnectororigin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDConnectorNiHeight)
2518 + fgkSSDConnectorAlHeight};
2519 const char* ssdconnectorname[kssdconnectornumber] = {"SSDConnectorAl","SSDConnectorNi"};
2520 TGeoVolume* ssdconnector[kssdconnectornumber];
2521 for(Int_t i=0; i<kssdconnectornumber; i++){
2522 ssdconnectorshape[i] = new TGeoBBox(0.5*fgkSSDConnectorLength,
2523 0.5*fgkSSDConnectorWidth,
2524 0.5*((1-i)*fgkSSDConnectorAlHeight
2525 + i*fgkSSDConnectorNiHeight),
2526 i==0? ssdAlconnectororigin : ssdNiconnectororigin);
2527 ssdconnector[i] = new TGeoVolume(ssdconnectorname[i],ssdconnectorshape[i],
2528 i==0 ? fSSDAlTraceFlexMedium
2529 : fSSDStiffenerConnectorMedium);
2530 ssdconnector[i]->SetLineColor(i==0 ? fColorAl : fColorPhynox);
2531 }
2532 TGeoTranslation* ssdconnectortrans[2*kssdconnectornumber];
2533 ssdconnectortrans[0] = new TGeoTranslation(-ssdstiffenershape->GetDX()
2534 + fgkSSDConnectorPosition[0]
2535 - fgkSSDConnectorSeparation
2536 - 1.5*fgkSSDConnectorLength,
2537 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2538 - fgkSSDConnectorPosition[1]
2539 - ssdconnectorshape[0]->GetDY(),0.0);
2540 ssdconnectortrans[1] = new TGeoTranslation(
2541 - ssdstiffenershape->GetDX()
2542 + fgkSSDConnectorPosition[0]
2543 - 0.5*fgkSSDConnectorLength,
2544 ssdstiffenerseparation+ssdstiffenershape->GetDY()
2545 - fgkSSDConnectorPosition[1]
2546 - ssdconnectorshape[0]->GetDY(),0.0);
2547 ssdconnectortrans[2] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2548 - fgkSSDConnectorPosition[0]
2549 + fgkSSDConnectorSeparation
2550 + 1.5*fgkSSDConnectorLength,
2551 -(ssdstiffenershape->GetDY()
2552 - fgkSSDConnectorPosition[1]
2553 - ssdconnectorshape[0]->GetDY()),0.0);
2554 ssdconnectortrans[3] = new TGeoTranslation(+ssdstiffenershape->GetDX()
2555 - fgkSSDConnectorPosition[0]
2556 + 0.5*fgkSSDConnectorLength,
2557 -(ssdstiffenershape->GetDY()
2558 - fgkSSDConnectorPosition[1]
2559 - ssdconnectorshape[0]->GetDY()),0.0);
2560 for(Int_t i=0; i<2*kssdconnectornumber; i++)
2561 for(Int_t j=0; j<kssdconnectornumber; j++)
2562 ssdhybridcapacitormother->AddNode(ssdconnector[j],i+1,ssdconnectortrans[i]);
2563////////////////////////////
2564// Capacitor 1812-330 nF
2565///////////////////////////
2566 Double_t ssdcapacitor1812origin[3] = {0.0,0.0,0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor1812Height)};
2567 TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape",
2568 0.5*fgkSSDCapacitor1812Length,
2569 0.5*fgkSSDCapacitor1812Width,
2570 0.5*fgkSSDCapacitor1812Height,
2571 ssdcapacitor1812origin);
2572 TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
2573 fSSDStiffener1812CapacitorMedium);
2574 capacitor1812->SetLineColor(fColorAl);
2575 TGeoTranslation* capacitor1812trans = new TGeoTranslation(0.0,
2576 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
2577 - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],0.0);
2578 ssdhybridcapacitormother->AddNode(capacitor1812,1,capacitor1812trans);
2579////////////////////////////
2580//Hybrid Wire
2581////////////////////////////
2582 Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
2583 - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
2584 - fgkSSDConnectorSeparation;
2585 Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
2586 - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
60e55aee 2587 Double_t ssdwireradius = TMath::Sqrt(wirex*wirex+wirey*wirey);
2588
bf210566 2589 Double_t wireangle = TMath::ATan(wirex/wirey);
2590 TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
2591 fgkSSDWireRadius, 0.5*ssdwireradius);
2592 TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
2593 fSSDStiffenerHybridWireMedium);
2594 hybridwire->SetLineColor(fColorPhynox);
2595 TGeoCombiTrans* hybridwirecombitrans[2];
2596 hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
2597 0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
2598 + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
2599 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
2600 + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
2601 ssdstiffenershape->GetDZ()
2602 + fgkSSDWireRadius+fgkSSDConnectorAlHeight+fgkSSDConnectorNiHeight,
2603 new TGeoRotation("HybridWireRot1",0.,90.,0.));
2604 hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
2605 0.0,
2606 - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
2607 0.0,
2608 new TGeoRotation("HybridWireRot2",
2609 - wireangle*TMath::RadToDeg(),0.,0.));
2610 TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
2611 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
2612 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
2613 ssdhybridcapacitormother->AddNode(hybridwire,1,hybridwirematrix);
2614 ssdhybridlist->Add(ssdhybridcapacitormother);
2615 /////////////////////////////////////////////////////////////
2616 // Deallocating memory
2617 /////////////////////////////////////////////////////////////
2618 delete hybridwirecombitrans[0];
2619 delete hybridwirecombitrans[1];
2620 delete ssdchipsystemlist;
2621 return ssdhybridlist;
44285dfa 2622 /////////////////////////////////////////////////////////////
d7599219 2623}
bf210566 2624///////////////////////////////////////////////////////////////////////////////
2625TGeoVolume* AliITSv11GeometrySSD::GetCoolingBlockSystem(){
2626 /////////////////////////////////////////////////////////////
2627 // SSD Cooling Block System
2628 /////////////////////////////////////////////////////////////
2629 // SSD Cooling Block and Cooling Tube Transformations
2630 /////////////////////////////////////////////////////////////
2631 TGeoRotation* localcoolingblockrot = new TGeoRotation();
2632 localcoolingblockrot->SetAngles(0.,90.,0.);
535e8862 2633 TGeoCombiTrans localcoolingblockmatrix(0.,0.5*fgkSSDCoolingBlockWidth,0.,localcoolingblockrot);
bf210566 2634 TVector3* coolingblocktransvector;
2635 coolingblocktransvector = new TVector3(fgkSSDModuleSensorSupportDistance
2636 + fgkSSDCoolingBlockLength,
2637 fgkSSDSensorLength
2638 - 2.*fgkSSDModuleStiffenerPosition[1]
2639 - fgkSSDCoolingBlockWidth);
2640 const Int_t kcoolingblocktransnumber = 2;
2641 const Int_t kcoolingblocknumber = 4;
2642 TGeoHMatrix* coolingblockmatrix[kcoolingblocknumber];
2643 TGeoHMatrix* coolingtubematrix[kcoolingblocknumber];
2644 TGeoRotation* localcoolingtuberot = new TGeoRotation();
2645 localcoolingtuberot->SetAngles(0.0,90.0,0.0);
2646 TGeoTranslation* localcoolingtubetrans = new TGeoTranslation();
2647 localcoolingtubetrans->SetTranslation(0.5*fgkSSDCoolingBlockLength,
535e8862 2648 0.5*fgkSSDCoolingBlockWidth,
2649 fgkSSDCoolingBlockHoleCenter);
2650 TGeoCombiTrans localcoolingtubematrix (*localcoolingtubetrans,*localcoolingtuberot);
bf210566 2651 Double_t coolingtubedistance = fgkCoolingTubeSupportRmax-fgkCoolingTubeSupportRmin;
2652 for(Int_t i=0; i<kcoolingblocktransnumber; i++){
535e8862 2653 for(Int_t j=0; j<kcoolingblocktransnumber; j++){
2654 TGeoTranslation localcoolingblocktrans(i*coolingblocktransvector->X()+2*coolingtubedistance,
2655 j*coolingblocktransvector->Y(),
2656 - 0.5*(fgkSSDCoolingBlockHoleCenter
2657 + fgkCoolingTubeRmax));
2658 coolingblockmatrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingblockmatrix);
2659 coolingtubematrix[2*i+j] = new TGeoHMatrix(localcoolingblocktrans*localcoolingtubematrix);
2660 }
bf210566 2661 }
44285dfa 2662 /////////////////////////////////////////////////////////////
bf210566 2663 // Virtual Volume containing CoolingBlock System
44285dfa 2664 /////////////////////////////////////////////////////////////
bf210566 2665 TGeoXtru* coolingsystemothershape = new TGeoXtru(2);
2666 const Int_t kmothervertexnumber = 16;
2667 Double_t xmothervertex[kmothervertexnumber];
2668 Double_t ymothervertex[kmothervertexnumber];
2669 ///////////////////////
2670 // Setting the vertices
2671 ///////////////////////fgkCoolingTubeSupportRmax
2672 xmothervertex[0] = 0.0,ymothervertex[0] = 0.0;
2673 xmothervertex[1] = xmothervertex[0], ymothervertex[1] = coolingblocktransvector->Y()
2674 + fgkSSDCoolingBlockWidth;
2675 xmothervertex[2] = coolingblocktransvector->X()
2676 + fgkSSDCoolingBlockLength
2677 + 4*coolingtubedistance;
2678 ymothervertex[2] = ymothervertex[1];
2679 xmothervertex[3] = xmothervertex[2], ymothervertex[3] = ymothervertex[0];
2680 xmothervertex[4] = xmothervertex[3]-2.*coolingtubedistance-fgkSSDCoolingBlockLength;
2681 ymothervertex[4] = ymothervertex[0];
2682 xmothervertex[5] = xmothervertex[4], ymothervertex[5] = fgkSSDCoolingBlockWidth;
2683 xmothervertex[6] = xmothervertex[3]-coolingtubedistance;
2684 ymothervertex[6] = ymothervertex[5];
2685 xmothervertex[7] = xmothervertex[6], ymothervertex[7] = ymothervertex[2]
2686 - fgkSSDCoolingBlockWidth;
2687 xmothervertex[8] = xmothervertex[5], ymothervertex[8] = ymothervertex[7];
2688 xmothervertex[9] = xmothervertex[8], ymothervertex[9] = ymothervertex[2]
2689 - coolingtubedistance;
2690 xmothervertex[10] = fgkSSDCoolingBlockLength+2.*coolingtubedistance;
2691 ymothervertex[10] = ymothervertex[9];
2692 xmothervertex[11] = xmothervertex[10], ymothervertex[11] = ymothervertex[8];
2693 xmothervertex[12] = coolingtubedistance, ymothervertex[12] = ymothervertex[11];
2694 xmothervertex[13] = xmothervertex[12], ymothervertex[13] = fgkSSDCoolingBlockWidth;
2695 xmothervertex[14] = 2.*coolingtubedistance+fgkSSDCoolingBlockLength;
2696 ymothervertex[14] = ymothervertex[13];
2697 xmothervertex[15] = xmothervertex[14], ymothervertex[15] = ymothervertex[0];
2698 //////////////////////////////////////////////////////////
2699 coolingsystemothershape->DefinePolygon(kmothervertexnumber,
2700 xmothervertex,ymothervertex);
2701 coolingsystemothershape->DefineSection(0,-0.5*(fgkSSDCoolingBlockHoleCenter
2702 + fgkCoolingTubeRmax));
2703 coolingsystemothershape->DefineSection(1, 0.5*(fgkSSDCoolingBlockHoleCenter
2704 + fgkCoolingTubeRmax));
ca86fdb4 2705 TGeoVolume* coolingsystemother = new TGeoVolumeAssembly("CoolingBlockSystem");
2706// TGeoVolume* coolingsystemother = new TGeoVolume("CoolingBlockSystem",
2707// coolingsystemothershape,fSSDAir);
bf210566 2708 /////////////////////////////////////////////////////////////
2709 // SSD Cooling Tube Part
2710 /////////////////////////////////////////////////////////////
2711 TGeoTube* coolingtubeshape[fgkcoolingtubenumber];
2712 coolingtubeshape[0] = new TGeoTube(fgkCoolingTubeRmin,fgkCoolingTubeRmax,
ca86fdb4 2713 0.5*(fgkSSDCoolingBlockWidth-fgkSSDTolerance));
bf210566 2714 coolingtubeshape[1] = new TGeoTube(0.0,fgkCoolingTubeRmin,
ca86fdb4 2715 0.5*(fgkSSDCoolingBlockWidth-fgkSSDTolerance));
bf210566 2716 TGeoVolume* coolingtube[fgkcoolingtubenumber];
2717 coolingtube[0] = new TGeoVolume("OuterCoolingTube",coolingtubeshape[0],
2718 fSSDCoolingTubePhynox);
2719 coolingtube[1] = new TGeoVolume("InnerCoolingTube",coolingtubeshape[1],
2720 fSSDCoolingTubeWater);
2721 coolingtube[0]->SetLineColor(fColorPhynox);
2722 coolingtube[1]->SetLineColor(fColorWater);
2723 TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock(30);
2724 /////////////////////////////////////////////////////////////
2725 // Adding Cooling block to mother volume
2726 /////////////////////////////////////////////////////////////
2727 for(Int_t i=0; i<kcoolingblocknumber; i++){
9f5fafaf 2728 coolingsystemother->AddNode(ssdcoolingblock,i+1,coolingblockmatrix[i]);
bf210566 2729 coolingsystemother->AddNode(coolingtube[0],i+1,coolingtubematrix[i]);
2730 coolingsystemother->AddNode(coolingtube[1],i+1,coolingtubematrix[i]);
2731 }
2732 /////////////////////////////////////////////////////////////
2733 // Deallocating memory
2734 /////////////////////////////////////////////////////////////
2735 delete coolingblocktransvector;
bf210566 2736 delete localcoolingblockrot;
bf210566 2737 delete localcoolingtubetrans;
2738 delete localcoolingtuberot;
2739 /////////////////////////////////////////////////////////////
2740 // Checking overlaps
2741 /////////////////////////////////////////////////////////////
6727e2db 2742 //coolingsystemother->CheckOverlaps(0.01);
bf210566 2743 /////////////////////////////////////////////////////////////
2744 return coolingsystemother;
d7599219 2745}
bf210566 2746/////////////////////////////////////////////////////////////////////////////////
2747TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerFlex()const{
44285dfa 2748 /////////////////////////////////////////////////////////////
bf210566 2749 // SSD Flex
44285dfa 2750 /////////////////////////////////////////////////////////////
bf210566 2751 const Int_t kssdflexlayernumber = 2;
2752 TGeoXtru* ssdflexshape[kssdflexlayernumber];
2753 for(Int_t i=0; i<kssdflexlayernumber; i++) ssdflexshape[i] = new TGeoXtru(2);
2754 const Int_t kmothervertexnumber = 17;
2755 Double_t xmothervertex[kmothervertexnumber];
2756 Double_t ymothervertex[kmothervertexnumber];
2757 /////////////////////////////////////////////
2758 // Auxiliary variables for vertex positioning
2759 /////////////////////////////////////////////
2760 const Int_t kssdflexboxnumber = 5;
2761 Double_t ssdflexboxlength[kssdflexboxnumber];
2762 ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
2763 * fgkSSDChipLength+(fgkSSDChipNumber-1)
2764 * fgkSSDChipSeparationLength
2765 - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
2766 - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
2767 ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
2768 ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
2769 - fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
2770 ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
2771 ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
2772 - ssdflexboxlength[1];
2773 Double_t ssdflexboxwidth[kssdflexboxnumber];
2774 ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
2775 ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
2776 ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
2777 ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
2778 ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
2779 ///////////////////////
2780 // Setting the vertices
2781 ///////////////////////
2782 xmothervertex[0] = 0.0;
2783 xmothervertex[1] = xmothervertex[0];
2784 xmothervertex[2] = fgkSSDFlexLength[0]-fgkSSDFlexLength[1];
2785 xmothervertex[3] = xmothervertex[2]+ssdflexboxlength[0]+ssdflexboxlength[1]
2786 + ssdflexboxlength[4];
2787 xmothervertex[4] = xmothervertex[3];
2788 xmothervertex[5] = xmothervertex[4]-ssdflexboxlength[4];
2789 xmothervertex[6] = xmothervertex[5];
2790 xmothervertex[7] = xmothervertex[6]-fgkSSDFlexHoleLength;
2791 xmothervertex[8] = xmothervertex[7];
2792 xmothervertex[9] = xmothervertex[8]-ssdflexboxlength[2];
2793 xmothervertex[10] = xmothervertex[9];
2794 xmothervertex[11] = xmothervertex[10]-ssdflexboxlength[3];
2795 xmothervertex[12] = xmothervertex[11];
2796 xmothervertex[13] = xmothervertex[12]-ssdflexboxlength[2];
2797 xmothervertex[14] = xmothervertex[13];
2798 xmothervertex[15] = xmothervertex[14]-fgkSSDFlexHoleLength;
2799 xmothervertex[16] = xmothervertex[15];
2800 ymothervertex[0] = 0.0;
2801 ymothervertex[1] = fgkSSDFlexWidth[1];
2802 ymothervertex[2] = fgkSSDFlexWidth[0];
2803 ymothervertex[3] = ymothervertex[2];
2804 ymothervertex[4] = ymothervertex[0];
2805 ymothervertex[5] = ymothervertex[4];
2806 ymothervertex[6] = ssdflexboxwidth[2];
2807 ymothervertex[7] = ymothervertex[6];
2808 ymothervertex[8] = ymothervertex[0];
2809 ymothervertex[9] = ymothervertex[8];
2810 ymothervertex[10] = ssdflexboxwidth[2]-ssdflexboxwidth[3];
2811 ymothervertex[11] = ymothervertex[10];
2812 ymothervertex[12] = ymothervertex[0];
2813 ymothervertex[13] = ymothervertex[12];
2814 ymothervertex[14] = ymothervertex[7];
2815 ymothervertex[15] = ymothervertex[14];
2816 ymothervertex[16] = ymothervertex[0];
2817 /////////////////////////////////////////////////////////////
2818 // First Mother Volume containing SSDFlex
2819 /////////////////////////////////////////////////////////////
2820 TGeoXtru* ssdflexmothershape = new TGeoXtru(2);
2821 ssdflexmothershape->DefinePolygon(kmothervertexnumber,xmothervertex,
2822 ymothervertex);
2823 ssdflexmothershape->DefineSection(0,-1.5*fgkSSDFlexHeight[0]-2.*fgkSSDFlexHeight[1]);
2824 ssdflexmothershape->DefineSection(1, 0.5*fgkSSDFlexHeight[0]);
ca86fdb4 2825 TGeoVolumeAssembly* ssdflexmother = new TGeoVolumeAssembly("SSDFlexMother");
2826// TGeoVolume* ssdflexmother = new TGeoVolume("SSDFlexMother",ssdflexmothershape,
2827// fSSDAir);
bf210566 2828 /////////////////////////////////////////////////////////////
2829 // SSDFlex Layer Shapes
2830 /////////////////////////////////////////////////////////////
2831 for(Int_t i=0; i<kssdflexlayernumber; i++){
2832 ssdflexshape[i]->DefinePolygon(kmothervertexnumber,xmothervertex,
2833 ymothervertex);
2834 ssdflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexHeight[i]);
2835 ssdflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexHeight[i]);
2836 }
2837 /////////////////////////////////////
2838 // Setting Layers into Mother Volume
2839 /////////////////////////////////////
2840 Int_t ssdflexcolor[kssdflexlayernumber] = {fColorAl,fColorPolyhamide};
2841 TGeoMedium* ssdflexmed[kssdflexlayernumber] = {fSSDAlTraceFlexMedium,
2842 fSSDKaptonFlexMedium};
2843 const char* ssdflexname[2*kssdflexlayernumber] = {"AlFlexLay1","KaptonFlexLay1",
2844 "AlFlexLay2","KaptonFlexLay2"};
2845 TGeoVolume* ssdflex[2*kssdflexlayernumber];
2846 TGeoTranslation* ssdflextrans[2*kssdflexlayernumber];
2847 for(Int_t i=0; i<2*kssdflexlayernumber; i++){
2848 ssdflex[i] = new TGeoVolume(ssdflexname[i],
2849 i%2==0 ? ssdflexshape[0] : ssdflexshape[1],
2850 i%2==0 ? ssdflexmed[0] : ssdflexmed[1]);
2851 ssdflex[i]->SetLineColor(i%2==0 ? ssdflexcolor[0] : ssdflexcolor[1]);
2852 ssdflextrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(fgkSSDFlexHeight[0]
2853 + fgkSSDFlexHeight[1]));
2854 ssdflexmother->AddNode(ssdflex[i],1,ssdflextrans[i]);
2855 }
bf210566 2856 return ssdflexmother;
2857}
2858/////////////////////////////////////////////////////////////////////////////////
2859TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(){
2860 /////////////////////////////////////////////////////////////
2861 // Method generating SSD End Flex
2862 /////////////////////////////////////////
2863 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
2864 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
2865 Double_t ssdflexboxlength = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
2866 * TMath::DegToRad()*ssdflexradiusmax
2867 - fgkSSDFlexLength[2]-TMath::Pi()
0fb26117 2868 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
2869 - 0.1*fgkSSDFlexFullLength;
bf210566 2870 const Int_t knedges = 20;
2871 const Int_t karcnumber = 2;
2872 TVector3* vertexposition[karcnumber*(knedges+1)];
2873 Double_t deltangle[karcnumber] = {2.*fgkSSDFlexAngle/knedges,180.0/knedges};
2874 Double_t angle[karcnumber] = {90.-2.*fgkSSDFlexAngle,180.0};
2875 Double_t radius[karcnumber] = {ssdflexradiusmax-fgkSSDStiffenerHeight,fgkSSDStiffenerHeight};
2876 Double_t referenceangle[karcnumber] = {-180.0*TMath::DegToRad(),
2877 - 90.0*TMath::DegToRad()};
2878 TVector3* referencetrans[karcnumber];
2879 referencetrans[0] = new TVector3(ssdflexboxlength*CosD(2.*fgkSSDFlexAngle)
2880 + radius[0]*SinD(2.*fgkSSDFlexAngle),
2881 radius[0]);
2882 referencetrans[1] = new TVector3(referencetrans[0]->X()
2883 + fgkSSDFlexLength[2],
2884 - fgkSSDStiffenerHeight);
2885for(Int_t i=0; i<karcnumber; i++){
2886 for(Int_t j=0; j<knedges+1; j++){
2887 vertexposition[j+i*(knedges+1)] = new TVector3(radius[i]*CosD(angle[i]),
2888 radius[i]*SinD(angle[i]));
2889 angle[i] += deltangle[i]*(1.0-2.0*i);
2890 }
2891 }
2892 ///////////////////////
2893 // Setting the vertices
2894 ///////////////////////
2895 const Int_t kendflexlayernumber = 4;
2896 const Int_t kendflexvertexnumber = 4*(knedges+1)+2;
2897 TVector3** vertex[kendflexlayernumber];
2898 for(Int_t i=0; i<kendflexlayernumber; i++)
2899 vertex[i] = new TVector3*[kendflexvertexnumber];
2900 TVector3* transvector[kendflexlayernumber+1];
2901 TVector3* deltatransvector = new TVector3();
2902 for(Int_t i=0; i<kendflexlayernumber+1; i++) transvector[i] = new TVector3();
2903 transvector[0]->SetXYZ(0.0,ssdflexboxlength*SinD(2.*fgkSSDFlexAngle)
2904 + radius[0]*(1.0-CosD(2.*fgkSSDFlexAngle)),0.0);
2905 for(Int_t i=1; i<kendflexlayernumber+1; i++){
2906 deltatransvector->SetXYZ((i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2907 * CosD(fgkSSDFlexAngle),
2908 (i%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2909 * SinD(fgkSSDFlexAngle),0.0);
2910 *transvector[i] = *transvector[i-1]+*deltatransvector;
2911 }
2912 Double_t ratioradius[karcnumber][kendflexlayernumber+1];
2913 ratioradius[0][0] = 1., ratioradius[1][0] = 1.;
2914 for(Int_t i=0; i<karcnumber; i++){
2915 for(Int_t j=1; j<kendflexlayernumber+1; j++){
2916 ratioradius[i][j] = ratioradius[i][j-1]-TMath::Power(-1.0,i)
2917 * (j%2!=0?fgkSSDFlexHeight[0]:fgkSSDFlexHeight[1])
2918 /radius[i];
2919 }
2920 }
2921 for(Int_t i=0; i<kendflexlayernumber; i++){
2922 vertex[i][0] = new TVector3(transvector[i]->X(),transvector[i]->Y());
2923 vertex[i][1] = new TVector3(transvector[i+1]->X(),transvector[i+1]->Y());
2924 for(Int_t j=0; j<karcnumber*(knedges+1); j++){
2925 if(j<(knedges+1)){
2926 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[0][i+1],
2927 vertexposition[j]->Y()*ratioradius[0][i+1]);
2928 vertex[i][j+2]->RotateZ(referenceangle[0]);
2929 *vertex[i][j+2] += *referencetrans[0];
2930 vertex[i][4*(knedges+1)-j+1] =
2931 new TVector3(vertexposition[j]->X()*ratioradius[0][i],
2932 vertexposition[j]->Y()*ratioradius[0][i]);
2933 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[0]);
2934 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[0];
2935 }
2936 else{
2937
2938 vertex[i][j+2] = new TVector3(vertexposition[j]->X()*ratioradius[1][i+1],
2939 vertexposition[j]->Y()*ratioradius[1][i+1]);
2940 vertex[i][j+2]->RotateZ(referenceangle[1]);
2941 *vertex[i][j+2] += *referencetrans[1];
2942 vertex[i][4*(knedges+1)-j+1] =
2943 new TVector3(vertexposition[j]->X()*ratioradius[1][i],
2944 vertexposition[j]->Y()*ratioradius[1][i]);
2945 vertex[i][4*(knedges+1)-j+1]->RotateZ(referenceangle[1]);
2946 *vertex[i][4*(knedges+1)-j+1] += *referencetrans[1];
2947 }
2948 }
2949 }
2950 /////////////////////////////////////////////////////////////
2951 // First Mother Volume containing SSDEndFlex
2952 /////////////////////////////////////////////////////////////
2953 TGeoXtru* ssdendflexmothershape = new TGeoXtru(2);
2954 Double_t xmothervertex[kendflexvertexnumber];
2955 Double_t ymothervertex[kendflexvertexnumber];
2956 xmothervertex[0] = vertex[0][0]->X();
2957 ymothervertex[0] = vertex[0][0]->Y();
2958 for(Int_t i=1; i<kendflexvertexnumber; i++){
2959 if(i<2*(knedges+1)+2){
2960 xmothervertex[i] = vertex[3][i]->X();
2961 ymothervertex[i] = vertex[3][i]->Y();
2962 }
2963 else{
2964 xmothervertex[i] = vertex[0][i]->X();
2965 ymothervertex[i] = vertex[0][i]->Y();
2966 }
2967 }
2968 ssdendflexmothershape->DefinePolygon(kendflexvertexnumber,
2969 xmothervertex,ymothervertex);
2970 ssdendflexmothershape->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2971 ssdendflexmothershape->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
0fb26117 2972// TGeoVolume* ssdendflexmother = new TGeoVolume("SSDEndFlexMother",
2973// ssdendflexmothershape,fSSDAir);
2974 TGeoVolumeAssembly* ssdendflexmother = new TGeoVolumeAssembly("SSDEndFlexMother");
bf210566 2975 //////////////////////////////////////
2976 // End Flex TGeoXtru Layer Definition
2977 //////////////////////////////////////
2978 TGeoXtru* ssdendflexshape[kendflexlayernumber];
2979 TGeoVolume* ssdendflex[kendflexlayernumber];
2980 for(Int_t i=0; i<kendflexlayernumber; i++) ssdendflexshape[i] = new TGeoXtru(2);
2981 Double_t xvertex[kendflexlayernumber][kendflexvertexnumber];
2982 Double_t yvertex[kendflexlayernumber][kendflexvertexnumber];
2983 Int_t ssdendflexcolor[kendflexlayernumber] = {fColorAl,fColorPolyhamide};
2984 TGeoMedium* ssdendflexmed[kendflexlayernumber] = {fSSDAlTraceFlexMedium,
2985 fSSDKaptonFlexMedium};
2986 const char* ssdendflexname[kendflexlayernumber] = {"AlEndFlexLay1","KaptonEndFlexLay1",
2987 "AlEndFlexLay2","KaptonEndFlexLay2"};
2988 for(Int_t i=0; i<kendflexlayernumber; i++){
2989 for(Int_t j=0; j<4*(knedges+1)+2; j++){
2990 xvertex[i][j] = vertex[i][j]->X();
2991 yvertex[i][j] = vertex[i][j]->Y();
2992 }
2993 ssdendflexshape[i]->DefinePolygon(kendflexvertexnumber,xvertex[i],yvertex[i]);
2994 ssdendflexshape[i]->DefineSection(0,-0.5*fgkSSDFlexWidth[0]);
2995 ssdendflexshape[i]->DefineSection(1, 0.5*fgkSSDFlexWidth[0]);
2996 ssdendflex[i] = new TGeoVolume(ssdendflexname[i],ssdendflexshape[i],
2997 i%2==0 ? ssdendflexmed[0] : ssdendflexmed[1]);
2998 ssdendflex[i]->SetLineColor(i%2==0 ? ssdendflexcolor[0] : ssdendflexcolor[1]);
2999 ssdendflexmother->AddNode(ssdendflex[i],1);
3000 }
3001 /////////////////////////////////////////////////////////////
3002 // Deallocating memory
3003 /////////////////////////////////////////////////////////////
3004 for(Int_t i=0; i<karcnumber*(knedges+1); i++) delete vertexposition[i];
3005 for(Int_t i=0; i<karcnumber; i++) delete referencetrans[i];
3006 for(Int_t i=0; i<kendflexlayernumber; i++){
3007 for(Int_t j=0; j<kendflexvertexnumber; j++) delete vertex[i][j];
3008 delete [] vertex[i];
3009 }
3010 for(Int_t i=0; i<kendflexlayernumber+1; i++) delete transvector[i];
3011 delete deltatransvector;
3012 /////////////////////////////////////////////////////////////
6727e2db 3013 //ssdendflexmother->CheckOverlaps(0.01);
bf210566 3014 return ssdendflexmother;
d7599219 3015}
9b0c60ab 3016///////////////////////////////////////////////////////////////////////////////
d7599219 3017TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
44285dfa 3018 /////////////////////////////////////////////////////////////
9b0c60ab 3019 // Method generating the Mounting Block
44285dfa 3020 /////////////////////////////////////////////////////////////
9b0c60ab 3021 const Int_t kvertexnumber = 8;
3022 Double_t xvertex[kvertexnumber];
3023 Double_t yvertex[kvertexnumber];
3024 xvertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3025 xvertex[1] = xvertex[0];
3026 xvertex[2] = -xvertex[0];
3027 xvertex[3] = xvertex[2];
3028 xvertex[4] = xvertex[3]+0.5*(fgkSSDMountingBlockLength[1]
3029 - fgkSSDMountingBlockLength[2]);
3030 xvertex[5] = xvertex[4];
3031 xvertex[6] = 0.5*fgkSSDMountingBlockLength[0]-xvertex[2]
3032 - 0.5*fgkSSDMountingBlockScrewHoleEdge
3033 - fgkSSDMountingBlockScrewHoleRadius[0];
3034 xvertex[7] = xvertex[6];
3035 yvertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
0fb26117 3036 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
9b0c60ab 3037 yvertex[1] = 0.5*fgkSSDMountingBlockHeight[0];
3038 yvertex[2] = yvertex[1];
3039 yvertex[3] = fgkSSDMountingBlockHeight[1]-yvertex[1];
3040 yvertex[4] = yvertex[3];
3041 yvertex[5] = yvertex[2]+fgkSSDMountingBlockHeight[2]
3042 - fgkSSDMountingBlockHeight[0];
3043 yvertex[6] = yvertex[5];
3044 yvertex[7] = yvertex[0];
160835d5 3045
9b0c60ab 3046 ///////////////////////////////////////////////////////////////////////
3047 // TGeoXTru Volume definition for Mounting Block Part
3048 ///////////////////////////////////////////////////////////////////////
3049 TGeoXtru* ssdmountingblockshape = new TGeoXtru(2);
3050 ssdmountingblockshape->DefinePolygon(kvertexnumber,xvertex,yvertex);
3051 ssdmountingblockshape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3052 ssdmountingblockshape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
44285dfa 3053 TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
9b0c60ab 3054 ssdmountingblockshape,
3055 fSSDMountingBlockMedium);
3056 ssdmountingblock->SetLineColor(fColorG10);
3057 TGeoCombiTrans* mountingblockcombitrans = new TGeoCombiTrans();
3058 mountingblockcombitrans->SetTranslation(2.*xvertex[2]+fgkSSDMountingBlockLength[1],0.,0.);
3059 TGeoRotation* mountingblockrot = new TGeoRotation();
3060 mountingblockrot->SetAngles(90.,180.,-90.);
3061 mountingblockcombitrans->SetRotation(*mountingblockrot);
3062 /////////////////////////////////////////////////////////////
3063 // Generating the Mounting Block Screw Vertices
3064 /////////////////////////////////////////////////////////////
3065 const Int_t kscrewvertexnumber = 15;
3066 Double_t alpha = TMath::ACos(0.5*(fgkSSDMountingBlockHeight[1]
3067 - fgkSSDMountingBlockScrewHoleEdge)
3068 / fgkSSDMountingBlockScrewHoleRadius[0])
3069 * TMath::RadToDeg();
3070 Double_t phi0 = 90.+alpha;
3071 Double_t phi = 270.-2*alpha;
3072 Double_t deltaphi = phi/kscrewvertexnumber;
3073 TVector3* screwvertex[kscrewvertexnumber+1];
3074 for(Int_t i=0; i<kscrewvertexnumber+1; i++)
3075 screwvertex[i] = new TVector3(fgkSSDMountingBlockScrewHoleRadius[0]
3076 *CosD(phi0+i*deltaphi),
3077 fgkSSDMountingBlockScrewHoleRadius[0]
3078 *SinD(phi0+i*deltaphi));
3079 Double_t xscrewvertex[kscrewvertexnumber+6];
3080 Double_t yscrewvertex[kscrewvertexnumber+6];
3081 xscrewvertex[0] = - fgkSSDMountingBlockScrewHoleRadius[0];
3082 yscrewvertex[0] = -0.5*(fgkSSDMountingBlockWidth
3083 - fgkSSDMountingBlockScrewHoleEdge);
3084 xscrewvertex[1] = xscrewvertex[0];
3085 yscrewvertex[1] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3086 xscrewvertex[2] = screwvertex[0]->X();
3087 yscrewvertex[2] = yscrewvertex[1];
3088 for(Int_t i=0; i<kscrewvertexnumber+1; i++){
3089 xscrewvertex[i+3] = screwvertex[i]->X();
3090 yscrewvertex[i+3] = screwvertex[i]->Y();
3091 }
3092 xscrewvertex[kscrewvertexnumber+4] = 0.5*fgkSSDMountingBlockScrewHoleEdge;
3093 yscrewvertex[kscrewvertexnumber+4] = yscrewvertex[kscrewvertexnumber+3];
3094 xscrewvertex[kscrewvertexnumber+5] = xscrewvertex[kscrewvertexnumber+4];
3095 yscrewvertex[kscrewvertexnumber+5] = yscrewvertex[0];
3096 TGeoXtru* ssdmountingblockscrewshape = new TGeoXtru(2);
3097 ssdmountingblockscrewshape->DefinePolygon(kscrewvertexnumber+6,xscrewvertex,yscrewvertex);
3098 ssdmountingblockscrewshape->DefineSection(0,yvertex[0]);
3099 ssdmountingblockscrewshape->DefineSection(1,-0.5*fgkSSDMountingBlockHeight[0]
3100 + fgkSSDMountingBlockHeight[2]);
3101 TGeoVolume* ssdmountingblockscrew = new TGeoVolume("SSDMountingBlockScrew",
3102 ssdmountingblockscrewshape,
3103 fSSDMountingBlockMedium);
3104 ssdmountingblockscrew->SetLineColor(fColorG10);
3105 TGeoCombiTrans* ssdmountingblockscrewcombitrans[4];
3106 for(Int_t i=0; i<4; i++) ssdmountingblockscrewcombitrans[i] = new TGeoCombiTrans();
3107 ssdmountingblockscrewcombitrans[0]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3108 - yscrewvertex[1],
3109 0.5*fgkSSDMountingBlockHeight[0]
3110 - fgkSSDMountingBlockHeight[2]
3111 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3112 + fgkSSDMountingBlockHeight[2]
3113 - yvertex[0]));
3114 ssdmountingblockscrewcombitrans[1]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3115 -0.5*fgkSSDMountingBlockScrewHoleEdge,
3116 yscrewvertex[1]
3117 -0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3118 +fgkSSDMountingBlockHeight[2]
3119 -yvertex[0]));
3120 ssdmountingblockscrewcombitrans[2]->SetTranslation(-0.5*fgkSSDMountingBlockScrewHoleEdge,
3121 yscrewvertex[1],
3122 - 0.5*fgkSSDMountingBlockHeight[0]
3123 + fgkSSDMountingBlockHeight[2]
3124 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3125 + fgkSSDMountingBlockHeight[2]
3126 - yvertex[0]));
3127 ssdmountingblockscrewcombitrans[3]->SetTranslation(0.5*fgkSSDMountingBlockScrewHoleEdge,
3128 yscrewvertex[1],
3129 - yscrewvertex[1]
3130 + 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3131 + fgkSSDMountingBlockHeight[2]
3132 - yvertex[0]));
3133 TGeoRotation* ssdmountingblockscrewrot[4];
3134 for(Int_t i=0; i<4; i++) ssdmountingblockscrewrot[i] = new TGeoRotation();
3135 ssdmountingblockscrewrot[1]->SetAngles(90.,-180.,-90.);
3136 ssdmountingblockscrewrot[2]->SetAngles(0.,180.,0.);
3137 ssdmountingblockscrewrot[3]->SetAngles(180.,0.,0.);
3138 for(Int_t i=1; i<4; i++)
3139 ssdmountingblockscrewcombitrans[i]->SetRotation(*ssdmountingblockscrewrot[i]);
3140 TGeoRotation* ssdmountingblockglobalrot = new TGeoRotation();
3141 ssdmountingblockglobalrot->SetAngles(0.,90.,0.);
3142 TGeoTranslation* ssdmountingblockglobaltrans = new TGeoTranslation();
3143 ssdmountingblockglobaltrans->SetTranslation(0.5*fgkSSDMountingBlockLength[0]
3144 + xvertex[0],yscrewvertex[1]
3145 - 0.5*(-0.5*fgkSSDMountingBlockHeight[0]
3146 + fgkSSDMountingBlockHeight[2]
3147 - yvertex[0]),0.);
3148 TGeoHMatrix* ssdmountingblockscrewmatrix[4];
3149 for(Int_t i=0; i<4; i++){
3150 ssdmountingblockscrewmatrix[i] =
3151 new TGeoHMatrix((*ssdmountingblockglobalrot)*(*ssdmountingblockscrewcombitrans[i]));
3152 ssdmountingblockscrewmatrix[i]->MultiplyLeft(ssdmountingblockglobaltrans);
3153 }
3154 ///////////////////////////////////////////////////////////////////////
3155 // TGeoXtru for Mother Volume
3156 ///////////////////////////////////////////////////////////////////////
3157 const Int_t kvertexmothernumber = 12;
3158 Double_t xmothervertex[kvertexmothernumber];
3159 Double_t ymothervertex[kvertexmothernumber];
3160 for(Int_t i=0; i<6; i++){
3161 xmothervertex[i] = xvertex[i];
3162 ymothervertex[i] = yvertex[i];
3163 }
3164 xmothervertex[6] = xvertex[5]+fgkSSDMountingBlockLength[2];
3165 ymothervertex[6] = ymothervertex[5];
3166 xmothervertex[7] = xmothervertex[6];
3167 ymothervertex[7] = ymothervertex[4];
3168 xmothervertex[8] = xmothervertex[7]
3169 + 0.5*(fgkSSDMountingBlockLength[1]
3170 - fgkSSDMountingBlockLength[2]);
3171 ymothervertex[8] = ymothervertex[4];
3172 xmothervertex[9] = xmothervertex[8];
3173 ymothervertex[9] = ymothervertex[2];
3174 xmothervertex[10] = xvertex[0]+fgkSSDMountingBlockLength[0];
3175 ymothervertex[10] = ymothervertex[1];
3176 xmothervertex[11] = xmothervertex[10];
3177 ymothervertex[11] = ymothervertex[0];
3178 TGeoXtru* ssdmountingblockmothershape = new TGeoXtru(2);
3179 ssdmountingblockmothershape->DefinePolygon(kvertexmothernumber,xmothervertex,ymothervertex);
3180 ssdmountingblockmothershape->DefineSection(0,-0.5*fgkSSDMountingBlockWidth);
3181 ssdmountingblockmothershape->DefineSection(1,0.5*fgkSSDMountingBlockWidth);
3182 TGeoVolume* ssdmountingblockmother = new TGeoVolume("SSDMountingBlockMother",
3183 ssdmountingblockmothershape,
3184 fSSDAir);
3185 /////////////////////////////////////////////////////////////
3186 // Placing the Volumes into Mother Volume
3187 /////////////////////////////////////////////////////////////
3188 ssdmountingblockmother->AddNode(ssdmountingblock,1);
3189 ssdmountingblockmother->AddNode(ssdmountingblock,2,mountingblockcombitrans);
3190 for(Int_t i=0; i<4; i++)
3191 ssdmountingblockmother->AddNode(ssdmountingblockscrew,i+1,
3192 ssdmountingblockscrewmatrix[i]);
3193 /////////////////////////////////////////////////////////////
3194 // Deallocating memory
3195 /////////////////////////////////////////////////////////////
3196 delete mountingblockrot;
3197 for(Int_t i=0; i<4; i++) delete ssdmountingblockscrewrot[i];
3198 delete ssdmountingblockglobalrot;
3199 delete ssdmountingblockglobaltrans;
3200 /////////////////////////////////////////////////////////////
3201 return ssdmountingblockmother;
3202}
3203///////////////////////////////////////////////////////////////////////////////
3204 TGeoVolume* AliITSv11GeometrySSD::GetMountingBlockClip() const {
3205 /////////////////////////////////////////////////////////////
3206 // Method generating the Mounting Block Clip
3207 /////////////////////////////////////////////////////////////
3208 const Int_t kmothervertexnumber = 10;
3209 Double_t xmothervertex[kmothervertexnumber];
3210 Double_t ymothervertex[kmothervertexnumber];
3211 xmothervertex[0] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1])
3212 - 0.5*(fgkSSDSensorWidth-fgkSSDMountingBlockLength[0]);
3213 xmothervertex[1] = xmothervertex[0];
3214 xmothervertex[2] = xmothervertex[0]+0.5*(fgkMountingBlockClibScrewPosition
3215 - fgkMountingBlockClibScrewRadius);
3216 xmothervertex[3] = xmothervertex[2];
3217 xmothervertex[4] = xmothervertex[3]+2.*fgkMountingBlockClibScrewRadius;
3218 xmothervertex[5] = xmothervertex[4];
3219 xmothervertex[6] = xmothervertex[0]+fgkMountingBlockClipLength;
3220 xmothervertex[7] = xmothervertex[6];
3221 xmothervertex[8] = -0.25*(fgkSSDMountingBlockLength[0]-fgkSSDMountingBlockLength[1]);
3222 xmothervertex[9] = xmothervertex[8];
3223 ymothervertex[0] = -0.5*fgkCoolingTubeSupportHeight-fgkSSDModuleCoolingBlockToSensor
0fb26117 3224 + fgkSSDMountingBlockHeight[1]-0.5*fgkSSDMountingBlockHeight[0];
9b0c60ab 3225 ymothervertex[1] = 0.5*fgkSSDMountingBlockHeight[0]+fgkMountingBlockClipThickness;
3226 ymothervertex[2] = ymothervertex[1];
3227 ymothervertex[3] = ymothervertex[2]+(fgkSSDMountingBlockHeight[1]
3228 - fgkSSDMountingBlockHeight[0]-fgkMountingBlockClipThickness
3229 - 0.5*fgkCoolingTubeSupportHeight-fgkCoolingTubeSupportRmax);