]> git.uio.no Git - u/mrichter/AliRoot.git/blame - ITS/AliITSv11GeometrySSD.cxx
git://git.uio.no / u / mrichter / AliRoot.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
for non-miscalibrated digits, set an ad-hoc conversion factor fAdC->fToT to have...
[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
16
17//*************************************************************************
18// SSD geometry, based on ROOT geometrical modeler
19//
20// Enrico Cattaruzza ecattar@ts.infn.it
21//*************************************************************************
22#include "TMath.h"
23#include "TGeoVolume.h"
d7599219 24#include "TGeoMatrix.h"
25#include <TGeoManager.h>
d7599219 26#include "TVector3.h"
27#include "TGeoArb8.h"
28#include "TList.h"
29#include "TGeoMatrix.h"
30#include "TGeoCompositeShape.h"
31#include "TGeoTube.h"
32#include "TGeoBBox.h"
44285dfa 33#include "AliITSv11GeometrySSD.h"
d7599219 34/////////////////////////////////////////////////////////////////////////////////
35//Parameters for SSD Geometry
36/////////////////////////////////////////////////////////////////////////////////
37// Layer5 (lengths are in mm and angles in degrees)
38/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 39const Double_t AliITSv11GeometrySSD::fgkSSDLay5LadderLength = 950.7*fgkmm;
d7599219 40const Int_t AliITSv11GeometrySSD::fgkSSDLay5SensorsNumber = 22;
41const Int_t AliITSv11GeometrySSD::fgkSSDLay5LadderNumber = 34;
9acf2ecc 42const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMin = 378.0*fgkmm;
43const Double_t AliITSv11GeometrySSD::fgkSSDLay5RadiusMax = 384.0*fgkmm;
44const Double_t AliITSv11GeometrySSD::fgkLay5CenterITSPosition = 467.85*fgkmm;
d7599219 45/////////////////////////////////////////////////////////////////////////////////
46// Layer6 (lengths are in mm and angles in degrees)
47/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 48const Double_t AliITSv11GeometrySSD::fgkSSDLay6LadderLength = 1068.0*fgkmm;
d7599219 49const Int_t AliITSv11GeometrySSD::fgkSSDLay6SensorsNumber = 25;
50const Int_t AliITSv11GeometrySSD::fgkSSDLay6LadderNumber = 38;
9acf2ecc 51const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMin = 428.0*fgkmm;
52const Double_t AliITSv11GeometrySSD::fgkSSDLay6RadiusMax = 434.0*fgkmm;
53const Double_t AliITSv11GeometrySSD::fgkLay6CenterITSPosition = 526.50*fgkmm;
d7599219 54/////////////////////////////////////////////////////////////////////////////////
55// SSD Chips and Hybrid (lengths are in mm and angles in degrees)
56/////////////////////////////////////////////////////////////////////////////////
57const Int_t AliITSv11GeometrySSD::fgkSSDChipNumber = 6;
9acf2ecc 58const Double_t AliITSv11GeometrySSD::fgkSSDChipLength = 11.100*fgkmm;
59const Double_t AliITSv11GeometrySSD::fgkSSDChipWidth = 3.850*fgkmm;
60const Double_t AliITSv11GeometrySSD::fgkSSDChipHeight = 0.180*fgkmm;
61const Double_t AliITSv11GeometrySSD::fgkSSDChipSeparationLength = 1.000*fgkmm;
d7599219 62const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueLength = fgkSSDChipLength;
63const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueWidth = fgkSSDChipWidth;
9acf2ecc 64const Double_t AliITSv11GeometrySSD::fgkSSDChipGlueHeight = 0.030*fgkmm;
d7599219 65/////////////////////////////////////////////////////////////////////////////////
66// Stiffener (lengths are in mm and angles in degrees)
67/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 68const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerLength = 73.000*fgkmm;
69const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerWidth = 6.500*fgkmm;
70const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerHeight = 0.315*fgkmm;
71const Double_t AliITSv11GeometrySSD::fgkSSDStiffenerToChipDist = 2.500*fgkmm;
72const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Length = 1.600*fgkmm;
73const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Width = 0.870*fgkmm;
74const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor0603Height = 0.800*fgkmm;
75const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Length = 4.600*fgkmm;
76const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Width = 3.400*fgkmm;
77const Double_t AliITSv11GeometrySSD::fgkSSDCapacitor1812Height = 1.400*fgkmm;
78const Double_t AliITSv11GeometrySSD::fgkSSDWireLength = 30.000*fgkmm;
79const Double_t AliITSv11GeometrySSD::fgkSSDWireRadius = 0.185*fgkmm;
80const Double_t AliITSv11GeometrySSD::fgkSSDConnectorPosition[2] = {44.32*fgkmm,
81 0.33*fgkmm};
82const Double_t AliITSv11GeometrySSD::fgkSSDConnectorSeparation = 0.44*fgkmm;
83const Double_t AliITSv11GeometrySSD::fgkSSDConnectorLength = 2.16*fgkmm;
84const Double_t AliITSv11GeometrySSD::fgkSSDConnectorWidth = 3.60*fgkmm;
d7599219 85const Double_t AliITSv11GeometrySSD::fgkSSDConnectorHeight =
9acf2ecc 86 0.25*fgkSSDStiffenerHeight;
d7599219 87/////////////////////////////////////////////////////////////////////////////////
88// Cooling Block (lengths are in mm and angles in degrees)
89/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 90const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockLength = 3.000*fgkmm;
91const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockWidth = 4.000*fgkmm;
d7599219 92const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHeight[3] =
9acf2ecc 93 {1.950*fgkmm, 0.240*fgkmm, 0.300*fgkmm};
d7599219 94const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleRadius[2] =
9acf2ecc 95 {1.000*fgkmm, 0.120*fgkmm};
d7599219 96const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleLength[2] =
9acf2ecc 97 {1.900*fgkmm, 0.400*fgkmm};
d7599219 98const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleCenter =
9acf2ecc 99 1.500*fgkmm;
d7599219 100const Double_t AliITSv11GeometrySSD::fgkSSDCoolingBlockHoleHeight =
9acf2ecc 101 0.300*fgkmm;
d7599219 102/////////////////////////////////////////////////////////////////////////////////
103// SSD Sensor (lengths are in mm and angles in degrees)
104/////////////////////////////////////////////////////////////////////////////////
105const char* AliITSv11GeometrySSD::fgkSSDSensitiveVolName =
106 "SSDSensorSensitiveVol";
9acf2ecc 107const Double_t AliITSv11GeometrySSD::fgkSSDSensorLength = 42.000*fgkmm;
108const Double_t AliITSv11GeometrySSD::fgkSSDSensorHeight = 0.300*fgkmm;
109const Double_t AliITSv11GeometrySSD::fgkSSDSensorWidth = 75.000*fgkmm;
d7599219 110const Double_t AliITSv11GeometrySSD::fgkSSDSensorOverlap =
9acf2ecc 111 fgkSSDSensorLength-39.1*fgkmm;
112const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveLength = 1.*fgkmm;
113const Double_t AliITSv11GeometrySSD::fgkSSDSensorInsensitiveWidth = 1.*fgkmm;
d7599219 114/////////////////////////////////////////////////////////////////////////////////
115// Flex (lengths are in mm and angles in degrees)
116/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 117const Double_t AliITSv11GeometrySSD::fgkSSDFlexFullLength = 106.000*fgkmm;
d7599219 118const Double_t AliITSv11GeometrySSD::fgkSSDFlexLength[4] =
119 {0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
120 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
121 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
9acf2ecc 122 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)-4.000*fgkmm,
123 9.500*fgkmm, 10.000*fgkmm};
d7599219 124const Double_t AliITSv11GeometrySSD::fgkSSDFlexWidth[2] =
9acf2ecc 125 { 9.340*fgkmm, 5.380*fgkmm};
d7599219 126const Double_t AliITSv11GeometrySSD::fgkSSDFlexHeight[2] =
9acf2ecc 127 { 0.030*fgkmm, 0.020*fgkmm};
d7599219 128const Double_t AliITSv11GeometrySSD::fgkSSDFlexAngle = 30.000;
9acf2ecc 129const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleLength = 1.430*fgkmm;
130const Double_t AliITSv11GeometrySSD::fgkSSDFlexHoleWidth = 3.000*fgkmm;
d7599219 131const Double_t AliITSv11GeometrySSD::fgkSSDEndFlexCompLength[6] =
9acf2ecc 132 {3.30*fgkmm,4.12*fgkmm,4.22*fgkmm,1.70*fgkmm,0.75*fgkmm,7.18*fgkmm};
d7599219 133const Double_t AliITSv11GeometrySSD:: fgkSSDEndFlexCompWidth[3] =
9acf2ecc 134 {15.03*fgkmm,23.48*fgkmm,12.28*fgkmm};
d7599219 135/////////////////////////////////////////////////////////////////////////////////
136// SSD Ladder Cable (lengths are in mm and angles in degrees)
137/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 138const Double_t AliITSv11GeometrySSD::fgkSSDLadderCableWidth = 23.5*fgkmm;
d7599219 139/////////////////////////////////////////////////////////////////////////////////
140// SSD Module (lengths are in mm and angles in degrees)
141/////////////////////////////////////////////////////////////////////////////////
142const Double_t AliITSv11GeometrySSD::fgkSSDModuleStiffenerPosition[2] =
9acf2ecc 143 { 1.000*fgkmm, 3.900*fgkmm};
d7599219 144const Double_t AliITSv11GeometrySSD::fgkSSDModuleSensorSupportDistance =
9acf2ecc 145 45.600*fgkmm;
d7599219 146const Double_t AliITSv11GeometrySSD::fgkSSDModuleCoolingBlockToSensor =
9acf2ecc 147 5.075*fgkmm;
d7599219 148/////////////////////////////////////////////////////////////////////////////////
149// Sensor Support (lengths are in mm and angles in degrees)
150/////////////////////////////////////////////////////////////////////////////////
151const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportLength =
9acf2ecc 152 5.800*fgkmm;
d7599219 153const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportWidth =
9acf2ecc 154 2.000*fgkmm;
d7599219 155const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportHeight[2] =
9acf2ecc 156 { 4.620*fgkmm, 5.180*fgkmm};
d7599219 157const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportThickness[2] =
9acf2ecc 158 { 0.450*fgkmm, 0.450*fgkmm};
d7599219 159const Double_t AliITSv11GeometrySSD::fgkSSDSensorSideSupportPosition =
160 0.5*(fgkSSDModuleSensorSupportDistance
161 + fgkSSDSensorSideSupportThickness[0])
162 - fgkSSDSensorSideSupportLength;
163const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportLength =
9acf2ecc 164 5.250*fgkmm;
d7599219 165const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportWidth =
9acf2ecc 166 1.680*fgkmm;
d7599219 167const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportHeight[2] =
168 {fgkSSDSensorSideSupportHeight[0]+fgkSSDSensorSideSupportThickness[0],
169 fgkSSDSensorSideSupportHeight[1]+fgkSSDSensorSideSupportThickness[1]};
170const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportThickness[2] =
171 {fgkSSDSensorSideSupportThickness[0],fgkSSDSensorSideSupportThickness[1]};
172const Double_t AliITSv11GeometrySSD::fgkSSDSensorCenterSupportPosition =
9acf2ecc 173 19.000*fgkmm;
d7599219 174/////////////////////////////////////////////////////////////////////////////////
175// Chip Cables (lengths are in mm and angles in degrees)
176/////////////////////////////////////////////////////////////////////////////////
177const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesLength[2] =
9acf2ecc 178 {73.12/fgkSSDChipNumber*fgkmm,fgkSSDChipLength+2.*0.19*fgkmm};
d7599219 179const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesHeight[4] =
9acf2ecc 180 { 0.014*fgkmm, 0.010*fgkmm, fgkSSDModuleCoolingBlockToSensor
d7599219 181 - (fgkSSDSensorSideSupportHeight[1]-fgkSSDSensorSideSupportHeight[0])
182 - fgkSSDCoolingBlockHoleCenter-fgkSSDStiffenerHeight
183 - fgkSSDChipHeight-fgkSSDSensorHeight,
184 fgkSSDModuleCoolingBlockToSensor
185 - fgkSSDCoolingBlockHoleCenter-fgkSSDStiffenerHeight
186 - fgkSSDChipHeight-fgkSSDSensorHeight};
187const Double_t AliITSv11GeometrySSD::fgkSSDChipCablesWidth[3] =
9acf2ecc 188 { 11.000*fgkmm, 0.800*fgkmm, 0.600*fgkmm};
d7599219 189/////////////////////////////////////////////////////////////////////////////////
190// Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
191/////////////////////////////////////////////////////////////////////////////////
192const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionLength =
9acf2ecc 193 3.820*fgkmm;
d7599219 194const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionWidth =
195 fgkSSDSensorLength-fgkSSDSensorOverlap;
196const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionEdge[2] =
9acf2ecc 197 { 0.86*fgkmm, 0.30*fgkmm};
d7599219 198const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionAngle[2] =
199 { 30.00, 90.00};
200const Double_t AliITSv11GeometrySSD::fgkCarbonFiberJunctionToSensorSupport =
9acf2ecc 201 1.78*fgkmm;
d7599219 202/////////////////////////////////////////////////////////////////////////////////
203//Carbon Fiber Parameters (lengths are in mm and angles in degrees)
204/////////////////////////////////////////////////////////////////////////////////
205const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleLength =
206 fgkSSDModuleSensorSupportDistance-2.*fgkCarbonFiberJunctionToSensorSupport;
207const Double_t AliITSv11GeometrySSD::fgkCarbonFiberTriangleAngle =
208 60.00;
209const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportTopEdgeDist[2] =
9acf2ecc 210 { 0.751*fgkmm, 0.482*fgkmm};
d7599219 211const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportEdgeLength =
9acf2ecc 212 1.630*fgkmm;
d7599219 213const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportWidth =
9acf2ecc 214 0.950*fgkmm;
d7599219 215const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportXAxisLength =
216 fgkCarbonFiberTriangleLength-0.5*fgkCarbonFiberSupportTopEdgeDist[1]
217 / TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad());
218const Double_t AliITSv11GeometrySSD::fgkCarbonFiberSupportYAxisLength =
219 0.5*(fgkCarbonFiberJunctionWidth-fgkCarbonFiberSupportWidth)
220 - fgkCarbonFiberSupportTopEdgeDist[0]-fgkCarbonFiberSupportWidth;
221/////////////////////////////////////////////////////////////////////////////////
222// Carbon Fiber Lower Support Parameters (lengths are in mm)
223/////////////////////////////////////////////////////////////////////////////////
224const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportWidth
9acf2ecc 225 = 0.950*fgkmm;
d7599219 226const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportLowerLenght
9acf2ecc 227 = 1.600*fgkmm;
d7599219 228const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportHeight
9acf2ecc 229 = 0.830*fgkmm;
d7599219 230const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumeSeparation
231 = 0.5*fgkCarbonFiberSupportWidth;
232const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportTransverseWidth
233 = fgkCarbonFiberJunctionWidth
234 - 2.*(fgkCarbonFiberLowerSupportWidth
235 + fgkCarbonFiberLowerSupportVolumeSeparation);
236const Double_t AliITSv11GeometrySSD::fgkCarbonFiberLowerSupportVolumePosition[2]
237 = {fgkCarbonFiberLowerSupportWidth
238 + fgkCarbonFiberLowerSupportVolumeSeparation,
239 fgkCarbonFiberLowerSupportWidth
240 + fgkCarbonFiberLowerSupportVolumeSeparation
241 + fgkCarbonFiberLowerSupportTransverseWidth};
242/////////////////////////////////////////////////////////////////////////////////
243// End Ladder Carbon Fiber Junction Parameters (lengths are in mm and angles in degrees)
244/////////////////////////////////////////////////////////////////////////////////
245const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberLowerJunctionLength[2] =
246 {0.5*(fgkSSDLay5LadderLength
247 -fgkSSDLay5SensorsNumber*fgkCarbonFiberJunctionWidth
248 -fgkCarbonFiberLowerSupportWidth),
249 0.5*(fgkSSDLay5LadderLength
250 -fgkSSDLay5SensorsNumber*fgkCarbonFiberJunctionWidth
251 +fgkCarbonFiberLowerSupportWidth)};
252const Double_t AliITSv11GeometrySSD::fgkEndLadderCarbonFiberUpperJunctionLength[2] =
9acf2ecc 253 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-20.4*fgkmm,
254 fgkEndLadderCarbonFiberLowerJunctionLength[1]-20.6*fgkmm};
d7599219 255const Double_t AliITSv11GeometrySSD::fgkEndLadderMountingBlockPosition[2] =
9acf2ecc 256 {fgkEndLadderCarbonFiberLowerJunctionLength[0]-16.50*fgkmm,
257 fgkEndLadderCarbonFiberLowerJunctionLength[1]-31.50*fgkmm};
d7599219 258/////////////////////////////////////////////////////////////////////////////////
259// Cooling Tube Support (lengths are in mm and angles in degrees)
260/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 261const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmax = 1.45*fgkmm;
d7599219 262const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportRmin
263 = fgkSSDCoolingBlockHoleRadius[0];
9acf2ecc 264const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportLength = 8.55*fgkmm;
265const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportHeight = 0.85*fgkmm;
266const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportWidth = 2.00*fgkmm;
d7599219 267const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportSeparation =
268 fgkSSDSensorLength-2.*fgkSSDSensorOverlap;
9acf2ecc 269const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSupportToCarbonFiber = 11.70*fgkmm;
d7599219 270/////////////////////////////////////////////////////////////////////////////////
271// Cooling Tube (lengths are in mm and angles in degrees)
272/////////////////////////////////////////////////////////////////////////////////
273const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmax =
274 fgkCoolingTubeSupportRmin;
9acf2ecc 275const Double_t AliITSv11GeometrySSD::fgkCoolingTubeRmin = 0.96*fgkmm;
d7599219 276const Double_t AliITSv11GeometrySSD::fgkCoolingTubeLength =
277 fgkCarbonFiberJunctionWidth;
278const Double_t AliITSv11GeometrySSD::fgkCoolingTubeSeparation =
279 fgkSSDModuleSensorSupportDistance+fgkSSDCoolingBlockLength;
d7599219 280/////////////////////////////////////////////////////////////////////////////////
281// SSD Mounting Block Parameters (lengths are in mm and angles in degrees)
282/////////////////////////////////////////////////////////////////////////////////
283const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockLength[3] =
9acf2ecc 284 { 60.0*fgkmm, 42.2*fgkmm, 34.0*fgkmm};
d7599219 285const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHeight[4] =
9acf2ecc 286 { 4.0*fgkmm, 8.0*fgkmm, 5.0*fgkmm, 0.2*fgkmm};
d7599219 287const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockWidth =
9acf2ecc 288 20.0*fgkmm;
d7599219 289const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidAngle =
290 40.0;
291const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidHeight =
292 0.30*(fgkSSDMountingBlockHeight[1]-fgkSSDMountingBlockHeight[2]);
293const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTrapezoidUpBasis =
9acf2ecc 294 2.5*fgkmm;
d7599219 295const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeLength[2] =
9acf2ecc 296 { 56.0*fgkmm, 12.0*fgkmm};
d7599219 297const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleTubeWidth[2] =
9acf2ecc 298 { 5.0*fgkmm, 2.9*fgkmm};
d7599219 299const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockHoleRadius =
9acf2ecc 300 1.0*fgkmm;
d7599219 301const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleEdge =
9acf2ecc 302 6.0*fgkmm;
d7599219 303const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleHeigth =
9acf2ecc 304 4.0*fgkmm;
d7599219 305const Double_t AliITSv11GeometrySSD::fgkSSDMountingBlockScrewHoleRadius[2] =
9acf2ecc 306 { 1.5*fgkmm,fgkSSDMountingBlockScrewHoleEdge/6.};
d7599219 307/////////////////////////////////////////////////////////////////////////////////
44285dfa 308ClassImp(AliITSv11GeometrySSD)
309/////////////////////////////////////////////////////////////////////////////////
9acf2ecc 310AliITSv11GeometrySSD::AliITSv11GeometrySSD():
311 AliITSv11Geometry(),
44285dfa 312 fSSDChipMedium(),
313 fSSDChipGlueMedium(),
314 fSSDStiffenerMedium(),
315 fSSDStiffenerConnectorMedium(),
316 fSSDStiffener0603CapacitorMedium(),
317 fSSDStiffener1812CapacitorMedium(),
318 fSSDStiffenerHybridWireMedium(),
319 fSSDKaptonFlexMedium(),
320 fSSDAlTraceFlexMedium(),
321 fSSDAlTraceLadderCableMedium(),
322 fSSDKaptonLadderCableMedium(),
323 fSSDKaptonChipCableMedium(),
324 fSSDAlTraceChipCableMedium(),
325 fSSDAlCoolBlockMedium(),
326 fSSDSensorMedium(),
327 fSSDSensorSupportMedium(),
328 fSSDCarbonFiberMedium(),
329 fSSDTubeHolderMedium(),
330 fSSDCoolingTubeWater(),
331 fSSDCoolingTubePhynox(),
332 fSSDMountingBlockMedium(),
333 fMotherVol(0),
334 fColorCarbonFiber(4),
335 fColorRyton(5),
336 fColorPhynox(5),
337 fColorSilicon(3),
338 fColorAl(7),
339 fColorKapton(6),
340 fColorPolyhamide(5),
341 fColorStiffener(9),
342 fColorEpoxy(30)
343{
344 ////////////////////////
345 // Standard constructor
346 ////////////////////////
347 CreateMaterials();
348}
349/////////////////////////////////////////////////////////////////////////////////
350AliITSv11GeometrySSD::AliITSv11GeometrySSD(const AliITSv11GeometrySSD &s):
9acf2ecc 351 AliITSv11Geometry(s.GetDebug()),
44285dfa 352 fSSDChipMedium(s.fSSDChipMedium),
353 fSSDChipGlueMedium(s.fSSDChipGlueMedium),
354 fSSDStiffenerMedium(s.fSSDStiffenerMedium),
355 fSSDStiffenerConnectorMedium(s.fSSDStiffenerConnectorMedium),
356 fSSDStiffener0603CapacitorMedium(s.fSSDStiffener0603CapacitorMedium),
357 fSSDStiffener1812CapacitorMedium(s.fSSDStiffener1812CapacitorMedium),
358 fSSDStiffenerHybridWireMedium(s.fSSDStiffenerHybridWireMedium),
359 fSSDKaptonFlexMedium(s.fSSDKaptonFlexMedium),
360 fSSDAlTraceFlexMedium(s.fSSDAlTraceFlexMedium),
361 fSSDAlTraceLadderCableMedium(s.fSSDAlTraceLadderCableMedium),
362 fSSDKaptonLadderCableMedium(s.fSSDKaptonLadderCableMedium),
363 fSSDKaptonChipCableMedium(s.fSSDKaptonChipCableMedium),
364 fSSDAlTraceChipCableMedium(s.fSSDAlTraceChipCableMedium),
365 fSSDAlCoolBlockMedium(s.fSSDAlCoolBlockMedium),
366 fSSDSensorMedium(s.fSSDSensorMedium),
367 fSSDSensorSupportMedium(s.fSSDSensorSupportMedium),
368 fSSDCarbonFiberMedium(s.fSSDCarbonFiberMedium),
369 fSSDTubeHolderMedium(s.fSSDTubeHolderMedium),
370 fSSDCoolingTubeWater(s.fSSDCoolingTubeWater),
371 fSSDCoolingTubePhynox(s.fSSDCoolingTubePhynox),
372 fSSDMountingBlockMedium(s.fSSDMountingBlockMedium),
373 fMotherVol(s.fMotherVol),
374 fColorCarbonFiber(s.fColorCarbonFiber),
375 fColorRyton(s.fColorRyton),
376 fColorPhynox(s.fColorPhynox),
377 fColorSilicon(s.fColorSilicon),
378 fColorAl(s.fColorAl),
379 fColorKapton(s.fColorKapton),
380 fColorPolyhamide(s.fColorPolyhamide),
381 fColorStiffener(s.fColorStiffener),
382 fColorEpoxy(s.fColorEpoxy)
383{
384 ////////////////////////
385 // Copy Constructor
386 ////////////////////////
d7599219 387 CreateMaterials();
388}
389/////////////////////////////////////////////////////////////////////////////////
44285dfa 390AliITSv11GeometrySSD& AliITSv11GeometrySSD::
391operator=(const AliITSv11GeometrySSD &s){
392 ////////////////////////
393 // Assignment operator
394 ////////////////////////
395 this->~AliITSv11GeometrySSD();
396 new(this) AliITSv11GeometrySSD(s);
397 return *this;
398/*
399 if(&s == this) return *this;
400 fMotherVol = s.fMotherVol;
401 return *this;
402 */
403}
404/////////////////////////////////////////////////////////////////////////////////
d7599219 405// Setting the transformation Matrices
406/////////////////////////////////////////////////////////////////////////////////
407void AliITSv11GeometrySSD::SetSSDSensorSupportCombiTransMatrix(){
44285dfa 408 /////////////////////////////////////////////////////////////
409 // Method generating CombiTrans Matrix for SSD Sensor Support
410 /////////////////////////////////////////////////////////////
d7599219 411 //Translation Parameters SSDSensorSupportAssembly:
412 ////////////////////////////////////////////////////////
44285dfa 413 const Double_t kssdsensorsupporttransx[3] = {-0.5*fgkSSDSensorSideSupportWidth,
d7599219 414 0.5*fgkSSDSensorSideSupportWidth,
415 0.5*fgkSSDSensorCenterSupportThickness[0]
416 - fgkSSDSensorCenterSupportPosition};
44285dfa 417 const Double_t kssdsensorsupporttransy[3] =
d7599219 418 {0.5*fgkSSDSensorSideSupportThickness[0],
419 -0.5*fgkSSDSensorSideSupportThickness[0]
420 -fgkSSDModuleSensorSupportDistance,
421 0.5*fgkSSDSensorCenterSupportWidth
422 -0.5*fgkSSDModuleSensorSupportDistance};
44285dfa 423 const Double_t kssdsensorsupporttransz[3] = {0.,0.,
d7599219 424 fgkSSDSensorCenterSupportThickness[0]};
425 ////////////////////////////////////////////////////////
426 //Rotational Parameters SSDSensorSupportAssembly:
427 ////////////////////////////////////////////////////////
44285dfa 428 const Double_t kssdsensorsupportrotphi[3] = { 0., 180., 270.};
429 const Double_t kssdsensorsupportrottheta[3] = { 90., 90., 90.};
430 const Double_t kssdsensorsupportrotpsi[3] = {- 90.,- 90.,- 90.};
d7599219 431 ////////////////////////////////////////////////////////////////
432 //Name of CombiTrans Transformation of SSDSensorSupportAssembly:
433 ////////////////////////////////////////////////////////////////
44285dfa 434 char ssdsensorsupportcombitransname[40];
435 char ssdsensorsupportrotname[40];
436 TGeoCombiTrans *ssdsensorsupportlocalmatrix[fgkSSDSensorSupportCombiTransNumber];
d7599219 437 for(Int_t i=0; i<fgkSSDSensorSupportCombiTransNumber; i++){
44285dfa 438 sprintf(ssdsensorsupportcombitransname,"SSDSensorSupportCombiTrans%i",i);
439 sprintf(ssdsensorsupportrotname,"SSDSensorSupportRot%i",i);
440 ssdsensorsupportlocalmatrix[i] =
441 new TGeoCombiTrans(ssdsensorsupportcombitransname,
442 kssdsensorsupporttransx[i],
443 kssdsensorsupporttransy[i],
444 kssdsensorsupporttransz[i],
445 new TGeoRotation(ssdsensorsupportrotname,
446 kssdsensorsupportrotphi[i],
447 kssdsensorsupportrottheta[i],
448 kssdsensorsupportrotpsi[i]));
449 fSSDSensorSupportCombiTransMatrix[i] = ssdsensorsupportlocalmatrix[i];
d7599219 450 }
451}
452/////////////////////////////////////////////////////////////////////////////////
453void AliITSv11GeometrySSD::SetSSDModuleCombiTransMatrix(Double_t SSDChipCablesHeigth){
44285dfa 454 /////////////////////////////////////////////////////////////
455 // Method generating CombiTrans Matrix for SSD Module
456 /////////////////////////////////////////////////////////////
457 //Translation Parameters SSDModuleAssembly:
458 ////////////////////////////////////////////////////////
459 const Double_t kssdmoduletransx[7] = {0.5*fgkSSDStiffenerLength,
d7599219 460 0.5*fgkSSDChipLength+0.5*(fgkSSDStiffenerLength
461 - (fgkSSDChipNumber*fgkSSDChipLength+(fgkSSDChipNumber-1)
462 * fgkSSDChipSeparationLength)),
463 - fgkSSDModuleStiffenerPosition[0]+0.5*fgkSSDSensorWidth,
464 0.5*(fgkSSDStiffenerLength-fgkSSDChipNumber*fgkSSDChipLength
465 - (fgkSSDChipNumber-1)*fgkSSDChipSeparationLength),
466 0.5*fgkSSDStiffenerLength-0.5*fgkSSDModuleSensorSupportDistance
467 - fgkSSDCoolingBlockLength,
468 0.5*(fgkSSDStiffenerLength+fgkSSDChipCablesLength[1]
469 + (fgkSSDChipNumber-1)*fgkSSDChipCablesLength[0]),
470 0.5*(fgkSSDStiffenerLength+fgkSSDChipNumber*fgkSSDChipLength
471 +(fgkSSDChipNumber-1)*fgkSSDChipSeparationLength)};
44285dfa 472 const Double_t kssdmoduletransy[7] = {0.5*fgkSSDStiffenerWidth,
d7599219 473 0.5*fgkSSDChipWidth+(fgkSSDStiffenerWidth
474 - fgkSSDStiffenerToChipDist-fgkSSDChipWidth),
475 - fgkSSDModuleStiffenerPosition[1]+0.5*fgkSSDSensorLength,
476 fgkSSDStiffenerWidth,
477 0.,
478 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
479 - fgkSSDStiffenerWidth
480 + fgkSSDStiffenerToChipDist+fgkSSDChipWidth,
481 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
482 - fgkSSDStiffenerWidth};
44285dfa 483 const Double_t kssdmoduletransz[7] = {0.5*fgkSSDStiffenerHeight,
d7599219 484 - 0.5*fgkSSDChipHeight,
485 0.5*fgkSSDSensorHeight-fgkSSDStiffenerHeight-fgkSSDChipHeight
486 - SSDChipCablesHeigth,
487 - 0.5*fgkSSDFlexHeight[0],
488 fgkSSDStiffenerHeight,
489 - fgkSSDChipHeight,
490 - 0.5*fgkSSDChipHeight};
491 ////////////////////////////////////////////////////////
492 //Rotational Parameters SSDModuleAssembly:
493 ////////////////////////////////////////////////////////
44285dfa 494 const Double_t kssdmodulerotphi[7] = { 0., 0., 90., 0., 0., 90., 180.};
495 const Double_t kssdmodulerottheta[7] = { 0., 0., 0., 0., 0., 0., 0.};
496 const Double_t kssdmodulerotpsi[7] = { 0., 0., 0., 0., 0., 0., 0.};
d7599219 497 ////////////////////////////////////////////////////////
498 //Name of CombiTrans Transformation of SSDModuleAssembly:
499 ////////////////////////////////////////////////////////
44285dfa 500 const char* ssdmodulecombitransname[7] = {"SSDStiffenerCombiTrans",
d7599219 501 "SSDChipCombiTrans",
502 "SSDSensorCombiTrans",
503 "SSDFlex0CombiTrans",
504 "SSDCoolingBlockCombiTrans",
505 "SSDChipCablesCombiTrans",
506 "SSDFlex1CombiTrans"};
44285dfa 507 const char* ssdmodulerotname[7] = {"SSDStiffenerRotName",
d7599219 508 "SSDChipRotName",
509 "SSDSensorRotName",
510 "SSDFlex0RotName",
511 "SSDCoolingBlockRotName",
512 "SSDChipCablesRotName",
513 "SSDFlex1RotName"};
44285dfa 514 TGeoCombiTrans *ssdmodulelocalmatrix[fgkSSDModuleCombiTransNumber];
d7599219 515 for(Int_t i=0; i<fgkSSDModuleCombiTransNumber; i++){
44285dfa 516 ssdmodulelocalmatrix[i] =
517 new TGeoCombiTrans(ssdmodulecombitransname[i],
518 kssdmoduletransx[i],
519 kssdmoduletransy[i],
520 kssdmoduletransz[i],
521 new TGeoRotation(ssdmodulerotname[i],
522 kssdmodulerotphi[i],
523 kssdmodulerottheta[i],
524 kssdmodulerotpsi[i]));
525 fSSDModuleCombiTransMatrix[i] = ssdmodulelocalmatrix[i];
d7599219 526 }
527}
528/////////////////////////////////////////////////////////////////////////////////
529void AliITSv11GeometrySSD::SetCarbonFiberJunctionCombiTransMatrix(){
44285dfa 530 /////////////////////////////////////////////////////////////
531 // Method generating CombiTrans Matrix for Carbon Fiber Junction
532 /////////////////////////////////////////////////////////////
d7599219 533 //Translation Parameters CarbonFiberJunction:
534 ////////////////////////////////////////////////////////
44285dfa 535 const Double_t kcarbonfiberjunctiontransx[3] =
d7599219 536 { 0.0,fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength
537 * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
44285dfa 538 const Double_t kcarbonfiberjunctiontransy[3] =
d7599219 539 { 0.0, 0.0,fgkCarbonFiberTriangleLength
540 * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
44285dfa 541 const Double_t kcarbonfiberjunctiontransz[3] = { 0.0, 0.0, 0.0};
d7599219 542 ////////////////////////////////////////////////////////
543 //Rotational Parameters CarbonFiberJunction:
544 ////////////////////////////////////////////////////////
44285dfa 545 const Double_t kcarbonfiberjunctionrotphi[3] = { 0., 120., 240.};
546 const Double_t kcarbonfiberjunctionrottheta[3] = { 0., 0., 0.};
547 const Double_t kcarbonfiberjunctionrotpsi[3] = { 0., 0., 0.};
d7599219 548 ///////////////////////////////////////////////////////////
549 //Name of CombiTrans Transformation of CarbonFiberJunction:
550 ///////////////////////////////////////////////////////////
44285dfa 551 char carbonfiberjunctioncombitransname[40];
552 char carbonfiberjunctionrotname[40];
553 TGeoCombiTrans *carbonfiberjunctionlocalmatrix[fgkCarbonFiberJunctionCombiTransNumber];
d7599219 554 for(Int_t i=0; i<fgkCarbonFiberJunctionCombiTransNumber; i++) {
44285dfa 555 sprintf(carbonfiberjunctioncombitransname,"CarbonFiberJunctionCombiTrans%i",i);
556 sprintf(carbonfiberjunctionrotname,"CarbonFiberJunctionRot%i",i);
557 carbonfiberjunctionlocalmatrix[i] =
558 new TGeoCombiTrans(carbonfiberjunctioncombitransname,
559 kcarbonfiberjunctiontransx[i],
560 kcarbonfiberjunctiontransy[i],
561 kcarbonfiberjunctiontransz[i],
562 new TGeoRotation(carbonfiberjunctionrotname,
563 kcarbonfiberjunctionrotphi[i],
564 kcarbonfiberjunctionrottheta[i],
565 kcarbonfiberjunctionrotpsi[i]));
566 fCarbonFiberJunctionCombiTransMatrix[i] = carbonfiberjunctionlocalmatrix[i];
d7599219 567 }
568}
569/////////////////////////////////////////////////////////////////////////////////
570void AliITSv11GeometrySSD::SetEndLadderCarbonFiberJunctionCombiTransMatrix(Int_t i){
44285dfa 571 /////////////////////////////////////////////////////////////
572 // Method generating CombiTrans Matrix for End Ladder Carbon Fiber Junction
573 /////////////////////////////////////////////////////////////
d7599219 574 //Translation Parameters EndLadderCarbonFiberJunction:
575 ////////////////////////////////////////////////////////
44285dfa 576 const Double_t kendladdercarbonfiberjunctiontransx[3] =
d7599219 577 { 0.0,fgkCarbonFiberTriangleLength,fgkCarbonFiberTriangleLength
578 * TMath::Cos(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
44285dfa 579 const Double_t kendladdercarbonfiberjunctiontransy[3] =
d7599219 580 { 0.0, 0.0,fgkCarbonFiberTriangleLength
581 * TMath::Sin(fgkCarbonFiberTriangleAngle*TMath::DegToRad())};
44285dfa 582 const Double_t kendladdercarbonfiberjunctiontransz[3] = { 0.0, 0.0,
d7599219 583 0.5*(fgkEndLadderCarbonFiberLowerJunctionLength[i]
584 -fgkEndLadderCarbonFiberUpperJunctionLength[i])};
585 ////////////////////////////////////////////////////////
586 //Rotational Parameters EndLadderCarbonFiberJunction:
587 ////////////////////////////////////////////////////////
44285dfa 588 const Double_t kendladdercarbonfiberjunctionrotphi[3] = { 0., 120., 240.};
589 const Double_t kendladdercarbonfiberjunctionrottheta[3] = { 0., 0., 0.};
590 const Double_t kendladdercarbonfiberjunctionrotpsi[3] = { 0., 0., 0.};
d7599219 591 ///////////////////////////////////////////////////////////
592 //Name of CombiTrans Transformation of CarbonFiberJunction:
593 ///////////////////////////////////////////////////////////
44285dfa 594 char endladdercarbonfiberjunctioncombitransname[40];
595 char endladdercarbonfiberjunctionrotname[40];
596 TGeoCombiTrans *endladdercarbonfiberjunctionlocalmatrix[fgkEndLadderCarbonFiberJunctionCombiTransNumber];
d7599219 597 for(Int_t i=0; i<fgkEndLadderCarbonFiberJunctionCombiTransNumber; i++) {
44285dfa 598 sprintf(endladdercarbonfiberjunctioncombitransname,"EndLadderCarbonFiberJunctionCombiTrans%i",i);
599 sprintf(endladdercarbonfiberjunctionrotname,"EndLadderCarbonFiberJunctionRot%i",i);
600 endladdercarbonfiberjunctionlocalmatrix[i] =
601 new TGeoCombiTrans(endladdercarbonfiberjunctioncombitransname,
602 kendladdercarbonfiberjunctiontransx[i],
603 kendladdercarbonfiberjunctiontransy[i],
604 kendladdercarbonfiberjunctiontransz[i],
605 new TGeoRotation(endladdercarbonfiberjunctionrotname,
606 kendladdercarbonfiberjunctionrotphi[i],
607 kendladdercarbonfiberjunctionrottheta[i],
608 kendladdercarbonfiberjunctionrotpsi[i]));
609 fEndLadderCarbonFiberJunctionCombiTransMatrix[i] =
610 endladdercarbonfiberjunctionlocalmatrix[i];
d7599219 611 }
612}
613////////////////////////////////////////////////////////////////////////////////
614void AliITSv11GeometrySSD::SetCarbonFiberAssemblyCombiTransMatrix(){
44285dfa 615 /////////////////////////////////////////////////////////////
616 // Method generating CombiTrans Matrix for Carbon fiber Assembly
617 /////////////////////////////////////////////////////////////
d7599219 618 //Translation Parameters CarbonFiberAssembly:
619 ////////////////////////////////////////////////////////
44285dfa 620 const Double_t kcarbonfiberassemblytransx[3] = { 0.0, 0.0, 0.0};
621 const Double_t kcarbonfiberassemblytransy[3] =
d7599219 622 { 0.5*fgkCarbonFiberJunctionWidth, 0.0,
623 fgkCarbonFiberJunctionWidth-fgkCarbonFiberLowerSupportWidth
624 - fgkCarbonFiberLowerSupportVolumePosition[0]
625 - fgkCarbonFiberLowerSupportVolumePosition[1]};
44285dfa 626 const Double_t kcarbonfiberassemblytransz[3] =
d7599219 627 { 0.0, 0.0,- 0.5*fgkCarbonFiberLowerSupportHeight};
628 ////////////////////////////////////////////////////////
629 //Rotational Parameters CarbonFiberAssembly:
630 ////////////////////////////////////////////////////////
44285dfa 631 const Double_t kcarbonfiberassemblyrotphi[3] = { 0., 90., 0.};
632 const Double_t kcarbonfiberassemblyrottheta[3] = { 90.,
d7599219 633 -fgkCarbonFiberTriangleAngle, 0.};
44285dfa 634 const Double_t kcarbonfiberassemblyrotpsi[3] = { 0.,- 90., 0.};
d7599219 635 ///////////////////////////////////////////////////////////
636 //Name of CombiTrans Transformation of CarbonFiberAssembly:
637 ///////////////////////////////////////////////////////////
44285dfa 638 char carbonfiberassemblycombitransname[30];
639 char carbonfiberassemblyrotname[30];
640 TGeoCombiTrans *carbonfiberassemblylocalmatrix[fgkCarbonFiberAssemblyCombiTransNumber];
d7599219 641 for(Int_t i=0; i<fgkCarbonFiberAssemblyCombiTransNumber; i++) {
44285dfa 642 sprintf(carbonfiberassemblycombitransname,"CarbonFiberAssemblyCombiTrans%i",i);
643 sprintf(carbonfiberassemblyrotname,"CarbonFiberAssemblyRot%i",i);
644 carbonfiberassemblylocalmatrix[i] =
645 new TGeoCombiTrans(carbonfiberassemblycombitransname,
646 kcarbonfiberassemblytransx[i],
647 kcarbonfiberassemblytransy[i],
648 kcarbonfiberassemblytransz[i],
649 new TGeoRotation(carbonfiberassemblyrotname,
650 kcarbonfiberassemblyrotphi[i],
651 kcarbonfiberassemblyrottheta[i],
652 kcarbonfiberassemblyrotpsi[i]));
653 fCarbonFiberAssemblyCombiTransMatrix[i] = carbonfiberassemblylocalmatrix[i];
d7599219 654 }
655}
656/////////////////////////////////////////////////////////////////////////////////
657void AliITSv11GeometrySSD::SetCoolingTubeSupportCombiTransMatrix(){
44285dfa 658 /////////////////////////////////////////////////////////////
659 // Method generating CombiTrans Matrix for Cooling Tube Support
660 /////////////////////////////////////////////////////////////
d7599219 661 //Translation Parameters CoolingTubeSupport:
662 ////////////////////////////////////////////////////////
44285dfa 663 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
d7599219 664 /fgkCoolingTubeSupportRmax);
44285dfa 665 const Double_t kcoolingtubesupporttransx[2] =
666 {0.,2.*fgkCoolingTubeSupportRmax*TMath::Cos(phi)
d7599219 667 + 2.*(fgkCoolingTubeSupportLength
44285dfa 668 - fgkCoolingTubeSupportRmax*(1.+TMath::Cos(phi)))
d7599219 669 + fgkCarbonFiberTriangleLength
670 - 2.0*fgkCarbonFiberJunctionLength};
44285dfa 671 const Double_t kcoolingtubesupporttransy[2] = { 0.0, 0.0};
672 const Double_t kcoolingtubesupporttransz[2] = { 0.0, 0.0};
d7599219 673 ////////////////////////////////////////////////////////
674 //Rotational Parameters CoolingTubeSupport:
675 ////////////////////////////////////////////////////////
44285dfa 676 const Double_t kcoolingsubesupportrotphi[2] = { 0., 180.};
677 const Double_t kcoolingsubesupportrottheta[2] = { 0., 0.};
678 const Double_t kcoolingsubesupportrotpsi[2] = { 0., 0.};
d7599219 679 ///////////////////////////////////////////////////////////
680 //Name of CombiTrans Transformation of CarbonFiberJunction:
681 ///////////////////////////////////////////////////////////
44285dfa 682 char coolingtubesupportcombitransname[40];
683 char coolingtubesupportrotname[40];
684 TGeoCombiTrans *coolingtubesupportlocalmatrix[fgkCoolingTubeSupportCombiTransNumber];
d7599219 685 for(Int_t i=0; i<fgkCoolingTubeSupportCombiTransNumber; i++) {
44285dfa 686 sprintf(coolingtubesupportcombitransname,"CoolingTubeSupportCombiTrans%i",i);
687 sprintf(coolingtubesupportrotname,"CoolingTubeSupportRot%i",i);
688 coolingtubesupportlocalmatrix[i] =
689 new TGeoCombiTrans(coolingtubesupportcombitransname,
690 kcoolingtubesupporttransx[i],
691 kcoolingtubesupporttransy[i],
692 kcoolingtubesupporttransz[i],
693 new TGeoRotation(coolingtubesupportrotname,
694 kcoolingsubesupportrotphi[i],
695 kcoolingsubesupportrottheta[i],
696 kcoolingsubesupportrotpsi[i]));
697 fCoolingTubeSupportCombiTransMatrix[i] = coolingtubesupportlocalmatrix[i];
d7599219 698 }
699}
700/////////////////////////////////////////////////////////////////////////////////
701void AliITSv11GeometrySSD::SetCoolingTubeCombiTransMatrix(){
44285dfa 702 /////////////////////////////////////////////////////////////
703 // Method generating CombiTrans Matrix for Cooling Tube
704 /////////////////////////////////////////////////////////////
d7599219 705 //Translation Parameters CoolingTube:
706 ////////////////////////////////////////////////////////
44285dfa 707 const Double_t kcoolingtubetransx[2] = { 0., fgkCoolingTubeSeparation};
708 const Double_t kcoolingtubetransy[2] = { fgkCoolingTubeLength/2.0, fgkCoolingTubeLength/2.0};
709 const Double_t kcoolingtubetransz[2] = { 0.0, 0.};
d7599219 710 ////////////////////////////////////////////////////////
711 //Rotational Parameters CoolingTube:
712 ////////////////////////////////////////////////////////
44285dfa 713 const Double_t kcoolingtuberotphi[2] = { 0., 0.};
714 const Double_t kcoolingtuberottheta[2] = { 90., 90.};
715 const Double_t kcoolingtuberotpsi[2] = { 0., 0.};
d7599219 716 ///////////////////////////////////////////////////////////
717 //Name of CombiTrans Transformation of CarbonFiberJunction:
718 ///////////////////////////////////////////////////////////
44285dfa 719 const char* coolingtubecombitransname[fgkCoolingTubeCombiTransNumber] =
d7599219 720 {"CoolingTubeCombiTrans0","CoolingTubeCombiTrans1"};
44285dfa 721 const char* coolingtuberotationname[fgkCoolingTubeCombiTransNumber] =
d7599219 722 {"CoolingTubeRotation0","CoolingTubeRotation1"};
44285dfa 723 TGeoCombiTrans *coolingtubelocalmatrix[fgkCoolingTubeCombiTransNumber];
d7599219 724 for(Int_t i=0; i<fgkCoolingTubeCombiTransNumber; i++) {
44285dfa 725 coolingtubelocalmatrix[i] =
726 new TGeoCombiTrans(coolingtubecombitransname[i],
727 kcoolingtubetransx[i],
728 kcoolingtubetransy[i],
729 kcoolingtubetransz[i],
730 new TGeoRotation(coolingtuberotationname[i],
731 kcoolingtuberotphi[i],
732 kcoolingtuberottheta[i],
733 kcoolingtuberotpsi[i]) );
734 fCoolingTubeTransMatrix[i] = coolingtubelocalmatrix[i];
d7599219 735 }
736}
737/////////////////////////////////////////////////////////////////////////////////
738void AliITSv11GeometrySSD::SetLadderSegmentCombiTransMatrix(){
44285dfa 739 /////////////////////////////////////////////////////////////
740 // Method generating CombiTrans Matrix for SSD Ladder Segment
741 /////////////////////////////////////////////////////////////
d7599219 742 //Translation Parameters LadderSegment:
743 ////////////////////////////////////////////////////////
44285dfa 744 const Double_t kladdersegmenttransx[fgkLadderSegmentCombiTransNumber] = { 0.,
d7599219 745 - 0.5*(fgkSSDSensorWidth-fgkCarbonFiberTriangleLength),
746 fgkCarbonFiberTriangleLength+fgkCarbonFiberJunctionToSensorSupport,
747 fgkCarbonFiberJunctionLength-(fgkCoolingTubeSupportLength
748 - fgkCoolingTubeSupportRmax),
749 0.5*(fgkCarbonFiberTriangleLength-fgkCoolingTubeSeparation)};
44285dfa 750 const Double_t kladdersegmenttransy[fgkLadderSegmentCombiTransNumber] = { 0.,
d7599219 751 - (2.*fgkSSDSensorLength-fgkSSDSensorOverlap)+
752 fgkSSDModuleStiffenerPosition[1]+fgkSSDStiffenerWidth
753 + 0.5*fgkSSDFlexHoleLength+2.*fgkCarbonFiberJunctionWidth
754 - 0.5*(fgkCarbonFiberLowerSupportWidth+fgkSSDSensorCenterSupportLength
755 - fgkSSDSensorCenterSupportThickness[0]),
756 fgkCarbonFiberJunctionWidth-0.5*(fgkCarbonFiberLowerSupportWidth
757 + fgkSSDSensorCenterSupportLength
758 - fgkSSDSensorCenterSupportThickness[0])
759 - fgkSSDSensorCenterSupportPosition,
760 fgkCarbonFiberJunctionWidth-fgkCarbonFiberLowerSupportWidth
761 - fgkCoolingTubeSupportToCarbonFiber,
762 0.0};
44285dfa 763 const Double_t kladdersegmenttransz[fgkLadderSegmentCombiTransNumber] = { 0.,
d7599219 764 - (fgkSSDModuleCoolingBlockToSensor+0.5*fgkCoolingTubeSupportHeight
765 - fgkSSDSensorHeight-fgkSSDChipCablesHeight[3]-fgkSSDChipHeight),
766 0.,
767 - 0.5*fgkCoolingTubeSupportHeight,
768 - 0.5*fgkCoolingTubeSupportHeight};
769//////////////////////////////////////////////////
770 //Rotational Parameters LadderSegment:
771 ////////////////////////////////////////////////////////
44285dfa 772 const Double_t kladdersegmentrotphi[fgkLadderSegmentCombiTransNumber] =
d7599219 773 { 0., 0.,- 90., 0., 0.};
44285dfa 774 const Double_t kladdersegmentrottheta[fgkLadderSegmentCombiTransNumber] =
d7599219 775 { 0., 0., 0., 90., 0.};
44285dfa 776 const Double_t kladdersegmentrotpsi[fgkLadderSegmentCombiTransNumber] =
d7599219 777 { 0., 0., 0., 0., 0.};
778 //////////////////////////////////////////////////////
779 //Name of CombiTrans Transformation of LadderSegment:
780 //////////////////////////////////////////////////////
44285dfa 781 char laddersegmentcombitransname[40];
782 char laddersegmentrotname[40];
783 TGeoCombiTrans *laddersegmentlocalmatrix[fgkLadderSegmentCombiTransNumber];
d7599219 784 for(Int_t i=0; i<fgkLadderSegmentCombiTransNumber; i++) {
44285dfa 785 sprintf(laddersegmentcombitransname,"LadderSegmentCombiTrans%i",i);
786 sprintf(laddersegmentrotname,"LadderSegmentRot%i",i);
787 laddersegmentlocalmatrix[i] =
788 new TGeoCombiTrans(laddersegmentcombitransname,
789 kladdersegmenttransx[i],
790 kladdersegmenttransy[i],
791 kladdersegmenttransz[i],
792 new TGeoRotation(laddersegmentrotname,
793 kladdersegmentrotphi[i],
794 kladdersegmentrottheta[i],
795 kladdersegmentrotpsi[i]));
796 fLadderSegmentCombiTransMatrix[i] = laddersegmentlocalmatrix[i];
d7599219 797 }
798}
799/////////////////////////////////////////////////////////////////////////////////
800void AliITSv11GeometrySSD::SetEndLadderSegmentCombiTransMatrix(Int_t i){
44285dfa 801 /////////////////////////////////////////////////////////////
802 // Method generating CombiTrans Matrix for SSD End Ladder Segment
803 /////////////////////////////////////////////////////////////
d7599219 804 //Translation Parameters EndLadderSegment:
805 ////////////////////////////////////////////////////////
44285dfa 806 const Double_t kendladdersegmenttransx[fgkEndLadderSegmentCombiTransNumber] =
807 {0.0,
d7599219 808 0.0,
44285dfa 809 - 0.25*(fgkSSDMountingBlockLength[0]
810 + fgkSSDMountingBlockLength[1])
811 + 0.5*fgkCarbonFiberTriangleLength,
d7599219 812 0.0};
44285dfa 813 const Double_t kendladdersegmenttransy[fgkEndLadderSegmentCombiTransNumber] =
d7599219 814 {0.5*fgkEndLadderCarbonFiberLowerJunctionLength[i],
44285dfa 815 i==0 ? 0. : fgkCarbonFiberLowerSupportWidth,
816 fgkEndLadderMountingBlockPosition[i],
d7599219 817 (1-i)*(fgkEndLadderMountingBlockPosition[i]
818 + 0.5*fgkSSDMountingBlockWidth)};
44285dfa 819 const Double_t kendladdersegmenttransz[fgkEndLadderSegmentCombiTransNumber] =
820 {0.0,
d7599219 821 0.0,
822 - fgkSSDMountingBlockHeight[1]
823 + 0.5*fgkSSDMountingBlockHeight[0],
44285dfa 824 - 0.5*fgkCarbonFiberLowerSupportHeight};
d7599219 825 ////////////////////////////////////////////////////////
826 //Rotational Parameters EndLadderSegment:
827 ////////////////////////////////////////////////////////
44285dfa 828 const Double_t kendladdersegmentrotphi[fgkEndLadderSegmentCombiTransNumber] =
829 { 0., 90., 0., 0.};
830 const Double_t kendladdersegmentrottheta[fgkEndLadderSegmentCombiTransNumber] =
831 { 90.,-fgkCarbonFiberTriangleAngle, 0., 0.};
832 const Double_t kendladdersegmentrotpsi[fgkEndLadderSegmentCombiTransNumber] =
833 { 0.,- 90., 0., 0.};
d7599219 834 ////////////////////////////////////////////////////////
835 //Name of CombiTrans Transformation of EndLadderSegment:
836 ////////////////////////////////////////////////////////
44285dfa 837 char endladdersegmentcombitransname[30];
838 char endladdersegmentrotname[30];
839 TGeoCombiTrans *endladdersegmentlocalmatrix[fgkEndLadderSegmentCombiTransNumber];
d7599219 840 for(Int_t i=0; i<fgkEndLadderSegmentCombiTransNumber; i++){
44285dfa 841 sprintf(endladdersegmentcombitransname,"EndLadderSegmentCombiTrans%i",i);
842 sprintf(endladdersegmentrotname,"EndLadderSegmentRot%i",i);
843 endladdersegmentlocalmatrix[i] =
844 new TGeoCombiTrans(endladdersegmentcombitransname,
845 kendladdersegmenttransx[i],
846 kendladdersegmenttransy[i],
847 kendladdersegmenttransz[i],
848 new TGeoRotation(endladdersegmentrotname,
849 kendladdersegmentrotphi[i],
850 kendladdersegmentrottheta[i],
851 kendladdersegmentrotpsi[i]));
852 fEndLadderSegmentCombiTransMatrix[i] = endladdersegmentlocalmatrix[i];
d7599219 853 }
854}
855/////////////////////////////////////////////////////////////////////////////////
856void AliITSv11GeometrySSD::SetLadderCableCombiTransMatrix(Int_t iLayer){
44285dfa 857 /////////////////////////////////////////////////////////////
858 // Method generating CombiTrans Matrix for SSD Ladder Cable
859 /////////////////////////////////////////////////////////////
860 // Translation Parameters for LadderCable
861 /////////////////////////////////////////
862 Double_t ssdflexradius = fgkSSDStiffenerHeight+2*fgkSSDFlexHeight[0]
d7599219 863 + fgkSSDFlexHeight[1];
44285dfa 864 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
d7599219 865 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
44285dfa 866 Double_t ssdladdercabletransx[3];
867 ssdladdercabletransx[0] = (ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
d7599219 868 * TMath::Sin(2.*fgkSSDFlexAngle*TMath::DegToRad())
869 * TMath::Cos(2.*fgkSSDFlexAngle*TMath::DegToRad());
44285dfa 870 ssdladdercabletransx[1] = ((ssdflexradiusmax-fgkSSDFlexHeight[1]-ssdflexradius)
871 - ssdladdercabletransx[0]
d7599219 872 / TMath::Sin(2.*fgkSSDFlexAngle*TMath::DegToRad()))
873 * TMath::Cos(fgkSSDFlexAngle*TMath::DegToRad());
44285dfa 874 ssdladdercabletransx[2] = (fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
875 * TMath::DegToRad()*ssdflexradiusmax
d7599219 876 - fgkSSDFlexLength[2]-TMath::Pi()
877 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0]
878 - fgkSSDLadderCableWidth)
879 * TMath::Cos(2.*fgkSSDFlexAngle*TMath::DegToRad());
44285dfa 880 Double_t ssdladdercabletransz[3] = {ssdladdercabletransx[0]
d7599219 881 * TMath::Tan(2.*fgkSSDFlexAngle*TMath::DegToRad()),
44285dfa 882 ssdladdercabletransx[1]
d7599219 883 * TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad()),
44285dfa 884 ssdladdercabletransx[2]
d7599219 885 * TMath::Tan(2.*fgkSSDFlexAngle*TMath::DegToRad())};
44285dfa 886 TGeoRotation* localladdercablerot[3];
887 localladdercablerot[0] = new TGeoRotation("LocalLadderCableRot0",90.,0.,0.);
888 localladdercablerot[1] = new TGeoRotation("LocalLadderCableRot1",90.,60.,-90.);
889 localladdercablerot[2] = new TGeoRotation("LocalLadderCableRot2");
890 localladdercablerot[2]->SetRotation((*localladdercablerot[1])
891 * (*localladdercablerot[0]));
892 ////////////////////////////////////////////
893 // LocalLadderCableCombiTransMatrix
894 ////////////////////////////////////////////
895 const Int_t klocalladdersidecablesnumber = 2;
896 const Int_t klocalladdercombitransnumber = 5;
897 TGeoCombiTrans** localladdercablecombitransmatrix[klocalladdersidecablesnumber];
898 for(Int_t i=0; i<klocalladdersidecablesnumber; i++)
899 localladdercablecombitransmatrix[i] =
900 new TGeoCombiTrans*[klocalladdercombitransnumber];
901 ///////////////////////////////////////////
902 // Left Side Ladder Cables Transformations
903 ///////////////////////////////////////////
904 localladdercablecombitransmatrix[0][0] =
d7599219 905 new TGeoCombiTrans(-0.5*fgkCarbonFiberTriangleLength,
906 0.,0.,NULL);
44285dfa 907 localladdercablecombitransmatrix[0][1] = fLadderSegmentCombiTransMatrix[1];
908 localladdercablecombitransmatrix[0][2] =
d7599219 909 new TGeoCombiTrans(fgkSSDModuleStiffenerPosition[0],
910 fgkSSDModuleStiffenerPosition[1],0.,0);
44285dfa 911 localladdercablecombitransmatrix[0][3] = fSSDModuleCombiTransMatrix[6];
912 localladdercablecombitransmatrix[0][4] =
913 new TGeoCombiTrans(-ssdladdercabletransx[0]
914 - ssdladdercabletransx[1]-ssdladdercabletransx[2]
d7599219 915 + fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
916 0.,
917 0.5*fgkSSDFlexHeight[0]+2.*(fgkSSDFlexHeight[0]
918 + fgkSSDFlexHeight[1])+2.*fgkSSDStiffenerHeight
44285dfa 919 + ssdladdercabletransz[0]-ssdladdercabletransz[1]
920 + ssdladdercabletransz[2],localladdercablerot[2]);
921 ///////////////////////////////////////////
922 // Rigth Side Ladder Cables Transformations
923 ///////////////////////////////////////////
924 for(Int_t i=0; i<klocalladdercombitransnumber; i++)
925 localladdercablecombitransmatrix[1][i] =
926 (i!=3 ? localladdercablecombitransmatrix[0][i]:
927 fSSDModuleCombiTransMatrix[3]);
928 ///////////////////////////////////////////
929 // Setting LadderCableCombiTransMatrix
930 ///////////////////////////////////////////
931 Int_t beamaxistrans[3] = {0,0,0};
932 switch(iLayer){
933 case 5:
934 beamaxistrans[0] = fgkSSDLay5SensorsNumber/2;
935 beamaxistrans[1] = beamaxistrans[0]+1;
936 beamaxistrans[2] = beamaxistrans[0]-1;
937 break;
938 case 6:
939 beamaxistrans[0] = (fgkSSDLay6SensorsNumber-1)/2;
940 beamaxistrans[1] = beamaxistrans[0]+1;
941 beamaxistrans[2] = beamaxistrans[0];
942 break;
943 }
944 TGeoHMatrix* localladdercablehmatrix[klocalladdersidecablesnumber];
945 TGeoRotation* laddercablerot;
946 TGeoTranslation* laddercabletrans;
947 for(Int_t i=0; i<klocalladdersidecablesnumber; i++){
948 localladdercablehmatrix[i] = new TGeoHMatrix();
949 for(Int_t j=0; j<klocalladdercombitransnumber; j++){
950 localladdercablehmatrix[i]->MultiplyLeft(
951 localladdercablecombitransmatrix[i][klocalladdercombitransnumber-j-1]);
952 }
953 laddercablerot = new TGeoRotation();
954 laddercablerot->SetMatrix(localladdercablehmatrix[i]->GetRotationMatrix());
955 laddercabletrans = new TGeoTranslation();
956 Double_t* laddercabletransvector = localladdercablehmatrix[i]->GetTranslation();
957 laddercabletrans->SetTranslation(laddercabletransvector[0],
958 laddercabletransvector[1]
959 + (i==0 ? beamaxistrans[0] : 0.)
d7599219 960 * fgkCarbonFiberJunctionWidth,
44285dfa 961 laddercabletransvector[2]);
962 fLadderCableCombiTransMatrix[i] = new TGeoCombiTrans(*laddercabletrans,
963 *laddercablerot);
d7599219 964 }
44285dfa 965 fLadderCableCombiTransMatrix[2] =
966 AddTranslationToCombiTrans(fLadderCableCombiTransMatrix[1],0.,
967 beamaxistrans[1]*fgkCarbonFiberJunctionWidth,0.);
968 fLadderCableCombiTransMatrix[3] =
969 AddTranslationToCombiTrans(fLadderCableCombiTransMatrix[0],0.,
970 beamaxistrans[2]*fgkCarbonFiberJunctionWidth,0.);
971}
d7599219 972/////////////////////////////////////////////////////////////////////////////////
973TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupportShape(Double_t length,
974 Double_t height,Double_t width,Double_t* thickness){
44285dfa 975 /////////////////////////////////////////////////////////////
976 // Method generating SSD Sensor Support Shape
977 /////////////////////////////////////////////////////////////
978 const Int_t kvertexnumber = 4;
979 const Int_t kshapesnumber = 2;
980 Double_t shapewidth[2] = {width,width};
981 TVector3** vertexposition[kshapesnumber];
982 for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
983 new TVector3*[kvertexnumber];
d7599219 984 //First Shape Vertex Positioning
44285dfa 985 vertexposition[0][0] = new TVector3();
986 vertexposition[0][1] = new TVector3(height);
987 vertexposition[0][2] = new TVector3(thickness[0]);
988 vertexposition[0][3] = new TVector3(*vertexposition[0][1]);
d7599219 989 //Second Shape Vertex Positioning
44285dfa 990 vertexposition[1][0] = new TVector3(*vertexposition[0][0]);
991 vertexposition[1][1] = new TVector3(length);
992 vertexposition[1][2] = new TVector3(thickness[1]);
993 vertexposition[1][3] = new TVector3(vertexposition[1][1]->X());
994 char* ssdsensorsupportshapename[kshapesnumber] =
d7599219 995 {"SSDSensorSupportShape1","SSDSensorSupportShape2"};
44285dfa 996 TGeoArb8* lSSDSensorSupportShape[kshapesnumber];
997 for(Int_t i = 0; i< kshapesnumber; i++) lSSDSensorSupportShape[i] =
998 GetArbShape(vertexposition[i],shapewidth,i==0 ?
d7599219 999 thickness[1]: thickness[0],
44285dfa 1000 ssdsensorsupportshapename[i]);
d7599219 1001 /////////////////////////////////////
1002 //Setting Translations and Rotations:
1003 /////////////////////////////////////
44285dfa 1004 TGeoRotation* ssdsensorsupportshaperot[2];
1005 ssdsensorsupportshaperot[0] =
d7599219 1006 new TGeoRotation("SSDSensorSupportShapeRot1",180.,0.,0.);
44285dfa 1007 ssdsensorsupportshaperot[1] =
d7599219 1008 new TGeoRotation("SSDSensorSupportShapeRot2",90.,90.,-90.);
44285dfa 1009 TGeoTranslation* ssdsensorsupportshapetrans =
d7599219 1010 new TGeoTranslation("SSDSensorSupportShapeTrans",0.,0.,
1011 0.5*thickness[0]);
44285dfa 1012 TGeoCombiTrans* ssdsensorsupportcombitrans =
d7599219 1013 new TGeoCombiTrans("SSDSensorSupportCombiTrans",0.5*thickness[0],width,0.,
44285dfa 1014 new TGeoRotation((*ssdsensorsupportshaperot[1])
1015 * (*ssdsensorsupportshaperot[0])));
1016 TGeoVolume* ssdsensorsupportcompvolume =
d7599219 1017 new TGeoVolumeAssembly("SSDSensorSupportCompVolume");
44285dfa 1018 ssdsensorsupportcompvolume->AddNode(new TGeoVolume("SSDSensorSupportVolume1",
1019 lSSDSensorSupportShape[0],fSSDSensorSupportMedium),1,
1020 ssdsensorsupportshapetrans);
1021 ssdsensorsupportcompvolume->AddNode(new TGeoVolume("SSDSensorSupportVolume2",
1022 lSSDSensorSupportShape[1],fSSDSensorSupportMedium),1,
1023 ssdsensorsupportcombitrans);
1024 return ssdsensorsupportcompvolume;
d7599219 1025}
1026/////////////////////////////////////////////////////////////////////////////////
1027TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupport(Int_t VolumeKind, Int_t n){
44285dfa 1028 /////////////////////////////////////////////////////////////
1029 // Method generating SSD Sensor Support
1030 /////////////////////////////////////////////////////////////
1031 TGeoVolume* ssdsensorsupport;
1032 Double_t sidesupporthickness[2] = {fgkSSDSensorSideSupportThickness[0],
d7599219 1033 fgkSSDSensorSideSupportThickness[1]};
44285dfa 1034 VolumeKind == 0 ? ssdsensorsupport = GetSSDSensorSupportShape(
d7599219 1035 fgkSSDSensorSideSupportLength,
1036 fgkSSDSensorSideSupportHeight[(n==0 ? 0 : 1)],
1037 fgkSSDSensorSideSupportWidth,
44285dfa 1038 sidesupporthickness) :
1039 ssdsensorsupport = GetSSDSensorSupportShape(fgkSSDSensorCenterSupportLength,
d7599219 1040 fgkSSDSensorCenterSupportHeight[(n==0 ? 0 : 1)],
1041 fgkSSDSensorCenterSupportWidth,
44285dfa 1042 sidesupporthickness);
1043 return ssdsensorsupport;
d7599219 1044}
1045/////////////////////////////////////////////////////////////////////////////////
1046TGeoVolume* AliITSv11GeometrySSD::GetSSDSensorSupportAssembly(Int_t n){
44285dfa 1047 /////////////////////////////////////////////////////////////
1048 // Method generating SSD Sensor Support Assembly
1049 /////////////////////////////////////////////////////////////
1050 TGeoVolume* ssdsensorsupportassembly =
d7599219 1051 new TGeoVolumeAssembly("SSDSensorSupportAssembly");
44285dfa 1052 const Int_t kvolumenumber = 2;
1053 TGeoVolume* ssdsensorsupport[kvolumenumber];
1054 for(Int_t i=0; i<kvolumenumber; i++) ssdsensorsupport[i] =
d7599219 1055 GetSSDSensorSupport(i,n);
1056 SetSSDSensorSupportCombiTransMatrix();
1057 for(Int_t i=0; i<fgkSSDSensorSupportCombiTransNumber; i++)
44285dfa 1058 ssdsensorsupportassembly->AddNode((i<2 ? ssdsensorsupport[0]:
1059 ssdsensorsupport[1]),
1060 i+1,fSSDSensorSupportCombiTransMatrix[i]);
1061 return ssdsensorsupportassembly;
d7599219 1062}
1063/////////////////////////////////////////////////////////////////////////////////
1064TGeoVolume* AliITSv11GeometrySSD::GetSSDModule(Int_t iChipCablesHeight){
44285dfa 1065 /////////////////////////////////////////////////////////////
1066 // Method generating SSD Sensor Module
1067 /////////////////////////////////////////////////////////////
1068 TGeoVolume* ssdmodulevolume[fgkSSDModuleCombiTransNumber-1];
1069 ssdmodulevolume[0] = GetSSDStiffenerAssembly();
1070 ssdmodulevolume[1] = GetSSDChipAssembly();
1071 ssdmodulevolume[2] = GetSSDSensor();
1072 ssdmodulevolume[3] = GetSSDFlexAssembly();
1073 ssdmodulevolume[4] = GetSSDCoolingBlockAssembly();
1074 ssdmodulevolume[5] = GetSSDChipCablesAssembly(fgkSSDChipCablesHeight[iChipCablesHeight+2]);
d7599219 1075 SetSSDModuleCombiTransMatrix(fgkSSDChipCablesHeight[iChipCablesHeight+2]);
44285dfa 1076 TGeoCombiTrans* ssdmoduleglobalcombitrans =
d7599219 1077 new TGeoCombiTrans("SSDModuleGlobalCombiTrans",
1078 fgkSSDModuleStiffenerPosition[0],
1079 fgkSSDModuleStiffenerPosition[1],0.,NULL);
44285dfa 1080 TGeoHMatrix* ssdmodulehmatrix[fgkSSDModuleCombiTransNumber];
1081 TGeoVolume* ssdmodule = new TGeoVolumeAssembly("SSDModule");
d7599219 1082 for(Int_t i=0; i<fgkSSDModuleCombiTransNumber; i++){
44285dfa 1083 ssdmodulehmatrix[i] = new TGeoHMatrix((*ssdmoduleglobalcombitrans)
1084 * (*fSSDModuleCombiTransMatrix[i]));
1085 ssdmodule->AddNode(i==fgkSSDModuleCombiTransNumber-1 ? ssdmodulevolume[3] :
1086 ssdmodulevolume[i],i!=fgkSSDModuleCombiTransNumber-1?1:2,
1087 ssdmodulehmatrix[i]);
d7599219 1088 }
44285dfa 1089 return ssdmodule;
d7599219 1090}
1091/////////////////////////////////////////////////////////////////////////////////
1092TGeoVolume* AliITSv11GeometrySSD::GetSSDSensor(){
44285dfa 1093 /////////////////////////////////////////////////////////////
1094 // Method generating SSD Sensor
1095 /////////////////////////////////////////////////////////////
1096 Double_t ssdsensitivelength = fgkSSDSensorLength-2.*fgkSSDSensorInsensitiveLength;
1097 Double_t ssdsensitivewidth = fgkSSDSensorWidth-2.*fgkSSDSensorInsensitiveWidth;
1098 TGeoBBox* ssdsensorsensitiveshape = new TGeoBBox("SSDSensorSensitiveShape",
1099 0.5*ssdsensitivelength,
1100 0.5*ssdsensitivewidth,
d7599219 1101 0.5*fgkSSDSensorHeight);
44285dfa 1102 TGeoVolume* ssdsensorsensitive =
1103 new TGeoVolume(fgkSSDSensitiveVolName,ssdsensorsensitiveshape,fSSDSensorMedium);
1104 ssdsensorsensitive->SetLineColor(fColorSilicon);
1105 TGeoBBox* ssdsensorinsensitiveshape[2];
1106 ssdsensorinsensitiveshape[0] = new TGeoBBox("SSDSensorInsensitiveShape1",
d7599219 1107 0.5*fgkSSDSensorLength,
1108 0.5*fgkSSDSensorInsensitiveWidth,
1109 0.5*fgkSSDSensorHeight);
44285dfa 1110 ssdsensorinsensitiveshape[1] = new TGeoBBox("SSDSensorInsensitiveShape2",
d7599219 1111 0.5*fgkSSDSensorInsensitiveWidth,
44285dfa 1112 0.5*ssdsensitivewidth,
d7599219 1113 0.5*fgkSSDSensorHeight);
44285dfa 1114 const char* ssdsensorinsensitivename[2] = {"SSDSensorInsensitive1",
d7599219 1115 "SSDSensorInsensitive2"};
44285dfa 1116 TGeoVolume* ssdsensorinsensitive[2];
1117 for(Int_t i=0; i<2; i++){ ssdsensorinsensitive[i] =
1118 new TGeoVolume(ssdsensorinsensitivename[i],ssdsensorinsensitiveshape[i],
1119 fSSDSensorMedium);
1120 ssdsensorinsensitive[i]->SetLineColor(fColorCarbonFiber);
d7599219 1121 }
44285dfa 1122 TGeoVolume* ssdsensorinsensitivevol =
d7599219 1123 new TGeoVolumeAssembly("SSDSensorInsensitiveVol");
1124 for(Int_t i=0; i<4; i++)
44285dfa 1125 ssdsensorinsensitivevol->AddNode(i%2==0 ? ssdsensorinsensitive[0]:
1126 ssdsensorinsensitive[1],i<2?1:2,
d7599219 1127 new TGeoTranslation(0.5*(1.-TMath::Power(-1.,i))*(i==1? 1.:-1.)
44285dfa 1128 * (ssdsensorsensitiveshape->GetDX()+ssdsensorinsensitiveshape[1]->GetDX()),
d7599219 1129 0.5*(1.+TMath::Power(-1.,i))*(i==0?-1.: 1.)
44285dfa 1130 * (ssdsensorsensitiveshape->GetDY()+ssdsensorinsensitiveshape[0]->GetDY()),0.));
1131 TGeoVolume* ssdsensor = new TGeoVolumeAssembly("SSDSensor");
1132 ssdsensor->AddNode(ssdsensorsensitive,1),ssdsensor->AddNode(ssdsensorinsensitivevol,1);
1133 return ssdsensor;
d7599219 1134}
1135/////////////////////////////////////////////////////////////////////////////////
44285dfa 1136TGeoVolume* AliITSv11GeometrySSD::GetSSDChipAssembly() const{
1137 /////////////////////////////////////////////////////////////
1138 // Method generating SSD Chip Assembly
1139 /////////////////////////////////////////////////////////////
1140 const Int_t kssdchiprownumber = 2;
1141 TGeoBBox* ssdchipcompshape[2];
1142 ssdchipcompshape[0] = new TGeoBBox("SSDChipCompShape",
d7599219 1143 0.5*fgkSSDChipLength,
1144 0.5*fgkSSDChipWidth,
1145 0.5*(fgkSSDChipHeight-fgkSSDChipGlueHeight));
44285dfa 1146 ssdchipcompshape[1] = new TGeoBBox("SSDChipGlueCompShape",
d7599219 1147 0.5*fgkSSDChipLength,
1148 0.5*fgkSSDChipWidth,
1149 0.5*fgkSSDChipGlueHeight);
44285dfa 1150 TGeoVolume* ssdchipcomp[2];
1151 ssdchipcomp[0] = new TGeoVolume("SSDChipComp",ssdchipcompshape[0],fSSDChipMedium);
1152 ssdchipcomp[1] = new TGeoVolume("SSDChipGlueComp",ssdchipcompshape[1],
1153 fSSDChipGlueMedium);
1154 ssdchipcomp[0]->SetLineColor(fColorSilicon);
1155 ssdchipcomp[1]->SetLineColor(fColorEpoxy);
1156 TGeoTranslation* ssdchipcomptrans[2];
1157 ssdchipcomptrans[0] = new TGeoTranslation(0.,0.,-ssdchipcompshape[1]->GetDZ());
1158 ssdchipcomptrans[1] = new TGeoTranslation(0.,0.,ssdchipcompshape[0]->GetDZ());
1159 TGeoVolume* ssdchip = new TGeoVolumeAssembly("SSDChip");
1160 for(Int_t i=0; i<2; i++) ssdchip->AddNode(ssdchipcomp[i],1,ssdchipcomptrans[i]);
1161 Double_t ssdchipseparation[2] = {fgkSSDChipLength+fgkSSDChipSeparationLength,
d7599219 1162 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
1163 - 2.*(fgkSSDStiffenerWidth-fgkSSDStiffenerToChipDist
1164 - 0.5*fgkSSDChipWidth)};
44285dfa 1165 TGeoVolume* ssdchipassembly = new TGeoVolumeAssembly("SSDChipAssembly");
1166 for(Int_t i=0; i<kssdchiprownumber; i++)
d7599219 1167 for(Int_t j=0; j<fgkSSDChipNumber; j++)
44285dfa 1168 ssdchipassembly->AddNode(ssdchip,fgkSSDChipNumber*i+j+1,
1169 new TGeoTranslation(j*ssdchipseparation[0],i*ssdchipseparation[1],0.));
1170 return ssdchipassembly;
d7599219 1171}
1172/////////////////////////////////////////////////////////////////////////////////
1173TGeoVolume* AliITSv11GeometrySSD::GetSSDStiffenerAssembly(){
44285dfa 1174 /////////////////////////////////////////////////////////////
1175 // Method generating SSD Stiffener Assembly
1176 /////////////////////////////////////////////////////////////
1177 const Int_t kssdstiffenernumber = 2;
1178 Double_t ssdstiffenerseparation = fgkSSDSensorLength
d7599219 1179 - 2.*fgkSSDModuleStiffenerPosition[1]
1180 - fgkSSDStiffenerWidth;
44285dfa 1181 TGeoVolume* ssdstiffener = new TGeoVolumeAssembly("SSDStiffener");
d7599219 1182////////////////////////////
1183// Stiffener Volumes
1184///////////////////////////
44285dfa 1185 const Int_t kstiffenerboxnumber = 6;
1186 TGeoBBox* ssdstiffenerboxshapes[kstiffenerboxnumber];
1187 ssdstiffenerboxshapes[0] = new TGeoBBox("SSDStiffenerBoxShape1",
d7599219 1188 0.5* fgkSSDStiffenerLength,
1189 0.5* fgkSSDStiffenerWidth,
1190 0.5*(fgkSSDStiffenerHeight
1191 - fgkSSDConnectorHeight));
44285dfa 1192 ssdstiffenerboxshapes[1] = new TGeoBBox("SSDStiffenerBoxShape2",
d7599219 1193 0.5*(fgkSSDConnectorPosition[0]
1194 - 2.0* fgkSSDConnectorLength
1195 - fgkSSDConnectorSeparation),
1196 0.5* fgkSSDStiffenerWidth,
1197 0.5* fgkSSDConnectorHeight);
44285dfa 1198 ssdstiffenerboxshapes[2] = new TGeoBBox("SSDStiffenerBoxShape3",
d7599219 1199 0.5*(fgkSSDConnectorSeparation
1200 + 2.* fgkSSDConnectorLength),
1201 0.5* fgkSSDConnectorPosition[1],
1202 0.5* fgkSSDConnectorHeight);
44285dfa 1203 ssdstiffenerboxshapes[3] = new TGeoBBox("SSDStiffenerBoxShape4",
1204 ssdstiffenerboxshapes[2]->GetDX(),
d7599219 1205 0.5*(fgkSSDStiffenerWidth
1206 - fgkSSDConnectorPosition[1]
1207 - fgkSSDConnectorWidth),
1208 0.5* fgkSSDConnectorHeight);
44285dfa 1209 ssdstiffenerboxshapes[4] = new TGeoBBox("SSDStiffenerBoxShape5",
d7599219 1210 0.5* fgkSSDConnectorSeparation,
1211 0.5* fgkSSDConnectorWidth,
1212 0.5* fgkSSDConnectorHeight);
44285dfa 1213 ssdstiffenerboxshapes[5] = new TGeoBBox("SSDStiffenerBoxShape6",
d7599219 1214 0.5*(fgkSSDStiffenerLength
1215 - fgkSSDConnectorPosition[0]),
1216 0.5* fgkSSDStiffenerWidth,
1217 0.5* fgkSSDConnectorHeight);
44285dfa 1218 TGeoVolume* ssdstiffenerbox[kstiffenerboxnumber];
1219 char ssdtiffenerboxname[30];
1220 for(Int_t i=0; i<kstiffenerboxnumber; i++){
1221 sprintf(ssdtiffenerboxname,"SSDStiffenerBox%i",i+1);
1222 ssdstiffenerbox[i] = new TGeoVolume(ssdtiffenerboxname,ssdstiffenerboxshapes[i],
1223 fSSDStiffenerMedium);
1224 ssdstiffenerbox[i]->SetLineColor(fColorStiffener);
d7599219 1225 }
1226////////////////////////////
1227// Connector
1228///////////////////////////
44285dfa 1229 TGeoBBox* ssdconnectorshape = new TGeoBBox("SSDConnectorShape",
d7599219 1230 0.5*fgkSSDConnectorLength,
1231 0.5*fgkSSDConnectorWidth,
1232 0.5*fgkSSDConnectorHeight);
44285dfa 1233 TGeoVolume* ssdconnector = new TGeoVolume("SSDConnector",ssdconnectorshape,
1234 fSSDStiffenerConnectorMedium);
1235 ssdconnector->SetLineColor(fColorAl);
1236 const Int_t kssdconnectornumber = 2;
1237 TGeoTranslation* ssdconnectortrans[kssdconnectornumber];
1238 ssdconnectortrans[0] = new TGeoTranslation("SSDConnectorTrans1",
1239 - ssdstiffenerboxshapes[0]->GetDX()+fgkSSDConnectorPosition[0]
d7599219 1240 - fgkSSDConnectorSeparation-1.5*fgkSSDConnectorLength,
44285dfa 1241 ssdstiffenerboxshapes[0]->GetDY()-fgkSSDConnectorPosition[1]
1242 - ssdconnectorshape->GetDY(),
1243 ssdstiffenerboxshapes[0]->GetDZ()+ssdconnectorshape->GetDZ());
1244 ssdconnectortrans[1] = new TGeoTranslation("SSDConnectorTrans2",
1245 - ssdstiffenerboxshapes[0]->GetDX()+fgkSSDConnectorPosition[0]
d7599219 1246 - 0.5*fgkSSDConnectorLength,
44285dfa 1247 ssdstiffenerboxshapes[0]->GetDY()-fgkSSDConnectorPosition[1]
1248 - ssdconnectorshape->GetDY(),
1249 ssdstiffenerboxshapes[0]->GetDZ()+ssdconnectorshape->GetDZ());
1250 for(Int_t i=0; i<kssdconnectornumber; i++)
1251 ssdstiffener->AddNode(ssdconnector,i+1,ssdconnectortrans[i]);
d7599219 1252//////////////////////////////////////
1253// TGeoTranslation for Stiffener Boxes
1254//////////////////////////////////////
44285dfa 1255 TGeoTranslation* ssdstiffenerboxtrans[kstiffenerboxnumber];
1256 ssdstiffenerboxtrans[0] = new TGeoTranslation("SSDStiffenerBoxTrans1",0.,0.,0.);
1257 ssdstiffenerboxtrans[1] = new TGeoTranslation("SSDStiffenerBoxTrans2",
1258 - (ssdstiffenerboxshapes[0]->GetDX()-ssdstiffenerboxshapes[1]->GetDX()),
d7599219 1259 0.,
44285dfa 1260 ssdstiffenerboxshapes[0]->GetDZ()+ssdstiffenerboxshapes[1]->GetDZ());
1261 ssdstiffenerboxtrans[2] = new TGeoTranslation("SSDStiffenerBoxTrans3",
1262 - ssdstiffenerboxshapes[0]->GetDX()-ssdstiffenerboxshapes[2]->GetDX()
d7599219 1263 + fgkSSDConnectorPosition[0],
44285dfa 1264 ssdstiffenerboxshapes[0]->GetDY()-ssdstiffenerboxshapes[2]->GetDY(),
1265 ssdstiffenerboxshapes[0]->GetDZ()+ssdstiffenerboxshapes[2]->GetDZ());
1266 ssdstiffenerboxtrans[3] = new TGeoTranslation("SSDStiffenerBoxTrans4",
1267 - ssdstiffenerboxshapes[0]->GetDX()-ssdstiffenerboxshapes[3]->GetDX()
d7599219 1268 + fgkSSDConnectorPosition[0],
44285dfa 1269 - ssdstiffenerboxshapes[0]->GetDY()+ssdstiffenerboxshapes[3]->GetDY(),
1270 ssdstiffenerboxshapes[0]->GetDZ()+ssdstiffenerboxshapes[3]->GetDZ());
1271 ssdstiffenerboxtrans[4] = new TGeoTranslation("SSDStiffenerBoxTrans5",
1272 - ssdstiffenerboxshapes[0]->GetDX()+fgkSSDConnectorPosition[0]
1273 - 0.5*fgkSSDConnectorSeparation-2.*ssdconnectorshape->GetDX(),
1274 ssdstiffenerboxshapes[0]->GetDY()-fgkSSDConnectorPosition[1]
1275 - ssdconnectorshape->GetDY(),
1276 ssdstiffenerboxshapes[0]->GetDZ()+ssdconnectorshape->GetDZ());
1277 ssdstiffenerboxtrans[5] = new TGeoTranslation("SSDStiffenerBoxTrans6",
1278 - ssdstiffenerboxshapes[0]->GetDX()+fgkSSDConnectorPosition[0]
1279 + ssdstiffenerboxshapes[5]->GetDX(),
d7599219 1280 0.,
44285dfa 1281 ssdstiffenerboxshapes[0]->GetDZ()+ssdstiffenerboxshapes[5]->GetDZ());
1282 for(Int_t i=0; i<kstiffenerboxnumber; i++)
1283 ssdstiffener->AddNode(ssdstiffenerbox[i],1,ssdstiffenerboxtrans[i]);
1284 TGeoCombiTrans* ssdstiffenercombitrans[kssdstiffenernumber];
1285 char ssdstiffenercombitransname[30];
1286 for(Int_t i=0; i<kssdstiffenernumber; i++){
1287 sprintf(ssdstiffenercombitransname,"SSDStiffenerCombiTrans%i",i+1);
1288 ssdstiffenercombitrans[i] = new TGeoCombiTrans(ssdstiffenercombitransname,
1289 0.,i*ssdstiffenerseparation,0.,new TGeoRotation("",180*(1-i),0.,0.));
d7599219 1290 }
1291////////////////////////////
1292// Capacitor 0603-2200 nF
1293///////////////////////////
44285dfa 1294 const Int_t knapacitor0603number = 5;
1295 TGeoBBox* capacitor0603shape = new TGeoBBox("Capacitor0603Shape",
d7599219 1296 0.5*fgkSSDCapacitor0603Length,
1297 0.5*fgkSSDCapacitor0603Width,
1298 0.5*fgkSSDCapacitor0603Height);
44285dfa 1299 TGeoVolume* capacitor0603 = new TGeoVolume("Capacitor0603",capacitor0603shape,
1300 fSSDStiffener0603CapacitorMedium);
1301 capacitor0603->SetLineColor(fColorAl);
d7599219 1302////////////////////////////
1303// Capacitor 1812-330 nF
1304///////////////////////////
44285dfa 1305 TGeoBBox* capacitor1812shape = new TGeoBBox("Capacitor1812Shape",
d7599219 1306 0.5*fgkSSDCapacitor1812Length,
1307 0.5*fgkSSDCapacitor1812Width,
1308 0.5*fgkSSDCapacitor1812Height);
44285dfa 1309 TGeoVolume* capacitor1812 = new TGeoVolume("Capacitor1812",capacitor1812shape,
1310 fSSDStiffener1812CapacitorMedium);
1311 capacitor1812->SetLineColor(fColorAl);
1312 TGeoTranslation* capacitor1812trans = new TGeoTranslation("Capacitor1812Trans",
d7599219 1313 0.,
44285dfa 1314 0.5*fgkSSDStiffenerWidth+ssdstiffenerseparation
1315 - capacitor1812shape->GetDY()-fgkSSDConnectorPosition[1],
1316 ssdstiffenerboxshapes[0]->GetDZ()+fgkSSDConnectorHeight
d7599219 1317 + 0.5*fgkSSDCapacitor1812Height);
1318////////////////////////////
1319//Hybrid Wire
1320////////////////////////////
44285dfa 1321 Double_t wirex = 2.*(fgkSSDConnectorPosition[0]-0.5*fgkSSDStiffenerLength
d7599219 1322 - 0.5*fgkSSDConnectorLength)-fgkSSDConnectorLength
1323 - fgkSSDConnectorSeparation;
44285dfa 1324 Double_t wirey = ssdstiffenerseparation+fgkSSDStiffenerWidth
d7599219 1325 - 2.*fgkSSDConnectorPosition[1]-fgkSSDConnectorWidth;
44285dfa 1326 Double_t ssdwireradius = TMath::Sqrt(TMath::Power(wirex,2.)
1327 + TMath::Power(wirey,2));
1328 Double_t wireangle = TMath::ATan(wirex/wirey);
1329 TGeoTube *hybridwireshape = new TGeoTube("HybridWireShape", 0.,
1330 fgkSSDWireRadius, 0.5*ssdwireradius);
1331 TGeoVolume* hybridwire = new TGeoVolume("HybridWire",hybridwireshape,
1332 fSSDStiffenerHybridWireMedium);
1333 hybridwire->SetLineColor(fColorPhynox);
1334 TGeoCombiTrans* hybridwirecombitrans[2];
1335 hybridwirecombitrans[0] = new TGeoCombiTrans("HybridWireCombiTrans1",
d7599219 1336 0.5*fgkSSDStiffenerLength-fgkSSDConnectorPosition[0]
1337 + 1.5*fgkSSDConnectorLength+fgkSSDConnectorSeparation,
44285dfa 1338 0.5*ssdwireradius-0.5*fgkSSDStiffenerWidth
d7599219 1339 + fgkSSDConnectorPosition[1]+0.5*fgkSSDConnectorWidth,
44285dfa 1340 ssdstiffenerboxshapes[0]->GetDZ()+fgkSSDConnectorHeight
d7599219 1341 + fgkSSDWireRadius,
1342 new TGeoRotation("HybridWireRot1",0.,90.,0.));
44285dfa 1343 hybridwirecombitrans[1] = new TGeoCombiTrans("HybridWireCombiTrans2",
d7599219 1344 0.,
1345 - 0.5*fgkSSDConnectorWidth+fgkSSDWireRadius,
1346 0.,
1347 new TGeoRotation("HybridWireRot2",
44285dfa 1348 - wireangle*TMath::RadToDeg(),0.,0.));
1349 TGeoHMatrix* hybridwirematrix = new TGeoHMatrix();
1350 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[0]);
1351 hybridwirematrix->MultiplyLeft(hybridwirecombitrans[1]);
d7599219 1352////////////////////////////
1353// Stiffener Assembly
1354///////////////////////////
44285dfa 1355 TGeoVolume* ssdstiffenerassembly =
d7599219 1356 new TGeoVolumeAssembly("SSDStiffenerAssembly");
44285dfa 1357 ssdstiffenerassembly->AddNode(hybridwire,1,hybridwirematrix);
1358 for(Int_t i=0; i<kssdstiffenernumber; i++) {
1359 ssdstiffenerassembly->AddNode(ssdstiffener,i+1,ssdstiffenercombitrans[i]);
1360 for(Int_t j=1; j<knapacitor0603number+1; j++){
1361 ssdstiffenerassembly->AddNode(capacitor0603,knapacitor0603number*i+j,new TGeoTranslation("",(j-3.
d7599219 1362 )/6*fgkSSDStiffenerLength,
44285dfa 1363 i*ssdstiffenerseparation+
d7599219 1364 0.5*((i==0? 1:-1)*fgkSSDStiffenerWidth
1365 +(i==0? -1:+1)*fgkSSDCapacitor0603Width),
1366 -0.5*(fgkSSDStiffenerHeight+fgkSSDCapacitor0603Height)));
1367 }
44285dfa 1368 if(i==1) ssdstiffenerassembly->AddNode(capacitor1812,1,capacitor1812trans);
d7599219 1369}
44285dfa 1370 return ssdstiffenerassembly;
d7599219 1371}
1372/////////////////////////////////////////////////////////////////////////////////
1373TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCables(Double_t SSDChipCablesHeigth,
1374 char* side){
44285dfa 1375 /////////////////////////////////////////////////////////////
1376 // Method generating SSD Chip Cables
1377 /////////////////////////////////////////////////////////////
1378 const Int_t kssdchipcableslaynumber = 2;
1379 Int_t ssdchipcablescolor[2] = {fColorAl,fColorPolyhamide};
1380 Double_t ssdchipcablesradius[2];
1381 ssdchipcablesradius[0] = 0.25*(SSDChipCablesHeigth
d7599219 1382 - fgkSSDChipCablesHeight[0]
1383 - fgkSSDChipCablesHeight[1]);
44285dfa 1384 ssdchipcablesradius[1] = ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0];
1385 Double_t ssdchipcablespiecelength = 0.5*(fgkSSDChipCablesWidth[0]
1386 - 2.*TMath::Pi()*ssdchipcablesradius[0]
1387 - ssdchipcablesradius[0]
d7599219 1388 - fgkSSDChipCablesWidth[1]
1389 - fgkSSDChipCablesWidth[2]
1390 - (side=="Right" ? 0 :
1391 fgkSSDModuleStiffenerPosition[1]
1392 + TMath::Pi()*(0.5*fgkSSDSensorHeight
1393 + fgkSSDChipCablesHeight[0]
1394 + fgkSSDChipCablesHeight[1])));
1395 //////////////////////////
1396 //Box and Tube Seg Shapes
1397 //////////////////////////
44285dfa 1398 char* ssdchipcablesboxshapename[2*kssdchipcableslaynumber] =
d7599219 1399 {"SSDChipCablesBoxLay0Shape0","SSDChipCablesBoxLay0Shape1",
1400 "SSDChipCablesBoxLay1Shape0","SSDChipCablesBoxLay1Shape1"};
44285dfa 1401 char* ssdchipcablestubesegshapename[2*kssdchipcableslaynumber] =
d7599219 1402 {"SSDChipCablesTubeSegLay0Shape0","SSDChipCablesTubeSegLay0Shape1",
1403 "SSDChipCablesTubeSegLay1Shape0","SSDChipCablesTubeSegLay1Shape1"};
44285dfa 1404 TGeoBBox** ssdchipcablesboxshape[kssdchipcableslaynumber];
1405 TGeoTubeSeg** ssdchipcablestubesegshape[kssdchipcableslaynumber];
1406 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
1407 ssdchipcablesboxshape[i] = new TGeoBBox*[2];
1408 ssdchipcablestubesegshape[i] = new TGeoTubeSeg*[2+(side=="Right" ? 0 : 1)];
1409 ssdchipcablesboxshape[i][0] = new TGeoBBox(ssdchipcablesboxshapename[2*i],
1410 0.5*ssdchipcablespiecelength,
d7599219 1411 0.5*fgkSSDChipCablesLength[1],
1412 0.5*fgkSSDChipCablesHeight[i]);
44285dfa 1413 ssdchipcablesboxshape[i][1] = new TGeoBBox(ssdchipcablesboxshapename[2*i+1],
1414 0.5*(ssdchipcablespiecelength+ssdchipcablesradius[0]
d7599219 1415 + (side=="Right" ? 0. : fgkSSDModuleStiffenerPosition[1])),
1416 0.5*fgkSSDChipCablesLength[1],0.5*fgkSSDChipCablesHeight[i]);
44285dfa 1417 ssdchipcablestubesegshape[i][0] =
1418 new TGeoTubeSeg(ssdchipcablestubesegshapename[2*i],
1419 ssdchipcablesradius[1]-i*fgkSSDChipCablesHeight[1],
1420 ssdchipcablesradius[i],0.5*fgkSSDChipCablesLength[1],
d7599219 1421 0.,180.);
44285dfa 1422 ssdchipcablestubesegshape[i][1] =
1423 new TGeoTubeSeg(ssdchipcablestubesegshapename[2*i+1],
1424 ssdchipcablesradius[0]+i*fgkSSDChipCablesHeight[0],
1425 ssdchipcablesradius[0]+fgkSSDChipCablesHeight[0]
d7599219 1426 + i*fgkSSDChipCablesHeight[1],
1427 0.5*fgkSSDChipCablesLength[1],0.,180.);
44285dfa 1428 if(side!="Right") ssdchipcablestubesegshape[i][2] =
1429 new TGeoTubeSeg(ssdchipcablestubesegshapename[2*i],
d7599219 1430 0.5*fgkSSDSensorHeight+(1-i)*fgkSSDChipCablesHeight[1],
1431 0.5*fgkSSDSensorHeight+(1-i)*fgkSSDChipCablesHeight[0]
1432 + fgkSSDChipCablesHeight[1],
1433 0.5*fgkSSDChipCablesLength[1],0.,180.);
1434 }
1435 //////////////////////////
1436 //Box under Chip
1437 //////////////////////////
44285dfa 1438 char ssdunderchipcablesboxshapename[30];
1439 char ssdunderchipcablesboxname[30];
1440 char ssdunderchipcablesboxtransname[30];
1441 TGeoBBox* ssdunderchipcablesboxshape[kssdchipcableslaynumber];
1442 TGeoVolume* ssdunderchipcablesbox[kssdchipcableslaynumber];
1443 TGeoTranslation* ssdunderchipcablesboxtrans[kssdchipcableslaynumber];
1444 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
1445 sprintf(ssdunderchipcablesboxshapename,"SSDUnderChipCablesBoxShape%i",i+1);
1446 sprintf(ssdunderchipcablesboxname,"SSDUnderChipCablesBox%i",i+1);
1447 sprintf(ssdunderchipcablesboxtransname,"SSDUnderChipCablesBoxTrans%i",i+1);
1448 ssdunderchipcablesboxshape[i] =
1449 new TGeoBBox(ssdunderchipcablesboxshapename,
d7599219 1450 0.5*fgkSSDChipWidth,
1451 0.5*fgkSSDChipCablesLength[1],
1452 0.5*fgkSSDChipCablesHeight[i]);
44285dfa 1453 ssdunderchipcablesbox[i] = new TGeoVolume(ssdunderchipcablesboxname,
1454 ssdunderchipcablesboxshape[i],
1455 (i==0?fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium));
1456 ssdunderchipcablesbox[i]->SetLineColor(ssdchipcablescolor[i]);
1457 ssdunderchipcablesboxtrans[i] =
1458 new TGeoTranslation(ssdunderchipcablesboxtransname,
d7599219 1459 (side=="Right"?-1.:1.)*0.5*fgkSSDChipWidth,
1460 0.5*(fgkSSDChipCablesLength[0]-fgkSSDChipCablesLength[1])
1461 +0.5*fgkSSDChipCablesLength[1],
1462 (i==0?1.:-1.)*0.5*fgkSSDChipCablesHeight[1-i]);
1463 }
1464 //////////////////
1465 //Trapezoid Shapes
1466 //////////////////
44285dfa 1467 const Int_t kssdchipcablesvertexnumber = 2;
1468 const Int_t kssdchipcablestrapezoidnumber = 2;
1469 TVector3** ssdchipcablestrapezoidvertex[kssdchipcablesvertexnumber];
1470 for(Int_t i = 0; i< kssdchipcablestrapezoidnumber; i++)
1471 ssdchipcablestrapezoidvertex[i] = new TVector3*[kssdchipcablesvertexnumber];
d7599219 1472 //First Shape Vertex Positioning
44285dfa 1473 ssdchipcablestrapezoidvertex[0][0] = new TVector3();
1474 ssdchipcablestrapezoidvertex[0][1] =
d7599219 1475 new TVector3(0.5*(fgkSSDChipCablesLength[0]-fgkSSDChipCablesLength[1]));
1476 //Second Shape Vertex Positioning
44285dfa 1477 ssdchipcablestrapezoidvertex[1][0] =
1478 new TVector3(*ssdchipcablestrapezoidvertex[0][0]);
1479 ssdchipcablestrapezoidvertex[1][1] =
1480 new TVector3(*ssdchipcablestrapezoidvertex[0][1]);
d7599219 1481 //Setting the names of shapes and volumes
44285dfa 1482 char* ssdchipcablestrapezoidboxshapename[kssdchipcablestrapezoidnumber] =
d7599219 1483 {"SSDChipCablesTrapezoidBoxShape1","SSDChipCablesTrapezoidBoxShape2"};
44285dfa 1484 char* ssdchipcablestrapezoidshapename[kssdchipcablestrapezoidnumber] =
d7599219 1485 {"SSDChipCablesTrapezoidShape1","SSDChipCablesTrapezoidShape2"};
44285dfa 1486 char* ssdchipcablestrapezoidboxname[kssdchipcablestrapezoidnumber] =
d7599219 1487 {"SSDChipCablesTrapezoidBox1","SSDChipCablesTrapezoidBox2"};
44285dfa 1488 char* ssdhipcablestrapezoidname[kssdchipcablestrapezoidnumber] =
d7599219 1489 {"SSDChipCablesTrapezoid1","SSDChipCablesTrapezoid2"};
44285dfa 1490 char* ssdchipcablestrapezoidassemblyname[kssdchipcablestrapezoidnumber] =
d7599219 1491 {"SSDChipCablesTrapezoidAssembly1","SSDChipCablesTrapezoidAssembly2"};
1492 //Setting the Shapes
44285dfa 1493 TGeoBBox* ssdchipcablestrapezoidboxshape[kssdchipcablestrapezoidnumber];
1494 TGeoArb8* ssdchipcablestrapezoidshape[kssdchipcablestrapezoidnumber];
d7599219 1495 //Setting the Volumes
44285dfa 1496 TGeoVolume* ssdchipcablestrapezoidbox[kssdchipcablestrapezoidnumber];
1497 TGeoVolume* ssdchipcablestrapezoid[kssdchipcablestrapezoidnumber];
1498 TGeoVolume* ssdchipcablestrapezoidassembly[kssdchipcablestrapezoidnumber];
1499 Double_t ssdchipcablestrapezoidwidth[kssdchipcablesvertexnumber] =
d7599219 1500 {fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2],fgkSSDChipCablesWidth[1]};
44285dfa 1501 for(Int_t i=0; i<kssdchipcablestrapezoidnumber; i++){
1502 ssdchipcablestrapezoidboxshape[i] =
1503 new TGeoBBox(ssdchipcablestrapezoidboxshapename[i],
d7599219 1504 0.5*fgkSSDChipCablesLength[1],
1505 0.5*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]),
1506 0.5*fgkSSDChipCablesHeight[i]);
44285dfa 1507 ssdchipcablestrapezoidshape[i] =
1508 GetTrapezoidShape(ssdchipcablestrapezoidvertex[i],
1509 ssdchipcablestrapezoidwidth,
d7599219 1510 fgkSSDChipCablesHeight[i],
44285dfa 1511 ssdchipcablestrapezoidshapename[i]);
1512 ssdchipcablestrapezoidbox[i] =
1513 new TGeoVolume(ssdchipcablestrapezoidboxname[i],
1514 ssdchipcablestrapezoidboxshape[i],
1515 (i==0?fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium));
1516 ssdchipcablestrapezoid[i] = new TGeoVolume(ssdhipcablestrapezoidname[i],
1517 ssdchipcablestrapezoidshape[i],
1518 (i==0?fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium));
1519 ssdchipcablestrapezoidbox[i]->SetLineColor(ssdchipcablescolor[i]);
1520 ssdchipcablestrapezoid[i]->SetLineColor(ssdchipcablescolor[i]);
1521 ssdchipcablestrapezoidassembly[i] =
1522 new TGeoVolumeAssembly(ssdchipcablestrapezoidassemblyname[i]);
1523 ssdchipcablestrapezoidassembly[i]->AddNode(ssdchipcablestrapezoidbox[i],1,
d7599219 1524 new TGeoTranslation(0.5*fgkSSDChipCablesLength[1],
1525 0.5*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2]),0.));
44285dfa 1526 ssdchipcablestrapezoidassembly[i]->AddNode(ssdchipcablestrapezoid[i],0,
d7599219 1527 new TGeoCombiTrans(0.,0.,0.,new TGeoRotation("",90.,180.,-90.)));
44285dfa 1528 ssdchipcablestrapezoidassembly[i]->AddNode(ssdchipcablestrapezoid[i],1,
d7599219 1529 new TGeoTranslation(fgkSSDChipCablesLength[1],0.,0.));
1530 }
1531 /////////////////////////////
1532 //Box and Tube Seg CombiTrans
1533 /////////////////////////////
44285dfa 1534 TGeoTranslation* ssdchipcablesboxtrans[2*kssdchipcableslaynumber];
1535 ssdchipcablesboxtrans[0] =
d7599219 1536 new TGeoTranslation("SSDChipCablesLay1Box1Trans",0.,0.,0.);
44285dfa 1537 ssdchipcablesboxtrans[1] =
d7599219 1538 new TGeoTranslation("SSDChipCablesLay1Box2Trans",
44285dfa 1539 ssdchipcablesboxshape[0][1]->GetDX()
1540 - 0.5*ssdchipcablespiecelength,
d7599219 1541 0.0,
44285dfa 1542 - 2.*ssdchipcablesradius[0]
d7599219 1543 - fgkSSDChipCablesHeight[0]);
44285dfa 1544 ssdchipcablesboxtrans[2] = new TGeoTranslation("SSDChipCablesLay2Box1Trans",
d7599219 1545 0.0,
1546 0.0,
1547 0.5*(fgkSSDChipCablesHeight[0]
1548 + fgkSSDChipCablesHeight[1]));
44285dfa 1549 ssdchipcablesboxtrans[3] =
d7599219 1550 new TGeoTranslation("SSDChipCablesLay2Box2Trans",
44285dfa 1551 ssdchipcablesboxshape[1][1]->GetDX()
1552 - 0.5*ssdchipcablespiecelength,
d7599219 1553 0.0,
44285dfa 1554 - 2.*ssdchipcablesradius[0]
d7599219 1555 - 0.5*fgkSSDChipCablesHeight[1]
1556 - 1.5*fgkSSDChipCablesHeight[0]);
44285dfa 1557 TGeoRotation* ssdchipcablesrot[3];
1558 ssdchipcablesrot[0] = new TGeoRotation("SSDChipCablesRot1",0.,90.,0.);
1559 ssdchipcablesrot[1] = new TGeoRotation("SSDChipCablesRot2",90.,90.,-90.);
1560 ssdchipcablesrot[2] = new TGeoRotation("SSDChipCablesRot3",90.,-90.,-90.);
1561 TGeoCombiTrans* ssdchipcablestubesegcombitrans[2*(kssdchipcableslaynumber+1)];
1562// TGeoCombiTrans* SSDChipCablesTubeSegCombiTrans[2*(SSDChipCablesLayNumber+
1563// (side=="Right" ? 0 : 1))];
1564 ssdchipcablestubesegcombitrans[0] =
d7599219 1565 new TGeoCombiTrans("SSDChipCablesLay1TubeSeg1CombiTrans",
44285dfa 1566 0.5*ssdchipcablespiecelength,
d7599219 1567 0.0,
44285dfa 1568 ssdchipcablesradius[0]
d7599219 1569 - 0.5*fgkSSDChipCablesHeight[0],
44285dfa 1570 new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0])));
1571 ssdchipcablestubesegcombitrans[1] =
d7599219 1572 new TGeoCombiTrans("SSDChipCablesLay1TubeSeg2CombiTrans",
44285dfa 1573 - 0.5*ssdchipcablespiecelength,
d7599219 1574 0.0,
44285dfa 1575 - ssdchipcablesradius[0]-0.5*fgkSSDChipCablesHeight[0],
1576 new TGeoRotation((*ssdchipcablesrot[2])*(*ssdchipcablesrot[0])));
1577 ssdchipcablestubesegcombitrans[2] =
d7599219 1578 new TGeoCombiTrans("SSDChipCablesLay2TubeSeg1CombiTrans",
44285dfa 1579 0.5*ssdchipcablespiecelength,
d7599219 1580 0.0,
44285dfa 1581 ssdchipcablesradius[0]-0.5*fgkSSDChipCablesHeight[0],
1582 new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0])));
1583 ssdchipcablestubesegcombitrans[3] =
d7599219 1584 new TGeoCombiTrans("SSDChipCablesLay2TubeSeg2CombiTrans",
44285dfa 1585 - 0.5*ssdchipcablespiecelength,
d7599219 1586 0.0,
44285dfa 1587 - ssdchipcablesradius[0]+0.5*fgkSSDChipCablesHeight[0]
d7599219 1588 - fgkSSDChipCablesHeight[0],
44285dfa 1589 new TGeoRotation((*ssdchipcablesrot[2])*(*ssdchipcablesrot[0])));
1590 ssdchipcablestubesegcombitrans[4] =
d7599219 1591 new TGeoCombiTrans("SSDChipCablesLay1TubeSeg4CombiTrans",
44285dfa 1592 0.5*ssdchipcablespiecelength+ssdchipcablesradius[0]
d7599219 1593 + fgkSSDModuleStiffenerPosition[1],
1594 0.0,
44285dfa 1595 - 2.*ssdchipcablesradius[0]-0.5*fgkSSDChipCablesHeight[0]
d7599219 1596 - (0.5*fgkSSDSensorHeight+fgkSSDChipCablesHeight[0]
1597 + fgkSSDChipCablesHeight[1]),
44285dfa 1598 new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0])));
1599 ssdchipcablestubesegcombitrans[5] =
d7599219 1600 new TGeoCombiTrans("SSDChipCablesLay2TubeSeg5CombiTrans",
44285dfa 1601 0.5*ssdchipcablespiecelength+ssdchipcablesradius[0]
d7599219 1602 + fgkSSDModuleStiffenerPosition[1],
1603 0.0,
44285dfa 1604 - 2.*ssdchipcablesradius[0]-0.5*fgkSSDChipCablesHeight[0]
d7599219 1605 - (0.5*fgkSSDSensorHeight+fgkSSDChipCablesHeight[0]
1606 + fgkSSDChipCablesHeight[1]),
44285dfa 1607 new TGeoRotation((*ssdchipcablesrot[1])*(*ssdchipcablesrot[0])));
1608 TGeoCombiTrans* ssdchipcablestrapezoidcombitrans[kssdchipcableslaynumber];
1609 ssdchipcablestrapezoidcombitrans[0] = (side=="Right" ?
d7599219 1610 new TGeoCombiTrans("SSDChipCableLay1TrapezoidRightCombiTrans",
44285dfa 1611 0.5*ssdchipcablespiecelength+ssdchipcablestrapezoidwidth[0]
1612 + ssdchipcablesradius[0],
d7599219 1613 - 0.5*fgkSSDChipCablesLength[1],
44285dfa 1614 - fgkSSDChipCablesHeight[0]-2.*ssdchipcablesradius[0],
d7599219 1615 new TGeoRotation("",90.,0.,0.)) :
1616 new TGeoCombiTrans("SSDChipCableLay1TrapezoidLeftCombiTrans",
1617 - 2.*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2])
44285dfa 1618 + 0.5*ssdchipcablespiecelength+ssdchipcablestrapezoidwidth[0]
1619 + ssdchipcablesradius[0]+fgkSSDModuleStiffenerPosition[1],
d7599219 1620 0.5*fgkSSDChipCablesLength[1],
1621 - 2.*(fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1])
44285dfa 1622 - 2.*ssdchipcablesradius[0]-fgkSSDSensorHeight,
d7599219 1623 new TGeoRotation("",-90.,0.,0.)));
44285dfa 1624 ssdchipcablestrapezoidcombitrans[1] = (side=="Right" ?
d7599219 1625 new TGeoCombiTrans("SSDChipCableLay2TrapezoidRightCombiTrans",
44285dfa 1626 0.5*ssdchipcablespiecelength+ssdchipcablestrapezoidwidth[0]
1627 + ssdchipcablesradius[0],
d7599219 1628 - 0.5*fgkSSDChipCablesLength[1],
1629 - 0.5*(fgkSSDChipCablesHeight[0]+fgkSSDChipCablesHeight[1])
44285dfa 1630 - fgkSSDChipCablesHeight[0]-2.*ssdchipcablesradius[0],
d7599219 1631 new TGeoRotation("",90.,0.,0.)) :
1632 new TGeoCombiTrans("SSDChipCableLay2TrapezoidLeftCombiTrans",
1633 - 2.*(fgkSSDChipCablesWidth[1]+fgkSSDChipCablesWidth[2])
44285dfa 1634 + 0.5*ssdchipcablespiecelength+ssdchipcablestrapezoidwidth[0]
1635 + ssdchipcablesradius[0]+fgkSSDModuleStiffenerPosition[1],
d7599219 1636 0.5*fgkSSDChipCablesLength[1],-0.5*(fgkSSDChipCablesHeight[0]
1637 + fgkSSDChipCablesHeight[1])-fgkSSDChipCablesHeight[1]
44285dfa 1638 - fgkSSDChipCablesHeight[0]-2.*ssdchipcablesradius[0]
d7599219 1639 - fgkSSDSensorHeight,new TGeoRotation("",-90.,0.,0.)));
1640 //////////////////////////
1641 //Box and Tube Seg Volumes
1642 //////////////////////////
44285dfa 1643 char* ssdchipcablesboxname[2*kssdchipcableslaynumber] =
d7599219 1644 {"SSDChipCablesLay1Box1","SSDChipCablesLay1Box2",
1645 "SSDChipCablesLay2Box1","SSDChipCablesLay2Box2"};
44285dfa 1646 char* ssdchiprightcablestubesegname[2*kssdchipcableslaynumber] =
d7599219 1647 {"SSDChipRightCablesLay1TubeSeg1","SSDChipRightCablesLay1TubeSeg2",
1648 "SSDChipRightCablesLay2TubeSeg1","SSDChipRightCablesLay2TubeSeg2"};
44285dfa 1649 char* ssdchipLeftcablestubesegname[2*kssdchipcableslaynumber] =
d7599219 1650 {"SSDChipLeftCablesLay1TubeSeg1","SSDChipLeftCablesLay1TubeSeg2",
1651 "SSDChipLeftCablesLay2TubeSeg1","SSDChipLeftCablesLay2TubeSeg2"};
44285dfa 1652 char* ssdchipcableslayassemblyname[kssdchipcableslaynumber] =
d7599219 1653 {"SSDChipCablesLay1","SSDChipCablesLay2"};
44285dfa 1654 TGeoVolume** ssdchipcablesbox[kssdchipcableslaynumber];
1655 TGeoVolume** ssdchipcablestubeseg[kssdchipcableslaynumber];
1656 TGeoVolume* ssdchipcableslayassembly[kssdchipcableslaynumber];
1657 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
1658 TGeoMedium* ssdchipcableslaymed =
1659 (i==0?fSSDAlTraceChipCableMedium:fSSDKaptonChipCableMedium);
1660 ssdchipcablesbox[i] = new TGeoVolume*[2];
1661 ssdchipcablestubeseg[i] = new TGeoVolume*[2+(side=="Right" ? 0 : 1)];
1662 ssdchipcablesbox[i][0] = new TGeoVolume(ssdchipcablesboxname[2*i],
1663 ssdchipcablesboxshape[i][0],ssdchipcableslaymed);
1664 ssdchipcablesbox[i][1] = new TGeoVolume(ssdchipcablesboxname[2*i+1],
1665 ssdchipcablesboxshape[i][1],ssdchipcableslaymed);
1666 ssdchipcablestubeseg[i][0] = new TGeoVolume(ssdchiprightcablestubesegname[2*i],
1667 ssdchipcablestubesegshape[i][0],ssdchipcableslaymed);
1668 ssdchipcablestubeseg[i][1] = new TGeoVolume(ssdchiprightcablestubesegname[2*i+1],
1669 ssdchipcablestubesegshape[i][1],ssdchipcableslaymed);
1670 ssdchipcablesbox[i][0]->SetLineColor(ssdchipcablescolor[i]);
1671 ssdchipcablesbox[i][1]->SetLineColor(ssdchipcablescolor[i]);
1672 ssdchipcablestubeseg[i][0]->SetLineColor(ssdchipcablescolor[i]);
1673 ssdchipcablestubeseg[i][1]->SetLineColor(ssdchipcablescolor[i]);
1674 ssdchipcableslayassembly[i] = new TGeoVolumeAssembly(ssdchipcableslayassemblyname[i]);
1675 ssdchipcableslayassembly[i]->AddNode(ssdchipcablesbox[i][0],1,
1676 ssdchipcablesboxtrans[2*i]);
1677 ssdchipcableslayassembly[i]->AddNode(ssdchipcablesbox[i][1],1,
1678 ssdchipcablesboxtrans[2*i+1]);
1679 ssdchipcableslayassembly[i]->AddNode(ssdchipcablestubeseg[i][0],1,
1680 ssdchipcablestubesegcombitrans[2*i]);
1681 ssdchipcableslayassembly[i]->AddNode(ssdchipcablestubeseg[i][1],1,
1682 ssdchipcablestubesegcombitrans[2*i+1]);
d7599219 1683 if(side!="Right"){
44285dfa 1684 ssdchipcablestubeseg[i][2] = new TGeoVolume(ssdchipLeftcablestubesegname[2*i],
1685 ssdchipcablestubesegshape[i][2],
1686 ssdchipcableslaymed);
1687 ssdchipcablestubeseg[i][2]->SetLineColor(ssdchipcablescolor[i]);
1688 ssdchipcableslayassembly[i]->AddNode(ssdchipcablestubeseg[i][2],1,
1689 ssdchipcablestubesegcombitrans[4+i]);
d7599219 1690 }
44285dfa 1691 ssdchipcableslayassembly[i]->AddNode(ssdchipcablestrapezoidassembly[i],1,
1692 ssdchipcablestrapezoidcombitrans[i]);
d7599219 1693 }
44285dfa 1694 TGeoCombiTrans* ssdchipcablescombitrans[kssdchipcableslaynumber];
1695 ssdchipcablescombitrans[0] = new TGeoCombiTrans("SSDChipCablesCombiTrans1",
1696 (side=="Right" ? -1 : 1)*0.5*ssdchipcablespiecelength,
d7599219 1697 0.5*fgkSSDChipCablesLength[0],
44285dfa 1698 - (2.*ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0]
d7599219 1699 - 0.5*fgkSSDChipCablesHeight[1]),
1700 new TGeoRotation("",(side=="Right" ? 0 : 1)*180.,0.,0.));
44285dfa 1701 ssdchipcablescombitrans[1] = new TGeoCombiTrans("SSDChipCablesCombiTrans2",
1702 (side=="Right" ? -1 : 1)*0.5*ssdchipcablespiecelength,
d7599219 1703 0.5*fgkSSDChipCablesLength[0],
44285dfa 1704 - (2.*ssdchipcablesradius[0]-fgkSSDChipCablesHeight[0]
d7599219 1705 - 0.5*fgkSSDChipCablesHeight[1]),
1706 new TGeoRotation("",(side=="Right" ? 0 : 1)*180.,0.,0.));
44285dfa 1707 TGeoVolume* ssdchipcablesassembly =
d7599219 1708 new TGeoVolumeAssembly("SSDChipCables");
44285dfa 1709 for(Int_t i=0; i<kssdchipcableslaynumber; i++){
1710 ssdchipcablesassembly->AddNode(ssdchipcableslayassembly[i],1,
1711 ssdchipcablescombitrans[i]);
1712 ssdchipcablesassembly->AddNode(ssdunderchipcablesbox[i],1,ssdunderchipcablesboxtrans[i]);
d7599219 1713 }
44285dfa 1714 return ssdchipcablesassembly;
d7599219 1715}
1716/////////////////////////////////////////////////////////////////////////////////
1717TGeoVolume* AliITSv11GeometrySSD::GetSSDChipCablesAssembly(Double_t SSDChipCablesHeigth){
44285dfa 1718 /////////////////////////////////////////////////////////////
1719 // Method generating SSD Chip Cables Assembly
1720 /////////////////////////////////////////////////////////////
1721 const Int_t kchipcablesnumber = 2;
1722 Double_t chipcablestransvector = fgkSSDSensorLength
d7599219 1723 - 2.*fgkSSDModuleStiffenerPosition[1]
1724 - 2.*(fgkSSDStiffenerWidth
1725 - fgkSSDStiffenerToChipDist-fgkSSDChipWidth);
44285dfa 1726 char* ssdchipcablesname[kchipcablesnumber] = {"Right","Left"};
1727 TGeoVolume* ssdchipcables[kchipcablesnumber];
1728 TGeoVolume* ssdchipcablesassembly =
d7599219 1729 new TGeoVolumeAssembly("SSDChipCablesAssembly");
44285dfa 1730 for(Int_t i=0; i<kchipcablesnumber; i++) ssdchipcables[i] =
1731 GetSSDChipCables(SSDChipCablesHeigth,ssdchipcablesname[i]);
1732 for(Int_t i=0; i<kchipcablesnumber; i++)
d7599219 1733 for(Int_t j=0; j<fgkSSDChipNumber; j++)
44285dfa 1734 ssdchipcablesassembly->AddNode(ssdchipcables[i],fgkSSDChipNumber*i+j+1,
1735 new TGeoTranslation(-(ssdchipcablesname[i]=="Left" ? 1. : 0.)
1736 * chipcablestransvector,(j-0.5)*fgkSSDChipCablesLength[0]
d7599219 1737 + 0.5*fgkSSDChipCablesLength[1],0.));
44285dfa 1738 return ssdchipcablesassembly;
d7599219 1739}
1740/////////////////////////////////////////////////////////////////////////////////
44285dfa 1741TGeoVolume* AliITSv11GeometrySSD::GetSSDFlex(Double_t ssdflexradius, Double_t SSDFlexHeigth){
1742 /////////////////////////////////////////////////////////////
1743 // Method generating SSD Flex
1744 /////////////////////////////////////////////////////////////
1745 const Int_t kssdflexvolumenumber = 3;
1746 TGeoVolume* ssdflexvolume[kssdflexvolumenumber];
d7599219 1747 ////////////////////////
1748 // Setting Display Color
1749 ////////////////////////
44285dfa 1750 Int_t ssdflexcolor;
1751 ssdflexcolor = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fColorAl: fColorPolyhamide);
1752 TGeoMedium* ssdflexmed = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fSSDAlTraceFlexMedium :
1753 fSSDKaptonFlexMedium);
d7599219 1754 ////////////////////////
1755 // SSDFlexTrapezoidShape
1756 ////////////////////////
44285dfa 1757 const Int_t kssdflexvertexnumber = 2;
1758 Double_t ssdflexwidth[kssdflexvertexnumber] = {fgkSSDFlexWidth[1],
d7599219 1759 fgkSSDFlexWidth[0]};
44285dfa 1760 TVector3* ssdflexvertex[kssdflexvertexnumber];
1761 ssdflexvertex[0] = new TVector3();
1762 ssdflexvertex[1] = new TVector3(fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
1763 TGeoArb8* ssdflextrapezoidshape = GetTrapezoidShape(ssdflexvertex,
1764 ssdflexwidth,SSDFlexHeigth,
d7599219 1765 "SSDFlexTrapezoidShape");
44285dfa 1766 ssdflexvolume[0] = new TGeoVolume("SSDFlexTrapezoid",ssdflextrapezoidshape,ssdflexmed);
1767 ssdflexvolume[0]->SetLineColor(ssdflexcolor);
d7599219 1768 /////////////////////////
1769 //SSDFlexTubeSeg Assembly
1770 /////////////////////////
44285dfa 1771 const Int_t kssdflextubesegnumber = 2;
1772 TGeoTubeSeg* ssdflextubesegshape[kssdflextubesegnumber];
1773 Double_t ssdflexradiusmax = (fgkSSDFlexLength[3]-fgkSSDFlexLength[2])
d7599219 1774 / TMath::Tan(fgkSSDFlexAngle*TMath::DegToRad());
44285dfa 1775 ssdflextubesegshape[0] = new TGeoTubeSeg("SSDFlexTubeSegShape1",
1776 ssdflexradius,ssdflexradius+SSDFlexHeigth,
d7599219 1777 0.5*fgkSSDFlexWidth[0],0.,180.);
44285dfa 1778 ssdflextubesegshape[1] = new TGeoTubeSeg("SSDFlexTubeSegShape2",
1779 ssdflexradiusmax-ssdflexradius-SSDFlexHeigth,
1780 ssdflexradiusmax-ssdflexradius,0.5*fgkSSDFlexWidth[0],
d7599219 1781 0.,2.*fgkSSDFlexAngle);
44285dfa 1782 TGeoRotation** ssdflextubsegrot[kssdflextubesegnumber];
1783 for(Int_t i = 0; i<kssdflextubesegnumber; i++)
1784 ssdflextubsegrot[i] = new TGeoRotation*[2];
1785 ssdflextubsegrot[0][0] = new TGeoRotation("SSDFlexTubeSeg1Rot1", 0., 90., 0.);
1786 ssdflextubsegrot[0][1] = new TGeoRotation("SSDFlexTubeSeg1Rot2",90., 90.,-90.);
1787 ssdflextubsegrot[1][0] = new TGeoRotation("SSDFlexTubeSeg2Rot1", 0.,-90., 0.);
1788 ssdflextubsegrot[1][1] = new TGeoRotation("SSDFlexTubeSeg2Rot2",90., 90.,-90.);
1789 TGeoCombiTrans* ssdflextubesegcombitrans[kssdflextubesegnumber];
1790 ssdflextubesegcombitrans[0] = new TGeoCombiTrans("SSDFlexTubeSegCombiTrans1",
d7599219 1791 fgkSSDFlexLength[0],0.5*fgkSSDFlexWidth[0],
44285dfa 1792 ssdflexradius+0.5*SSDFlexHeigth,
1793 new TGeoRotation((*ssdflextubsegrot[0][1])
1794 * (*ssdflextubsegrot[0][0])));
1795 ssdflextubesegcombitrans[1] = new TGeoCombiTrans("SSDFlexTubeSegCombiTrans2",
d7599219 1796 fgkSSDFlexLength[0]-fgkSSDFlexLength[2],
1797 0.5*fgkSSDFlexWidth[0],
44285dfa 1798 ssdflexradiusmax+0.5*SSDFlexHeigth+ssdflexradius,
1799 new TGeoRotation((*ssdflextubsegrot[1][1])
1800 * (*ssdflextubsegrot[1][0])));
1801 ssdflexvolume[1] = new TGeoVolumeAssembly("SSDFlexTubeSegAssembly");
1802 TGeoVolume* ssdflextubeseg[kssdflextubesegnumber];
1803 char ssdflextubesegname[30];
1804 for(Int_t i=0; i<kssdflextubesegnumber; i++){
1805 sprintf(ssdflextubesegname,"SSDFlexTubeSeg%i",i+1);
1806 ssdflextubeseg[i] = new TGeoVolume(ssdflextubesegname,ssdflextubesegshape[i],
1807 ssdflexmed);
1808 ssdflextubeseg[i]->SetLineColor(ssdflexcolor);
1809 ssdflexvolume[1]->AddNode(ssdflextubeseg[i],1,ssdflextubesegcombitrans[i]);
d7599219 1810 }
1811 ///////////
1812 //Box Shape
1813 ///////////
44285dfa 1814 const Int_t kssdflexboxnumber = 7;
1815 Double_t ssdflexboxlength[kssdflexboxnumber];
1816 ssdflexboxlength[0] = 0.5*(fgkSSDChipNumber
d7599219 1817 * fgkSSDChipLength+(fgkSSDChipNumber-1)
1818 * fgkSSDChipSeparationLength
1819 - fgkSSDModuleSensorSupportDistance-fgkSSDFlexHoleLength)
1820 - (fgkSSDFlexLength[0]-fgkSSDFlexLength[1]);
44285dfa 1821 ssdflexboxlength[1] = fgkSSDModuleSensorSupportDistance+fgkSSDFlexHoleLength;
1822 ssdflexboxlength[2] = 0.5*(fgkSSDModuleSensorSupportDistance
d7599219 1823 - fgkSSDFlexHoleLength-fgkSSDFlexHoleWidth);
44285dfa 1824 ssdflexboxlength[3] = fgkSSDFlexHoleWidth;
1825 ssdflexboxlength[4] = fgkSSDFlexLength[1]-ssdflexboxlength[0]
1826 - ssdflexboxlength[1];
1827 ssdflexboxlength[5] = fgkSSDFlexLength[2];
1828 ssdflexboxlength[6] = fgkSSDFlexFullLength-2.*fgkSSDFlexAngle
1829 * TMath::DegToRad()*ssdflexradiusmax
d7599219 1830 - fgkSSDFlexLength[2]-TMath::Pi()
1831 * fgkSSDStiffenerHeight-fgkSSDFlexLength[0];
44285dfa 1832 Double_t ssdflexboxwidth[kssdflexboxnumber];
1833 ssdflexboxwidth[0] = fgkSSDFlexWidth[0];
1834 ssdflexboxwidth[1] = fgkSSDFlexWidth[0]-fgkSSDFlexHoleWidth;
1835 ssdflexboxwidth[2] = fgkSSDFlexHoleWidth;
1836 ssdflexboxwidth[3] = ssdflexboxwidth[2]-fgkSSDFlexHoleLength;
1837 ssdflexboxwidth[4] = fgkSSDFlexWidth[0];
1838 ssdflexboxwidth[5] = fgkSSDFlexWidth[0];
1839 ssdflexboxwidth[6] = fgkSSDFlexWidth[0];
1840 TGeoBBox* ssdflexboxshape[kssdflexboxnumber+1];
1841 for(Int_t i=0; i<kssdflexboxnumber+1; i++) ssdflexboxshape[i] =
1842 (i!= kssdflexboxnumber ? new TGeoBBox("SSDFlexBoxShape",
1843 0.5*ssdflexboxlength[i],
1844 0.5*ssdflexboxwidth[i],0.5*SSDFlexHeigth) :
1845 ssdflexboxshape[2]);
d7599219 1846 //////////////////////////////
1847 //SSDFlex Box Shape CombiTrans
1848 //////////////////////////////
44285dfa 1849 TGeoCombiTrans* ssdflexboxcombitrans[kssdflexboxnumber+1];
1850 ssdflexboxcombitrans[0] = new TGeoCombiTrans("SSDFlexBoxCombiTrans0",
1851 ssdflexvertex[1]->X()+0.5*ssdflexboxlength[0],
d7599219 1852 0.5*fgkSSDFlexWidth[0],0.,0);
44285dfa 1853 ssdflexboxcombitrans[1] = new TGeoCombiTrans("SSDFlexBoxCombiTrans1",
1854 ssdflexvertex[1]->X()+ssdflexboxlength[0]
1855 + 0.5*ssdflexboxlength[1],
1856 fgkSSDFlexHoleWidth+0.5*ssdflexboxwidth[1],0.,0);
1857 ssdflexboxcombitrans[2] = new TGeoCombiTrans("SSDFlexBoxCombiTrans2",
1858 ssdflexvertex[1]->X()+ssdflexboxlength[0]
1859 + fgkSSDFlexHoleLength+0.5*ssdflexboxlength[2],
1860 0.5*ssdflexboxwidth[2],0.,0);
1861 ssdflexboxcombitrans[3] = new TGeoCombiTrans("SSDFlexBoxCombiTrans3",
1862 ssdflexvertex[1]->X()+ssdflexboxlength[0]
1863 + fgkSSDFlexHoleLength+ssdflexboxlength[2]
d7599219 1864 + 0.5*fgkSSDFlexHoleWidth,
44285dfa 1865 fgkSSDFlexHoleLength+0.5*ssdflexboxwidth[3],0.,0);
1866 ssdflexboxcombitrans[4] = new TGeoCombiTrans("SSDFlexBoxCombiTrans4",
1867 ssdflexvertex[1]->X()+ssdflexboxlength[0]
1868 + ssdflexboxlength[1]+0.5*ssdflexboxlength[4],
d7599219 1869 0.5*fgkSSDFlexWidth[0],0.,0);
44285dfa 1870 ssdflexboxcombitrans[5] = new TGeoCombiTrans("SSDFlexBoxCombiTrans5",
d7599219 1871 - 0.5*fgkSSDFlexLength[2]+fgkSSDFlexLength[0],
1872 0.5*fgkSSDFlexWidth[0],
44285dfa 1873 2.*ssdflexradius+SSDFlexHeigth,0);
1874 ssdflexboxcombitrans[6] = new TGeoCombiTrans("SSDFlexBoxCombiTrans6",
1875 - ssdflexboxshape[6]->GetDX()
1876 + ssdflexboxshape[6]->GetDX()
d7599219 1877 * TMath::Cos(2.*fgkSSDFlexAngle*TMath::DegToRad())
1878 + fgkSSDFlexLength[0]-fgkSSDFlexLength[2]
44285dfa 1879 - (ssdflexradiusmax-ssdflexradius-0.5*SSDFlexHeigth)
d7599219 1880 * TMath::Cos(fgkSSDFlexAngle*TMath::DegToRad()),
44285dfa 1881 0.5*fgkSSDFlexWidth[0],ssdflexboxshape[6]->GetDX()
d7599219 1882 *TMath::Sin(2.*fgkSSDFlexAngle*TMath::DegToRad())
44285dfa 1883 + SSDFlexHeigth+2.*ssdflexradius+(ssdflexradiusmax
1884 - ssdflexradius-0.5*SSDFlexHeigth)
d7599219 1885 * TMath::Sin(fgkSSDFlexAngle*TMath::DegToRad()),
1886 new TGeoRotation("",90.,2.*fgkSSDFlexAngle,-90.));
44285dfa 1887 ssdflexboxcombitrans[7] = new TGeoCombiTrans("SSDFlexBoxCombiTrans7",
1888 ssdflexvertex[1]->X()+ssdflexboxlength[0]
1889 + fgkSSDFlexHoleLength+1.5*ssdflexboxlength[2]
1890 + ssdflexboxlength[3],
1891 0.5*ssdflexboxwidth[2],0.,0);
d7599219 1892 ////////////////////////////
1893 //SSDFlex Box Shape Assembly
1894 ////////////////////////////
44285dfa 1895 ssdflexvolume[2] = new TGeoVolumeAssembly("SSDFlexBoxAssembly");
1896 TGeoVolume* ssdflexbox[kssdflexboxnumber+1];
1897 TGeoVolume* ssdendflex = GetSSDEndFlex(ssdflexboxlength[6],SSDFlexHeigth);
1898 TGeoHMatrix* ssdendflexhmatrix = new TGeoHMatrix();
1899 TGeoRotation* ssdendflexrot = new TGeoRotation("SSDEndFlexRot",180.,0.,0);
1900 ssdendflexhmatrix->MultiplyLeft(ssdendflexrot);
1901 ssdendflexhmatrix->MultiplyLeft(ssdflexboxcombitrans[6]);
1902 char ssdflexboxname[30];
1903 for(Int_t i=0; i<kssdflexboxnumber+1; i++){
1904 sprintf(ssdflexboxname,"SSDFlexBox%i",i!=kssdflexboxnumber?i+1:7);
1905 if(i==6){ssdflexvolume[2]->AddNode(ssdendflex,1,ssdendflexhmatrix);}
d7599219 1906 else{
44285dfa 1907 ssdflexbox[i] = new TGeoVolume(ssdflexboxname,ssdflexboxshape[i],
1908 ssdflexmed);
1909 ssdflexbox[i]->SetLineColor(ssdflexcolor);
1910 ssdflexvolume[2]->AddNode(ssdflexbox[i],1,ssdflexboxcombitrans[i]);}
d7599219 1911 }
1912 //////////////////////
1913 //SSDFlex Construction
1914 //////////////////////
44285dfa 1915 TGeoVolume* ssdflex = new TGeoVolumeAssembly("SSDFlex");
1916 for(Int_t i =0; i<kssdflexvolumenumber; i++) ssdflex->AddNode(ssdflexvolume[i],1);
1917 return ssdflex;
d7599219 1918}
1919/////////////////////////////////////////////////////////////////////////////////
1920TGeoVolume* AliITSv11GeometrySSD::GetSSDEndFlex(Double_t SSDEndFlexLength,
1921 Double_t SSDFlexHeigth){
44285dfa 1922 /////////////////////////////////////////////////////////////
1923 // Method generating SSD End Flex
d7599219 1924 /////////////////////////////////////////
1925 // Setting Display Color, Media and Index
1926 /////////////////////////////////////////
44285dfa 1927 Int_t ssdflexcolor;
1928 ssdflexcolor = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fColorAl: fColorPolyhamide);
1929 TGeoMedium* ssdflexmed = (SSDFlexHeigth == fgkSSDFlexHeight[0] ? fSSDAlTraceFlexMedium :
1930 fSSDKaptonFlexMedium);
d7599219 1931 ////////////////////////
44285dfa 1932 const Int_t kssdendflexboxnumber = 5;
1933 TGeoBBox* ssdendflexbboxshape[kssdendflexboxnumber];
1934 ssdendflexbboxshape[0] = new TGeoBBox("SSDFlexBoxShape1",
d7599219 1935 0.5*SSDEndFlexLength,0.5*fgkSSDFlexWidth[0],
1936 0.5*SSDFlexHeigth);
44285dfa 1937 ssdendflexbboxshape[1] = new TGeoBBox("SSDFlexBoxShape2",
d7599219 1938 0.5*fgkSSDEndFlexCompLength[1],
1939 0.5*(fgkSSDEndFlexCompWidth[0]-fgkSSDFlexWidth[0])/2,
1940 0.5*SSDFlexHeigth);
44285dfa 1941 ssdendflexbboxshape[2] = new TGeoBBox("SSDFlexBoxShape3",
d7599219 1942 0.5*fgkSSDEndFlexCompLength[2],
1943 0.5*(fgkSSDEndFlexCompWidth[1]-fgkSSDFlexWidth[0])/2,
1944 0.5*SSDFlexHeigth);
44285dfa 1945 ssdendflexbboxshape[3] = new TGeoBBox("SSDFlexBoxShape4",
d7599219 1946 0.5*fgkSSDEndFlexCompLength[3],
1947 0.5*(fgkSSDEndFlexCompWidth[0]-fgkSSDFlexWidth[0])/2,
1948 0.5*SSDFlexHeigth);
44285dfa 1949 ssdendflexbboxshape[4] = new TGeoBBox("SSDFlexBoxShape5",
d7599219 1950 0.5*(fgkSSDEndFlexCompLength[4]+fgkSSDEndFlexCompLength[5]),
1951 0.25*(fgkSSDEndFlexCompWidth[2]-fgkSSDFlexWidth[0])/2,
1952 0.5*SSDFlexHeigth);
44285dfa 1953 TGeoVolume* ssdendflexbbox[kssdendflexboxnumber];
1954 char ssdendflexbboxname[30];
1955 for(Int_t i=0; i<kssdendflexboxnumber; i++){
1956 sprintf(ssdendflexbboxname,"SSDEndFlexBBox%i",i+1);
1957 ssdendflexbbox[i] = new TGeoVolume(ssdendflexbboxname,
1958 ssdendflexbboxshape[i],
1959 ssdflexmed);
1960 ssdendflexbbox[i]->SetLineColor(ssdflexcolor);
d7599219 1961 }
44285dfa 1962 TGeoVolume* ssdendflex = new TGeoVolumeAssembly("SSDEndFlex");
1963 Double_t partialsumlength = 0.;
1964 for(Int_t i=0; i<kssdendflexboxnumber+1; i++) partialsumlength += fgkSSDEndFlexCompLength[i];
1965 Double_t referencelength = SSDEndFlexLength-partialsumlength;
1966 ssdendflex->AddNode(ssdendflexbbox[0],1);
1967 ssdendflex->AddNode(ssdendflexbbox[1],1,new TGeoTranslation(
1968 - 0.5*SSDEndFlexLength+referencelength+fgkSSDEndFlexCompLength[0]
d7599219 1969 + 0.5*fgkSSDEndFlexCompLength[1],
44285dfa 1970 0.5*fgkSSDFlexWidth[0]+ssdendflexbboxshape[1]->GetDY(),
d7599219 1971 0.));
44285dfa 1972 ssdendflex->AddNode(ssdendflexbbox[1],2,new TGeoTranslation(
1973 - 0.5*SSDEndFlexLength+referencelength+fgkSSDEndFlexCompLength[0]
d7599219 1974 + 0.5*fgkSSDEndFlexCompLength[1],
44285dfa 1975 - 0.5*fgkSSDFlexWidth[0]-ssdendflexbboxshape[1]->GetDY(),
d7599219 1976 0.));
44285dfa 1977 ssdendflex->AddNode(ssdendflexbbox[2],1,new TGeoTranslation(
1978 - 0.5*SSDEndFlexLength+referencelength+fgkSSDEndFlexCompLength[0]
d7599219 1979 + fgkSSDEndFlexCompLength[1]+0.5*fgkSSDEndFlexCompLength[2],
44285dfa 1980 + 0.5*fgkSSDFlexWidth[0]+ssdendflexbboxshape[2]->GetDY(),
d7599219 1981 0.));
44285dfa 1982 ssdendflex->AddNode(ssdendflexbbox[2],2,new TGeoTranslation(
1983 - 0.5*SSDEndFlexLength+referencelength+fgkSSDEndFlexCompLength[0]
d7599219 1984 + fgkSSDEndFlexCompLength[1]+0.5*fgkSSDEndFlexCompLength[2],
44285dfa 1985 - 0.5*fgkSSDFlexWidth[0]-ssdendflexbboxshape[2]->GetDY(),
d7599219 1986 0.));
44285dfa 1987 ssdendflex->AddNode(ssdendflexbbox[3],1,new TGeoTranslation(
1988 - 0.5*SSDEndFlexLength+referencelength+fgkSSDEndFlexCompLength[0]
d7599219 1989 + fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
1990 + 0.5*fgkSSDEndFlexCompLength[3],
44285dfa 1991 + 0.5*fgkSSDFlexWidth[0]+ssdendflexbboxshape[3]->GetDY(),
d7599219 1992 0.));
44285dfa 1993 ssdendflex->AddNode(ssdendflexbbox[3],2,new TGeoTranslation(
1994 - 0.5*SSDEndFlexLength+referencelength+fgkSSDEndFlexCompLength[0]
d7599219 1995 + fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
1996 + 0.5*fgkSSDEndFlexCompLength[3],
44285dfa 1997 - 0.5*fgkSSDFlexWidth[0]-ssdendflexbboxshape[3]->GetDY(),
d7599219 1998 0.));
44285dfa 1999 ssdendflex->AddNode(ssdendflexbbox[4],1,new TGeoTranslation(
2000 - 0.5*SSDEndFlexLength+referencelength+fgkSSDEndFlexCompLength[0]
d7599219 2001 + fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
2002 + fgkSSDEndFlexCompLength[3]+0.5*(fgkSSDEndFlexCompLength[4]+fgkSSDEndFlexCompLength[5]),
44285dfa 2003 + 0.5*fgkSSDFlexWidth[0]+ssdendflexbboxshape[4]->GetDY(),
d7599219 2004 0.));
44285dfa 2005 ssdendflex->AddNode(ssdendflexbbox[4],2,new TGeoTranslation(
2006 - 0.5*SSDEndFlexLength+referencelength+fgkSSDEndFlexCompLength[0]
d7599219 2007 + fgkSSDEndFlexCompLength[1]+fgkSSDEndFlexCompLength[2]
2008 + fgkSSDEndFlexCompLength[3]+0.5*(fgkSSDEndFlexCompLength[4]
2009 + fgkSSDEndFlexCompLength[5]),
44285dfa 2010 - 0.5*fgkSSDFlexWidth[0]-ssdendflexbboxshape[4]->GetDY(),
d7599219 2011 0.));
44285dfa 2012 return ssdendflex;
d7599219 2013}
2014/////////////////////////////////////////////////////////////////////////////////
2015TGeoVolume* AliITSv11GeometrySSD::GetSSDFlexAssembly(){
44285dfa 2016 /////////////////////////////////////////////////////////////
2017 // Method generating SSD Flex Assembly
2018 /////////////////////////////////////////////////////////////
2019 TGeoVolume* ssdflexassembly = new TGeoVolumeAssembly("SSDFlexAssembly");
2020 const Int_t kssdflexlayernumber = 4;
2021 Double_t ssdflexheight[kssdflexlayernumber];
2022 Double_t ssdflexradius[kssdflexlayernumber];
2023 TGeoTranslation* ssdflextrans[kssdflexlayernumber];
2024 for(Int_t i=0; i<kssdflexlayernumber; i++){
2025 ssdflexheight[i] = (i%2==0 ? fgkSSDFlexHeight[0] : fgkSSDFlexHeight[1]);
2026 ssdflexradius[i] = (i==0 ? fgkSSDStiffenerHeight : ssdflexradius[i-1]
2027 + ssdflexheight[i-1]);
2028 ssdflextrans[i] = new TGeoTranslation(0.,0.,-0.5*i*(ssdflexheight[0]
2029 + ssdflexheight[1]));
2030 ssdflexassembly->AddNode(GetSSDFlex(ssdflexradius[i],ssdflexheight[i]),i+1,
2031 ssdflextrans[i]);
d7599219 2032 }
44285dfa 2033 return ssdflexassembly;
d7599219 2034}
2035/////////////////////////////////////////////////////////////////////////////////
2036TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlockAssembly(){
44285dfa 2037 /////////////////////////////////////////////////////////////
2038 // Method generating SSD Cooling Block Assembly
2039 /////////////////////////////////////////////////////////////
2040 const Int_t kssdcoolingblocktransnumber = 2;
2041 Double_t ssdcoolingblocktransvector[kssdcoolingblocktransnumber] =
d7599219 2042 {fgkSSDModuleSensorSupportDistance+fgkSSDCoolingBlockLength,
2043 fgkSSDSensorLength-2.*fgkSSDModuleStiffenerPosition[1]
2044 - fgkSSDCoolingBlockWidth};
44285dfa 2045 TGeoVolume* ssdcoolingblock = GetSSDCoolingBlock();
2046 TGeoVolume* ssdcoolingblockassembly =
d7599219 2047 new TGeoVolumeAssembly("SSDCoolingBlockAssembly");
44285dfa 2048 for(Int_t i=0; i<kssdcoolingblocktransnumber; i++)
2049 for(Int_t j=0; j<kssdcoolingblocktransnumber; j++)
2050 ssdcoolingblockassembly->AddNode(ssdcoolingblock,
2051 kssdcoolingblocktransnumber*i+j+1,
2052 new TGeoTranslation(i*ssdcoolingblocktransvector[0],
2053 j*ssdcoolingblocktransvector[1],0.));
2054 return ssdcoolingblockassembly;
d7599219 2055}
2056/////////////////////////////////////////////////////////////////////////////////
2057TGeoVolume* AliITSv11GeometrySSD::GetSSDCoolingBlock(){
44285dfa 2058 /////////////////////////////////////////////////////////////
2059 // Method generating SSD Cooling Block
2060 /////////////////////////////////////////////////////////////
d7599219 2061 // Center Cooling Block Hole
2062 ////////////////////////////
44285dfa 2063 Double_t coolingblockholeangle = TMath::ACos(0.5*fgkSSDCoolingBlockHoleLength[0]
d7599219 2064 /fgkSSDCoolingBlockHoleRadius[0])*TMath::RadToDeg();
44285dfa 2065 Double_t coolingblockholewidth = fgkSSDCoolingBlockWidth;
2066 new TGeoTubeSeg("CoolingBlockHoleShape",
d7599219 2067 0.,
2068 fgkSSDCoolingBlockHoleRadius[0],
44285dfa 2069 0.5*coolingblockholewidth,
2070 180.-coolingblockholeangle,360.+coolingblockholeangle);
2071 TVector3* coolingblockholevertex[3];
2072 coolingblockholevertex[0] = new TVector3();
2073 coolingblockholevertex[1] = new TVector3(fgkSSDCoolingBlockHoleRadius[0]
2074 * TMath::Cos((90.-coolingblockholeangle)*TMath::DegToRad()),
d7599219 2075 fgkSSDCoolingBlockHoleRadius[0]
44285dfa 2076 * TMath::Sin((90.-coolingblockholeangle)*TMath::DegToRad()));
2077 coolingblockholevertex[2] = new TVector3(coolingblockholevertex[1]->X(),
2078 - coolingblockholevertex[1]->Y());
2079 GetTriangleShape(coolingblockholevertex,
2080 coolingblockholewidth,"CoolingBlockTriangleHoleShape");
2081 TGeoRotation* coolingblockholerot =
d7599219 2082 new TGeoRotation("CoolingBlockHoleRot",90,0.,0.);
44285dfa 2083 coolingblockholerot->RegisterYourself();
2084 new TGeoCompositeShape("CoolingTubeHoleShape",
d7599219 2085 "CoolingBlockTriangleHoleShape:CoolingBlockHoleRot+"
2086 "CoolingBlockHoleShape");
2087 ///////////////////////////
2088 // Cooling Block Trapezoids
2089 ///////////////////////////
44285dfa 2090 const Int_t kvertexnumber = 4;
2091 const Int_t ktrapezoidnumber = 2;
2092 TVector3** coolingblocktrapezoidvertex[ktrapezoidnumber];
2093 for(Int_t i = 0; i<ktrapezoidnumber; i++) coolingblocktrapezoidvertex[i] =
2094 new TVector3*[kvertexnumber];
2095 Double_t coolingblockcomponentheight = fgkSSDCoolingBlockHeight[0]
d7599219 2096 - fgkSSDCoolingBlockHoleCenter
2097 - fgkSSDCoolingBlockHoleRadius[0]
44285dfa 2098 * TMath::Sin(coolingblockholeangle*TMath::DegToRad());
2099 Double_t coolingblocktrapezoidlength[ktrapezoidnumber] =
d7599219 2100 { fgkSSDCoolingBlockLength,
2101 0.5*(fgkSSDCoolingBlockLength-2.
2102 * (fgkSSDCoolingBlockHoleLength[1]
2103 - fgkSSDCoolingBlockHoleRadius[1])
2104 - fgkSSDCoolingBlockHoleLength[0])};
44285dfa 2105 Double_t coolingblocktrapezoidheigth[ktrapezoidnumber] =
2106 { fgkSSDCoolingBlockHeight[0]-coolingblockcomponentheight
d7599219 2107 - fgkSSDCoolingBlockHeight[1]-fgkSSDCoolingBlockHeight[2]
2108 - fgkSSDCoolingBlockHoleRadius[1],
44285dfa 2109 coolingblockcomponentheight};
2110 Double_t coolingblocktrapezoidwidth[ktrapezoidnumber] =
d7599219 2111 {fgkSSDCoolingBlockWidth,fgkSSDCoolingBlockWidth};
2112 //////////////////////////
2113 //Vertex Positioning Shape
2114 //////////////////////////
44285dfa 2115 coolingblocktrapezoidvertex[0][0] = new TVector3();
2116 coolingblocktrapezoidvertex[0][1] = new TVector3(coolingblocktrapezoidlength[0]);
2117 coolingblocktrapezoidvertex[0][2] = new TVector3(
2118 0.5*(coolingblocktrapezoidvertex[0][1]->X()
2119 - 2.*coolingblocktrapezoidlength[1]
d7599219 2120 - fgkSSDCoolingBlockHoleLength[0]));
44285dfa 2121 coolingblocktrapezoidvertex[0][3] =
2122 new TVector3(coolingblocktrapezoidvertex[0][1]->X()
2123 - coolingblocktrapezoidvertex[0][2]->X());
2124 coolingblocktrapezoidvertex[1][0] = new TVector3();
2125 coolingblocktrapezoidvertex[1][1] = new TVector3(coolingblocktrapezoidlength[1]);
2126 coolingblocktrapezoidvertex[1][2] =
2127 new TVector3(coolingblocktrapezoidheigth[1]
2128 / coolingblocktrapezoidheigth[0]
2129 * coolingblocktrapezoidvertex[0][2]->X());
2130 coolingblocktrapezoidvertex[1][3] =
2131 new TVector3(coolingblocktrapezoidvertex[1][1]->X());
2132 char* coolingblocktrapezoidshapename[ktrapezoidnumber] =
d7599219 2133 {"CoolingBlockTrapezoidShape0","CoolingBlockTrapezoidShape1"};
44285dfa 2134 TGeoArb8* coolingblocktrapezoidshape[ktrapezoidnumber];
2135 for(Int_t i = 0; i< ktrapezoidnumber; i++) coolingblocktrapezoidshape[i] =
2136 GetArbShape(coolingblocktrapezoidvertex[i],
2137 coolingblocktrapezoidwidth,
2138 coolingblocktrapezoidheigth[i],
2139 coolingblocktrapezoidshapename[i]);
2140 TGeoTranslation* coolingblocktrapezoidtrans =
d7599219 2141 new TGeoTranslation("CoolingBlockTrapezoidTrans",
44285dfa 2142 coolingblocktrapezoidvertex[0][2]->X(),
d7599219 2143 0.0,
44285dfa 2144 0.5*(coolingblocktrapezoidheigth[0]
2145 + coolingblocktrapezoidheigth[1]));
2146 coolingblocktrapezoidtrans->RegisterYourself();
2147 TGeoCombiTrans* coolingblocktrapezoidcombitrans =
d7599219 2148 new TGeoCombiTrans("CoolingBlockTrapezoidCombiTrans",
44285dfa 2149 coolingblocktrapezoidvertex[0][3]->X(),
d7599219 2150 fgkSSDCoolingBlockWidth,
44285dfa 2151 0.5*(coolingblocktrapezoidheigth[0]
2152 + coolingblocktrapezoidheigth[1]),
d7599219 2153 new TGeoRotation("",180.,0.,0.));
44285dfa 2154 coolingblocktrapezoidcombitrans->RegisterYourself();
d7599219 2155 new TGeoCompositeShape("CoolingBlockTrapezoidCompositeShape",
2156 "CoolingBlockTrapezoidShape0+CoolingBlockTrapezoidShape1:CoolingBlockTrapezoidTrans+"
2157 "CoolingBlockTrapezoidShape1:CoolingBlockTrapezoidCombiTrans");
2158 /////////////////////////////
2159 // Cooling Block Boxes Shapes
2160 /////////////////////////////
44285dfa 2161 const Int_t kboxnumber = 3;
2162 TGeoBBox* coolingblockboxshape[kboxnumber];
2163 coolingblockboxshape[0] = new TGeoBBox("CoolingBlockBoxShape0",
d7599219 2164 0.5*fgkSSDCoolingBlockLength,
2165 0.5*fgkSSDCoolingBlockWidth,
2166 0.5*fgkSSDCoolingBlockHoleRadius[1]);
44285dfa 2167 coolingblockboxshape[1] = new TGeoBBox("CoolingBlockBoxShape1",
d7599219 2168 0.5*(fgkSSDCoolingBlockLength
2169 - 2.*fgkSSDCoolingBlockHoleLength[1]),
2170 0.5*fgkSSDCoolingBlockWidth,
2171 0.5*fgkSSDCoolingBlockHeight[2]);
44285dfa 2172 coolingblockboxshape[2] = new TGeoBBox("CoolingBlockBoxShape2",
d7599219 2173 0.5*fgkSSDCoolingBlockLength,
2174 0.5*fgkSSDCoolingBlockWidth,
2175 0.5*fgkSSDCoolingBlockHeight[1]);
44285dfa 2176 TGeoTranslation* coolingblockboxtrans[kboxnumber-1];
2177 coolingblockboxtrans[0] = new TGeoTranslation("CoolingBlockBoxTrans0",0.,0.,
d7599219 2178 0.5*(fgkSSDCoolingBlockHeight[1]
2179 + fgkSSDCoolingBlockHoleRadius[1])
2180 + fgkSSDCoolingBlockHeight[2]);
44285dfa 2181 coolingblockboxtrans[1] = new TGeoTranslation("CoolingBlockBoxTrans1",
d7599219 2182 0.0,
2183 0.0,
2184 0.5*(fgkSSDCoolingBlockHeight[1]
2185 + fgkSSDCoolingBlockHeight[2]));
44285dfa 2186 for(Int_t i=0; i<kboxnumber-1; i++) coolingblockboxtrans[i]->RegisterYourself();
d7599219 2187 new TGeoCompositeShape("CoolingBlockBoxCompositeShape",
2188 "CoolingBlockBoxShape0:CoolingBlockBoxTrans0+"
2189 "CoolingBlockBoxShape1:CoolingBlockBoxTrans1+CoolingBlockBoxShape2");
2190 ///////////////////////
2191 // Cooling Block Shape
2192 //////////////////////
44285dfa 2193 TGeoCombiTrans* coolingtubeholeshapecombitrans =
d7599219 2194 new TGeoCombiTrans("CoolingTubeHoleShapeCombiTrans",
2195 0.5*fgkSSDCoolingBlockLength,
2196 0.5*fgkSSDCoolingBlockWidth,
2197 fgkSSDCoolingBlockHoleCenter,
2198 new TGeoRotation("",0.,90.,0.));
44285dfa 2199 coolingtubeholeshapecombitrans->RegisterYourself();
2200 TGeoTranslation* coolingblocktrapezoidcompositeshapetrans =
d7599219 2201 new TGeoTranslation("CoolingBlockTrapezoidCompositeShapeTrans",
2202 0.0,
2203 0.0,
44285dfa 2204 0.5*coolingblocktrapezoidheigth[0]+fgkSSDCoolingBlockHeight[1]+
d7599219 2205 fgkSSDCoolingBlockHeight[2]+fgkSSDCoolingBlockHoleRadius[1]);
44285dfa 2206 coolingblocktrapezoidcompositeshapetrans->RegisterYourself();
2207 TGeoTranslation* coolingblockboxcompositeshapetrans =
d7599219 2208 new TGeoTranslation("CoolingBlockBoxCompositeShapeTrans",
2209 0.5*fgkSSDCoolingBlockLength,
2210 0.5*fgkSSDCoolingBlockWidth,
2211 0.5*fgkSSDCoolingBlockHeight[1]);
44285dfa 2212 coolingblockboxcompositeshapetrans->RegisterYourself();
2213 TGeoCompositeShape* ssdoolingblockshape =
d7599219 2214 new TGeoCompositeShape("SSDCoolingBlockShape",
2215 "CoolingBlockBoxCompositeShape:CoolingBlockBoxCompositeShapeTrans+"
2216 "CoolingBlockTrapezoidCompositeShape:CoolingBlockTrapezoidCompositeShapeTrans-"
2217 "CoolingTubeHoleShape:CoolingTubeHoleShapeCombiTrans");
44285dfa 2218 TGeoVolume* ssdcoolingblock = new TGeoVolume("SSDCoolingBlock",
2219 ssdoolingblockshape,fSSDAlCoolBlockMedium);
2220 return ssdcoolingblock;
d7599219 2221}
2222/////////////////////////////////////////////////////////////////////////////////
2223TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunction(Double_t width){
44285dfa 2224 /////////////////////////////////////////////////////////////
2225 // Method generating SSD Carbon Fiber Junction
2226 /////////////////////////////////////////////////////////////
2227 const Int_t kvertexnumber = 4;
2228 TVector3* vertex[kvertexnumber];
2229 vertex[0] = new TVector3();
2230 vertex[1] = new TVector3(fgkCarbonFiberJunctionLength,0.);
2231 vertex[2] = new TVector3(fgkCarbonFiberJunctionLength
d7599219 2232 - fgkCarbonFiberJunctionEdge[1]
2233 * TMath::Cos(fgkCarbonFiberJunctionAngle[1]*TMath::DegToRad()),
2234 fgkCarbonFiberJunctionEdge[1]*TMath::Sin(fgkCarbonFiberJunctionAngle[1]
2235 * TMath::DegToRad()));
44285dfa 2236 vertex[3] = new TVector3(fgkCarbonFiberJunctionEdge[0]
d7599219 2237 * TMath::Cos(fgkCarbonFiberJunctionAngle[0]*TMath::DegToRad()),
2238 fgkCarbonFiberJunctionEdge[0]
2239 * TMath::Sin(fgkCarbonFiberJunctionAngle[0]*TMath::DegToRad()));
44285dfa 2240 TGeoArb8* carbonfiberjunctionshapepiece =
d7599219 2241 new TGeoArb8("CarbonFiberJunctionShapePiece",0.5*width);
2242 //////////////////////////////////
2243 //Setting the vertices in TGeoArb8
2244 //////////////////////////////////
44285dfa 2245 for(Int_t i = 0; i<2*kvertexnumber; i++)
2246 carbonfiberjunctionshapepiece->SetVertex(i,
2247 vertex[(i < kvertexnumber ? i: i-kvertexnumber)]->X(),
2248 vertex[(i < kvertexnumber ? i : i-kvertexnumber)]->Y());
2249 TGeoRotation* carbonfiberjunctionrot =
d7599219 2250 new TGeoRotation("CarbonFiberJunctionRot",
2251 180.,
2252 180.,
2253 180-2.*fgkCarbonFiberJunctionAngle[0]);
44285dfa 2254 TGeoVolume* carbonfiberjunctionpiece =
d7599219 2255 new TGeoVolume("CarbonFiberJunctionPiece",
44285dfa 2256 carbonfiberjunctionshapepiece,fSSDCarbonFiberMedium);
2257 TGeoVolume* carbonfiberjunction =
d7599219 2258 new TGeoVolumeAssembly("CarbonFiberJunction");
44285dfa 2259 carbonfiberjunctionpiece->SetLineColor(fColorCarbonFiber);
2260 carbonfiberjunction->AddNode(carbonfiberjunctionpiece,1);
2261 carbonfiberjunction->AddNode(carbonfiberjunctionpiece,2,carbonfiberjunctionrot);
2262 return carbonfiberjunction;
d7599219 2263}
2264/////////////////////////////////////////////////////////////////////////////////
2265TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberJunctionAssembly(){
44285dfa 2266 /////////////////////////////////////////////////////////////
2267 // Method generating SSD Carbon Fiber Junction Assembly
2268 /////////////////////////////////////////////////////////////
d7599219 2269 SetCarbonFiberJunctionCombiTransMatrix();
44285dfa 2270 TGeoVolume* carbonfiberjunctionassembly =
d7599219 2271 new TGeoVolumeAssembly("CarbonFiberJunctionAssembly");
44285dfa 2272 TGeoVolume* carbonfiberjunction =
d7599219 2273 GetCarbonFiberJunction(fgkCarbonFiberJunctionWidth);
2274 for(Int_t i=0; i<fgkCarbonFiberJunctionCombiTransNumber;i++)
44285dfa 2275 carbonfiberjunctionassembly->AddNode(carbonfiberjunction,i+1,
2276 fCarbonFiberJunctionCombiTransMatrix[i]);
2277 return carbonfiberjunctionassembly;
d7599219 2278}
2279/////////////////////////////////////////////////////////////////////////////////
44285dfa 2280TList* AliITSv11GeometrySSD::GetLadderCableSegment(Double_t ssdendladdercablelength){
2281 /////////////////////////////////////////////////////////////
2282 // Method returning a List containing pointers to Ladder Cable Volumes
2283 /////////////////////////////////////////////////////////////
2284 const Int_t kladdercablesegmentnumber = 2;
2285 /////////////////////////////////////////
2286 // LadderSegmentBBox Volume
2287 /////////////////////////////////////////
2288 TGeoBBox* laddercablesegmentbboxshape[kladdercablesegmentnumber];
2289 const char* laddercablesegmentbboxshapename[kladdercablesegmentnumber] =
d7599219 2290 {"LadderCableSegmentBBoxShape1","LadderCableSegmentBBoxShape2"};
44285dfa 2291 for(Int_t i=0; i<kladdercablesegmentnumber; i++) laddercablesegmentbboxshape[i] =
2292 new TGeoBBox(laddercablesegmentbboxshapename[i],
d7599219 2293 0.5*fgkSSDFlexWidth[0],
2294 0.5*fgkSSDLadderCableWidth,
2295 0.5*fgkSSDFlexHeight[i]);
44285dfa 2296 const char* laddercablesegmentbboxname[kladdercablesegmentnumber] =
d7599219 2297 {"LadderCableSegmentBBox1","LadderCableSegmentBBox2"};
44285dfa 2298 TGeoVolume* laddercablesegmentbbox[kladdercablesegmentnumber];
2299 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
2300 laddercablesegmentbbox[i] =
2301 new TGeoVolume(laddercablesegmentbboxname[i],
2302 laddercablesegmentbboxshape[i],
2303 (i==0?fSSDAlTraceLadderCableMedium:
2304 fSSDKaptonLadderCableMedium));
2305 laddercablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
d7599219 2306 fColorPolyhamide);
2307 }
44285dfa 2308 TGeoTranslation* laddercablesegmentbboxtrans[kladdercablesegmentnumber];
2309 laddercablesegmentbboxtrans[0] =
d7599219 2310 new TGeoTranslation("LadderCableSegmentBBoxTrans1",
2311 0.5*fgkSSDFlexWidth[0],
2312 0.5*fgkSSDLadderCableWidth,
2313 0.5*fgkSSDFlexHeight[0]);
44285dfa 2314 laddercablesegmentbboxtrans[1] =
d7599219 2315 new TGeoTranslation("LadderCableSegmentBBoxTrans2",
2316 0.5*fgkSSDFlexWidth[0],
2317 0.5*fgkSSDLadderCableWidth,
2318 fgkSSDFlexHeight[0]
2319 +0.5*fgkSSDFlexHeight[1]);
44285dfa 2320 TGeoVolume* laddercablesegmentbboxassembly =
d7599219 2321 new TGeoVolumeAssembly("LadderCableSegmentBBoxAssembly");
44285dfa 2322 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
2323 laddercablesegmentbboxassembly->AddNode(laddercablesegmentbbox[i],1,
2324 laddercablesegmentbboxtrans[i]);
d7599219 2325/////////////////////////////////////////
2326// LadderSegmentArb8 Volume
2327/////////////////////////////////////////
44285dfa 2328 const Int_t kvertexnumber = 4;
2329 TVector3** laddercablesegmentvertexposition[kladdercablesegmentnumber];
2330 for(Int_t i = 0; i<kladdercablesegmentnumber; i++) laddercablesegmentvertexposition[i] =
2331 new TVector3*[kvertexnumber];
d7599219 2332//Shape Vertex Positioning
44285dfa 2333 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
2334 laddercablesegmentvertexposition[i][0] = new TVector3(0.,i*fgkSSDFlexHeight[0]);
2335 laddercablesegmentvertexposition[i][1] = new TVector3(fgkSSDLadderCableWidth,
d7599219 2336 i*fgkSSDFlexHeight[0]);
44285dfa 2337 laddercablesegmentvertexposition[i][2] = new TVector3(0.,fgkSSDFlexHeight[0]
d7599219 2338 + fgkSSDFlexHeight[1]
2339 + i*fgkSSDFlexHeight[0]);
44285dfa 2340 laddercablesegmentvertexposition[i][3] =
2341 new TVector3(laddercablesegmentvertexposition[i][1]->X(),
2342 laddercablesegmentvertexposition[i][2]->Y());
d7599219 2343 }
44285dfa 2344 Double_t laddercablesegmentwidth[2][2] = {{fgkSSDFlexHeight[0],fgkSSDFlexHeight[0]},
d7599219 2345 {fgkSSDFlexHeight[1],fgkSSDFlexHeight[1]}};
44285dfa 2346 char* laddercablesegmentarbshapename[kladdercablesegmentnumber] =
d7599219 2347 {"LadderCableSegmentArbShape1","LadderCableSegmentArbShape2"};
44285dfa 2348 TGeoArb8* laddercablesegmentarbshape[kladdercablesegmentnumber];
2349 for(Int_t i = 0; i< kladdercablesegmentnumber; i++) laddercablesegmentarbshape[i] =
2350 GetArbShape(laddercablesegmentvertexposition[i],
2351 laddercablesegmentwidth[i],
d7599219 2352 fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0],
44285dfa 2353 laddercablesegmentarbshapename[i]);
2354 const char* laddercablesegmentarbname[kladdercablesegmentnumber] =
d7599219 2355 {"LadderCableSegmentArb1","LadderCableSegmentArb2"};
44285dfa 2356 TGeoVolume* laddercablesegmentarb[kladdercablesegmentnumber];
2357 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
2358 laddercablesegmentarb[i] =
2359 new TGeoVolume(laddercablesegmentarbname[i],
2360 laddercablesegmentarbshape[i],
2361 (i==0?fSSDAlTraceLadderCableMedium:
2362 fSSDKaptonLadderCableMedium));
2363 laddercablesegmentarb[i]->SetLineColor(i==0 ? fColorAl :
d7599219 2364 fColorPolyhamide);
2365}
44285dfa 2366 TGeoRotation* laddercablesegmentarbrot[kladdercablesegmentnumber];
2367 laddercablesegmentarbrot[0] = new TGeoRotation("LadderCableSegmentArbRot1",
d7599219 2368 90.,90,-90.);
44285dfa 2369 laddercablesegmentarbrot[1] = new TGeoRotation("LadderCableSegmentArbRot2",
d7599219 2370 0.,90.,0.);
44285dfa 2371 TGeoCombiTrans* laddercablesegmentarbcombitrans =
d7599219 2372 new TGeoCombiTrans("LadderCableSegmentArbCombiTrans",
2373 0.5*(fgkCarbonFiberJunctionWidth-fgkSSDFlexWidth[0])
2374 + fgkSSDFlexWidth[0],0.,0.,
44285dfa 2375 new TGeoRotation((*laddercablesegmentarbrot[1])
2376 *(*laddercablesegmentarbrot[0])));
2377 TGeoVolume* laddercablesegmentarbassembly =
d7599219 2378 new TGeoVolumeAssembly("LadderCableSegmentArbAssembly");
44285dfa 2379 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
2380 laddercablesegmentarbassembly->AddNode(laddercablesegmentarb[i],1,
2381 laddercablesegmentarbcombitrans);
d7599219 2382/////////////////////////////////////////
2383// End Ladder Cable Volume
2384/////////////////////////////////////////
44285dfa 2385 TGeoBBox* ladderendcablesegmentbboxshape[kladdercablesegmentnumber];
2386 const char* ladderendcablesegmentbboxshapename[kladdercablesegmentnumber] =
d7599219 2387 {"LadderEndCableSegmentBBoxShape1","LadderEndCableSegmentBBoxShape2"};
44285dfa 2388 for(Int_t i=0; i<kladdercablesegmentnumber; i++) ladderendcablesegmentbboxshape[i] =
2389 new TGeoBBox(ladderendcablesegmentbboxshapename[i],
2390 0.5*ssdendladdercablelength,
d7599219 2391 0.5*fgkSSDLadderCableWidth,
2392 0.5*fgkSSDFlexHeight[i]);
44285dfa 2393 const char* ladderendcablesegmentbboxname[kladdercablesegmentnumber] =
d7599219 2394 {"LadderEndCableSegmentBBox1","LadderEndCableSegmentBBox2"};
44285dfa 2395 TGeoVolume* ladderendcablesegmentbbox[kladdercablesegmentnumber];
2396 for(Int_t i=0; i<kladdercablesegmentnumber; i++){
2397 ladderendcablesegmentbbox[i] =
2398 new TGeoVolume(ladderendcablesegmentbboxname[i],
2399 ladderendcablesegmentbboxshape[i],
2400 (i==0?fSSDAlTraceLadderCableMedium:
2401 fSSDKaptonLadderCableMedium));
2402 ladderendcablesegmentbbox[i]->SetLineColor(i==0 ? fColorAl :
d7599219 2403 fColorPolyhamide);
2404 }
44285dfa 2405 TGeoTranslation* ladderendcablesegmentbboxtrans[kladdercablesegmentnumber];
2406 ladderendcablesegmentbboxtrans[0] =
d7599219 2407 new TGeoTranslation("LadderEndCableSegmentBBoxTrans0",
44285dfa 2408 0.5*ssdendladdercablelength,
d7599219 2409 0.5*fgkSSDLadderCableWidth,
2410 0.5*fgkSSDFlexHeight[0]);
44285dfa 2411 ladderendcablesegmentbboxtrans[1] =
d7599219 2412 new TGeoTranslation("LadderEndCableSegmentBBoxTrans1",
44285dfa 2413 0.5*ssdendladdercablelength,
d7599219 2414 0.5*fgkSSDLadderCableWidth,
2415 fgkSSDFlexHeight[0]
2416 +0.5*fgkSSDFlexHeight[1]);
44285dfa 2417 TGeoVolume* ladderendcablesegmentbboxassembly =
d7599219 2418 new TGeoVolumeAssembly("LadderEndCableSegmentBBoxAssembly");
44285dfa 2419 for(Int_t i=0; i<kladdercablesegmentnumber; i++)
2420 ladderendcablesegmentbboxassembly->AddNode(ladderendcablesegmentbbox[i],1,
2421 ladderendcablesegmentbboxtrans[i]);
d7599219 2422/////////////////////////////////////////
44285dfa 2423 TList* laddercablesegmentlist = new TList();
2424 laddercablesegmentlist->Add(laddercablesegmentbboxassembly);
2425 laddercablesegmentlist->Add(laddercablesegmentarbassembly);
2426 laddercablesegmentlist->Add(ladderendcablesegmentbboxassembly);
2427 return laddercablesegmentlist;
d7599219 2428 }
2429/////////////////////////////////////////////////////////////////////////////////
44285dfa 2430TGeoVolume* AliITSv11GeometrySSD::GetLadderCable(Int_t n, Double_t ssdendladdercablelength){
2431 /////////////////////////////////////////////////////////////
2432 // Method generating Ladder Cable Volumes Assemblies
2433 /////////////////////////////////////////////////////////////
2434 TList* laddercablesegmentlist = GetLadderCableSegment(ssdendladdercablelength);
2435 TGeoVolume* laddercable = new TGeoVolumeAssembly("LadderCable");
d7599219 2436 for(Int_t i=0; i<n; i++){
44285dfa 2437 TGeoTranslation* laddercabletrans = new TGeoTranslation(
d7599219 2438 i*(fgkCarbonFiberJunctionWidth),
2439 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
2440 i*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
44285dfa 2441 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(0),i+1,laddercabletrans);
2442 if(i!=n-1) laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(1),i+1,laddercabletrans);
d7599219 2443 }
44285dfa 2444 TGeoTranslation* endladdercabletrans = new TGeoTranslation("EndLadderCableTrans",
d7599219 2445 (n-1)*fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
2446 fgkSSDLadderCableWidth-fgkSSDFlexWidth[0],
2447 (n-1)*(fgkSSDFlexHeight[0]+fgkSSDFlexHeight[1]));
44285dfa 2448 laddercable->AddNode((TGeoVolume*)laddercablesegmentlist->At(2),1,endladdercabletrans);
2449 return laddercable;
d7599219 2450}
2451/////////////////////////////////////////////////////////////////////////////////
44285dfa 2452TGeoVolume* AliITSv11GeometrySSD::GetLadderCableAssembly(Int_t n, Double_t ssdendladdercablelength){
2453 /////////////////////////////////////////////////////////////
2454 // Method generating Ladder Cable Volumes Assembly
2455 /////////////////////////////////////////////////////////////
2456 TGeoVolume* laddercableassembly = new TGeoVolumeAssembly("LadderCableAssembly");
2457 char laddercabletransname[30];
d7599219 2458 for(Int_t i=0; i<n; i++){
44285dfa 2459 sprintf(laddercabletransname,"LadderCableTrans%i",i+1);
2460 laddercableassembly->AddNode(GetLadderCable(n-i,ssdendladdercablelength),i+1,
2461 new TGeoTranslation(laddercabletransname,i*fgkCarbonFiberJunctionWidth,0.,0.));
d7599219 2462 }
44285dfa 2463 return laddercableassembly;
d7599219 2464}
2465/////////////////////////////////////////////////////////////////////////////////
44285dfa 2466TList* AliITSv11GeometrySSD::GetLadderCableAssemblyList(Int_t n, Double_t ssdendladdercablelength){
2467 /////////////////////////////////////////////////////////////
2468 // Method generating Ladder Cable List Assemblies
2469 /////////////////////////////////////////////////////////////
2470 const Int_t kladdercableassemblynumber = 2;
2471 TGeoVolume* laddercableassembly = GetLadderCableAssembly(n,ssdendladdercablelength);
2472 TGeoVolume* ladderCable[kladdercableassemblynumber];
2473 char laddercableassemblyname[30];
2474 TList* laddercableassemblylist = new TList();
2475 for(Int_t i=0; i<kladdercableassemblynumber; i++){
2476 sprintf(laddercableassemblyname,"LadderCableAssembly%i",i+1);
2477 ladderCable[i] = new TGeoVolumeAssembly(laddercableassemblyname);
2478 ladderCable[i]->AddNode(laddercableassembly,i+1,i==0 ? NULL :
d7599219 2479 new TGeoCombiTrans((n-1)
2480 * fgkCarbonFiberJunctionWidth+fgkSSDFlexWidth[0],
2481 2.*fgkSSDLadderCableWidth+0.5*fgkSSDFlexWidth[0],
2482 0.,new TGeoRotation("",180,0.,0.)));
44285dfa 2483 laddercableassemblylist->Add(ladderCable[i]);
d7599219 2484}
44285dfa 2485 return laddercableassemblylist;
d7599219 2486}
2487/////////////////////////////////////////////////////////////////////////////////
2488TList* AliITSv11GeometrySSD::GetEndLadderCarbonFiberJunctionAssembly(){
44285dfa 2489 /////////////////////////////////////////////////////////////
2490 // Method generating the End Ladder Carbon Fiber Junction Assembly
2491 /////////////////////////////////////////////////////////////
2492 const Int_t kendlabbercarbonfiberjunctionumber = 2;
2493 TGeoVolume* endladdercarbonfiberjunctionassembly[kendlabbercarbonfiberjunctionumber];
2494 endladdercarbonfiberjunctionassembly[0] =
d7599219 2495 new TGeoVolumeAssembly("EndLadderCarbonFiberJunctionAssembly1");
44285dfa 2496 endladdercarbonfiberjunctionassembly[1] =
d7599219 2497 new TGeoVolumeAssembly("EndLadderCarbonFiberJunctionAssembly2");
44285dfa 2498 TGeoVolume** endladdercarbonfiberjunction[kendlabbercarbonfiberjunctionumber];
2499 for(Int_t i=0; i<kendlabbercarbonfiberjunctionumber; i++)
2500 endladdercarbonfiberjunction[i] = new TGeoVolume*[2];
2501 for(Int_t i=0; i<kendlabbercarbonfiberjunctionumber; i++){
2502 endladdercarbonfiberjunction[i][0] =
d7599219 2503 GetCarbonFiberJunction(fgkEndLadderCarbonFiberLowerJunctionLength[i]);
44285dfa 2504 endladdercarbonfiberjunction[i][1] =
d7599219 2505 GetCarbonFiberJunction(fgkEndLadderCarbonFiberUpperJunctionLength[i]);
2506 }
44285dfa 2507 TList* endladdercarbonfiberjunctionlist = new TList();
2508 for(Int_t i=0; i<kendlabbercarbonfiberjunctionumber; i++){
d7599219 2509 SetEndLadderCarbonFiberJunctionCombiTransMatrix(i);
2510 for(Int_t j=0; j<fgkCarbonFiberJunctionCombiTransNumber; j++)
44285dfa 2511 endladdercarbonfiberjunctionassembly[i]->AddNode(j==2 ?
2512 endladdercarbonfiberjunction[i][1] :
2513 endladdercarbonfiberjunction[i][0],
2514 j+1,fEndLadderCarbonFiberJunctionCombiTransMatrix[j]);
2515 endladdercarbonfiberjunctionlist->Add(endladdercarbonfiberjunctionassembly[i]);
d7599219 2516 }
44285dfa 2517 return endladdercarbonfiberjunctionlist;
d7599219 2518}
2519////////////////////////////////////////////////////////////////////////////////
2520TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberSupport(){
44285dfa 2521 /////////////////////////////////////////////////////////////
2522 // Method generating the Carbon Fiber Support
2523 /////////////////////////////////////////////////////////////
2524 const Int_t kvertexnumber = 4;
2525 const Int_t kshapesnumber = 2;
2526 TVector3** vertexposition[kshapesnumber];
2527 for(Int_t i=0; i<kshapesnumber; i++) vertexposition[i] = new TVector3*[kvertexnumber];
2528 Double_t carbonfibersupportxaxisEdgeproj =
d7599219 2529 fgkCarbonFiberSupportEdgeLength*TMath::Cos(fgkCarbonFiberJunctionAngle[0]
2530 * TMath::DegToRad());
44285dfa 2531 Double_t theta = TMath::ATan(fgkCarbonFiberSupportYAxisLength
d7599219 2532 / fgkCarbonFiberSupportXAxisLength);
2533 /////////////////////
2534 //Vertex Positioning
2535 ////////////////////
44285dfa 2536 vertexposition[0][0] = new TVector3();
2537 vertexposition[0][1] = new TVector3(fgkCarbonFiberSupportXAxisLength,
d7599219 2538 fgkCarbonFiberSupportYAxisLength);
44285dfa 2539 vertexposition[0][2] = new TVector3(carbonfibersupportxaxisEdgeproj,
2540 carbonfibersupportxaxisEdgeproj
2541 * TMath::Tan(theta));
2542 vertexposition[0][3] = new TVector3(fgkCarbonFiberSupportXAxisLength
2543 - carbonfibersupportxaxisEdgeproj,
d7599219 2544 fgkCarbonFiberSupportYAxisLength
44285dfa 2545 - vertexposition[0][2]->Y());
d7599219 2546 ////////////////////////////////////////////////////
2547 //Setting the parameters for Isometry Transformation
2548 ////////////////////////////////////////////////////
44285dfa 2549 Double_t symmetryplaneposition = (fgkCarbonFiberSupportYAxisLength
d7599219 2550 + fgkCarbonFiberSupportTopEdgeDist[0]
2551 + fgkCarbonFiberSupportWidth);
2552 Double_t* param = new Double_t[4];
44285dfa 2553 param[0] = 0., param[1] = 1., param[2] = 0., param[3] = -symmetryplaneposition;
2554 for(Int_t j=0; j<kvertexnumber; j++) vertexposition[1][j] =
2555 new TVector3((GetReflection(vertexposition[0][j],param))->X(),
2556 (GetReflection(vertexposition[0][j],param))->Y());
2557 char* carbonfibersupportshapename[kshapesnumber] =
d7599219 2558 {"CarbonFiberSupportShape1","CarbonFiberSupportShape2"};
44285dfa 2559 TGeoArb8* carbonfibersupportshape[kshapesnumber];
2560 Double_t width[2] = {fgkCarbonFiberSupportWidth,fgkCarbonFiberSupportWidth};
2561 Double_t carbonfibersupportheight =
2562 carbonfibersupportxaxisEdgeproj*TMath::Tan(fgkCarbonFiberJunctionAngle[0]
d7599219 2563 *TMath::DegToRad());
44285dfa 2564 for(Int_t i = 0; i< kshapesnumber; i++) carbonfibersupportshape[i] =
2565 GetArbShape(vertexposition[i],width,carbonfibersupportheight,
2566 carbonfibersupportshapename[i],i==0 ? 1: -1);
d7599219 2567 /////////////////////////////////////
2568 //Setting Translations and Rotations:
2569 /////////////////////////////////////
44285dfa 2570 TGeoTranslation* carbonfibersupporttrans =
d7599219 2571 new TGeoTranslation("CarbonFiberSupportTrans",
44285dfa 2572 0.0,0.0,0.5*carbonfibersupportheight);
2573 carbonfibersupporttrans->RegisterYourself();
2574 TGeoRotation* carbonfibercompshaperot[2];
2575 carbonfibercompshaperot[0] = new TGeoRotation("CarbonFiberCompShapeRot1",
d7599219 2576 0.0,180.0,0.0);
44285dfa 2577 carbonfibercompshaperot[1] = new TGeoRotation("CarbonFiberCompShapeRot2",
d7599219 2578 90.,-fgkCarbonFiberTriangleAngle,-90.);
44285dfa 2579 Double_t transvector[3] = {fgkCarbonFiberTriangleLength
d7599219 2580 * TMath::Cos(fgkCarbonFiberTriangleAngle
2581 * TMath::DegToRad()),0.,-fgkCarbonFiberTriangleLength
2582 * TMath::Sin(fgkCarbonFiberTriangleAngle
2583 * TMath::DegToRad())};
44285dfa 2584 TGeoCombiTrans* carbonfibersupportcombitrans =
d7599219 2585 new TGeoCombiTrans("CarbonFiberSupportCombiTrans",
44285dfa 2586 transvector[0],2.*symmetryplaneposition
2587 + transvector[1],transvector[2],
2588 new TGeoRotation((*carbonfibercompshaperot[1])
2589 * (*carbonfibercompshaperot[0])));
2590 carbonfibersupportcombitrans->RegisterYourself();
d7599219 2591////////////////////////////////////////////////////////////////////////////////
44285dfa 2592 TGeoCompositeShape* carbonfibersupportcompshape =
d7599219 2593 new TGeoCompositeShape("CarbonFiberSupportCompShape",
2594 "CarbonFiberSupportShape1:CarbonFiberSupportTrans+"
2595 "CarbonFiberSupportShape2:CarbonFiberSupportTrans");
44285dfa 2596 TGeoVolume* carbonfibersupport = new TGeoVolume("CarbonFiberSupport",
2597 carbonfibersupportcompshape,fSSDCarbonFiberMedium);
2598 carbonfibersupport->SetLineColor(fColorCarbonFiber);
2599 TGeoVolume* carbonfibersupportassembly =
d7599219 2600 new TGeoVolumeAssembly("CarbonFiberSupportAssembly");
44285dfa 2601 carbonfibersupportassembly->AddNode(carbonfibersupport,1);
2602 carbonfibersupportassembly->AddNode(carbonfibersupport,2,
2603 carbonfibersupportcombitrans);
2604 return carbonfibersupportassembly;
d7599219 2605}
2606////////////////////////////////////////////////////////////////////////////////
2607TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberLowerSupport(Int_t ikind, Bool_t EndLadder){
44285dfa 2608 /////////////////////////////////////////////////////////////
2609 // Method generating the Carbon Fiber Lower Support
2610 /////////////////////////////////////////////////////////////
2611 const Int_t kvertexnumber = 4;
2612 const Int_t kshapesnumber = 2;
2613 Double_t width[2] = {fgkCarbonFiberLowerSupportWidth,
d7599219 2614 fgkCarbonFiberLowerSupportWidth};
44285dfa 2615 TVector3** vertexposition[kshapesnumber];
2616 for(Int_t i = 0; i<kshapesnumber; i++) vertexposition[i] =
2617 new TVector3*[kvertexnumber];
d7599219 2618 //First Shape Vertex Positioning
44285dfa 2619 vertexposition[0][0] = new TVector3(fgkCarbonFiberLowerSupportLowerLenght);
2620 vertexposition[0][1] = new TVector3(fgkCarbonFiberTriangleLength
d7599219 2621 - fgkCarbonFiberLowerSupportLowerLenght);
44285dfa 2622 vertexposition[0][2] = new TVector3();
2623 vertexposition[0][3] = new TVector3(fgkCarbonFiberTriangleLength);
d7599219 2624 //Second Shape Vertex Positioning
44285dfa 2625 Double_t theta = TMath::ATan((fgkCarbonFiberLowerSupportVolumePosition[1]
d7599219 2626 - fgkCarbonFiberLowerSupportVolumePosition[0])
2627 / fgkCarbonFiberTriangleLength);
44285dfa 2628 vertexposition[1][0] = new TVector3(vertexposition[0][0]->X(),
2629 vertexposition[0][0]->X()*TMath::Tan(theta)
d7599219 2630 + fgkCarbonFiberLowerSupportVolumePosition[0]);
44285dfa 2631 vertexposition[1][1] = new TVector3(vertexposition[0][1]->X(),
2632 vertexposition[0][1]->X()*TMath::Tan(theta)
d7599219 2633 + fgkCarbonFiberLowerSupportVolumePosition[0]);
44285dfa 2634 vertexposition[1][2] = new TVector3(0.,fgkCarbonFiberLowerSupportVolumePosition[0]);
2635 vertexposition[1][3] = new TVector3(fgkCarbonFiberTriangleLength,
d7599219 2636 fgkCarbonFiberLowerSupportVolumePosition[1]);
44285dfa 2637 char* carbonfiberlowersupportname[kshapesnumber] =
d7599219 2638 {"CarbonFiberLowerSupportShape1","CarbonFiberLowerSupportShape2"};
44285dfa 2639 TGeoArb8* carbonfiberlowersupportshape[kshapesnumber];
2640 for(Int_t i = 0; i< kshapesnumber; i++) carbonfiberlowersupportshape[i] =
2641 GetArbShape(vertexposition[i],width,
d7599219 2642 fgkCarbonFiberLowerSupportHeight,
44285dfa 2643 carbonfiberlowersupportname[i]);
d7599219 2644 ///////////////////////////////////////////////////////
44285dfa 2645 TGeoTranslation* carbonfiberlowersupporttrans[kshapesnumber];
2646 carbonfiberlowersupporttrans[0] =
d7599219 2647 new TGeoTranslation("CarbonFiberLowerSupportTrans1",
2648 0.0,
44285dfa 2649 vertexposition[1][3]->Y()+vertexposition[1][2]->Y(),
d7599219 2650 0.0);
44285dfa 2651 carbonfiberlowersupporttrans[1] =
d7599219 2652 new TGeoTranslation("CarbonFiberLowerSupportTrans2",
2653 0.0,
44285dfa 2654 - vertexposition[1][3]->Y()-vertexposition[1][2]->Y(),
d7599219 2655 0.0);
44285dfa 2656 for(Int_t i = 0; i< kshapesnumber; i++)
2657 carbonfiberlowersupporttrans[i]->RegisterYourself();
d7599219 2658 ///////////////////////////////////////////////////////
44285dfa 2659 TGeoCompositeShape* carbonfiberlowersupportcompshape;
d7599219 2660 if(EndLadder==false)
44285dfa 2661 carbonfiberlowersupportcompshape =
d7599219 2662 new TGeoCompositeShape("CarbonFiberLowerSupportCompShape",
2663 "CarbonFiberLowerSupportShape2+"
2664 "CarbonFiberLowerSupportShape1:CarbonFiberLowerSupportTrans1");
2665 else
2666 if(ikind==0)
44285dfa 2667 carbonfiberlowersupportcompshape =
2668 (TGeoCompositeShape*)carbonfiberlowersupportshape[0];
d7599219 2669 else
44285dfa 2670 carbonfiberlowersupportcompshape =
d7599219 2671 new TGeoCompositeShape("CarbonFiberLowerSupportCompShape",
2672 "CarbonFiberLowerSupportShape1+"
2673 "CarbonFiberLowerSupportShape1:CarbonFiberLowerSupportTrans1");
44285dfa 2674 TGeoVolume* carbonfiberlowersupport = new TGeoVolume("CarbonFiberLowerSupport",
2675 carbonfiberlowersupportcompshape,fSSDCarbonFiberMedium);
2676 carbonfiberlowersupport->SetLineColor(fColorCarbonFiber);
2677 return carbonfiberlowersupport;
d7599219 2678}
2679////////////////////////////////////////////////////////////////////////////////
2680TGeoVolume* AliITSv11GeometrySSD::GetCarbonFiberAssemblySupport(){
44285dfa 2681 /////////////////////////////////////////////////////////////
2682 // Method generating the Carbon Fiber Assembly Support
2683 /////////////////////////////////////////////////////////////
d7599219 2684 SetCarbonFiberAssemblyCombiTransMatrix();
44285dfa 2685 TGeoVolume* carbonfiberassemblysupport =
d7599219 2686 new TGeoVolumeAssembly("CarbonFiberAssembly");
44285dfa 2687 TGeoVolume* carbonfiberassemblyvolumes[fgkCarbonFiberAssemblyCombiTransNumber];
2688 carbonfiberassemblyvolumes[0] = GetCarbonFiberJunctionAssembly();
2689 carbonfiberassemblyvolumes[1] = GetCarbonFiberSupport();
2690 carbonfiberassemblyvolumes[2] = GetCarbonFiberLowerSupport();
d7599219 2691 for(Int_t i=0; i<fgkCarbonFiberAssemblyCombiTransNumber;i++)
44285dfa 2692 carbonfiberassemblysupport->AddNode(carbonfiberassemblyvolumes[i],1,
2693 fCarbonFiberAssemblyCombiTransMatrix[i]);
2694 return carbonfiberassemblysupport;
d7599219 2695}
2696////////////////////////////////////////////////////////////////////////////////
2697TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupport(){
44285dfa 2698 /////////////////////////////////////////////////////////////
2699 // Method generating the Cooling Tube Support
2700 /////////////////////////////////////////////////////////////
2701 const Int_t kvertexnumber = 3;
2702 Double_t phi = TMath::ASin(0.5*fgkCoolingTubeSupportHeight
d7599219 2703 / fgkCoolingTubeSupportRmax)*TMath::RadToDeg();
d7599219 2704 new TGeoTubeSeg("CoolingTubeSegShape",0.0,
2705 fgkCoolingTubeSupportRmax,
44285dfa 2706 0.5*fgkCoolingTubeSupportWidth,phi,
2707 360-phi);
d7599219 2708 new TGeoTube("CoolingTubeHoleShape",0.0,
2709 fgkCoolingTubeSupportRmin,
2710 0.5*fgkCoolingTubeSupportWidth);
44285dfa 2711 TVector3* vertexposition[kvertexnumber];
d7599219 2712 ///////////////////////////
2713 //Shape Vertex Positioning
2714 ///////////////////////////
44285dfa 2715 vertexposition[0] = new TVector3();
2716 vertexposition[1] = new TVector3(fgkCoolingTubeSupportRmax
2717 * TMath::Cos(phi*TMath::DegToRad()),
d7599219 2718 fgkCoolingTubeSupportRmax
44285dfa 2719 * TMath::Sin(phi*TMath::DegToRad()));
2720 vertexposition[2] = new TVector3(vertexposition[1]->X(),
2721 - vertexposition[1]->Y());
2722 GetTriangleShape(vertexposition,
d7599219 2723 fgkCoolingTubeSupportWidth,
2724 "CoolingTubeTriangleShape");
44285dfa 2725 Double_t* boxorigin = new Double_t[3];
2726 Double_t boxlength = fgkCoolingTubeSupportLength-fgkCoolingTubeSupportRmax
2727 - vertexposition[1]->X();
2728 boxorigin[0] = vertexposition[1]->X()+0.5*boxlength, boxorigin[1] = boxorigin[2] = 0.;
2729 new TGeoBBox("CoolingTubeBoxShape",0.5*boxlength,
d7599219 2730 0.5*fgkCoolingTubeSupportHeight,
44285dfa 2731 0.5*fgkCoolingTubeSupportWidth,boxorigin);
2732 TGeoCompositeShape* coolingtubesupportshape =
d7599219 2733 new TGeoCompositeShape("CoolingTubeSupportShape",
2734 "(CoolingTubeSegShape+CoolingTubeTriangleShape"
2735 "+CoolingTubeBoxShape)-CoolingTubeHoleShape");
44285dfa 2736 TGeoVolume* coolingtubesupport = new TGeoVolume("CoolingTubeSupport",
2737 coolingtubesupportshape,fSSDTubeHolderMedium);
2738 return coolingtubesupport;
d7599219 2739}
2740////////////////////////////////////////////////////////////////////////////////
2741TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeSupportAssembly(){
44285dfa 2742 /////////////////////////////////////////////////////////////
2743 // Method generating the Cooling Tube Support Assembly
2744 /////////////////////////////////////////////////////////////
2745 TGeoVolume* coolingtubesupportassembly =
d7599219 2746 new TGeoVolumeAssembly("CoolingTubeSupportAssembly");
44285dfa 2747 TGeoVolume* coolingtubesupport = GetCoolingTubeSupport();
d7599219 2748 SetCoolingTubeSupportCombiTransMatrix();
2749 for(Int_t i=0; i<fgkCoolingTubeSupportCombiTransNumber;i++)
44285dfa 2750 coolingtubesupportassembly->AddNode(coolingtubesupport,i+1,
2751 fCoolingTubeSupportCombiTransMatrix[i]);
2752 return coolingtubesupportassembly;
d7599219 2753}
2754////////////////////////////////////////////////////////////////////////////////
44285dfa 2755TGeoVolume* AliITSv11GeometrySSD::GetCoolingTube() const{
2756 /////////////////////////////////////////////////////////////
2757 // Method generating the Cooling Tube
2758 /////////////////////////////////////////////////////////////
2759 TGeoVolume* coolingtubeassembly = new TGeoVolumeAssembly("CoolingTubeAssembly");
2760 TGeoTube *coolingtubeshape = new TGeoTube("CoolingTubeShape", fgkCoolingTubeRmin,
d7599219 2761 fgkCoolingTubeRmax, fgkCoolingTubeLength/2.0);
44285dfa 2762 TGeoVolume* coolingtube = new TGeoVolume("CoolingTube",
2763 coolingtubeshape,fSSDCoolingTubePhynox);
2764 TGeoTube *coolingtubeinteriorshape = new TGeoTube("CoolingTubeInteriorShape",
d7599219 2765 0, fgkCoolingTubeRmin,
2766 fgkCoolingTubeLength/2.0);
44285dfa 2767 TGeoVolume *coolingtubeinterior = new TGeoVolume("CoolingTubeInterior",
2768 coolingtubeinteriorshape,fSSDCoolingTubeWater);
2769 coolingtubeassembly->AddNode(coolingtube,1);
2770 coolingtubeassembly->AddNode(coolingtubeinterior,2);
2771 return coolingtubeassembly;
d7599219 2772}
2773////////////////////////////////////////////////////////////////////////////////
2774TGeoVolume* AliITSv11GeometrySSD::GetCoolingTubeAssembly(){
44285dfa 2775 /////////////////////////////////////////////////////////////
2776 // Method generating the Cooling Tube Assembly
2777 /////////////////////////////////////////////////////////////
2778 TGeoVolume* coolingtubeassembly = new TGeoVolumeAssembly("CoolingTubeAssembly");
2779 TGeoVolume* coolingtube = GetCoolingTube();
d7599219 2780 SetCoolingTubeCombiTransMatrix();
2781 for(Int_t i=0; i<fgkCoolingTubeCombiTransNumber;i++)
44285dfa 2782 coolingtubeassembly->AddNode(coolingtube,i+1,fCoolingTubeTransMatrix[i]);
2783 return coolingtubeassembly;
d7599219 2784}
2785////////////////////////////////////////////////////////////////////////////////
2786TGeoVolume* AliITSv11GeometrySSD::GetLadderSegment(Int_t iChipCablesHeight){
44285dfa 2787 /////////////////////////////////////////////////////////////
2788 // Method generating the basic Ladder Segment element which will be replicated
2789 /////////////////////////////////////////////////////////////
2790 TGeoVolume*laddersegment = new TGeoVolumeAssembly("LadderSegment");
2791 TGeoVolume* laddersegmentvolumes[fgkLadderSegmentCombiTransNumber];
2792 laddersegmentvolumes[0] = GetCarbonFiberAssemblySupport();
2793 laddersegmentvolumes[1] = GetSSDModule(iChipCablesHeight);
2794 laddersegmentvolumes[2] = GetSSDSensorSupportAssembly(iChipCablesHeight);
2795 laddersegmentvolumes[3] = GetCoolingTubeSupportAssembly();
2796 laddersegmentvolumes[4] = GetCoolingTubeAssembly();
2797 SetLadderSegmentCombiTransMatrix();
2798 for(Int_t i=0; i<fgkLadderSegmentCombiTransNumber; i++)
2799 laddersegment->AddNode(laddersegmentvolumes[i],1,
2800 fLadderSegmentCombiTransMatrix[i]);
2801 return laddersegment;
2802 }
d7599219 2803////////////////////////////////////////////////////////////////////////////////
2804TList* AliITSv11GeometrySSD::GetEndLadderSegment(){
44285dfa 2805 /////////////////////////////////////////////////////////////
2806 // Method generating the Terminal Ladder Segment
2807 /////////////////////////////////////////////////////////////
2808 const Int_t kendladdersegmentnumber = 2;
2809 TList* endladdercarbonfiberjunctionlist = GetEndLadderCarbonFiberJunctionAssembly();
2810 TGeoVolume* endladdersegment[kendladdersegmentnumber];
2811 endladdersegment[0] = new TGeoVolumeAssembly("EndLadderSegment1");
2812 endladdersegment[1] = new TGeoVolumeAssembly("EndLadderSegment2");
2813 TGeoVolume** laddersegmentvolumes[kendladdersegmentnumber];
2814 const Int_t kladdersegmentvolumenumber = 4;
2815 for(Int_t i=0; i<kendladdersegmentnumber; i++) laddersegmentvolumes[i] =
2816 new TGeoVolume*[kladdersegmentvolumenumber];
2817 laddersegmentvolumes[0][0] = (TGeoVolume*)endladdercarbonfiberjunctionlist->At(0);
2818 laddersegmentvolumes[0][1] = GetCarbonFiberSupport();
2819 laddersegmentvolumes[0][2] = GetSSDMountingBlock();
2820 laddersegmentvolumes[0][3] = GetCarbonFiberLowerSupport(0,true);
2821 laddersegmentvolumes[1][0] = (TGeoVolume*)endladdercarbonfiberjunctionlist->At(1);
2822 laddersegmentvolumes[1][1] = laddersegmentvolumes[0][1];
2823 laddersegmentvolumes[1][2] = laddersegmentvolumes[0][2];
2824 laddersegmentvolumes[1][3] = GetCarbonFiberLowerSupport(1,true);
2825 TList* endladdersegmentlist = new TList();
2826 for(Int_t i=0; i<kendladdersegmentnumber; i++){
d7599219 2827 SetEndLadderSegmentCombiTransMatrix(i);
44285dfa 2828 for(Int_t j=0; j<kladdersegmentvolumenumber; j++)
2829 endladdersegment[i]->AddNode(laddersegmentvolumes[i][j],1,
2830 fEndLadderSegmentCombiTransMatrix[j]);
2831 endladdersegmentlist->Add(endladdersegment[i]);
d7599219 2832 }
44285dfa 2833 return endladdersegmentlist;
d7599219 2834}
2835////////////////////////////////////////////////////////////////////////////////
2836TGeoVolume* AliITSv11GeometrySSD::GetSSDMountingBlock(){
44285dfa 2837 /////////////////////////////////////////////////////////////
2838 // Method generating the Mounting Block
2839 /////////////////////////////////////////////////////////////
d7599219 2840 // Mounting Block Boxes Shapes
2841 ///////////////////////////////////////
44285dfa 2842 const Int_t kmountingblockboxnumber = 3;
2843 TGeoBBox* mountingblockboxshape[kmountingblockboxnumber];
2844 mountingblockboxshape[0] = new TGeoBBox("MountingBlockBoxShape0",
d7599219 2845 0.25*(fgkSSDMountingBlockLength[0]
2846 - fgkSSDMountingBlockLength[1]),
2847 0.5*fgkSSDMountingBlockWidth,
2848 0.5*fgkSSDMountingBlockHeight[0]);
44285dfa 2849 mountingblockboxshape[1] = new TGeoBBox("MountingBlockBoxShape1",
d7599219 2850 0.25*(fgkSSDMountingBlockLength[1]
2851 - fgkSSDMountingBlockLength[2]),
2852 0.5*fgkSSDMountingBlockWidth,
2853 0.5*(fgkSSDMountingBlockHeight[1]
2854 - fgkSSDMountingBlockHeight[3]));
44285dfa 2855 mountingblockboxshape[2] = new TGeoBBox("MountingBlockBoxShape2",
d7599219 2856 0.5*fgkSSDMountingBlockLength[2],
2857 0.5*fgkSSDMountingBlockWidth,
2858 0.5*(fgkSSDMountingBlockHeight[2]
2859 - fgkSSDMountingBlockHeight[3]));
44285dfa 2860 TGeoTranslation* mountingblockboxtrans[kmountingblockboxnumber+2];
2861 mountingblockboxtrans[0] = new TGeoTranslation("MountingBlockBoxTrans0",0.,0.,0.);
2862 mountingblockboxtrans[1] = new TGeoTranslation("MountingBlockBoxTrans1",
2863 mountingblockboxshape[0]->GetDX()
2864 + mountingblockboxshape[1]->GetDX(),
d7599219 2865 0.0,
44285dfa 2866 mountingblockboxshape[1]->GetDZ()
2867 - mountingblockboxshape[0]->GetDZ()
d7599219 2868 + fgkSSDMountingBlockHeight[3]);
44285dfa 2869 mountingblockboxtrans[2] = new TGeoTranslation("MountingBlockBoxTrans2",
2870 mountingblockboxshape[0]->GetDX()
2871 + 2.*mountingblockboxshape[1]->GetDX()
2872 + mountingblockboxshape[2]->GetDX(),
d7599219 2873 0.0,
44285dfa 2874 mountingblockboxshape[2]->GetDZ()
2875 - mountingblockboxshape[0]->GetDZ()
d7599219 2876 + fgkSSDMountingBlockHeight[3]);
44285dfa 2877 mountingblockboxtrans[3] = new TGeoTranslation("MountingBlockBoxTrans3",
2878 mountingblockboxshape[0]->GetDX()
2879 + mountingblockboxshape[1]->GetDX()
2880 + 2.*(mountingblockboxshape[1]->GetDX()
2881 + mountingblockboxshape[2]->GetDX()),
d7599219 2882 0.0,
44285dfa 2883 mountingblockboxshape[1]->GetDZ()
2884 - mountingblockboxshape[0]->GetDZ()
d7599219 2885 + fgkSSDMountingBlockHeight[3]);
44285dfa 2886 mountingblockboxtrans[4] = new TGeoTranslation("MountingBlockBoxTrans4",
2887 2.*(mountingblockboxshape[0]->GetDX()
2888 + 2.*mountingblockboxshape[1]->GetDX()
2889 + mountingblockboxshape[2]->GetDX()),
d7599219 2890 0.0,
2891 0.0);
44285dfa 2892 for(Int_t i=0; i<kmountingblockboxnumber+2; i++)
2893 mountingblockboxtrans[i]->RegisterYourself();
d7599219 2894 ///////////////////////////////////////
2895 // Mounting Block Trapezoid Hole Shapes
2896 ///////////////////////////////////////
44285dfa 2897 const Int_t kholetrapezoidvertexnumber = 4;
2898 TVector3* holetrapezoidvertex[kholetrapezoidvertexnumber];
2899 holetrapezoidvertex[0] = new TVector3();
2900 holetrapezoidvertex[1] = new TVector3(fgkSSDMountingBlockHoleTrapezoidHeight);
2901 holetrapezoidvertex[2] = new TVector3(*holetrapezoidvertex[0]);
2902 holetrapezoidvertex[3] = new TVector3(*holetrapezoidvertex[1]);
2903 Double_t holetrapezoidwidth[2] = {fgkSSDMountingBlockHoleTrapezoidUpBasis
2904 + 2.*mountingblockboxshape[1]->GetDX()
d7599219 2905 * TMath::Tan(fgkSSDMountingBlockHoleTrapezoidAngle
2906 * TMath::DegToRad()),
2907 fgkSSDMountingBlockHoleTrapezoidUpBasis};
44285dfa 2908 GetArbShape(holetrapezoidvertex,
2909 holetrapezoidwidth,
2910 2.*mountingblockboxshape[1]->GetDX(),
d7599219 2911 "HoleTrapezoidShape");
44285dfa 2912 TGeoRotation* holetrapezoidshaperot[2];
2913 holetrapezoidshaperot[0] = new TGeoRotation("HoleTrapezoidShapeRot0",
d7599219 2914 90.,-90.,-90.);
44285dfa 2915 holetrapezoidshaperot[1] = new TGeoRotation("HoleTrapezoidShapeRot1",
d7599219 2916 -180.,0.,0.);
44285dfa 2917 TGeoCombiTrans* holetrapezoidshapecombitrans =
d7599219 2918 new TGeoCombiTrans("HoleTrapezoidShapeCombiTrans",
44285dfa 2919 mountingblockboxshape[0]->GetDX()
2920 + 3.*mountingblockboxshape[1]->GetDX()
2921 + 2.*mountingblockboxshape[2]->GetDX(),
d7599219 2922 0.5*fgkSSDMountingBlockWidth,
2923 - fgkSSDMountingBlockHoleTrapezoidHeight
44285dfa 2924 + 2.*mountingblockboxshape[1]->GetDZ()
2925 - mountingblockboxshape[0]->GetDZ()
d7599219 2926 + fgkSSDMountingBlockHeight[3],
44285dfa 2927 new TGeoRotation((*holetrapezoidshaperot[1])
2928 * (*holetrapezoidshaperot[0])));
2929 holetrapezoidshapecombitrans->RegisterYourself();
d7599219 2930 ///////////////////////////////////
2931 // Mounting Block Screw Hole Shapes
2932 ///////////////////////////////////
44285dfa 2933 const Int_t kmountingblocktubenumber = 2;
2934 TGeoTube* mountingblocktubeshape[kmountingblocktubenumber];
2935 mountingblocktubeshape[0] = new TGeoTube("MountingBlockTubeShape0",0.0,
d7599219 2936 fgkSSDMountingBlockHoleRadius,
44285dfa 2937 mountingblockboxshape[0]->GetDZ());
2938 mountingblocktubeshape[1] = new TGeoTube("MountingBlockTubeShape1",0.0,
d7599219 2939 fgkSSDMountingBlockHoleRadius,
44285dfa 2940 mountingblockboxshape[2]->GetDZ());
2941 TGeoTranslation* mountingblocktubetrans[2*kmountingblocktubenumber];
2942 mountingblocktubetrans[0] = new TGeoTranslation("MountingBlockTubeTrans0",
d7599219 2943 - 0.5*(fgkSSDMountingBlockLength[0]
2944 - fgkSSDMountingBlockHoleTubeLength[0]),
2945 0.5*fgkSSDMountingBlockWidth
2946 - fgkSSDMountingBlockHoleTubeWidth[0],0.);
44285dfa 2947 mountingblocktubetrans[1] = new TGeoTranslation("MountingBlockTubeTrans1",
d7599219 2948 - 0.5*(fgkSSDMountingBlockLength[0]
2949 - fgkSSDMountingBlockHoleTubeLength[0])
2950 + fgkSSDMountingBlockHoleTubeLength[0],
2951 - 0.5*fgkSSDMountingBlockWidth
2952 + fgkSSDMountingBlockHoleTubeWidth[0],
2953 0.);
44285dfa 2954 mountingblocktubetrans[2] = new TGeoTranslation("MountingBlockTubeTrans2",
2955 - mountingblockboxshape[0]->GetDX()
d7599219 2956 + 0.5*fgkSSDMountingBlockLength[0]
2957 - fgkSSDMountingBlockHoleTubeLength[1],
2958 0.5*fgkSSDMountingBlockWidth
2959 - fgkSSDMountingBlockHoleTubeWidth[0],
44285dfa 2960 mountingblockboxshape[2]->GetDZ()
2961 - mountingblockboxshape[0]->GetDZ()
d7599219 2962 + fgkSSDMountingBlockHeight[3]);
44285dfa 2963 mountingblocktubetrans[3] = new TGeoTranslation("MountingBlockTubeTrans3",
2964 - mountingblockboxshape[0]->GetDX()
d7599219 2965 + 0.5*fgkSSDMountingBlockLength[0],
2966 - 0.5*fgkSSDMountingBlockWidth
2967 + fgkSSDMountingBlockHoleTubeWidth[1],
44285dfa 2968 mountingblockboxshape[2]->GetDZ()
2969 - mountingblockboxshape[0]->GetDZ()
d7599219 2970 + fgkSSDMountingBlockHeight[3]);
44285dfa 2971 for(Int_t i=0; i<2*kmountingblocktubenumber; i++)
2972 mountingblocktubetrans[i]->RegisterYourself();
d7599219 2973 new TGeoCompositeShape("MountingBlockMainShape",
2974 "MountingBlockBoxShape0:MountingBlockBoxTrans0+"
2975 "MountingBlockBoxShape1:MountingBlockBoxTrans1+"
2976 "MountingBlockBoxShape2:MountingBlockBoxTrans2+"
2977 "MountingBlockBoxShape1:MountingBlockBoxTrans3+"
2978 "MountingBlockBoxShape0:MountingBlockBoxTrans4");
2979 ////////////////////////////////////////////
2980 // Mounting Block Screw Composite Hole Shapes
2981 ////////////////////////////////////////////
44285dfa 2982 const Int_t kmountingblockholetubesegnumber = 4;
d7599219 2983 new TGeoTubeSeg("MountingBlockHoleTubeSegShape",
2984 0.0,
2985 fgkSSDMountingBlockScrewHoleRadius[0],
2986 0.5*fgkSSDMountingBlockScrewHoleHeigth,-90.,180.);
44285dfa 2987 TGeoCombiTrans* mountingblockholetubesegcombitrans[kmountingblockholetubesegnumber];
2988 char* mountingblockholetubesegcombitransname[kmountingblockholetubesegnumber] =
d7599219 2989 { "MountingBlockHoleTubeSegCombiTrans0",
2990 "MountingBlockHoleTubeSegCombiTrans1",
2991 "MountingBlockHoleTubeSegCombiTrans2",
2992 "MountingBlockHoleTubeSegCombiTrans3"};
44285dfa 2993 for(Int_t i=0; i<kmountingblockholetubesegnumber; i++){
2994 mountingblockholetubesegcombitrans[i] =
2995 new TGeoCombiTrans(mountingblockholetubesegcombitransname[i],
d7599219 2996 0.5*fgkSSDMountingBlockScrewHoleEdge*TMath::Sqrt(2)
2997 * TMath::Cos(45*(2*i+1)*TMath::DegToRad()),
2998 0.5*fgkSSDMountingBlockScrewHoleEdge*TMath::Sqrt(2)
2999 * TMath::Sin(45*(2*i+1)*TMath::DegToRad()),
3000 0.0,
3001 new TGeoRotation("",90.*i,0.,0.));
44285dfa 3002 mountingblockholetubesegcombitrans[i]->RegisterYourself();
d7599219 3003 }
44285dfa 3004 TGeoBBox* mountingblockholeboxshape =
d7599219 3005 new TGeoBBox("MountingBlockHoleBoxShape",
3006 0.5*fgkSSDMountingBlockScrewHoleEdge,
3007 0.5*fgkSSDMountingBlockScrewHoleEdge,
3008 0.5*fgkSSDMountingBlockScrewHoleHeigth);
44285dfa 3009 TGeoCompositeShape* mountingblockscrewhole[2];
3010 mountingblockscrewhole[0] =
d7599219 3011 new TGeoCompositeShape("MountingBlockScrewHole0",
3012 "MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans0+"
3013 "MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans1+"
3014 "MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans2+"
3015 "MountingBlockHoleTubeSegShape:MountingBlockHoleTubeSegCombiTrans3+"
3016 "MountingBlockHoleBoxShape");
d7599219 3017 new TGeoTubeSeg("MountingBlockLowerHoleTubeSegShape",
3018 0.0,
3019 fgkSSDMountingBlockScrewHoleRadius[1],
3020 0.5*(fgkSSDMountingBlockHoleTubeWidth[0]
3021 - fgkSSDMountingBlockScrewHoleHeigth
3022 - fgkSSDMountingBlockHeight[3]),0.,90.);
44285dfa 3023 TGeoCombiTrans* mountingblocklowerholetubesegcombitrans[kmountingblockholetubesegnumber];
3024 char* mountingblocklowerholetubesegcombitransname[kmountingblockholetubesegnumber] =
d7599219 3025 { "MountingBlockLowerHoleTubeSegCombiTrans0",
3026 "MountingBlockLowerHoleTubeSegCombiTrans1",
3027 "MountingBlockLowerHoleTubeSegCombiTrans2",
3028 "MountingBlockLowerHoleTubeSegCombiTrans3"};
44285dfa 3029 for(Int_t i=0; i<kmountingblockholetubesegnumber; i++){
3030 mountingblocklowerholetubesegcombitrans[i] =
3031 new TGeoCombiTrans(mountingblocklowerholetubesegcombitransname[i],
d7599219 3032 0.5*(fgkSSDMountingBlockScrewHoleEdge
3033 - 2.*fgkSSDMountingBlockScrewHoleRadius[1])
3034 * TMath::Sqrt(2)*TMath::Cos(45*(2*i+1)*TMath::DegToRad()),
3035 0.5*(fgkSSDMountingBlockScrewHoleEdge
3036 - 2.0*fgkSSDMountingBlockScrewHoleRadius[1])
3037 * TMath::Sqrt(2)*TMath::Sin(45*(2*i+1)*TMath::DegToRad()),0.,
3038 new TGeoRotation("",90.*i,0.,0.));
44285dfa 3039 mountingblocklowerholetubesegcombitrans[i]->RegisterYourself();
d7599219 3040 }
3041 Double_t fgkSSDMountingBlockLowerScrewHoleEdge = fgkSSDMountingBlockScrewHoleEdge
3042 - 2.*fgkSSDMountingBlockScrewHoleRadius[1];
44285dfa 3043 TGeoBBox* mountingblocklowerholeboxshape[2];
3044 mountingblocklowerholeboxshape[0] =
d7599219 3045 new TGeoBBox("MountingBlockLowerHoleBoxShape0",
3046 0.5*fgkSSDMountingBlockLowerScrewHoleEdge,
3047 0.5*fgkSSDMountingBlockLowerScrewHoleEdge,
3048 0.5*(fgkSSDMountingBlockHoleTubeWidth[0]
3049 - fgkSSDMountingBlockScrewHoleHeigth
3050 - fgkSSDMountingBlockHeight[3]));
44285dfa 3051 mountingblocklowerholeboxshape[1] =
d7599219 3052 new TGeoBBox("MountingBlockLowerHoleBoxShape1",
3053 0.5*fgkSSDMountingBlockLowerScrewHoleEdge,
3054 0.5*fgkSSDMountingBlockScrewHoleRadius[1],
3055 0.5*(fgkSSDMountingBlockHoleTubeWidth[0]
3056 - fgkSSDMountingBlockScrewHoleHeigth
3057 - fgkSSDMountingBlockHeight[3]));
44285dfa 3058 TGeoCombiTrans* mountingblocklowerholeBoxcombitrans[kmountingblockholetubesegnumber];
3059 char* mountingBlockLowerHoleBoxCombiTransName[kmountingblockholetubesegnumber] =
d7599219 3060 { "MountingBlockLowerHoleBoxCombiTrans0",
3061 "MountingBlockLowerHoleBoxCombiTrans1",
3062 "MountingBlockLowerHoleBoxCombiTrans2",
3063 "MountingBlockLowerHoleBoxCombiTrans3"};
44285dfa 3064 for(Int_t i=0; i<kmountingblockholetubesegnumber; i++){
3065 mountingblocklowerholeBoxcombitrans[i] =
3066 new TGeoCombiTrans(mountingBlockLowerHoleBoxCombiTransName[i],
d7599219 3067 0.5*(fgkSSDMountingBlockLowerScrewHoleEdge
3068 + fgkSSDMountingBlockScrewHoleRadius[1])
3069 * TMath::Cos(90*(i+1)*TMath::DegToRad()),
3070 0.5*(fgkSSDMountingBlockLowerScrewHoleEdge
3071 + fgkSSDMountingBlockScrewHoleRadius[1])
3072 * TMath::Sin(90*(i+1)*TMath::DegToRad()),0.,
3073 new TGeoRotation("",90.*i,0.,0.));
44285dfa 3074 mountingblocklowerholeBoxcombitrans[i]->RegisterYourself();
d7599219 3075 }
44285dfa 3076 mountingblockscrewhole[1] = new TGeoCompositeShape("MountingBlockScrewHole1",
d7599219 3077 "MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans0+"
3078 "MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans1+"
3079 "MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans2+"
3080 "MountingBlockLowerHoleTubeSegShape:MountingBlockLowerHoleTubeSegCombiTrans3+"
3081 "MountingBlockLowerHoleBoxShape0+"
3082 "MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans0+"
3083 "MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans1+"
3084 "MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans2+"
3085 "MountingBlockLowerHoleBoxShape1:MountingBlockLowerHoleBoxCombiTrans3");
44285dfa 3086 TGeoTranslation* mountingblockscrewhole1trans =
d7599219 3087 new TGeoTranslation("MountingBlockScrewHole1Trans",0.,0.,
44285dfa 3088 - mountingblocklowerholeboxshape[0]->GetDZ()
3089 - mountingblockholeboxshape->GetDZ());
3090 mountingblockscrewhole1trans->RegisterYourself();
d7599219 3091 new TGeoCompositeShape("MountingBlockHole",
3092 "MountingBlockScrewHole0+MountingBlockScrewHole1:MountingBlockScrewHole1Trans");
44285dfa 3093 TGeoTranslation* mountingblockholetrans = new TGeoTranslation("MountingBlockHoleTrans",
d7599219 3094 0.5*fgkSSDMountingBlockLength[0]
44285dfa 3095 - mountingblockboxshape[0]->GetDZ(),
d7599219 3096 0.0,
44285dfa 3097 2.*mountingblockboxshape[2]->GetDZ()
3098 - mountingblockboxshape[0]->GetDZ()
d7599219 3099 + fgkSSDMountingBlockHeight[3]
44285dfa 3100 - mountingblockholeboxshape->GetDZ());
3101 mountingblockholetrans->RegisterYourself();
3102 TGeoCompositeShape* mountingblockshape = new TGeoCompositeShape("MountingBlockShape",
d7599219 3103 "MountingBlockMainShape-(MountingBlockTubeShape0:MountingBlockTubeTrans0+"
3104 "MountingBlockTubeShape0:MountingBlockTubeTrans1+"
3105 "MountingBlockTubeShape1:MountingBlockTubeTrans2+"
3106 "MountingBlockTubeShape1:MountingBlockTubeTrans3+"
3107 "HoleTrapezoidShape:HoleTrapezoidShapeCombiTrans+"
3108 "MountingBlockHole:MountingBlockHoleTrans)");
44285dfa 3109 TGeoVolume* ssdmountingblock = new TGeoVolume("SSDMountingBlock",
3110 mountingblockshape,fSSDMountingBlockMedium);
3111 return ssdmountingblock;
d7599219 3112}
3113////////////////////////////////////////////////////////////////////////////////
3114TGeoVolume* AliITSv11GeometrySSD::GetLadder(Int_t iLayer){
44285dfa 3115 /////////////////////////////////////////////////////////////
3116 // Method generating the Layer5 or Layer6 Ladder
3117 /////////////////////////////////////////////////////////////
3118 TGeoVolume* ladder = new TGeoVolumeAssembly(iLayer==5 ? "ITSssdLay5Ladd"
d7599219 3119 : "ITSssdLay6Ladd");
44285dfa 3120 TGeoVolume* laddersegment[2];
3121 laddersegment[0] = GetLadderSegment(0);
3122 laddersegment[1] = GetLadderSegment(1);
3123 TList* endladdersegmentlist = GetEndLadderSegment();
3124 Double_t beamaxistransvector = fgkCarbonFiberJunctionWidth;
3125 Int_t ssdlaysensorsnumber = (iLayer==5 ?
d7599219 3126 fgkSSDLay5SensorsNumber :
3127 fgkSSDLay6SensorsNumber);
44285dfa 3128 for(Int_t i=0; i<ssdlaysensorsnumber; i++) ladder->AddNode(i%2==0 ?
3129 laddersegment[iLayer==5 ? 0 : 1] :
3130 laddersegment[iLayer==5 ? 1 : 0],
9acf2ecc 3131 ssdlaysensorsnumber-i-1,new TGeoTranslation(-0.5*fgkCarbonFiberTriangleLength,
44285dfa 3132 beamaxistransvector*i,0.));
3133 ladder->AddNode((TGeoVolume*)endladdersegmentlist->At(0),1,
d7599219 3134 new TGeoTranslation("",-0.5*fgkCarbonFiberTriangleLength,
44285dfa 3135 fgkCarbonFiberJunctionWidth*ssdlaysensorsnumber,0.));
3136 ladder->AddNode((TGeoVolume*)endladdersegmentlist->At(1),1,
d7599219 3137 new TGeoCombiTrans("",0.5*fgkCarbonFiberTriangleLength,
3138 0.,0.,new TGeoRotation("",180.,0.,0.)));
3139/////////////////////////////////////////////////////////////////////////////
3140/// Placing Ladder Cables
3141/////////////////////////////////////////////////////////////////////////////
3142 SetLadderCableCombiTransMatrix(iLayer);
44285dfa 3143 Int_t sidecablenumber[2] = {0,0};
d7599219 3144 switch(iLayer){
3145 case 5:
44285dfa 3146 sidecablenumber[0] = fgkSSDLay5SensorsNumber/2+1;
3147 sidecablenumber[1] = sidecablenumber[0]-2;
d7599219 3148 break;
3149 case 6:
44285dfa 3150 sidecablenumber[0] = (fgkSSDLay6SensorsNumber-1)/2+1;
3151 sidecablenumber[1] = sidecablenumber[0]-1;
d7599219 3152 break;
3153 }
44285dfa 3154 const Double_t* carbonfibertomoduleposition =
3155 fLadderSegmentCombiTransMatrix[1]->GetTranslation();
3156 Double_t ssdendladdercablelength[4];
3157 ssdendladdercablelength[0] = carbonfibertomoduleposition[1]
d7599219 3158 + fgkSSDSensorLength
3159 - fgkSSDModuleStiffenerPosition[1]
3160 - fgkSSDStiffenerWidth
3161 - fgkSSDFlexWidth[0]
3162 + fgkEndLadderCarbonFiberLowerJunctionLength[1];
44285dfa 3163 ssdendladdercablelength[1] = carbonfibertomoduleposition[1]
d7599219 3164 + fgkSSDModuleStiffenerPosition[1]
3165 + fgkSSDStiffenerWidth
3166 + fgkEndLadderCarbonFiberLowerJunctionLength[1];
44285dfa 3167 ssdendladdercablelength[2] = ssdendladdercablelength[1]
d7599219 3168 - fgkEndLadderCarbonFiberLowerJunctionLength[1]
3169 + fgkEndLadderCarbonFiberLowerJunctionLength[0];
44285dfa 3170 ssdendladdercablelength[3] = fgkCarbonFiberJunctionWidth-(fgkSSDSensorLength
3171 + carbonfibertomoduleposition[1]
d7599219 3172 - fgkSSDModuleStiffenerPosition[1]
3173 - fgkSSDStiffenerWidth)
3174 + fgkEndLadderCarbonFiberLowerJunctionLength[1];
44285dfa 3175 TList* laddercableassemblylist[4];
3176 const Int_t kendladdercablesnumber = 4;
3177 for(Int_t i=0; i<kendladdercablesnumber; i++){
3178 laddercableassemblylist[i] =
3179 GetLadderCableAssemblyList(sidecablenumber[i<2?0:1],
3180 ssdendladdercablelength[i]);
3181 ladder->AddNode((TGeoVolume*)laddercableassemblylist[i]->At(i%2==0?0:1),
3182 i<2?1:2,fLadderCableCombiTransMatrix[i]);
d7599219 3183 }
44285dfa 3184 return ladder;
d7599219 3185}
3186////////////////////////////////////////////////////////////////////////////////
3187TGeoVolume* AliITSv11GeometrySSD::GetLayer(Int_t iLayer){
44285dfa 3188 /////////////////////////////////////////////////////////////
3189 // Method generating the Layer5 or Layer6
3190 /////////////////////////////////////////////////////////////
3191 TGeoVolume* layer = new TGeoVolumeAssembly(iLayer==5 ? "ITSssdLayer5"
d7599219 3192 : "ITSssdLayer6");
44285dfa 3193 TGeoVolume* ladder = GetLadder(iLayer);
d7599219 3194 /////////////////////////////////////////////////////
3195 // Setting the CombiTransformation to pass ITS center
3196 /////////////////////////////////////////////////////
44285dfa 3197 Double_t itscentertransz = iLayer==5 ? fgkSSDLay5LadderLength
d7599219 3198 - fgkLay5CenterITSPosition:
3199 fgkSSDLay6LadderLength
3200 - fgkLay6CenterITSPosition;
44285dfa 3201 Double_t itssensorytrans = fgkSSDModuleCoolingBlockToSensor
d7599219 3202 + 0.5* fgkCoolingTubeSupportHeight
3203 -(iLayer==5 ? fgkSSDSensorSideSupportHeight[1]
3204 - fgkSSDSensorSideSupportHeight[0]: 0.);
44285dfa 3205 TGeoRotation* itscenterrot[3];
3206 itscenterrot[0] = new TGeoRotation("ITSCenterRot0",90.,180.,-90.);
3207 itscenterrot[1] = new TGeoRotation("ITSCenterRot1",0.,90.,0.);
3208 itscenterrot[2] = new TGeoRotation((*itscenterrot[1])*(*itscenterrot[0]));
3209 TGeoCombiTrans* itscentercombitrans = new TGeoCombiTrans("ITSCenterCombiTrans",0.,
3210 fgkSSDMountingBlockHeight[1]+itssensorytrans,
d7599219 3211 fgkEndLadderCarbonFiberLowerJunctionLength[1]
44285dfa 3212 - itscentertransz,itscenterrot[2]);
d7599219 3213 /////////////////////////////////////////////////////
3214 // Setting the Ladder into the Layer
3215 /////////////////////////////////////////////////////
44285dfa 3216 TGeoCombiTrans* lay5laddercombitrans[fgkSSDLay5LadderNumber];
3217 TGeoCombiTrans* lay6laddercombitrans[fgkSSDLay6LadderNumber];
3218 TGeoHMatrix* lay5ladderhmatrix[fgkSSDLay5LadderNumber];
3219 TGeoHMatrix* lay6ladderhmatrix[fgkSSDLay6LadderNumber];
3220 if(iLayer==5){
3221 Double_t lay5ladderangleposition = 360./fgkSSDLay5LadderNumber;
3222 char lay5laddercombitransname[30], lay5ladderrotname[30];
3223 for(Int_t i=0; i<fgkSSDLay5LadderNumber;i++){
3224 sprintf(lay5laddercombitransname,"Lay5LadderCombiTrans%i",i);
3225 sprintf(lay5ladderrotname,"Lay5LaddeRot%i",i);
3226 Double_t lay5layerradius = (i%2==0 ? fgkSSDLay5RadiusMin: fgkSSDLay5RadiusMax);
3227 lay5laddercombitrans[i] = new TGeoCombiTrans(lay5laddercombitransname,
3228 lay5layerradius * TMath::Cos((i+1)
3229 * lay5ladderangleposition*TMath::DegToRad()),
3230 lay5layerradius * TMath::Sin((i+1)
3231 * lay5ladderangleposition*TMath::DegToRad()),0.,
3232 new TGeoRotation(lay5ladderrotname,(i+1)
3233 * lay5ladderangleposition-90,0.,0.));
3234 lay5ladderhmatrix[i] = new TGeoHMatrix((*lay5laddercombitrans[i])
3235 * (*itscentercombitrans));
9acf2ecc 3236 layer->AddNode(ladder,i,lay5ladderhmatrix[i]);
44285dfa 3237 }
3238 }
3239 else{
3240 Double_t lay6ladderangleposition = 360./fgkSSDLay6LadderNumber;
3241 char lay6laddercombitransname[30], lay6ladderrotname[30];
3242 for(Int_t i=0; i<fgkSSDLay6LadderNumber;i++){
3243 sprintf(lay6laddercombitransname,"Lay6LadderCombiTrans%i",i);
3244 sprintf(lay6ladderrotname,"Lay6LaddeRot%i",i);
3245 Double_t lay6layerradius = (i%2==0 ? fgkSSDLay6RadiusMin: fgkSSDLay6RadiusMax);
3246 lay6laddercombitrans[i] = new TGeoCombiTrans(lay6laddercombitransname,
3247 lay6layerradius * TMath::Cos((i+1)
3248 * lay6ladderangleposition*TMath::DegToRad()),
3249 lay6layerradius * TMath::Sin((i+1)
3250 * lay6ladderangleposition*TMath::DegToRad()),0.,
3251 new TGeoRotation(lay6ladderrotname,(i+1)
3252 * lay6ladderangleposition-90,0.,0.));
3253 lay6ladderhmatrix[i] = new TGeoHMatrix((*lay6laddercombitrans[i])
3254 * (*itscentercombitrans));
9acf2ecc 3255 layer->AddNode(ladder,i,lay6ladderhmatrix[i]);
d7599219 3256 }
44285dfa 3257 }
3258 return layer;
d7599219 3259}
3260////////////////////////////////////////////////////////////////////////////////
3261void AliITSv11GeometrySSD::Layer5(TGeoVolume* moth){
44285dfa 3262 /////////////////////////////////////////////////////////////
3263 // Insert the layer 5 in the mother volume.
3264 /////////////////////////////////////////////////////////////
3265 if (! moth) {
3266 printf("Error::AliITSv11GeometrySSD: Can't insert layer5, mother is null!\n");
3267 return;
3268 };
3269 fMotherVol = moth;
3270 moth->AddNode(GetLayer(5),1,0);
3271 }
d7599219 3272////////////////////////////////////////////////////////////////////////////////
3273void AliITSv11GeometrySSD::Layer6(TGeoVolume* moth){
44285dfa 3274 /////////////////////////////////////////////////////////////
3275 // Insert the layer 6 in the mother volume.
3276 /////////////////////////////////////////////////////////////
3277 if (! moth) {
3278 printf("Error::AliITSv11GeometrySSD: Can't insert layer6, mother is null!\n");
3279 return;
3280 };
3281 fMotherVol = moth;
3282 moth->AddNode(GetLayer(6),1,0);
3283 }
d7599219 3284////////////////////////////////////////////////////////////////////////////////
3285TGeoArb8* AliITSv11GeometrySSD::GetTrapezoidShape(TVector3* vertexpos[],
44285dfa 3286 Double_t* width, Double_t height, char* shapename) const{
3287 /////////////////////////////////////////////////////////////
3288 // Method generating a trapezoid shape
3289 /////////////////////////////////////////////////////////////
3290 const Int_t kvertexnumber = 4;
3291 const Int_t ktransvectnumber = 2;
3292 TVector3* vertex[kvertexnumber];
3293 TVector3* transvector[2];
3294 for(Int_t i=0; i<ktransvectnumber; i++)
3295 transvector[i] = new TVector3(0.,width[i]);
3296 /////////////////////////////////////////////////////////////
d7599219 3297 //Setting the vertices
44285dfa 3298 /////////////////////////////////////////////////////////////
3299 vertex[0] = new TVector3(*vertexpos[0]);
3300 vertex[1] = new TVector3(*vertexpos[1]);
3301 vertex[2] = new TVector3(*vertex[1]+*transvector[1]);
3302 vertex[3] = new TVector3(*vertex[0]+*transvector[0]);
3303 TGeoArb8* trapezoidshape = new TGeoArb8(shapename,0.5*height);
3304 for(Int_t i=0; i<2*kvertexnumber; i++)
3305 trapezoidshape->SetVertex(i,vertex[(i<kvertexnumber ? i : i-kvertexnumber)]->X(),
3306 vertex[(i<kvertexnumber ? i : i-kvertexnumber)]->Y());
3307 return trapezoidshape;
d7599219 3308}
3309////////////////////////////////////////////////////////////////////////////////
3310TGeoArb8* AliITSv11GeometrySSD::GetArbShape(TVector3* vertexpos[], Double_t* width,
44285dfa 3311 Double_t height, char* shapename, Int_t isign) const{
3312 /////////////////////////////////////////////////////////////
3313 // Method generating an Arb shape
3314 /////////////////////////////////////////////////////////////
3315 const Int_t kvertexnumber = 8;
3316 const Int_t ktransvectnumber = 2;
3317 TVector3* vertex[kvertexnumber];
3318 TVector3* transvector[2];
3319 for(Int_t i=0; i<ktransvectnumber; i++) transvector[i] = new TVector3(0.,width[i]);
3320 /////////////////////////////////////////////////////////////
d7599219 3321 //Setting the vertices for TGeoArb8
44285dfa 3322 /////////////////////////////////////////////////////////////
3323 vertex[0] = new TVector3(*vertexpos[0]);
3324 vertex[1] = new TVector3(*vertexpos[1]);
3325 vertex[2] = new TVector3(*vertex[1]+isign*(*transvector[0]));
3326 vertex[3] = new TVector3(*vertex[0]+isign*(*transvector[0]));
3327 vertex[4] = new TVector3(*vertexpos[2]);
3328 vertex[5] = new TVector3(*vertexpos[3]);
3329 vertex[6] = new TVector3(*vertex[5]+isign*(*transvector[1]));
3330 vertex[7] = new TVector3(*vertex[4]+isign*(*transvector[1]));
3331 /////////////////////////////////////////////////////////////
3332 TGeoArb8* arbshape = new TGeoArb8(shapename,0.5*height);
3333 for(Int_t i = 0; i<kvertexnumber;i++)
3334 arbshape->SetVertex(i,vertex[i]->X(),vertex[i]->Y());
3335 return arbshape;
d7599219 3336}
3337////////////////////////////////////////////////////////////////////////////////
3338TGeoArb8* AliITSv11GeometrySSD::GetTriangleShape(TVector3* vertexpos[],
44285dfa 3339 Double_t height, char* shapename) const{
3340 /////////////////////////////////////////////////////////////
3341 // Method generating a triangle shape
3342 /////////////////////////////////////////////////////////////
3343 const Int_t kvertexnumber = 4;
3344 TVector3* vertex[kvertexnumber];
d7599219 3345//////////////////////////////////////
3346 //Setting the vertices for TGeoArb8
3347 ////////////////////////////////////
44285dfa 3348 for(Int_t i = 0; i<kvertexnumber; i++)
3349 vertex[i] = new TVector3(i!=kvertexnumber-1?*vertexpos[i]:*vertex[kvertexnumber-1-i]);
3350 TGeoArb8* triangleshape = new TGeoArb8(shapename,0.5*height);
3351 for(Int_t i = 0; i<2*kvertexnumber; i++)
3352 triangleshape->SetVertex(i,vertex[(i < kvertexnumber ? i: i-kvertexnumber)]->X(),
3353 vertex[(i < kvertexnumber ? i : i-kvertexnumber)]->Y());
3354 return triangleshape;
d7599219 3355}
3356////////////////////////////////////////////////////////////////////////////////
44285dfa 3357TVector3* AliITSv11GeometrySSD::GetReflection(TVector3* vector,Double_t* param) const{
3358 /////////////////////////////////////////////////////////////
3359 // Given an axis specified by param, it gives the reflection of the point
3360 // respect to the axis
3361 /////////////////////////////////////////////////////////////
3362 TVector3* n = new TVector3(param[0],param[1],param[2]);
3363 Double_t d = ((*vector)*(*n)+param[3])/n->Mag2();
3364 TVector3* reflectedvector = new TVector3(*vector-2*d*(*n));
3365 return reflectedvector;
d7599219 3366}
3367////////////////////////////////////////////////////////////////////////////////
3368TGeoCombiTrans* AliITSv11GeometrySSD::AddTranslationToCombiTrans(TGeoCombiTrans* ct,
3369 Double_t dx,
3370 Double_t dy,
3371 Double_t dz) const{
44285dfa 3372 /////////////////////////////////////////////////////////////
d7599219 3373 // Add a dx,dy,dz translation to the initial TGeoCombiTrans
44285dfa 3374 /////////////////////////////////////////////////////////////
3375 TGeoCombiTrans* combiTrans = new TGeoCombiTrans(*ct);
3376 const Double_t *vect = combiTrans->GetTranslation();
3377 Double_t newvect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
3378 combiTrans->SetTranslation(newvect);
3379 return combiTrans;
d7599219 3380}
3381////////////////////////////////////////////////////////////////////////////////
d7599219 3382TGeoMedium* AliITSv11GeometrySSD::GetMedium(const char* mediumName) {
44285dfa 3383 /////////////////////////////////////////////////////////////
3384 // Method returning the Medium type
3385 /////////////////////////////////////////////////////////////
d7599219 3386 char ch[30];
3387 sprintf(ch, "ITS_%s",mediumName);
3388 TGeoMedium* medium = gGeoManager->GetMedium(ch);
3389 if (! medium)
3390 printf("Error(AliITSv11GeometrySSD)::medium %s not found !\n", mediumName);
3391 return medium;
3392}
3393////////////////////////////////////////////////////////////////////////////////
3394//To be interfaced with AliRoot Materials file
3395////////////////////////////////////////////////////////////////////////////////
3396/*void AliITSv11GeometrySSD::CreateMaterials(){
3397///////////////////////////////////
3398// This part has to be modified
3399///////////////////////////////////
3400// Float_t ifield = 2.000;
3401// Float_t fieldm = 10.000;
3402// Int_t ifield = gAlice->Field()->Integ();
3403// Float_t fieldm = gAlice->Field()->Max();
3404 ///////////////////////////////////
3405 // Silicon for Sensor
3406 ///////////////////////////////////
3407 Int_t SINumber = 0;
3408 TGeoMaterial* SiMaterial = new TGeoMaterial("SiMaterial");
3409 TGeoMedium* Silicon = new TGeoMedium("Silicon",SINumber,SiMaterial);
44285dfa 3410 fSSDSensorMedium = Silicon;
d7599219 3411 ///////////////////////////////////
3412 // Silicon Mixture for Sensor
3413 ///////////////////////////////////
3414 Int_t SiMixtureNumber = 1;
3415 TGeoMaterial* SiMixtureMaterial = new TGeoMaterial("SiMixtureMaterial");
3416 TGeoMedium* SiliconMixture = new TGeoMedium("SiliconMixture",SiMixtureNumber,SiMixtureMaterial);
44285dfa 3417 fSSDChipMedium = SiliconMixture;
d7599219 3418 ///////////////////////////////////
3419 // Stiffener Components Materials
3420 ///////////////////////////////////
3421 Int_t K1100Number = 2;
3422 TGeoMaterial* K1100Material = new TGeoMaterial("K1100Material");
3423 TGeoMedium* K1100 = new TGeoMedium("K1100",K1100Number,K1100Material);
44285dfa 3424 fSSDStiffenerMedium = K1100;
d7599219 3425 ///////////////////////////
3426 // Stiffener Connectors
3427 ///////////////////////////
3428 Int_t SnMaterialNumber = 3;
3429 TGeoMaterial* SnMaterial = new TGeoMaterial("SnMaterial");
3430 TGeoMedium* SnMedium = new TGeoMedium("SnMedium",SnMaterialNumber,
3431 SnMaterial);
44285dfa 3432 fSSDStiffenerConnectorMedium = SnMedium;
d7599219 3433 ////////////////////////////////
3434 // Stiffener 0603-1812 Capacitor
3435 ////////////////////////////////
3436 Int_t Al2O3Number = 4;
3437 TGeoMaterial* Al2O3Material = new TGeoMaterial("Al2O3Material");
3438 TGeoMedium* Al2O3Medium = new TGeoMedium("Al2O3Medium",
3439 Al2O3Number,
3440 Al2O3Material);
44285dfa 3441 fSSDStiffener0603CapacitorMedium = Al2O3Medium;
3442 fSSDStiffener1812CapacitorMedium = Al2O3Medium;
d7599219 3443 ///////////////////////////
3444 // Stiffener Hybrid Wire
3445 ///////////////////////////
3446 Int_t CuHybridWireNumber = 5;
3447 TGeoMaterial* CuHybridWireMaterial = new TGeoMaterial("CuHybridWireMaterial");
3448 TGeoMedium* CuHybridWireMedium = new TGeoMedium("CuHybridWireMedium",
3449 CuHybridWireNumber,
3450 CuHybridWireMaterial);
44285dfa 3451 fSSDStiffenerHybridWireMedium = CuHybridWireMedium;
d7599219 3452 ///////////////////////////
3453 // Al for Cooling Block
3454 ///////////////////////////
3455 Int_t AlCoolBlockNumber = 6;
3456 TGeoMaterial* AlCoolBlockMaterial = new TGeoMaterial("AlCoolBlockMaterial");
3457 TGeoMedium* AlCoolBlockMedium = new TGeoMedium("AlCoolBlockMedium",
3458 AlCoolBlockNumber,
3459 AlCoolBlockMaterial);
44285dfa 3460 fSSDAlCoolBlockMedium = AlCoolBlockMedium;
d7599219 3461 //////////////////////////////////////////////////////
3462 // Kapton and Al for Chip Cable Flex and Ladder Cables
3463 //////////////////////////////////////////////////////
3464 Int_t KaptonBlockNumber = 7;
3465 TGeoMaterial* KaptonMaterial = new TGeoMaterial("KaptonMaterial");
3466 TGeoMedium* KaptonMedium = new TGeoMedium("KaptonMedium",
3467 KaptonBlockNumber,
3468 KaptonMaterial);
3469 Int_t AlTraceBlockNumber = 8;
3470 TGeoMaterial* AlTraceMaterial = new TGeoMaterial("AlTraceMaterial");
3471 TGeoMedium* AlTraceMedium = new TGeoMedium("AlTraceMedium",
3472 AlTraceBlockNumber,
3473 AlTraceMaterial);
44285dfa 3474 fSSDKaptonChipCableMedium = KaptonMedium;
3475 fSSDAlTraceChipCableMedium = AlTraceMedium;
3476 fSSDKaptonFlexMedium = KaptonMedium;
3477 fSSDAlTraceFlexMedium = AlTraceMedium;
3478 fSSDKaptonLadderCableMedium = KaptonMedium;
3479 fSSDAlTraceLadderCableMedium = AlTraceMedium;
d7599219 3480 /////////////////////////////////////////////////////////////////
3481 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
3482 //////////////////////////////////////////////////////////////////
3483 Int_t M55JNumber = 9;
3484 TGeoMaterial* M55JMaterial = new TGeoMaterial("M55JMaterial");
3485 TGeoMedium* M55JMedium = new TGeoMedium("M55JMedium",M55JNumber,
3486 M55JMaterial);
44285dfa 3487 fSSDCarbonFiberMedium = M55JMedium;
3488 fSSDMountingBlockMedium = M55JMedium;
d7599219 3489 /////////////////////////////////////////////////////////////////
3490 // G10 for Detector Leg, TubeHolder
3491 //////////////////////////////////////////////////////////////////
3492 Int_t G10Number = 10;
3493 TGeoMaterial* G10Material = new TGeoMaterial("G10Material");
3494 TGeoMedium* G10Medium = new TGeoMedium("G10Medium",G10Number,
3495 G10Material);
44285dfa 3496 fSSDTubeHolderMedium = G10Medium;
3497 fSSDSensorSupportMedium = G10Medium;
d7599219 3498 /////////////////////////////////////////////////////////////////
3499 // Water and Phynox for Cooling Tube
3500 //////////////////////////////////////////////////////////////////
3501 Int_t WaterNumber = 11;
3502 TGeoMaterial* WaterMaterial = new TGeoMaterial("WaterMaterial");
3503 TGeoMedium* WaterMedium = new TGeoMedium("WaterMedium",WaterNumber,
3504 WaterMaterial);
44285dfa 3505 fSSDCoolingTubeWater = WaterMedium;
d7599219 3506 Int_t PhynoxNumber = 12;
3507 TGeoMaterial* PhynoxMaterial = new TGeoMaterial("PhynoxMaterial");
3508 TGeoMedium* PhynoxMedium = new TGeoMedium("PhynoxMedium",PhynoxNumber,
3509 PhynoxMaterial);
44285dfa 3510 fSSDCoolingTubePhynox = PhynoxMedium;
d7599219 3511}
3512*/
3513void AliITSv11GeometrySSD::CreateMaterials(){
3514///////////////////////////////////
3515// This part has to be modified
3516///////////////////////////////////
3517 ///////////////////////////////////
3518 // Silicon for Sensor
3519 ///////////////////////////////////
44285dfa 3520 fSSDSensorMedium = GetMedium("Si");
d7599219 3521 ///////////////////////////////////
3522 // Silicon Mixture for Sensor
3523 ///////////////////////////////////
44285dfa 3524 fSSDChipMedium = GetMedium("SPD SI CHIP$");
3525 fSSDChipGlueMedium = GetMedium("EPOXY$");
d7599219 3526 ///////////////////////////////////
3527 // Stiffener Components Materials
3528 ///////////////////////////////////
44285dfa 3529 fSSDStiffenerMedium = GetMedium("ITSsddCarbonM55J");
d7599219 3530 ///////////////////////////
3531 // Stiffener Connectors
3532 ///////////////////////////
44285dfa 3533 fSSDStiffenerConnectorMedium = GetMedium("COPPER");
d7599219 3534 ////////////////////////////////
3535 // Stiffener 0603-1812 Capacitor
3536 ////////////////////////////////
44285dfa 3537 fSSDStiffener0603CapacitorMedium = GetMedium("SDD ruby sph. Al2O3");
3538 fSSDStiffener1812CapacitorMedium = GetMedium("SDD ruby sph. Al2O3");
d7599219 3539 ///////////////////////////
3540 // Stiffener Hybrid Wire
3541 ///////////////////////////
44285dfa 3542 fSSDStiffenerHybridWireMedium = GetMedium("COPPER");
d7599219 3543 ///////////////////////////
3544 // Al for Cooling Block
3545 ///////////////////////////
44285dfa 3546 fSSDAlCoolBlockMedium = GetMedium("ITSal");
d7599219 3547 //////////////////////////////////////////////////////
3548 // Kapton and Al for Chip Cable Flex and Ladder Cables
3549 //////////////////////////////////////////////////////
44285dfa 3550 fSSDKaptonChipCableMedium = GetMedium("KAPTONH(POLYCH2)");
3551 fSSDAlTraceChipCableMedium = GetMedium("ITSal");
3552 fSSDKaptonFlexMedium = GetMedium("KAPTONH(POLYCH2)");
3553 fSSDAlTraceFlexMedium = GetMedium("ITSal");
3554 fSSDKaptonLadderCableMedium = GetMedium("KAPTONH(POLYCH2)");
3555 fSSDAlTraceLadderCableMedium = GetMedium("ITSal");
d7599219 3556 /////////////////////////////////////////////////////////////////
3557 // M55J for Carbon Fiber, CarbonFiber Lower Support and Junction
3558 //////////////////////////////////////////////////////////////////
44285dfa 3559 fSSDCarbonFiberMedium = GetMedium("GEN C (M55J)$");
d7599219 3560 /////////////////////////////////////////////////////////////////
3561 // G10 for Detector Leg, TubeHolder
3562 //////////////////////////////////////////////////////////////////
44285dfa 3563 fSSDTubeHolderMedium = GetMedium("G10FR4$");
3564 fSSDSensorSupportMedium = GetMedium("G10FR4$");
3565 fSSDMountingBlockMedium = GetMedium("G10FR4$");
3566 fSSDMountingBlockMedium = GetMedium("G10FR4$");
d7599219 3567 /////////////////////////////////////////////////////////////////
3568 // Water and Phynox for Cooling Tube
3569 //////////////////////////////////////////////////////////////////
44285dfa 3570 fSSDCoolingTubeWater = GetMedium("WATER");
3571 fSSDCoolingTubePhynox = GetMedium("INOX$");
d7599219 3572}
3573/////////////////////////////////////////////////////////////////////
44285dfa 3574