Line data Source code
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 : //
19 : // SDD geometry, based on ROOT geometrical modeler
20 : //
21 : //
22 : // This geometry has no dependence with aliroot, you can run it with root
23 : // only, provided that the AliITSv11GeomCable classes are also compiled
24 : //
25 : // Ludovic Gaudichet gaudichet@to.infn.it
26 : //*************************************************************************
27 :
28 :
29 : // $Id$
30 :
31 :
32 : // General Root includes
33 : #include <Riostream.h>
34 : #include <TMath.h>
35 :
36 : // Root Geometry includes
37 : #include <TGeoManager.h>
38 : #include <TGeoVolume.h>
39 : #include <TGeoCone.h>
40 : #include <TGeoTube.h>
41 : #include <TGeoTrd1.h>
42 : #include <TGeoArb8.h>
43 : #include <TGeoXtru.h>
44 : #include <TGeoCompositeShape.h>
45 : #include <TGeoMatrix.h>
46 : #include <TGeoNode.h>
47 : #include <TGeoPcon.h>
48 : #include <TGeoTorus.h>
49 :
50 : #include "AliITSv11GeometrySDD.h"
51 : #include "AliITSv11GeomCableFlat.h"
52 : #include "AliITSv11GeomCableRound.h"
53 :
54 : const char* AliITSv11GeometrySDD::fgkSDDsensitiveVolName3 = "ITSsddSensitivL3";
55 : const char* AliITSv11GeometrySDD::fgkSDDsensitiveVolName4 = "ITSsddSensitivL4";
56 116 : const Double_t AliITSv11GeometrySDD::fgkSegmentLength = 37.21*2*fgkmm;
57 116 : const Double_t AliITSv11GeometrySDD::fgkLadderWidth = 50.0*fgkmm;
58 116 : const Double_t AliITSv11GeometrySDD::fgkLadderHeight = 30.0*fgkmm;
59 116 : const Double_t AliITSv11GeometrySDD::fgkLadderSegBoxDW = 7.5*fgkmm;
60 116 : const Double_t AliITSv11GeometrySDD::fgkLadderSegBoxDH = 7.1*fgkmm;
61 :
62 116 : const Double_t AliITSv11GeometrySDD::fgkLadderBeamRadius = 0.6*fgkmm;
63 116 : const Double_t AliITSv11GeometrySDD::fgkLadderLa = 3.*fgkmm;
64 116 : const Double_t AliITSv11GeometrySDD::fgkLadderHa = 0.721979*fgkmm;
65 116 : const Double_t AliITSv11GeometrySDD::fgkLadderLb = 3.7*fgkmm;
66 116 : const Double_t AliITSv11GeometrySDD::fgkLadderHb = 0.890428*fgkmm;
67 116 : const Double_t AliITSv11GeometrySDD::fgkLadderl = 0.25*fgkmm;
68 :
69 : const Double_t AliITSv11GeometrySDD::fgkBottomBeamAngle = 56.5;
70 : const Double_t AliITSv11GeometrySDD::fgkBeamSidePhi = 65;
71 :
72 116 : const Double_t AliITSv11GeometrySDD::fgkLadWaferSep = 2*fgkmm;
73 116 : const Double_t AliITSv11GeometrySDD::fgkPinSuppWidth = 2.5*fgkmm;
74 116 : const Double_t AliITSv11GeometrySDD::fgkPinSuppHeight = 2.*fgkmm;
75 116 : const Double_t AliITSv11GeometrySDD::fgkPinSuppRmax = 2.5/2.*fgkmm;
76 116 : const Double_t AliITSv11GeometrySDD::fgkPinR = 1.5/2.*fgkmm;
77 116 : const Double_t AliITSv11GeometrySDD::fgkPinSuppLength = 5.*fgkmm;
78 116 : const Double_t AliITSv11GeometrySDD::fgkPinSuppThickness = 0.5*fgkmm;
79 : const Double_t AliITSv11GeometrySDD::fgkPinSuppConeAngle = 4;
80 116 : const Double_t AliITSv11GeometrySDD::fgkPinDXminOnSensor = (39./2.)*fgkmm;
81 116 : const Double_t AliITSv11GeometrySDD::fgkPinPinDDXOnSensor = 3*fgkmm;
82 116 : const Double_t AliITSv11GeometrySDD::fgkPinDYOnSensor = (52.5/2.)*fgkmm;
83 :
84 : // parameters from ALR-0752/3
85 116 : const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppHeight = 3.2*fgkmm;
86 116 : const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppMaxLength = 14*fgkmm;
87 116 : const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppWidthExt = 0.4*fgkmm;
88 116 : const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppWidthIn = 0.65*fgkmm;
89 116 : const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppHoleDiam = 2*fgkmm;
90 116 : const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppFulWidth = 5.15*fgkmm;
91 116 : const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppTongW = 0.8*fgkmm;
92 : const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppAngle = 22.5;
93 116 : const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppSlitL = 4.9*fgkmm;
94 116 : const Double_t AliITSv11GeometrySDD::fgkCoolPipeSuppAxeDist = 3.05*fgkmm;
95 116 : const Double_t AliITSv11GeometrySDD::fgkCoolPipeInnerDiam = 1.84*fgkmm;
96 116 : const Double_t AliITSv11GeometrySDD::fgkCoolPipeOuterDiam = 2.*fgkmm;
97 :
98 116 : const Double_t AliITSv11GeometrySDD::fgkBTBthick = 0.25 *fgkmm;
99 116 : const Double_t AliITSv11GeometrySDD::fgkBTBlength = 55. *fgkmm;
100 116 : const Double_t AliITSv11GeometrySDD::fgkBTBwidth = 18*fgkmm;
101 116 : const Double_t AliITSv11GeometrySDD::fgkBTBaxisAtoBottom = 4*fgkmm;
102 116 : const Double_t AliITSv11GeometrySDD::fgkBTBaxisAtoBase = 2.2*fgkmm;
103 116 : const Double_t AliITSv11GeometrySDD::fgkRadiusAminBTB = 1. *fgkmm;
104 116 : const Double_t AliITSv11GeometrySDD::fgkRadiusBminBTB = 0.53 *fgkmm;
105 116 : const Double_t AliITSv11GeometrySDD::fgkBTBHoleLength = 15 *fgkmm;
106 116 : const Double_t AliITSv11GeometrySDD::fgkBTBHolewidth = 6 *fgkmm;
107 116 : const Double_t AliITSv11GeometrySDD::fgkBTBHoleRefX = 10 *fgkmm;
108 116 : const Double_t AliITSv11GeometrySDD::fgkBTBHoleRefY = 6.5 *fgkmm;
109 :
110 116 : const Double_t AliITSv11GeometrySDD::fgkLay3Rmin = 129.*fgkmm;
111 116 : const Double_t AliITSv11GeometrySDD::fgkLay3Rmax = 205.*fgkmm;
112 116 : const Double_t AliITSv11GeometrySDD::fgkLay3Length = (524.+0.)*fgkmm; // ladder+supporting rings (length of the virtual tube)
113 116 : const Double_t AliITSv11GeometrySDD::fgkLay3LadderLength = 524.*fgkmm;
114 116 : const Double_t AliITSv11GeometrySDD::fgkLay3DetShortRadius = 146.0*fgkmm;
115 116 : const Double_t AliITSv11GeometrySDD::fgkLay3DetLongRadius = 152.0*fgkmm;
116 116 : const Double_t AliITSv11GeometrySDD::fgkLay3LaddTopCornerEnd = 15.6*fgkmm;
117 : const Int_t AliITSv11GeometrySDD::fgkLay3Ndet = 6;
118 : const Int_t AliITSv11GeometrySDD::fgkLay3Nladd = 14;
119 116 : const Double_t AliITSv11GeometrySDD::fgkLay3CoolPipeSuppH = 7.5*fgkmm;
120 :
121 116 : const Double_t AliITSv11GeometrySDD::fgkLay4Rmin = 220.*fgkmm;
122 116 : const Double_t AliITSv11GeometrySDD::fgkLay4Rmax = 291.*fgkmm;
123 116 : const Double_t AliITSv11GeometrySDD::fgkLay4Length = (671.+0.)*fgkmm; // ladder+supporting rings (length of the virtual tube)
124 116 : const Double_t AliITSv11GeometrySDD::fgkLay4LadderLength = 671.*fgkmm;
125 116 : const Double_t AliITSv11GeometrySDD::fgkLay4DetShortRadius = 235.0*fgkmm;
126 116 : const Double_t AliITSv11GeometrySDD::fgkLay4DetLongRadius = 240.5*fgkmm;
127 116 : const Double_t AliITSv11GeometrySDD::fgkLay4LaddTopCornerEnd = 15.6*fgkmm;
128 : const Int_t AliITSv11GeometrySDD::fgkLay4Ndet = 8;
129 : const Int_t AliITSv11GeometrySDD::fgkLay4Nladd = 22;
130 116 : const Double_t AliITSv11GeometrySDD::fgkLay4CoolPipeSuppH = 7.5*fgkmm;
131 :
132 116 : const Double_t AliITSv11GeometrySDD::fgkEndLaddCardsShortRadiusLay3 = fgkLay3DetShortRadius;
133 116 : const Double_t AliITSv11GeometrySDD::fgkEndLaddCardsShortRadiusLay4 = fgkLay4DetShortRadius;
134 116 : const Double_t AliITSv11GeometrySDD::fgkDistEndLaddCardsLadd = 0.*fgkmm;
135 :
136 : //hybrid
137 : const Double_t AliITSv11GeometrySDD::fgkHybridAngle = 48.5; // approx !!!
138 : // Origine taken at the hybrid corner :
139 116 : const Double_t AliITSv11GeometrySDD::fgkHybridLength = 65*fgkmm;
140 116 : const Double_t AliITSv11GeometrySDD::fgkHybridWidth = 41*fgkmm;
141 116 : const Double_t AliITSv11GeometrySDD::fgkHybRndHoleRad = 1.05*fgkmm;
142 116 : const Double_t AliITSv11GeometrySDD::fgkHybRndHoleZ = 2.5*fgkmm;
143 116 : const Double_t AliITSv11GeometrySDD::fgkHybRndHoleX = fgkHybridWidth-23.599*fgkmm;
144 :
145 116 : const Double_t AliITSv11GeometrySDD::fgkHybFLlowHoleDZ = 9.698*fgkmm;
146 116 : const Double_t AliITSv11GeometrySDD::fgkHybFLlowHolePasDX = 10.754*fgkmm;
147 116 : const Double_t AliITSv11GeometrySDD::fgkHybFLlowHoleAmbDX = 9.122*fgkmm;
148 : // center of ships to the border
149 116 : const Double_t AliITSv11GeometrySDD::fgkHybFLlowChipZ4 = fgkHybridLength-(4.654 )*fgkmm-fgkHybFLlowHoleDZ/2;
150 116 : const Double_t AliITSv11GeometrySDD::fgkHybFLlowChipZ3 = fgkHybridLength-(4.654+15. )*fgkmm-fgkHybFLlowHoleDZ/2;
151 116 : const Double_t AliITSv11GeometrySDD::fgkHybFLlowChipZ2 = fgkHybridLength-(4.654+15.*2)*fgkmm-fgkHybFLlowHoleDZ/2;
152 116 : const Double_t AliITSv11GeometrySDD::fgkHybFLlowChipZ1 = fgkHybridLength-(4.654+15.*3)*fgkmm-fgkHybFLlowHoleDZ/2;
153 116 : const Double_t AliITSv11GeometrySDD::fgkHybFLlowPasX = fgkHybridWidth-32.775*fgkmm;
154 116 : const Double_t AliITSv11GeometrySDD::fgkHybFLlowAmbX = fgkHybridWidth-20.791*fgkmm;
155 116 : const Double_t AliITSv11GeometrySDD::fgkHybChipsDZ = 9.221*fgkmm;
156 116 : const Double_t AliITSv11GeometrySDD::fgkHybPascalDX = 10.245*fgkmm;
157 116 : const Double_t AliITSv11GeometrySDD::fgkHybAmbraDX = 8.51*fgkmm;
158 116 : const Double_t AliITSv11GeometrySDD::fgkHybFLUpperWidth = 15.012*fgkmm;
159 116 : const Double_t AliITSv11GeometrySDD::fgkHybFLUpperLength = 59.878*fgkmm;
160 116 : const Double_t AliITSv11GeometrySDD::fgkHybFLUpperAlDZ = 11.183*fgkmm;
161 116 : const Double_t AliITSv11GeometrySDD::fgkHybFLUpperAldx = 2.307*fgkmm;
162 :
163 116 : const Double_t AliITSv11GeometrySDD::fgkHybCC2SensorLen = 9.500*fgkmm;
164 116 : const Double_t AliITSv11GeometrySDD::fgkHybCC2SensorWid = 1.490*fgkcm; //???
165 : const Double_t AliITSv11GeometrySDD::fgkHybCC2SensorAng = 15.0;
166 :
167 116 : const Double_t AliITSv11GeometrySDD::fgkmu = 1*fgkmicron; // 1*fgkmicron; // can be increase for checking thin objects
168 116 : const Double_t AliITSv11GeometrySDD::fgkHybridThBridgeThick = 0.25*fgkmm; // ???
169 116 : const Double_t AliITSv11GeometrySDD::fgkHybAlThick = 30*fgkmu;
170 116 : const Double_t AliITSv11GeometrySDD::fgkHybUpThick = 20*fgkmu;
171 116 : const Double_t AliITSv11GeometrySDD::fgkHybGlueScrnThick = 50*fgkmu; // ??? ?????
172 116 : const Double_t AliITSv11GeometrySDD::fgkHybGlueLowThick = 90*fgkmu;
173 116 : const Double_t AliITSv11GeometrySDD::fgkHybGlueUpThick = 90*fgkmu; // sur ?????
174 116 : const Double_t AliITSv11GeometrySDD::fgkHybAlCCThick = 12*fgkmu;
175 116 : const Double_t AliITSv11GeometrySDD::fgkHybUpCCThick = 12*fgkmu;
176 116 : const Double_t AliITSv11GeometrySDD::fgkHybChipThick = 150*fgkmu;
177 116 : const Double_t AliITSv11GeometrySDD::fgkHybGlueAgThick = 50*fgkmu; // ??? ????
178 116 : const Double_t AliITSv11GeometrySDD::fgkHybUnderNiThick = 20*fgkmu; // ??? ????
179 : const Int_t AliITSv11GeometrySDD::fgkNHybSMD = 25;
180 : const Double_t AliITSv11GeometrySDD::fgkHybSMDposX[fgkNHybSMD] =
181 1276 : {2.92*fgkmm,6.5*fgkmm,10.13*fgkmm,13.59*fgkmm,21.40*fgkmm,
182 290 : 2.92*fgkmm,6.5*fgkmm,10.13*fgkmm,13.59*fgkmm,19.91*fgkmm,
183 348 : 2.92*fgkmm,6.5*fgkmm,10.13*fgkmm,13.59*fgkmm,17.09*fgkmm,21.40*fgkmm,
184 290 : 2.92*fgkmm,6.5*fgkmm,10.13*fgkmm,13.59*fgkmm,19.91*fgkmm,
185 290 : 1.63*fgkmm,5.22*fgkmm,13.59*fgkmm,21.40*fgkmm};
186 : const Double_t AliITSv11GeometrySDD::fgkHybSMDposZ[fgkNHybSMD] =
187 1276 : { 2.3 *fgkmm, 2.3 *fgkmm, 2.3 *fgkmm, 2.3 *fgkmm, 2.3 *fgkmm,
188 290 : 17.315*fgkmm,17.315*fgkmm,17.315*fgkmm,17.315*fgkmm,17.315*fgkmm,
189 348 : 32.31*fgkmm,32.31*fgkmm,32.31*fgkmm,32.31*fgkmm,32.31*fgkmm,32.31*fgkmm,
190 290 : 47.38*fgkmm,47.38*fgkmm,47.38*fgkmm,47.38*fgkmm,47.38*fgkmm,
191 290 : 62.68*fgkmm,62.06*fgkmm,62.06*fgkmm,62.06*fgkmm};
192 116 : const Double_t AliITSv11GeometrySDD::fgkHybSMDmiddleW = 0.954*fgkmm;
193 116 : const Double_t AliITSv11GeometrySDD::fgkHybSMDmiddleL = 0.47 *fgkmm;
194 116 : const Double_t AliITSv11GeometrySDD::fgkHybSMDendW = 1.132*fgkmm;
195 116 : const Double_t AliITSv11GeometrySDD::fgkHybSMDendL = 0.925*fgkmm;
196 116 : const Double_t AliITSv11GeometrySDD::fgkHybSMDheight = 400.*fgkmu; // ??? ????!!!!!!!
197 :
198 116 : const Double_t AliITSv11GeometrySDD::fgkWaferThickness = 300.*fgkmu;
199 116 : const Double_t AliITSv11GeometrySDD::fgkWaferWidth = 72.5 *fgkmm;
200 116 : const Double_t AliITSv11GeometrySDD::fgkWaferLength = 87.6 *fgkmm;
201 116 : const Double_t AliITSv11GeometrySDD::fgkWaferThickSens = 299.8*fgkmu;
202 116 : const Double_t AliITSv11GeometrySDD::fgkWaferWidthSens = 70.17*fgkmm;
203 : // 256 anodes times 294 microns of pitch
204 116 : const Double_t AliITSv11GeometrySDD::fgkWaferLengthSens = 256*294*fgkmicron;
205 :
206 116 : const Double_t AliITSv11GeometrySDD::fgkDigitCablWidth = 18.4*fgkmm;
207 116 : const Double_t AliITSv11GeometrySDD::fgkDigitCablAlThick = (30+30*8./10.)*fgkmicron; // will probably change
208 116 : const Double_t AliITSv11GeometrySDD::fgkDigitCablPolyThick = (20+12)*fgkmicron; // will probably change
209 :
210 116 : const Double_t AliITSv11GeometrySDD::fgkWaHVcableAlThick = 30*2./10.*fgkmu; // will probably change // Al ratio is random !!!
211 116 : const Double_t AliITSv11GeometrySDD::fgkWaHVcablePolyThick = 175*fgkmu; // will probably change
212 116 : const Double_t AliITSv11GeometrySDD::fgkWaHVcableLength = 67.08*fgkmm;
213 116 : const Double_t AliITSv11GeometrySDD::fgkWaHVcableWitdh = 17.4*fgkmm; // check !!!
214 116 : const Double_t AliITSv11GeometrySDD::fgkWaHVcableDW = 5.24*fgkmm; //5.24*fgkmm;// check !!!
215 :
216 116 : const Double_t AliITSv11GeometrySDD::fgkSensorGlassLX = 5. *fgkmm;
217 116 : const Double_t AliITSv11GeometrySDD::fgkSensorGlassLZ = 5. *fgkmm;
218 116 : const Double_t AliITSv11GeometrySDD::fgkSensorGlassLY = 150. *fgkmu;
219 116 : const Double_t AliITSv11GeometrySDD::fgkGlassDXOnSensor = 26.28*fgkmm; // check !!!
220 116 : const Double_t AliITSv11GeometrySDD::fgkGlassDZOnSensor = 22.50*fgkmm; // check !!!
221 :
222 116 : const Double_t AliITSv11GeometrySDD::fgkTransitHVAlThick = 30*2./10.*fgkmu; // check // will probably change //Al ratio is random
223 116 : const Double_t AliITSv11GeometrySDD::fgkTransitHVPolyThick = 100*fgkmu; // check // will probably change
224 116 : const Double_t AliITSv11GeometrySDD::fgkTransitHVHeadLX = 71.46*fgkmm; // check !!!
225 116 : const Double_t AliITSv11GeometrySDD::fgkTransitHVHeadLZ = 21.3*fgkmm;
226 116 : const Double_t AliITSv11GeometrySDD::fgkTransitHVBondingLZ = 3.6*fgkmm;
227 116 : const Double_t AliITSv11GeometrySDD::fgkTransitHVtailLength = 27*fgkmm; // ???, not yet fixed ...
228 116 : const Double_t AliITSv11GeometrySDD::fgkTransitHVtailWidth = 26*fgkmm;
229 116 : const Double_t AliITSv11GeometrySDD::fgkTransitHVtailXpos = 8*fgkmm; //8*fgkmm // ???, a mesurer !!!
230 116 : const Double_t AliITSv11GeometrySDD::fgkTransitHVsideLZ = 10.34*fgkmm;
231 116 : const Double_t AliITSv11GeometrySDD::fgkTransitHVsideLeftZ = 4.11*fgkmm;
232 116 : const Double_t AliITSv11GeometrySDD::fgkTransitHVsideRightZ = 3.5*fgkmm; // ???, a mesurer !!!
233 :
234 116 : const Double_t AliITSv11GeometrySDD::fgkLongHVcablePolyThick= (20+30+125+30+20+30+125+30+20)*fgkmu; // check // will probably change
235 116 : const Double_t AliITSv11GeometrySDD::fgkLongHVcableAlThick = (30+30*2/10+30)*fgkmu; // check // will probably change
236 116 : const Double_t AliITSv11GeometrySDD::fgkLongHVcableSeparation = 600*fgkmicron;
237 :
238 116 : const Double_t AliITSv11GeometrySDD::fgkRubyDX = 14.*fgkmm;
239 116 : const Double_t AliITSv11GeometrySDD::fgkRubyZladd3 = 250*fgkmm;
240 116 : const Double_t AliITSv11GeometrySDD::fgkRubyZladd4 = 325*fgkmm;
241 :
242 : // the stesalite ladder foot at its end
243 116 : const Double_t AliITSv11GeometrySDD::fgkLadFootX = 60.*fgkmm;
244 116 : const Double_t AliITSv11GeometrySDD::fgkLadFootZ = 20.*fgkmm;
245 116 : const Double_t AliITSv11GeometrySDD::fgkLadFootY = 8.*fgkmm;
246 116 : const Double_t AliITSv11GeometrySDD::fgkLadFootMiddleY = 4.5*fgkmm;
247 116 : const Double_t AliITSv11GeometrySDD::fgkLadBox1X = 23.*fgkmm;
248 116 : const Double_t AliITSv11GeometrySDD::fgkLadFingerPrintX = 6.*fgkmm;
249 116 : const Double_t AliITSv11GeometrySDD::fgkLadFingerPrintY = 1.*fgkmm;
250 116 : const Double_t AliITSv11GeometrySDD::fgkLadFingerPrintBorder = 4.*fgkmm;
251 116 : const Double_t AliITSv11GeometrySDD::fgkRubyCageHoleZ = 8.*fgkmm;
252 116 : const Double_t AliITSv11GeometrySDD::fgkRubyCageHoleX = 9.*fgkmm;
253 116 : const Double_t AliITSv11GeometrySDD::fgkRubyCageHoleY = 6.5*fgkmm;
254 116 : const Double_t AliITSv11GeometrySDD::fgkRubyCageAxisShift = 0.5*fgkmm;
255 116 : const Double_t AliITSv11GeometrySDD::fgkScrewM4diam = 4.*fgkmm;
256 :
257 : const Double_t AliITSv11GeometrySDD::fgkRubyScrewShiftToCenterY = 0.1;
258 : const Double_t AliITSv11GeometrySDD::fgkRubyHoleDiam = 0.5;
259 :
260 : // the U cooling pipe and its heat exchanger in end-ladder cards system
261 116 : const Double_t AliITSv11GeometrySDD::fgkEndLadPipeUlengthLay3 = 138*fgkmm;
262 116 : const Double_t AliITSv11GeometrySDD::fgkEndLadPipeUlengthLay4 = 150*fgkmm;
263 116 : const Double_t AliITSv11GeometrySDD::fgkEndLadPipeUwidth = 59*fgkmm;
264 116 : const Double_t AliITSv11GeometrySDD::fgkEndLadPipeRadius = 5*fgkmm;
265 116 : const Double_t AliITSv11GeometrySDD::fgkEndLadPipeInnerDiam = 2.8*fgkmm;
266 116 : const Double_t AliITSv11GeometrySDD::fgkEndLadPipeOuterDiam = 3.*fgkmm;
267 : //--- The al body of the cooling syst.of the heat exchanger :
268 116 : const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmZLay3 = 112.*fgkmm; //
269 116 : const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmZLay4 = 125.*fgkmm; //
270 116 : const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmX = 4.75*fgkmm; // the arms of the U cooling tube
271 116 : const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmY = 6.8*fgkmm;
272 116 : const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmBoxDY = 1.03*fgkmm; // shift in Y of the arms from the axis
273 116 : const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmBoxDX = 0.125*fgkmm;// shift in X of the arms from the axis
274 116 : const Double_t AliITSv11GeometrySDD::fgkEndLadPipeArmZpos = 8.9*fgkmm; //
275 :
276 : // LV card :
277 116 : const Double_t AliITSv11GeometrySDD::fgkLVcardX = 26.525*fgkmm;
278 116 : const Double_t AliITSv11GeometrySDD::fgkLVcardY = 44.95*fgkmm;
279 116 : const Double_t AliITSv11GeometrySDD::fgkLVcardZ = 1.*fgkmm; // all except Cu layer //???
280 116 : const Double_t AliITSv11GeometrySDD::fgkLVcardCuZ = 0.1*fgkmm; //???
281 :
282 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip0X = 16.525*fgkmm;
283 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip0Y = 10.8*fgkmm;
284 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip0Z = 3.5*fgkmm; // all except si layer //???
285 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip0SiZ = 0.2*fgkmm; //???????????????????????????????????????????????????
286 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip0PosX = 13.*fgkmm; //19.95*fgkmm; ???
287 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip0PosY = 10.3*fgkmm;
288 :
289 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip1X = 6.00*fgkmm;
290 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip1Y = 6.00*fgkmm;
291 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip1Z = 1*fgkmm; // ???
292 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip1SiZ = 0.2*fgkmm; // ???
293 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip1PosX = 18.*fgkmm;
294 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip1PosY = 27.6*fgkmm;
295 :
296 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip2X = 6.00*fgkmm;
297 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip2Y = 6.00*fgkmm;
298 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip2Z = 1*fgkmm; // ???
299 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip2SiZ = 0.2*fgkmm; //???
300 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip2PosX = 18.0*fgkmm;
301 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip2PosY = 39.0*fgkmm;
302 :
303 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip3X = 4.01*fgkmm;
304 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip3Y = 4.01*fgkmm;
305 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip3Z = 1*fgkmm; // ???
306 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip3SiZ = 0.2*fgkmm;
307 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip3PosX = 20.7*fgkmm;
308 116 : const Double_t AliITSv11GeometrySDD::fgkLVChip3PosY = 21.4*fgkmm;
309 :
310 116 : const Double_t AliITSv11GeometrySDD::fgkLVcoolX1 = 17.25*fgkmm;
311 116 : const Double_t AliITSv11GeometrySDD::fgkLVcoolY1 = 8.7*fgkmm;
312 116 : const Double_t AliITSv11GeometrySDD::fgkLVcoolZ1 = 1.*fgkmm;
313 :
314 116 : const Double_t AliITSv11GeometrySDD::fgkLVcoolX2 = 3.5*fgkmm;
315 116 : const Double_t AliITSv11GeometrySDD::fgkLVcoolY2 = 8.7*fgkmm;
316 116 : const Double_t AliITSv11GeometrySDD::fgkLVcoolZ2 = 2.3*fgkmm;
317 :
318 116 : const Double_t AliITSv11GeometrySDD::fgkLVcoolX3 = 4.75*fgkmm;
319 116 : const Double_t AliITSv11GeometrySDD::fgkLVcoolY3 = 3.1*fgkmm; //+0.1=glue
320 116 : const Double_t AliITSv11GeometrySDD::fgkLVcoolPosY = 6.5*fgkmm;
321 :
322 : // HV card :
323 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCeramX = 54.01*fgkmm;
324 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCeramY = 40.89*fgkmm;
325 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCeramZ = 0.7*fgkmm; // ???
326 :
327 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa1X = 6.8*fgkmm;
328 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa1Z = 1.*fgkmm; // ???
329 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa1Ymid = 4.1*fgkmm;
330 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa1Yend = 0.95*fgkmm; // doesn't take into account the soldering
331 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa1PosX = 13.1*fgkmm;
332 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa1PosY = 14.5*fgkmm;
333 :
334 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa2X = 6.8*fgkmm;
335 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa2Z = 1.*fgkmm; // ???
336 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa2Ymid = 2.9*fgkmm;
337 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa2Yend = 0.95*fgkmm;
338 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa2PosX = -12.6*fgkmm;
339 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa2PosY = 16.54*fgkmm;
340 :
341 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3Xmid = 3.0*fgkmm;
342 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3Xend = 0.91*fgkmm;
343 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3Z = 2.*fgkmm; // ???
344 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3Y = 3.43*fgkmm;
345 :
346 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosX1 = 14.6*fgkmm;
347 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosX2 = 7.2*fgkmm;
348 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosX3 = 2.52*fgkmm;
349 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosX4 = -4.96*fgkmm;
350 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosX5 = -13.82*fgkmm;
351 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosY1 = 6.27*fgkmm;
352 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosY2 = 0.7*fgkmm;
353 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCapa3PosY3 = 9.1*fgkmm;
354 :
355 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCool1X = 14.*fgkmm;
356 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCool1Y = 9.5*fgkmm;
357 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCool1Z = 2.*fgkmm;
358 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCool2X = 14.25*fgkmm;
359 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCool2Y = 3.5*fgkmm;
360 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCool2Z = 4.5*fgkmm;
361 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCool3X = 4.5*fgkmm;
362 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCool3Y = 3.5*fgkmm;
363 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCool3Z = 7.2*fgkmm;
364 116 : const Double_t AliITSv11GeometrySDD::fgkHVCardCoolDY = 6.*fgkmm;
365 :
366 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosSuppX1 = 19.5*fgkmm;
367 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosSuppY1 = 2*fgkmm;
368 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosSuppX2 = 35.*fgkmm;
369 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosSuppY2 = 3.9*fgkmm;
370 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosSuppZ = 17.*fgkmm;
371 : const Double_t AliITSv11GeometrySDD::fgkCarlosSuppAngle = 45;
372 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosSuppX3 = 4.5*fgkmm;
373 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosSuppY3 = 3.*fgkmm;
374 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosSuppZ3 = 12.*fgkmm;
375 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosSuppTopLen = 8.65*fgkmm;
376 :
377 : // screws fixing boards to the end-ladder on the U tube
378 116 : const Double_t AliITSv11GeometrySDD::fgkLittleScrewHeadR = 1.85*fgkmm;
379 116 : const Double_t AliITSv11GeometrySDD::fgkLittleScrewHeadH = 1.5*fgkmm;
380 116 : const Double_t AliITSv11GeometrySDD::fgkLittleScrewR = 0.7*fgkmm;
381 116 : const Double_t AliITSv11GeometrySDD::fgkShiftLittleScrewLV = 3*fgkmm; // ???
382 116 : const Double_t AliITSv11GeometrySDD::fgkLittleLVScrewHeadR = 1.2*fgkmm; // ???
383 :
384 : // CARLOS board
385 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosCardX1 = (25.50+28.50)*fgkmm; // length (first part of Carlos card)
386 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosCardY1 = 1.6*fgkmm; // thickness
387 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosCardZ1 = 40.8*fgkmm; // width
388 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosCardCuY = 0.1*fgkmm; // thickness of Cu layer (strips)
389 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosCardX2 = 25.50*fgkmm; // length (2nd part of Carlos card)
390 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosCardZ2 = 8.20*fgkmm; // width
391 :
392 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosCardChipSiThick = 0.1*fgkmm; // ??? idem for all chips ???
393 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosCardShift = 9*fgkmm; // ??? shift in z w.r.t. heat bridge
394 :
395 : // size and position of various chips on carlos end-ladder board
396 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU1X = 13*fgkmm;
397 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU1Y = 1.68*fgkmm;
398 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU1Z = 13*fgkmm;
399 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU1posX = 18.4*fgkmm;
400 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU1posZ = -7.2*fgkmm;
401 :
402 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU2X = 13.75*fgkmm;
403 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU2Y = 1.60*fgkmm;
404 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU2Z = 13.85*fgkmm;
405 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU2posX = -0.375*fgkmm;
406 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU2posZ = -9.725*fgkmm;
407 :
408 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU3X = 5*fgkmm;
409 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU3Y = 1.*fgkmm;
410 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU3Z = 5*fgkmm;
411 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU3posX = 6.4*fgkmm;
412 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU3posZ = 9.9*fgkmm;
413 :
414 : // U4 like U3
415 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU4posX = -12*fgkmm;
416 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU4posZ = 3.6*fgkmm;
417 :
418 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU17X = 16*fgkmm;
419 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU17Y = 3.5*fgkmm;
420 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU17Z = 10.9*fgkmm;
421 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU17posX = -17.84*fgkmm;
422 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU17posZ = -10.95*fgkmm;
423 :
424 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU35X = 4*fgkmm;
425 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU35Y = 1.*fgkmm;
426 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU35Z = 4*fgkmm;
427 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU35posX = -21.6*fgkmm;
428 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU35posZ = 2.3*fgkmm;
429 :
430 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU36X = 6*fgkmm;
431 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU36Y = 1.*fgkmm;
432 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU36Z = 6*fgkmm;
433 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU36posX = -21.6*fgkmm;
434 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosU36posZ = 9.6*fgkmm;
435 :
436 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosQZ1X = 8*fgkmm;
437 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosQZ1Y = 1.7*fgkmm; // look thicker than design number (0.7) ! ???
438 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosQZ1Z = 3.7*fgkmm;
439 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosQZ1posX = -12*fgkmm;
440 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosQZ1posZ = 10.6*fgkmm;
441 :
442 : // distance from the heat bridge center to the card center :
443 116 : const Double_t AliITSv11GeometrySDD::fgkCarlosCard2HeatBridge = fgkCarlosSuppY2/2+fgkCarlosCardY1/2+fgkCarlosU1Y+0.1*fgkmm;
444 :
445 : // some pieces at the end of the carbon fiber ladder
446 116 : const Double_t AliITSv11GeometrySDD::fgkCoolPipeLay3Len = 467.*fgkmm; // ???
447 116 : const Double_t AliITSv11GeometrySDD::fgkCoolPipeLay4Len = 616.*fgkmm; // ???
448 116 : const Double_t AliITSv11GeometrySDD::fgkHVguideX1 = 42.5*fgkmm;
449 116 : const Double_t AliITSv11GeometrySDD::fgkHVguideY1 = 7.*fgkmm;
450 116 : const Double_t AliITSv11GeometrySDD::fgkHVguideZ1 = 10.*fgkmm;
451 116 : const Double_t AliITSv11GeometrySDD::fgkHVguideZ2 = 6.*fgkmm;
452 116 : const Double_t AliITSv11GeometrySDD::fgkHVguideDX = -8.5*fgkmm;
453 116 : const Double_t AliITSv11GeometrySDD::fgkHVguideSuppFullZ = 37.5*fgkmm;
454 :
455 : // Cooling connector between phynox and plastic cooling water tubes
456 116 : const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeRmin = 1 *fgkmm;
457 116 : const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeR1 = 2.5*fgkmm; // ???
458 116 : const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeL1 = 3.*fgkmm; // ???
459 116 : const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeR2 = 3.5*fgkmm; // ???
460 116 : const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeL2 = 2.*fgkmm; // ???
461 116 : const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeR3 = 3.*fgkmm; // ???
462 116 : const Double_t AliITSv11GeometrySDD::fgkConnectorCoolTubeL3 = 5 *fgkmm; // ???
463 :
464 :
465 : // parameters for coding SDD cables on SDD and SSD cones
466 : const Double_t AliITSv11GeometrySDD::fgkSectionCuPerMod = 3*2*0.006 + 3*2*0.0005 + 2*0.002;
467 : // copper : LV + signal + HV(HV ???)
468 174 : const Double_t AliITSv11GeometrySDD::fgkSectionPlastPerMod = (TMath::Pi()*(3*0.36*0.36/4 + 3*0.21*0.21/4 + 2*0.115*0.115/4)
469 116 : - fgkSectionCuPerMod);
470 :
471 : const Double_t AliITSv11GeometrySDD::fgkSectionGlassPerMod = 3*0.006; // ???
472 : const Double_t AliITSv11GeometrySDD::fgkSectionCoolPolyuEL = 0.4672;
473 : const Double_t AliITSv11GeometrySDD::fgkSectionCoolWaterEL = 0.3496;
474 116 : const Double_t AliITSv11GeometrySDD::fgkEndLadderEarthCableR = 0.5*fgkmm;
475 : // (sections are given in cm square)
476 : const Double_t AliITSv11GeometrySDD::fgkCableBendRatio = 1.3; // ??? this factor account for the bending of cables
477 116 : const Double_t AliITSv11GeometrySDD::fgkHybridAlFoilThick = 0.1*fgkmm; // Thickness of Al foil on hybrid side - TO BE CHECKED
478 116 : const Double_t AliITSv11GeometrySDD::fgkHybridAlFoilWide = 4.2*fgkmm; // Width of Al foil on hybrid side - from digitCableA
479 116 : const Double_t AliITSv11GeometrySDD::fgkHybridAlFoilSide = 2.0*fgkmm; // Side length of Al foil on hybrid side
480 :
481 116 : const Double_t AliITSv11GeometrySDD::fgkConeSDDr1 = 11.87574*fgkcm;
482 116 : const Double_t AliITSv11GeometrySDD::fgkConeSDDr2 = 26.07574*fgkcm;
483 116 : const Double_t AliITSv11GeometrySDD::fgkConeSDDz1 = 3.36066*fgkcm + 186.0*fgkmm + 0.5*790.0*fgkmm - 19.18934*fgkcm - 1.6;
484 116 : const Double_t AliITSv11GeometrySDD::fgkConeSDDz2 = 17.56066*fgkcm + 186.0*fgkmm + 0.5*790.0*fgkmm - 19.18934*fgkcm - 1.6;
485 : // These last parameters come from cone's code and define the slope
486 : // and position of the SDD cone end. For some unknown reason, this doesn't
487 : // allow to stick on the SDD cone. This has to be checked when a correct
488 : // version of the cone is available ... For now 'm applying some approximative
489 : // corrections
490 :
491 116 : const Double_t AliITSv11GeometrySDD::fgkSDDCableR1 = 16*fgkcm; // ??? // part 1 of "cable cone"
492 116 : const Double_t AliITSv11GeometrySDD::fgkSDDCableR2 = 23*fgkcm; // ??? // part 1/2 of "cable cone"
493 116 : const Double_t AliITSv11GeometrySDD::fgkSDDCableR3 = 26*fgkcm; // ??? // part 2 of "cable cone"
494 :
495 116 : const Double_t AliITSv11GeometrySDD::fgkSDDCableDZint = 3.5*fgkcm;
496 116 : const Double_t AliITSv11GeometrySDD::fgkSDDCableR5 = 37*fgkcm; // third part of "cable cone"
497 116 : const Double_t AliITSv11GeometrySDD::fgkSDDCableZ5 = 65*fgkcm; // third part of "cable cone"
498 :
499 :
500 : using std::endl;
501 : using std::cout;
502 116 : ClassImp(AliITSv11GeometrySDD)
503 :
504 : //________________________________________________________________________
505 : AliITSv11GeometrySDD::AliITSv11GeometrySDD():
506 0 : AliITSv11Geometry(),
507 0 : fPinSupport(0),
508 0 : fCoolPipeSupportL(0),
509 0 : fCoolPipeSupportR(0),
510 0 : fSDDsensor3(0),
511 0 : fSDDsensor4(0),
512 0 : fBaseThermalBridge(0),
513 0 : fHybrid(0),
514 0 : fLadderFoot(0),
515 0 : fCardLVR(0),
516 0 : fCardLVL(0),
517 0 : fCardHV(0),
518 0 : fCardCarlos(0),
519 0 : fRaccordoL(0),
520 0 : fDigitCableLay3A(0),
521 0 : fDigitCableLay3B(0),
522 0 : fDigitCableLay4A(0),
523 0 : fDigitCableLay4B(0),
524 0 : fMotherVol(0),
525 0 : fAddHybrids(kTRUE),
526 0 : fAddSensors(kTRUE),
527 0 : fAddHVcables(kTRUE),
528 0 : fAddCables(kTRUE),
529 0 : fAddCoolingSyst(kTRUE),
530 0 : fCoolingOn(kTRUE),
531 0 : fAddOnlyLadder3min(-1),
532 0 : fAddOnlyLadder3max(-1),
533 0 : fAddOnlyLadder4min(-1),
534 0 : fAddOnlyLadder4max(-1),
535 0 : fColorCarbonFiber(4),
536 0 : fColorRyton(5),
537 0 : fColorPhynox(7),
538 0 : fColorSilicon(3),
539 0 : fColorAl(7),
540 0 : fColorPolyhamide(5),
541 0 : fColorGlass(2),
542 0 : fColorSMD(12),
543 0 : fColorSMDweld(17),
544 0 : fColorStesalite(20),
545 0 : fLay3LadderUnderSegDH(0),
546 0 : fLay4LadderUnderSegDH(0),
547 0 : fLay3LaddShortRadius(0),
548 0 : fLay3LaddLongRadius(0),
549 0 : fLay4LaddShortRadius(0),
550 0 : fLay4LaddLongRadius(0)
551 0 : {
552 : //
553 : // Standard constructor
554 : //
555 0 : fCommonVol[0] = NULL;
556 0 : fCommonVol[1] = NULL;
557 0 : fCommonTr[0] = NULL;
558 0 : fCommonTr[1] = NULL;
559 0 : for (Int_t i=0; i<fgkNladdSegCommonVol; i++){
560 0 : fLaddSegCommonVol[i] = NULL;
561 0 : fLaddSegCommonTr[i] = NULL;
562 : }
563 0 : SetParameters();
564 0 : }
565 :
566 :
567 : //________________________________________________________________________
568 : AliITSv11GeometrySDD::AliITSv11GeometrySDD(Int_t debug) :
569 1 : AliITSv11Geometry(debug),
570 1 : fPinSupport(0),
571 1 : fCoolPipeSupportL(0),
572 1 : fCoolPipeSupportR(0),
573 1 : fSDDsensor3(0),
574 1 : fSDDsensor4(0),
575 1 : fBaseThermalBridge(0),
576 1 : fHybrid(0),
577 1 : fLadderFoot(0),
578 1 : fCardLVR(0),
579 1 : fCardLVL(0),
580 1 : fCardHV(0),
581 1 : fCardCarlos(0),
582 1 : fRaccordoL(0),
583 1 : fDigitCableLay3A(0),
584 1 : fDigitCableLay3B(0),
585 1 : fDigitCableLay4A(0),
586 1 : fDigitCableLay4B(0),
587 1 : fMotherVol(0),
588 1 : fAddHybrids(kTRUE),
589 1 : fAddSensors(kTRUE),
590 1 : fAddHVcables(kTRUE),
591 1 : fAddCables(kTRUE),
592 1 : fAddCoolingSyst(kTRUE),
593 1 : fCoolingOn(kTRUE),
594 1 : fAddOnlyLadder3min(-1),
595 1 : fAddOnlyLadder3max(-1),
596 1 : fAddOnlyLadder4min(-1),
597 1 : fAddOnlyLadder4max(-1),
598 1 : fColorCarbonFiber(4),
599 1 : fColorRyton(5),
600 1 : fColorPhynox(7),
601 1 : fColorSilicon(3),
602 1 : fColorAl(7),
603 1 : fColorPolyhamide(5),
604 1 : fColorGlass(2),
605 1 : fColorSMD(12),
606 1 : fColorSMDweld(17),
607 1 : fColorStesalite(20),
608 1 : fLay3LadderUnderSegDH(0),
609 1 : fLay4LadderUnderSegDH(0),
610 1 : fLay3LaddShortRadius(0),
611 1 : fLay3LaddLongRadius(0),
612 1 : fLay4LaddShortRadius(0),
613 1 : fLay4LaddLongRadius(0)
614 5 : {
615 : //
616 : // Constructor setting debugging level
617 : //
618 1 : fCommonVol[0] = NULL;
619 1 : fCommonVol[1] = NULL;
620 1 : fCommonTr[0] = NULL;
621 1 : fCommonTr[1] = NULL;
622 42 : for (Int_t i=0; i<fgkNladdSegCommonVol; i++){
623 20 : fLaddSegCommonVol[i] = NULL;
624 20 : fLaddSegCommonTr[i] = NULL;
625 : }
626 1 : SetParameters();
627 2 : }
628 :
629 : //________________________________________________________________________
630 : AliITSv11GeometrySDD::AliITSv11GeometrySDD(const AliITSv11GeometrySDD &s) :
631 0 : AliITSv11Geometry(s.GetDebug()),
632 0 : fPinSupport(s.fPinSupport),
633 0 : fCoolPipeSupportL(s.fCoolPipeSupportL),
634 0 : fCoolPipeSupportR(s.fCoolPipeSupportR),
635 0 : fSDDsensor3(s.fSDDsensor3),
636 0 : fSDDsensor4(s.fSDDsensor4),
637 0 : fBaseThermalBridge(s.fBaseThermalBridge),
638 0 : fHybrid(s.fHybrid),
639 0 : fLadderFoot(s.fLadderFoot),
640 0 : fCardLVR(s.fCardLVR),
641 0 : fCardLVL(s.fCardLVL),
642 0 : fCardHV(s.fCardHV),
643 0 : fCardCarlos(s.fCardCarlos),
644 0 : fRaccordoL(s.fRaccordoL),
645 0 : fDigitCableLay3A(s.fDigitCableLay3A),
646 0 : fDigitCableLay3B(s.fDigitCableLay3B),
647 0 : fDigitCableLay4A(s.fDigitCableLay4A),
648 0 : fDigitCableLay4B(s.fDigitCableLay4B),
649 0 : fMotherVol(s.fMotherVol),
650 0 : fAddHybrids(s.fAddHybrids),
651 0 : fAddSensors(s.fAddSensors),
652 0 : fAddHVcables(s.fAddHVcables),
653 0 : fAddCables(s.fAddCables),
654 0 : fAddCoolingSyst(s.fAddCoolingSyst),
655 0 : fCoolingOn(s.fCoolingOn),
656 0 : fAddOnlyLadder3min(s.fAddOnlyLadder3min),
657 0 : fAddOnlyLadder3max(s.fAddOnlyLadder3max),
658 0 : fAddOnlyLadder4min(s.fAddOnlyLadder4min),
659 0 : fAddOnlyLadder4max(s.fAddOnlyLadder4max),
660 0 : fColorCarbonFiber(s.fColorCarbonFiber),
661 0 : fColorRyton(s.fColorRyton),
662 0 : fColorPhynox(s.fColorPhynox),
663 0 : fColorSilicon(s.fColorSilicon),
664 0 : fColorAl(s.fColorAl),
665 0 : fColorPolyhamide(s.fColorPolyhamide),
666 0 : fColorGlass(s.fColorGlass),
667 0 : fColorSMD(s.fColorSMD),
668 0 : fColorSMDweld(s.fColorSMDweld),
669 0 : fColorStesalite(s.fColorStesalite),
670 0 : fLay3LadderUnderSegDH(s.fLay3LadderUnderSegDH),
671 0 : fLay4LadderUnderSegDH(s.fLay4LadderUnderSegDH),
672 0 : fLay3LaddShortRadius(s.fLay3LaddShortRadius),
673 0 : fLay3LaddLongRadius(s.fLay3LaddLongRadius),
674 0 : fLay4LaddShortRadius(s.fLay4LaddShortRadius),
675 0 : fLay4LaddLongRadius(s.fLay4LaddLongRadius)
676 0 : {
677 : // Copy Constructor
678 : // do only a "shallow copy" ...
679 0 : fCommonVol[0] = s.fCommonVol[0];
680 0 : fCommonVol[1] = s.fCommonVol[1];
681 0 : fCommonTr[0] = s.fCommonTr[0];
682 0 : fCommonTr[1] = s.fCommonTr[1];
683 0 : for (Int_t i=0; i<fgkNladdSegCommonVol; i++){
684 0 : fLaddSegCommonVol[i] = s.fLaddSegCommonVol[i];
685 0 : fLaddSegCommonTr[i] = s.fLaddSegCommonTr[i];
686 : }
687 0 : SetParameters();
688 0 : }
689 :
690 : //________________________________________________________________________
691 : AliITSv11GeometrySDD& AliITSv11GeometrySDD::
692 : operator=(const AliITSv11GeometrySDD &s) {
693 : // Assignment operator
694 0 : if(&s == this) return *this;
695 0 : fMotherVol = s.fMotherVol;
696 0 : fAddHybrids = s.fAddHybrids;
697 0 : fAddSensors = s.fAddSensors;
698 0 : fAddHVcables = s.fAddHVcables;
699 0 : fAddCables = s.fAddCables;
700 0 : fAddCoolingSyst = s.fAddCoolingSyst;
701 0 : fCoolingOn = s.fCoolingOn;
702 0 : fAddOnlyLadder3min = s.fAddOnlyLadder3min;
703 0 : fAddOnlyLadder3max = s.fAddOnlyLadder3max;
704 0 : fAddOnlyLadder4min = s.fAddOnlyLadder4min;
705 0 : fAddOnlyLadder4max = s.fAddOnlyLadder4max;
706 0 : return *this;
707 0 : }
708 :
709 : //________________________________________________________________________
710 6 : AliITSv11GeometrySDD::~AliITSv11GeometrySDD() {
711 : // Look like a destructor
712 : // Smell like a destructor
713 : // And actually is the destructor
714 10 : if (fDigitCableLay3A) delete [] fDigitCableLay3A;
715 10 : if (fDigitCableLay3B) delete [] fDigitCableLay3B;
716 12 : if (fDigitCableLay4A) delete [] fDigitCableLay4A;
717 12 : if (fDigitCableLay4B) delete [] fDigitCableLay4B;
718 3 : }
719 :
720 : //________________________________________________________________________
721 : void AliITSv11GeometrySDD::SetParameters() {
722 : //
723 : // Define display colors and the non constant geometry parameters
724 : //
725 :
726 2 : Double_t detLadderDist = 8.4*fgkmm;
727 :
728 1 : fLay3LadderUnderSegDH = detLadderDist - (fgkWaHVcableAlThick+fgkWaHVcablePolyThick);
729 1 : fLay4LadderUnderSegDH = detLadderDist - (fgkWaHVcableAlThick+fgkWaHVcablePolyThick);
730 :
731 : // radius from the center to the CF ladder :
732 2 : fLay3LaddShortRadius = (fgkLay3DetShortRadius
733 1 : + fgkLadWaferSep+2*fgkWaferThickness
734 1 : + detLadderDist);
735 2 : fLay3LaddLongRadius = (fgkLay3DetLongRadius
736 1 : + fgkLadWaferSep+2*fgkWaferThickness
737 1 : + detLadderDist);
738 2 : fLay4LaddShortRadius = (fgkLay4DetShortRadius
739 1 : + fgkLadWaferSep+2*fgkWaferThickness
740 1 : + detLadderDist);
741 2 : fLay4LaddLongRadius = (fgkLay4DetLongRadius
742 1 : + fgkLadWaferSep+2*fgkWaferThickness
743 1 : + detLadderDist);
744 :
745 1 : fLay3sensorZPos[0]= ( 35.8+72.4+75.8 )*fgkmm;
746 1 : fLay3sensorZPos[1]= ( 35.8+72.4 )*fgkmm;
747 1 : fLay3sensorZPos[2]= ( 35.8 )*fgkmm;
748 1 : fLay3sensorZPos[3]= ( -37.9 )*fgkmm;
749 1 : fLay3sensorZPos[4]= ( -37.9-74.9 )*fgkmm;
750 1 : fLay3sensorZPos[5]= ( -37.9-74.9-71.1 )*fgkmm;
751 :
752 1 : fLay4sensorZPos[0] = ( 38.5+73.2+75.4+71.6 )*fgkmm;
753 1 : fLay4sensorZPos[1] = ( 38.5+73.2+75.4 )*fgkmm;
754 1 : fLay4sensorZPos[2] = ( 38.5+73.2 )*fgkmm;
755 1 : fLay4sensorZPos[3] = ( 38.5 )*fgkmm;
756 1 : fLay4sensorZPos[4] = ( -35.6 )*fgkmm;
757 1 : fLay4sensorZPos[5] = ( -35.6-74.8 )*fgkmm;
758 1 : fLay4sensorZPos[6] = ( -35.6-74.8-72.4 )*fgkmm;
759 1 : fLay4sensorZPos[7] = ( -35.6-74.8-72.4-76. )*fgkmm;
760 1 : }
761 :
762 :
763 : //________________________________________________________________________
764 : TGeoMedium* AliITSv11GeometrySDD::GetMedium(const char* mediumName) {
765 : //
766 : // Called to get a medium, checks that it exists.
767 : // If not, prints an error and returns 0
768 : //
769 :
770 380 : char ch[30];
771 190 : snprintf(ch, 30, "ITS_%s",mediumName);
772 190 : TGeoMedium* medium = gGeoManager->GetMedium(ch);
773 190 : if (! medium)
774 0 : printf("Error(AliITSv11GeometrySDD)::medium %s not found !\n", mediumName);
775 190 : return medium;
776 190 : }
777 :
778 :
779 : //________________________________________________________________________
780 : Int_t AliITSv11GeometrySDD::GetLay3NLadders() const{
781 : // Get the actual number of ladder in layer 3
782 0 : if ( (fAddOnlyLadder3min<0) ||
783 0 : (fAddOnlyLadder3min >= fgkLay3Nladd) ||
784 0 : (fAddOnlyLadder3max<0) ||
785 0 : (fAddOnlyLadder3max >= fgkLay3Nladd) )
786 0 : return fgkLay3Nladd;
787 0 : else return (fAddOnlyLadder3max-fAddOnlyLadder3min+1);
788 0 : }
789 :
790 :
791 : //________________________________________________________________________
792 : Int_t AliITSv11GeometrySDD::GetLay4NLadders() const{
793 : // Get the actual number of ladder in layer 4
794 0 : if ( (fAddOnlyLadder4min<0) ||
795 0 : (fAddOnlyLadder4min >= fgkLay4Nladd) ||
796 0 : (fAddOnlyLadder4max<0) ||
797 0 : (fAddOnlyLadder4max >= fgkLay4Nladd) )
798 0 : return fgkLay4Nladd;
799 0 : else return (fAddOnlyLadder4max-fAddOnlyLadder4min+1);
800 0 : }
801 :
802 :
803 : //________________________________________________________________________
804 : void AliITSv11GeometrySDD::CreateBasicObjects() {
805 : //
806 : // Create basics objets which will be assembled together
807 : // in Layer3 and Layer4 functions
808 : //
809 :
810 :
811 15 : fDigitCableLay3A = new AliITSv11GeomCableFlat[fgkLay3Ndet];
812 14 : fDigitCableLay3B = new AliITSv11GeomCableFlat[fgkLay3Ndet];
813 18 : fDigitCableLay4A = new AliITSv11GeomCableFlat[fgkLay4Ndet];
814 18 : fDigitCableLay4B = new AliITSv11GeomCableFlat[fgkLay4Ndet];
815 :
816 1 : fPinSupport = CreatePinSupport();
817 1 : fCoolPipeSupportL = CreateCoolPipeSupportL();
818 1 : fCoolPipeSupportR = CreateCoolPipeSupportR();
819 1 : CreateSDDsensor();
820 1 : fBaseThermalBridge = CreateBaseThermalBridge();
821 1 : fHybrid = CreateHybrid(0);
822 :
823 1 : TGeoMedium *carbonFiberLadderStruct = GetMedium("SDD C AL (M55J)$"); //ITSsddCarbonM55J
824 1 : TGeoMedium *polyhamideSDD = GetMedium("SDDKAPTON (POLYCH2)$");//ITSsddKAPTON_POLYCH2
825 1 : TGeoMedium *alSDD = GetMedium("AL$"); //ITSal
826 1 : TGeoMedium *stainless = GetMedium("AISI304L$"); // for screws
827 1 : TGeoMedium *coolerMediumSDD = GetMedium("WATER$");
828 1 : TGeoMedium *raccordMedium = GetMedium("INOX$"); // same as AISI 316-L
829 1 : TGeoMedium *copperMedium = GetMedium("COPPER$");
830 :
831 : //********************************************************************
832 : // pieces of the carbon fiber structure
833 : //********************************************************************
834 1 : Double_t dy = fgkLadderSegBoxDH/2;
835 1 : Double_t triangleHeight = fgkLadderHeight - fgkLadderBeamRadius;
836 1 : Double_t halfTheta = TMath::ATan( 0.5*fgkLadderWidth/triangleHeight );
837 1 : Double_t alpha = TMath::Pi()*3./4. - halfTheta/2.;
838 1 : Double_t beta = (TMath::Pi() - 2.*halfTheta)/4.;
839 1 : Double_t dYTranslation = (fgkLadderHeight/2.
840 1 : -0.5*fgkLadderWidth*TMath::Tan(beta)
841 1 : -fgkLadderBeamRadius);
842 1 : Double_t distCenterSideDown = 0.5*fgkLadderWidth/TMath::Cos(beta);
843 :
844 : //--- the top V of the Carbon Fiber Ladder (segment)
845 1 : TGeoArb8 *cfLaddTop1 = CreateLadderSide( "CFladdTopCornerVol1shape",
846 1 : fgkSegmentLength/2., halfTheta,
847 1 : -1, fgkLadderLa, fgkLadderHa, fgkLadderl);
848 2 : TGeoVolume *cfLaddTopVol1 = new TGeoVolume("ITSsddCFladdTopCornerVol1",
849 1 : cfLaddTop1,carbonFiberLadderStruct);
850 1 : TGeoArb8 *cfLaddTop2 = CreateLadderSide( "CFladdTopCornerVol2shape",
851 1 : fgkSegmentLength/2., halfTheta,
852 1 : 1, fgkLadderLa, fgkLadderHa, fgkLadderl);
853 2 : TGeoVolume *cfLaddTopVol2 = new TGeoVolume("ITSsddCFladdTopCornerVol2",
854 1 : cfLaddTop2, carbonFiberLadderStruct);
855 1 : cfLaddTopVol1->SetLineColor(fColorCarbonFiber);
856 1 : cfLaddTopVol2->SetLineColor(fColorCarbonFiber);
857 1 : TGeoTranslation *trTop1 = new TGeoTranslation(0, fgkLadderHeight/2-dy, 0);
858 :
859 : //--- the 2 side V
860 1 : TGeoArb8 *cfLaddSide1 = CreateLadderSide( "CFladdSideCornerVol1shape",
861 1 : fgkSegmentLength/2., beta, -1,
862 1 : fgkLadderLb, fgkLadderHb, fgkLadderl);
863 2 : TGeoVolume *cfLaddSideVol1 = new TGeoVolume( "ITSsddCFladdSideCornerVol1",
864 1 : cfLaddSide1,carbonFiberLadderStruct);
865 1 : TGeoArb8 *cfLaddSide2 = CreateLadderSide( "CFladdSideCornerVol2shape",
866 1 : fgkSegmentLength/2., beta, 1,
867 1 : fgkLadderLb, fgkLadderHb, fgkLadderl);
868 2 : TGeoVolume *cfLaddSideVol2 = new TGeoVolume( "ITSsddCFladdSideCornerVol2",
869 1 : cfLaddSide2,carbonFiberLadderStruct);
870 1 : cfLaddSideVol1->SetLineColor(fColorCarbonFiber);
871 1 : cfLaddSideVol2->SetLineColor(fColorCarbonFiber);
872 1 : TGeoCombiTrans *ctSideR = CreateCombiTrans("", distCenterSideDown, 0,
873 1 : alpha*TMath::RadToDeg());
874 1 : AddTranslationToCombiTrans(ctSideR, 0, -dYTranslation-dy, 0);
875 1 : TGeoCombiTrans *ctSideL = CreateCombiTrans("", distCenterSideDown,0,
876 1 : -alpha*TMath::RadToDeg());
877 1 : AddTranslationToCombiTrans(ctSideL, 0, -dYTranslation-dy, 0);
878 :
879 : //--- The beams
880 : // Beams on the sides
881 3 : Double_t beamPhiPrime = TMath::ASin(1./TMath::Sqrt( (1+TMath::Sin(2*beta)*
882 2 : TMath::Sin(2*beta)/(TanD(fgkBeamSidePhi)*TanD(fgkBeamSidePhi))) ));
883 : //cout<<"Phi prime = "<<beamPhiPrime*TMath::RadToDeg()<<endl;
884 3 : Double_t beamLength = TMath::Sqrt( fgkLadderHeight*fgkLadderHeight/
885 1 : ( TMath::Sin(beamPhiPrime)*TMath::Sin(beamPhiPrime))
886 2 : + fgkLadderWidth*fgkLadderWidth/4.)-fgkLadderLa/2-fgkLadderLb/2;
887 1 : TGeoTubeSeg *sideBeamS = new TGeoTubeSeg(0, fgkLadderBeamRadius,beamLength/2.,
888 : 0, 180);
889 1 : TGeoVolume *sideBeam = new TGeoVolume("ITSsddCFSideBeamVol", sideBeamS,
890 : carbonFiberLadderStruct);
891 1 : sideBeam->SetLineColor(fColorCarbonFiber);
892 :
893 : //Euler rotation : about Z, then new X, then new Z
894 2 : TGeoRotation *beamRot1 = new TGeoRotation("", 90-2.*beta*TMath::RadToDeg(),
895 1 : -beamPhiPrime*TMath::RadToDeg(),-90);
896 2 : TGeoRotation *beamRot2 = new TGeoRotation("", 90-2.*beta*TMath::RadToDeg(),
897 1 : beamPhiPrime*TMath::RadToDeg(), -90);
898 2 : TGeoRotation *beamRot3 = new TGeoRotation("", 90+2.*beta*TMath::RadToDeg(),
899 1 : beamPhiPrime*TMath::RadToDeg(), -90);
900 2 : TGeoRotation *beamRot4 = new TGeoRotation("", 90+2.*beta*TMath::RadToDeg(),
901 1 : -beamPhiPrime*TMath::RadToDeg(),-90);
902 :
903 : TGeoCombiTrans *beamTransf[8];
904 3 : beamTransf[0] = new TGeoCombiTrans( 0.5*triangleHeight*
905 1 : TMath::Tan(halfTheta),
906 1 : fgkLadderBeamRadius/2. - dy,
907 1 : -3*fgkSegmentLength/8, beamRot1);
908 :
909 3 : beamTransf[1] = new TGeoCombiTrans( 0.5*triangleHeight*
910 1 : TMath::Tan(halfTheta),
911 1 : fgkLadderBeamRadius/2. - dy,
912 1 : -3*fgkSegmentLength/8, beamRot1);
913 1 : AddTranslationToCombiTrans(beamTransf[1], 0, 0, fgkSegmentLength/2);
914 :
915 3 : beamTransf[2] = new TGeoCombiTrans(0.5*triangleHeight*
916 1 : TMath::Tan(halfTheta),
917 1 : fgkLadderBeamRadius/2. - dy,
918 1 : -fgkSegmentLength/8, beamRot2);
919 :
920 3 : beamTransf[3] = new TGeoCombiTrans(0.5*triangleHeight*
921 1 : TMath::Tan(halfTheta),
922 1 : fgkLadderBeamRadius/2. - dy,
923 1 : -fgkSegmentLength/8, beamRot2);
924 1 : AddTranslationToCombiTrans(beamTransf[3], 0, 0, fgkSegmentLength/2);
925 :
926 3 : beamTransf[4] = new TGeoCombiTrans(-0.5*triangleHeight*
927 1 : TMath::Tan(halfTheta),
928 1 : fgkLadderBeamRadius/2. - dy,
929 1 : -3*fgkSegmentLength/8, beamRot3);
930 :
931 3 : beamTransf[5] = new TGeoCombiTrans(-0.5*triangleHeight*
932 1 : TMath::Tan(halfTheta),
933 1 : fgkLadderBeamRadius/2. - dy,
934 1 : -3*fgkSegmentLength/8, beamRot3);
935 1 : AddTranslationToCombiTrans(beamTransf[5], 0, 0, fgkSegmentLength/2);
936 :
937 3 : beamTransf[6] = new TGeoCombiTrans(-0.5*triangleHeight*
938 2 : TMath::Tan(halfTheta),fgkLadderBeamRadius/2.-dy, -fgkSegmentLength/8,beamRot4);
939 3 : beamTransf[7] = new TGeoCombiTrans(-0.5*triangleHeight*
940 2 : TMath::Tan(halfTheta),fgkLadderBeamRadius/2.-dy,3*fgkSegmentLength/8,beamRot4);
941 :
942 : //--- Beams of the bottom
943 2 : TGeoTubeSeg *bottomBeam1 = new TGeoTubeSeg(0, fgkLadderBeamRadius,
944 1 : fgkLadderWidth/2.-fgkLadderLb/3, 0, 180);
945 2 : TGeoVolume *bottomBeam1Vol = new TGeoVolume("ITSsddBottomBeam1Vol",
946 1 : bottomBeam1, carbonFiberLadderStruct);
947 1 : bottomBeam1Vol->SetLineColor(fColorCarbonFiber);
948 2 : TGeoTubeSeg *bottomBeam2 = new TGeoTubeSeg(0, fgkLadderBeamRadius,
949 1 : fgkLadderWidth/2.-fgkLadderLb/3, 0, 90);
950 2 : TGeoVolume *bottomBeam2Vol = new TGeoVolume("ITSsddBottomBeam2Vol",
951 1 : bottomBeam2, carbonFiberLadderStruct);
952 1 : bottomBeam2Vol->SetLineColor(fColorCarbonFiber);
953 2 : TGeoTubeSeg *bottomBeam3 = new TGeoTubeSeg(0, fgkLadderBeamRadius,
954 2 : 0.5*fgkLadderWidth/SinD(fgkBottomBeamAngle)
955 1 : - fgkLadderLb/3, 0, 180);
956 2 : TGeoVolume *bottomBeam3Vol = new TGeoVolume("ITSsddBottomBeam3Vol",
957 1 : bottomBeam3, carbonFiberLadderStruct);
958 1 : bottomBeam3Vol->SetLineColor(fColorCarbonFiber);
959 : //bottomBeam3Vol->SetLineColor(2);
960 1 : TGeoRotation *bottomBeamRot1 = new TGeoRotation("", 90, 90, 90);
961 1 : TGeoRotation *bottomBeamRot2 = new TGeoRotation("",-90, 90, -90);
962 :
963 2 : TGeoCombiTrans *bottomBeamTransf1 = new TGeoCombiTrans
964 1 : (0,-(fgkLadderHeight/2-fgkLadderBeamRadius)-dy,0, bottomBeamRot1);
965 2 : TGeoCombiTrans *bottomBeamTransf2 = new TGeoCombiTrans(0,
966 1 : -(fgkLadderHeight/2-fgkLadderBeamRadius)-dy,
967 1 : -fgkSegmentLength/2, bottomBeamRot1);
968 2 : TGeoCombiTrans *bottomBeamTransf3 = new TGeoCombiTrans(0,
969 1 : -(fgkLadderHeight/2 - fgkLadderBeamRadius)
970 1 : - dy, fgkSegmentLength/2, bottomBeamRot2);
971 : // be careful for beams #3: when "reading" from -z to +z and
972 : // from the bottom of the ladder, it should draw a Lambda, and not a V
973 1 : TGeoRotation *bottomBeamRot4 = new TGeoRotation("", -90, fgkBottomBeamAngle, -90);
974 1 : TGeoRotation *bottomBeamRot5 = new TGeoRotation("" ,-90,-fgkBottomBeamAngle, -90);
975 2 : TGeoCombiTrans *bottomBeamTransf4 = new TGeoCombiTrans
976 1 : (0,-(fgkLadderHeight/2-fgkLadderBeamRadius)-dy,-fgkSegmentLength/4,bottomBeamRot4);
977 2 : TGeoCombiTrans *bottomBeamTransf5 = new TGeoCombiTrans
978 1 : (0,-(fgkLadderHeight/2-fgkLadderBeamRadius)-dy,fgkSegmentLength/4, bottomBeamRot5);
979 :
980 : // The ground wire running on the top vertex - M.S. 12 nov 2013
981 1 : TGeoTube *groundWire = new TGeoTube(0, fgkEndLadderEarthCableR, fgkSegmentLength/2);
982 1 : TGeoVolume *groundWireVol = new TGeoVolume("ITSsddGroundWire", groundWire,
983 : copperMedium);
984 1 : groundWireVol->SetLineColor(41); // should be something brown-ish
985 2 : TGeoTranslation *trGroundWire = new TGeoTranslation(0,
986 1 : fgkLadderHeight/2-5*fgkEndLadderEarthCableR, 0);
987 :
988 1 : fLaddSegCommonVol[0] = cfLaddTopVol1; fLaddSegCommonTr[0] = trTop1;
989 1 : fLaddSegCommonVol[1] = cfLaddTopVol2; fLaddSegCommonTr[1] = trTop1;
990 1 : fLaddSegCommonVol[2] = cfLaddSideVol1; fLaddSegCommonTr[2] = ctSideR;
991 1 : fLaddSegCommonVol[3] = cfLaddSideVol1; fLaddSegCommonTr[3] = ctSideL;
992 1 : fLaddSegCommonVol[4] = cfLaddSideVol2; fLaddSegCommonTr[4] = ctSideR;
993 1 : fLaddSegCommonVol[5] = cfLaddSideVol2; fLaddSegCommonTr[5] = ctSideL;
994 1 : fLaddSegCommonVol[6] = sideBeam; fLaddSegCommonTr[6] = beamTransf[0];
995 1 : fLaddSegCommonVol[7] = sideBeam; fLaddSegCommonTr[7] = beamTransf[1];
996 1 : fLaddSegCommonVol[8] = sideBeam; fLaddSegCommonTr[8] = beamTransf[2];
997 1 : fLaddSegCommonVol[9] = sideBeam; fLaddSegCommonTr[9] = beamTransf[3];
998 1 : fLaddSegCommonVol[10]= sideBeam; fLaddSegCommonTr[10]= beamTransf[4];
999 1 : fLaddSegCommonVol[11]= sideBeam; fLaddSegCommonTr[11]= beamTransf[5];
1000 1 : fLaddSegCommonVol[12]= sideBeam; fLaddSegCommonTr[12]= beamTransf[6];
1001 1 : fLaddSegCommonVol[13]= sideBeam; fLaddSegCommonTr[13]= beamTransf[7];
1002 1 : fLaddSegCommonVol[14]= bottomBeam1Vol; fLaddSegCommonTr[14]= bottomBeamTransf1;
1003 1 : fLaddSegCommonVol[15]= bottomBeam2Vol; fLaddSegCommonTr[15]= bottomBeamTransf2;
1004 1 : fLaddSegCommonVol[16]= bottomBeam2Vol; fLaddSegCommonTr[16]= bottomBeamTransf3;
1005 1 : fLaddSegCommonVol[17]= bottomBeam3Vol; fLaddSegCommonTr[17]= bottomBeamTransf4;
1006 1 : fLaddSegCommonVol[18]= bottomBeam3Vol; fLaddSegCommonTr[18]= bottomBeamTransf5;
1007 1 : fLaddSegCommonVol[19]= groundWireVol; fLaddSegCommonTr[19]= trGroundWire;
1008 :
1009 :
1010 : //********************************************************************
1011 : // cables
1012 : //********************************************************************
1013 1 : char cableName[30];
1014 14 : for (Int_t i=0; i<fgkLay3Ndet; i++) {
1015 6 : snprintf(cableName, 30, "digitCableLay3A_%i",i);
1016 6 : fDigitCableLay3A[i].SetName(cableName);
1017 6 : fDigitCableLay3A[i].SetWidth(fgkDigitCablWidth);
1018 6 : fDigitCableLay3A[i].SetThickness(fgkDigitCablPolyThick+fgkDigitCablAlThick);
1019 6 : fDigitCableLay3A[i].SetNLayers(2);
1020 12 : fDigitCableLay3A[i].SetLayer( 0, fgkDigitCablPolyThick, polyhamideSDD,
1021 6 : fColorPolyhamide);
1022 6 : fDigitCableLay3A[i].SetLayer(1, fgkDigitCablAlThick, alSDD, fColorAl);
1023 6 : snprintf(cableName, 30, "digitCableLay3B_%i",i);
1024 6 : fDigitCableLay3B[i].SetName(cableName);
1025 6 : fDigitCableLay3B[i].SetWidth(fgkDigitCablWidth);
1026 6 : fDigitCableLay3B[i].SetThickness(fgkDigitCablPolyThick+fgkDigitCablAlThick);
1027 6 : fDigitCableLay3B[i].SetNLayers(2);
1028 12 : fDigitCableLay3B[i].SetLayer( 0, fgkDigitCablPolyThick, polyhamideSDD,
1029 6 : fColorPolyhamide);
1030 6 : fDigitCableLay3B[i].SetLayer(1, fgkDigitCablAlThick, alSDD, fColorAl);
1031 : };
1032 18 : for (Int_t i=0; i<fgkLay4Ndet; i++) {
1033 8 : snprintf(cableName, 30, "digitCableLay4A_%i",i);
1034 8 : fDigitCableLay4A[i].SetName(cableName);
1035 8 : fDigitCableLay4A[i].SetWidth(fgkDigitCablWidth);
1036 8 : fDigitCableLay4A[i].SetThickness(fgkDigitCablPolyThick+fgkDigitCablAlThick);
1037 8 : fDigitCableLay4A[i].SetNLayers(2);
1038 16 : fDigitCableLay4A[i].SetLayer( 0, fgkDigitCablPolyThick, polyhamideSDD,
1039 8 : fColorPolyhamide);
1040 8 : fDigitCableLay4A[i].SetLayer(1, fgkDigitCablAlThick, alSDD, fColorAl);
1041 8 : snprintf(cableName, 30, "digitCableLay4B_%i",i);
1042 8 : fDigitCableLay4B[i].SetName(cableName);
1043 8 : fDigitCableLay4B[i].SetWidth(fgkDigitCablWidth);
1044 8 : fDigitCableLay4B[i].SetThickness(fgkDigitCablPolyThick+fgkDigitCablAlThick);
1045 8 : fDigitCableLay4B[i].SetNLayers(2);
1046 16 : fDigitCableLay4B[i].SetLayer( 0, fgkDigitCablPolyThick, polyhamideSDD,
1047 8 : fColorPolyhamide);
1048 8 : fDigitCableLay4B[i].SetLayer(1, fgkDigitCablAlThick, alSDD, fColorAl);
1049 : };
1050 : // Well, those digit cables could also include the analog cables
1051 : // which have the same width and the same path, at least in the ladder.
1052 : // It will gain some computing ressources (less volumes) and some
1053 : // coding efforts ... !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1054 : // The only thing to do is to change the names and put the correct total
1055 : // thicknesses
1056 :
1057 : // some transformations and volumes used in several places
1058 2 : fCommonTr[0] = new TGeoRotation("CarlosSuppRotN",
1059 : 0, -fgkCarlosSuppAngle, 0);
1060 :
1061 2 : TGeoTube *littleScrewHead = new TGeoTube("littleScrewHead", 0, fgkLittleScrewHeadR,
1062 1 : fgkLittleScrewHeadH/2);
1063 3 : fCommonVol[0] = new TGeoVolume("vLittleScrewHead",
1064 1 : littleScrewHead, stainless);
1065 1 : fCommonVol[0]->SetLineColor(kGray);
1066 :
1067 1 : fLadderFoot = CreateLadderFoot();
1068 1 : CreateLVCard();
1069 1 : fCardHV = CreateHVCard();
1070 1 : fCardCarlos = CreateCarlosCard(0);
1071 :
1072 : //==================
1073 : // link beteen phynox and plastic cooling tubes
1074 : //==================
1075 :
1076 2 : fRaccordoL = new TGeoVolumeAssembly("RaccordoL");
1077 1 : Double_t fullRacLen = fgkConnectorCoolTubeL1+fgkConnectorCoolTubeL2+fgkConnectorCoolTubeL3;
1078 1 : TGeoTube *waterRac = new TGeoTube("waterRac", 0, fgkConnectorCoolTubeRmin, fullRacLen/2);
1079 1 : TGeoVolume * vwaterRac = new TGeoVolume("vwaterRac", waterRac, coolerMediumSDD);
1080 1 : vwaterRac->SetLineColor(kBlue);
1081 :
1082 2 : TGeoTube *tube1Rac = new TGeoTube("tube1Rac", fgkConnectorCoolTubeRmin,
1083 1 : fgkConnectorCoolTubeR1, fgkConnectorCoolTubeL1/2);
1084 2 : TGeoTube *tube2Rac = new TGeoTube("tube2Rac", fgkConnectorCoolTubeRmin,
1085 1 : fgkConnectorCoolTubeR2, fgkConnectorCoolTubeL2/2);
1086 2 : TGeoTube *tube3Rac = new TGeoTube("tube3Rac", fgkConnectorCoolTubeRmin,
1087 1 : fgkConnectorCoolTubeR3, fgkConnectorCoolTubeL3/2);
1088 1 : TGeoVolume * vtube1Rac = new TGeoVolume("vtube1Rac", tube1Rac, raccordMedium);
1089 1 : TGeoVolume * vtube2Rac = new TGeoVolume("vtube2Rac", tube2Rac, raccordMedium);
1090 1 : TGeoVolume * vtube3Rac = new TGeoVolume("vtube3Rac", tube3Rac, raccordMedium);
1091 1 : vtube1Rac->SetLineColor(kGray);
1092 1 : vtube2Rac->SetLineColor(kGray);
1093 1 : vtube3Rac->SetLineColor(kGray);
1094 :
1095 2 : TGeoTranslation *trTube1Rac = new TGeoTranslation("trTube1Rac",0,0,
1096 1 : -fullRacLen/2+fgkConnectorCoolTubeL1/2);
1097 2 : TGeoTranslation *trTube2Rac = new TGeoTranslation("trTube2Rac",0,0,
1098 1 : (-fullRacLen/2+fgkConnectorCoolTubeL1+fgkConnectorCoolTubeL2/2));
1099 2 : TGeoTranslation *trTube3Rac = new TGeoTranslation("trTube3Rac",0,0,
1100 2 : (-fullRacLen/2+fgkConnectorCoolTubeL1+
1101 2 : fgkConnectorCoolTubeL2+fgkConnectorCoolTubeL3/2));
1102 1 : fRaccordoL->AddNode(vwaterRac, 1,0);
1103 1 : fRaccordoL->AddNode(vtube1Rac, 1,trTube1Rac);
1104 1 : fRaccordoL->AddNode(vtube2Rac, 1,trTube2Rac);
1105 1 : fRaccordoL->AddNode(vtube3Rac, 1,trTube3Rac);
1106 1 : fRaccordoL->GetShape()->ComputeBBox(); //RS: enforce recompting of BBox
1107 1 : }
1108 :
1109 :
1110 : //________________________________________________________________________
1111 : void AliITSv11GeometrySDD::CheckOverlaps(Double_t precision){
1112 : //
1113 : // a debugging function for checking some possible overlaps
1114 : //
1115 0 : if (fSDDsensor3) fSDDsensor3->CheckOverlaps(precision);
1116 0 : if (fSDDsensor4) fSDDsensor4->CheckOverlaps(precision);
1117 0 : if (fHybrid) fHybrid->CheckOverlaps(precision);
1118 0 : }
1119 :
1120 :
1121 : //________________________________________________________________________
1122 : TGeoCombiTrans *AliITSv11GeometrySDD::
1123 : CreateCombiTrans(const char *name, Double_t dy, Double_t dz, Double_t dphi,
1124 : Bool_t planeSym) {
1125 : //
1126 : // return the TGeoCombiTrans which make a translation in y and z
1127 : // and a rotation in phi in the global coord system
1128 : // If planeSym = true, the rotation places the object symetrically
1129 : // (with respect to the transverse plane) to its position in the
1130 : // case planeSym = false
1131 : //
1132 :
1133 150 : TGeoTranslation t1(dy*CosD(90.+dphi),dy*SinD(90.+dphi), dz);
1134 150 : TGeoRotation r1("",0.,0.,dphi);
1135 150 : TGeoRotation r2("",90, 180, -90-dphi);
1136 :
1137 300 : TGeoCombiTrans *combiTrans1 = new TGeoCombiTrans(name);
1138 150 : combiTrans1->SetTranslation(t1);
1139 257 : if (planeSym) combiTrans1->SetRotation(r1);
1140 43 : else combiTrans1->SetRotation(r2);
1141 : return combiTrans1;
1142 150 : }
1143 :
1144 :
1145 : //________________________________________________________________________
1146 : void AliITSv11GeometrySDD::AddTranslationToCombiTrans(TGeoCombiTrans* ct,
1147 : Double_t dx,
1148 : Double_t dy,
1149 : Double_t dz) const{
1150 : // Add a dx,dy,dz translation to the initial TGeoCombiTrans
1151 472 : const Double_t *vect = ct->GetTranslation();
1152 236 : Double_t newVect[3] = {vect[0]+dx, vect[1]+dy, vect[2]+dz};
1153 236 : ct->SetTranslation(newVect);
1154 236 : }
1155 :
1156 :
1157 : //________________________________________________________________________
1158 : void AliITSv11GeometrySDD::ShowOnePiece(TGeoVolume *moth) {
1159 : // for code developpment and debugging purposes
1160 :
1161 0 : if (! fSDDsensor3) CreateBasicObjects();
1162 :
1163 : // moth->AddNode(fPinSupport, 1, 0);
1164 : // moth->AddNode(fCoolPipeSupportL, 1, 0);
1165 : // moth->AddNode(fSDDsensor3, 1, 0);
1166 : // moth->AddNode(fSDDsensor4, 1, 0);
1167 : // moth->AddNode(fBaseThermalBridge, 1, 0);
1168 : // moth->AddNode(fHybrid,100,0);
1169 : // moth->AddNode(fLadderFoot,1,0);
1170 : //moth->AddNode(fCardLVL,1,0);
1171 : //moth->AddNode(fCardLVR,1,0);
1172 :
1173 0 : TGeoVolume* seg = CreateLadderSegment( 3, 0);
1174 0 : moth->AddNode(seg, 1, 0);
1175 :
1176 : // TGeoVolumeAssembly *lay3Ladder = CreateLadder(3);
1177 : // moth->AddNode(lay3Ladder, 1, 0);
1178 :
1179 : // TGeoVolumeAssembly *lay3Detectors = CreateDetectorsAssembly(3);
1180 : // moth->AddNode(lay3Detectors, 1, 0);
1181 :
1182 : // TGeoVolumeAssembly *lay3Detectors = CreateDetectorsAssembly(3);
1183 : // moth->AddNode(lay3Detectors, 1, 0);
1184 :
1185 :
1186 : // TGeoVolumeAssembly *endLadder = CreateEndLadder( 4 );
1187 : // moth->AddNode(endLadder, 1, 0);
1188 :
1189 : // TGeoVolumeAssembly *highVCard = CreateHVCard( 4 );
1190 : // moth->AddNode(highVCard, 1, 0);
1191 :
1192 : // TGeoVolumeAssembly *supportRing = CreateSupportRing();
1193 : // moth->AddNode(supportRing, 1, 0);
1194 :
1195 : // TGeoVolume *endLadderCards = CreateEndLadderCardsV( 4 );
1196 : // moth->AddNode(endLadderCards, 1, 0);
1197 :
1198 : // TGeoVolumeAssembly *carlosCard = CreateCarlosCard( 4 );
1199 : // moth->AddNode(carlosCard, 1, 0);
1200 :
1201 :
1202 :
1203 : /*
1204 : //==================================
1205 : //--- test of flat cable curvature
1206 : //==================================
1207 :
1208 : double angle = 90;
1209 : AliITSv11GeomCableFlat cable("test", 3, 0.3);
1210 : cable.SetNLayers(1);
1211 : cable.SetNLayers(2);
1212 : cable.SetLayer(0, 0.2, coolerMediumSDD, 2);
1213 : cable.SetLayer(1, 0.1, coolerMediumSDD, 3);
1214 : cable.SetInitialNode(endLadderCards);
1215 :
1216 : Double_t p1[3], p2[3], vX[3] = {1,0,0},vY[3] = {0,5,0};
1217 :
1218 : p1[0] = -3;
1219 : p1[1] = 1;
1220 : p1[2] = 10;
1221 :
1222 : p2[0] = 0;
1223 : p2[1] = 1;
1224 : p2[2] = 10;
1225 : cable.AddCheckPoint(endLadderCards, 0, p1, vX);
1226 : cable.AddCheckPoint(endLadderCards, 1, p2, vX);
1227 : cable.CreateAndInsertBoxCableSegment(1,angle);
1228 :
1229 : Double_t p3[3], p4[3];
1230 :
1231 : p3[0] = 2;
1232 : p3[1] = 3;
1233 : p3[2] = 10;
1234 : cable.AddCheckPoint(endLadderCards, 2, p3, vY);
1235 : cable.CreateAndInsertCableCylSegment(2,angle);
1236 :
1237 : p4[0] = 2;
1238 : p4[1] = 6;
1239 : p4[2] = 10;
1240 : cable.AddCheckPoint(endLadderCards, 3, p4, vY);
1241 : cable.CreateAndInsertCableSegment(3,angle);
1242 : */
1243 0 : }
1244 :
1245 :
1246 : //________________________________________________________________________
1247 : void AliITSv11GeometrySDD::Layer3(TGeoVolume *moth) {
1248 : //
1249 : // Insert the layer 3 in the mother volume. This is a virtual volume
1250 : // containing ladders of layer 3 and the supporting rings
1251 : //
1252 :
1253 2 : if (! moth) {
1254 0 : printf("Error::AliITSv11GeometrySDD: Can't insert layer3, mother is null!\n");
1255 0 : return;
1256 : };
1257 :
1258 1 : TGeoMedium *airSDD = GetMedium("SDD AIR$");
1259 :
1260 1 : fMotherVol = moth;
1261 2 : if (! fSDDsensor3) CreateBasicObjects();
1262 :
1263 : //====================================
1264 : // First we create the central barrel
1265 : //====================================
1266 :
1267 1 : TGeoVolumeAssembly *lay3Ladder = CreateLadder(3);
1268 1 : TGeoVolumeAssembly *lay3Detectors = CreateDetectorsAssembly(3);
1269 1 : TGeoVolumeAssembly *lay3Ladd2Det = CreateDetectorsAssemblyLadd2();
1270 : //TGeoVolume *lay3Detectors = CreateDetectors(3);
1271 2 : TGeoTube *virtualLayer3Shape = new TGeoTube("ITSsddLayer3Shape",
1272 1 : fgkLay3Rmin,fgkLay3Rmax,fgkLay3Length*0.5);
1273 2 : TGeoVolume *virtualLayer3 = new TGeoVolume("ITSsddLayer3",
1274 1 : virtualLayer3Shape, airSDD);
1275 :
1276 : Double_t dPhi = 360./fgkLay3Nladd;
1277 1 : Double_t detectorsThick = fgkLadWaferSep + 2*fgkWaferThickness;
1278 : // Placing virtual ladder and detectors volumes following
1279 : // ladder ordering convention
1280 1 : char rotName[30];
1281 : Int_t iLaddMin = 0;
1282 : Int_t iLaddMax = fgkLay3Nladd;
1283 1 : if ((fAddOnlyLadder3min>=0)&&(fAddOnlyLadder3max<fgkLay3Nladd)) {
1284 : iLaddMin = fAddOnlyLadder3min;
1285 0 : iLaddMax = fAddOnlyLadder3max+1;
1286 0 : };
1287 :
1288 30 : for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
1289 :
1290 14 : Double_t ladderPhi = -3*dPhi+iLadd*dPhi;
1291 14 : snprintf(rotName, 30, "ITSsddLay3Ladd%i",iLadd);
1292 14 : Double_t minRadiusLadBox = fLay3LaddShortRadius-fLay3LadderUnderSegDH;
1293 14 : if (iLadd%2 != 0)
1294 7 : minRadiusLadBox = fLay3LaddLongRadius-fLay3LadderUnderSegDH;
1295 14 : minRadiusLadBox += ((TGeoBBox*)lay3Ladder->GetShape())->GetDY();
1296 : TGeoCombiTrans *ctLadd;
1297 : //=============================================================
1298 : //
1299 : // Special modification for ladder 2 of layer 3:
1300 : // It has been inverted (pi rotation around y axis)
1301 : //
1302 : //=============================================================
1303 14 : if (iLadd != 2)
1304 13 : ctLadd = CreateCombiTrans(rotName,minRadiusLadBox,
1305 : 0, ladderPhi, kTRUE);
1306 : else
1307 1 : ctLadd = CreateCombiTrans(rotName,minRadiusLadBox,
1308 : 0, ladderPhi, kFALSE);
1309 14 : virtualLayer3->AddNode(lay3Ladder, iLadd, ctLadd);
1310 : ///////////////////////////////////////////////////
1311 14 : snprintf(rotName, 30, "ITSsddLay3DetBox%i",iLadd);
1312 14 : Double_t minRadiusDetBox = fgkLay3DetShortRadius;
1313 21 : if (iLadd%2 != 0) minRadiusDetBox = fgkLay3DetLongRadius;
1314 14 : minRadiusDetBox += detectorsThick/2;
1315 : TGeoCombiTrans *ctDet;
1316 14 : ctDet = CreateCombiTrans(rotName, minRadiusDetBox,
1317 : 0, ladderPhi, kTRUE);
1318 :
1319 14 : if (iLadd != 2)
1320 27 : virtualLayer3->AddNode(lay3Detectors, iLadd, ctDet);
1321 : else
1322 1 : virtualLayer3->AddNode(lay3Ladd2Det , iLadd, ctDet);
1323 :
1324 : ///////////////////////////////////////////////////
1325 : }
1326 :
1327 : /*
1328 : //====================================
1329 : // Then the forward rapidity pieces
1330 : // (cooling, Carlos, LV, HV ...)
1331 : //====================================
1332 :
1333 : Double_t fgkForwardLay3Length = fgkEndLadPipeUlengthLay3+10*fgkmm; // this has to be tune
1334 : Double_t fgkForwardLay3Rmin = fgkLay3Rmin-7*fgkmm;
1335 : Double_t fgkForwardLay3Rmax = fgkLay3Rmax-5*fgkmm;
1336 :
1337 : TGeoVolumeAssembly* lay3EndLadder = CreateEndLadderCards(3);
1338 : TGeoTube *virtualForward3Shape = new TGeoTube("virtualForward3Shape",
1339 : fgkForwardLay3Rmin, fgkForwardLay3Rmax,
1340 : fgkForwardLay3Length/2.);
1341 :
1342 : // TGeoPcon *virtualForward3Shape = new TGeoPcon("virtualForward3Shape",0,360,2);
1343 : // // virtualForward3Shape->DefineSection(Int_t snum, Double_t z, Double_t rmin, Double_t rmax);
1344 : // virtualForward3Shape->DefineSection(0, Double_t z, Double_t rmin, Double_t rmax);
1345 :
1346 :
1347 : TGeoVolume *virtualForward3Pos = new TGeoVolume("ITSsddForward3Pos",
1348 : virtualForward3Shape, airSDD);
1349 : TGeoVolume *virtualForward3Neg = new TGeoVolume("ITSsddForward3Neg",
1350 : virtualForward3Shape, airSDD);
1351 : // TGeoVolume *virtualForward3Neg = new TGeoVolumeAssembly("ITSsddForward3Neg");
1352 : // TGeoVolume *virtualForward3Pos = new TGeoVolumeAssembly("ITSsddForward3Pos");
1353 :
1354 : TGeoTranslation *virtualForward3TrPos = new TGeoTranslation("virtualForward3TrPos",0,0,
1355 : fgkLay3Length/2+fgkForwardLay3Length/2);
1356 : TGeoTranslation *virtualForward3TrNeg = new TGeoTranslation("virtualForward3TrNeg",0,0,
1357 : -fgkLay3Length/2-fgkForwardLay3Length/2);
1358 :
1359 : for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
1360 :
1361 : Double_t ladderPhi = -3*dPhi+iLadd*dPhi;
1362 : Double_t minRadiusDetBox = fgkLay3DetShortRadius;
1363 : if (iLadd%2 != 0) minRadiusDetBox = fgkLay3DetLongRadius;
1364 : minRadiusDetBox += detectorsThick/2;
1365 :
1366 : sprintf(rotName, "ITSsddLay3EndLadd%i",iLadd);
1367 :
1368 : TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
1369 : -fgkForwardLay3Length/2, ladderPhi, kTRUE);
1370 : TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
1371 : fgkForwardLay3Length/2, ladderPhi, kFALSE);
1372 :
1373 : virtualForward3Pos->AddNode(lay3EndLadder, iLadd*2, ctEndLaddPos);
1374 : virtualForward3Neg->AddNode(lay3EndLadder, iLadd*2, ctEndLaddNeg);
1375 : }
1376 :
1377 : */
1378 :
1379 :
1380 1 : if(GetDebug(1)) {
1381 0 : virtualLayer3->CheckOverlaps(0.01);
1382 : //virtualForward3Pos->CheckOverlaps(0.01);
1383 : //virtualForward3Neg->CheckOverlaps(0.01);
1384 0 : }
1385 :
1386 1 : virtualLayer3->SetVisibility(kFALSE);
1387 : //virtualForward3Pos->SetVisibility(kFALSE);
1388 : //virtualForward3Neg->SetVisibility(kFALSE);
1389 :
1390 :
1391 1 : moth->AddNode(virtualLayer3, 1, 0);
1392 : //moth->AddNode(virtualForward3Pos, 1, virtualForward3TrPos);
1393 : //moth->AddNode(virtualForward3Neg, 1, virtualForward3TrNeg);
1394 2 : }
1395 :
1396 :
1397 : // //________________________________________________________________________
1398 : // void AliITSv11GeometrySDD::ForwardLayer3(TGeoVolume *moth) {
1399 : // //
1400 : // // Insert the forward pieces of layer 3 in the mother volume.
1401 : // // (cooling, Carlos, LV, HV ...)
1402 : // //
1403 :
1404 : // if (! moth) {
1405 : // printf("Error::AliITSv11GeometrySDD: Can't insert layer3, mother is null!\n");
1406 : // return;
1407 : // };
1408 :
1409 : // TGeoMedium *airSDD = GetMedium("SDD AIR$");
1410 :
1411 : // if (! fSDDsensor3) CreateBasicObjects();
1412 :
1413 : // Double_t dPhi = 360./fgkLay3Nladd;
1414 : // Double_t detectorsThick = fgkLadWaferSep + 2*fgkWaferThickness;
1415 : // Int_t iLaddMin = 0;
1416 : // Int_t iLaddMax = fgkLay3Nladd;
1417 : // if ((fAddOnlyLadder3min>=0)&&(fAddOnlyLadder3max<fgkLay3Nladd)) {
1418 : // iLaddMin = fAddOnlyLadder3min;
1419 : // iLaddMax = fAddOnlyLadder3max+1;
1420 : // };
1421 : // char rotName[30];
1422 :
1423 :
1424 : // //=================
1425 :
1426 : // Double_t fgkForwardLay3Length = fgkEndLadPipeUlengthLay3+10*fgkmm; // this has to be tune
1427 : // Double_t fgkForwardLay3Rmin = fgkLay3Rmin-7*fgkmm;
1428 : // Double_t fgkForwardLay3Rmax = fgkLay3Rmax-5*fgkmm;
1429 :
1430 : // TGeoVolumeAssembly* lay3EndLadder = CreateEndLadderCards(3);
1431 : // TGeoTube *virtualForward3Shape = new TGeoTube("virtualForward3Shape",
1432 : // fgkForwardLay3Rmin, fgkForwardLay3Rmax,
1433 : // fgkForwardLay3Length/2.);
1434 :
1435 : // // TGeoPcon *virtualForward3Shape = new TGeoPcon("virtualForward3Shape",0,360,2);
1436 : // // // virtualForward3Shape->DefineSection(Int_t snum, Double_t z, Double_t rmin, Double_t rmax);
1437 : // // virtualForward3Shape->DefineSection(0, Double_t z, Double_t rmin, Double_t rmax);
1438 :
1439 :
1440 : // TGeoVolume *virtualForward3Pos = new TGeoVolume("ITSsddForward3Pos",
1441 : // virtualForward3Shape, airSDD);
1442 : // TGeoVolume *virtualForward3Neg = new TGeoVolume("ITSsddForward3Neg",
1443 : // virtualForward3Shape, airSDD);
1444 : // // TGeoVolume *virtualForward3Neg = new TGeoVolumeAssembly("ITSsddForward3Neg");
1445 : // // TGeoVolume *virtualForward3Pos = new TGeoVolumeAssembly("ITSsddForward3Pos");
1446 :
1447 : // TGeoTranslation *virtualForward3TrPos = new TGeoTranslation("virtualForward3TrPos",0,0,
1448 : // fgkLay3Length/2+fgkForwardLay3Length/2);
1449 : // TGeoTranslation *virtualForward3TrNeg = new TGeoTranslation("virtualForward3TrNeg",0,0,
1450 : // -fgkLay3Length/2-fgkForwardLay3Length/2);
1451 :
1452 : // for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
1453 :
1454 : // Double_t ladderPhi = -3*dPhi+iLadd*dPhi;
1455 : // Double_t minRadiusDetBox = fgkLay3DetShortRadius;
1456 : // if (iLadd%2 != 0) minRadiusDetBox = fgkLay3DetLongRadius;
1457 : // minRadiusDetBox += detectorsThick/2;
1458 :
1459 : // sprintf(rotName, "ITSsddLay3EndLadd%i",iLadd);
1460 :
1461 : // TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
1462 : // -fgkForwardLay3Length/2, ladderPhi, kTRUE);
1463 : // TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
1464 : // fgkForwardLay3Length/2, ladderPhi, kFALSE);
1465 :
1466 : // virtualForward3Pos->AddNode(lay3EndLadder, iLadd*2, ctEndLaddPos);
1467 : // virtualForward3Neg->AddNode(lay3EndLadder, iLadd*2, ctEndLaddNeg);
1468 : // }
1469 :
1470 : // if(GetDebug(1)) {
1471 : // virtualForward3Pos->CheckOverlaps(0.01);
1472 : // virtualForward3Neg->CheckOverlaps(0.01);
1473 : // }
1474 :
1475 : // virtualForward3Pos->SetVisibility(kFALSE);
1476 : // virtualForward3Neg->SetVisibility(kFALSE);
1477 :
1478 : // moth->AddNode(virtualForward3Pos, 1, virtualForward3TrPos);
1479 : // moth->AddNode(virtualForward3Neg, 1, virtualForward3TrNeg);
1480 : // }
1481 :
1482 :
1483 :
1484 : //________________________________________________________________________
1485 : void AliITSv11GeometrySDD::ForwardLayer3(TGeoVolume *moth) {
1486 : //
1487 : // Insert the end-ladder of layer 3 in the mother volume.
1488 : // (cooling, Carlos, LV, HV ...)
1489 : //
1490 :
1491 2 : if (! moth) {
1492 0 : printf("Error::AliITSv11GeometrySDD: Can't insert layer3, mother is null!\n");
1493 0 : return;
1494 : };
1495 :
1496 1 : if (! fSDDsensor3) CreateBasicObjects();
1497 :
1498 : Int_t iLaddMin = 0;
1499 : Int_t iLaddMax = fgkLay3Nladd;
1500 1 : if ((fAddOnlyLadder3min>=0)&&(fAddOnlyLadder3max<fgkLay3Nladd)) {
1501 : iLaddMin = fAddOnlyLadder3min;
1502 0 : iLaddMax = fAddOnlyLadder3max+1;
1503 0 : };
1504 :
1505 2 : TGeoVolume *virtualForward3Neg = new TGeoVolumeAssembly("ITSsddForward3Neg");
1506 2 : TGeoVolume *virtualForward3Pos = new TGeoVolumeAssembly("ITSsddForward3Pos");
1507 :
1508 1 : char rotName[30];
1509 : Double_t dPhi = 360./fgkLay3Nladd;
1510 1 : TGeoVolume* lay3EndLadder = CreateEndLadderCardsV(3);
1511 :
1512 30 : for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
1513 :
1514 14 : Double_t ladderPhi = -3*dPhi+iLadd*dPhi;
1515 : Double_t dR = 0;
1516 21 : if (iLadd%2 != 0) dR = fgkLay3DetLongRadius-fgkLay3DetShortRadius;
1517 :
1518 14 : snprintf(rotName, 30, "ITSsddLay3EndLadd%i",iLadd);
1519 :
1520 14 : TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, dR,
1521 14 : fgkLay3Length/2, ladderPhi, kTRUE);
1522 14 : TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, dR,
1523 14 : -fgkLay3Length/2, ladderPhi, kFALSE);
1524 :
1525 14 : virtualForward3Pos->AddNode(lay3EndLadder, iLadd*2, ctEndLaddPos);
1526 14 : virtualForward3Neg->AddNode(lay3EndLadder, iLadd*2, ctEndLaddNeg);
1527 : }
1528 :
1529 1 : virtualForward3Pos->GetShape()->ComputeBBox(); //RS: enforce recompting of BBox
1530 1 : virtualForward3Neg->GetShape()->ComputeBBox();
1531 :
1532 1 : if(GetDebug(1)) {
1533 0 : virtualForward3Pos->CheckOverlaps(0.01);
1534 0 : virtualForward3Neg->CheckOverlaps(0.01);
1535 0 : }
1536 :
1537 : // 180deg Y rotation to compensate the cancellation of ITSD volume
1538 : // (idortm[199] in AliITSv11Hybrid : z---> -z; x ---> -x; y ---> y)
1539 1 : TGeoRotation *y180 = new TGeoRotation();
1540 1 : y180->SetAngles( 90.,180., 90., 90.,180., 0.);
1541 1 : moth->AddNode(virtualForward3Pos, 1, y180);
1542 1 : moth->AddNode(virtualForward3Neg, 1, y180);
1543 2 : }
1544 :
1545 : //________________________________________________________________________
1546 : void AliITSv11GeometrySDD::Layer4(TGeoVolume *moth) {
1547 : //
1548 : // Insert the layer 4 in the mother volume. This is a virtual volume
1549 : // containing ladders of layer 4 and the supporting rings
1550 : //
1551 :
1552 2 : if (! moth) {
1553 0 : printf("Error::AliITSv11GeometrySDD: Can't insert layer4, mother is null!\n");
1554 0 : return;
1555 : };
1556 :
1557 1 : fMotherVol = moth;
1558 :
1559 1 : if (! fSDDsensor3) CreateBasicObjects();
1560 :
1561 2 : TGeoTube *virtualLayer4Shape =new TGeoTube("ITSsddLayer4Shape",
1562 1 : fgkLay4Rmin,fgkLay4Rmax,fgkLay4Length*0.5);
1563 1 : TGeoMedium *airSDD = GetMedium("SDD AIR$");
1564 2 : TGeoVolume *virtualLayer4 = new TGeoVolume("ITSsddLayer4",
1565 1 : virtualLayer4Shape, airSDD);
1566 :
1567 : //====================================
1568 : // First we create the central barrel
1569 : //====================================
1570 :
1571 1 : TGeoVolumeAssembly *lay4Ladder = CreateLadder(4);
1572 : //TGeoVolume *lay4Detectors = CreateDetectors(4);
1573 1 : TGeoVolumeAssembly *lay4Detectors = CreateDetectorsAssembly(4);
1574 :
1575 : Double_t dPhi = 360./fgkLay4Nladd;
1576 1 : Double_t detBoxThickness = fgkLadWaferSep + 2*fgkWaferThickness;
1577 :
1578 : // placing virtual ladder and detectors volumes following ladder
1579 : // ordering convention
1580 1 : char rotName[30];
1581 : Int_t iLaddMin = 0;
1582 : Int_t iLaddMax = fgkLay4Nladd;
1583 1 : if ((fAddOnlyLadder4min >= 0)&&(fAddOnlyLadder4max < fgkLay4Nladd)) {
1584 : iLaddMin = fAddOnlyLadder4min;
1585 0 : iLaddMax = fAddOnlyLadder4max+1;
1586 0 : }
1587 46 : for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
1588 :
1589 22 : Double_t ladderPhi = -5*dPhi + iLadd*dPhi;
1590 22 : snprintf(rotName, 30, "ITSsddLay4Ladd%i",iLadd);
1591 22 : Double_t minRadiusLadBox = fLay4LaddShortRadius-fLay4LadderUnderSegDH;
1592 22 : if (iLadd%2 != 0)
1593 11 : minRadiusLadBox = fLay4LaddLongRadius-fLay4LadderUnderSegDH;
1594 22 : minRadiusLadBox += ((TGeoBBox*)lay4Ladder->GetShape())->GetDY();
1595 22 : TGeoCombiTrans *ctLadd = CreateCombiTrans(rotName, minRadiusLadBox,
1596 : 0, ladderPhi, kTRUE);
1597 22 : virtualLayer4->AddNode(lay4Ladder, iLadd, ctLadd);
1598 : ///////////////////////////////////////////////////
1599 22 : snprintf(rotName, 30, "ITSsddLay4DetBox%i",iLadd);
1600 22 : Double_t minRadiusDetBox = fgkLay4DetShortRadius;
1601 22 : if (iLadd%2 != 0)
1602 11 : minRadiusDetBox = fgkLay4DetLongRadius;
1603 22 : minRadiusDetBox += detBoxThickness/2;
1604 22 : TGeoCombiTrans *ctDet = CreateCombiTrans(rotName, minRadiusDetBox,
1605 : 0, ladderPhi, kTRUE);
1606 22 : virtualLayer4->AddNode(lay4Detectors, iLadd, ctDet);
1607 : ///////////////////////////////////////////////////
1608 : }
1609 :
1610 : /*
1611 : //====================================
1612 : // Then the pieces at forward rapidity
1613 : // (cooling, Carlos, LV, HV ...)
1614 : //====================================
1615 :
1616 : Double_t fgkForwardLay4Length = fgkEndLadPipeUlengthLay4+10*fgkmm; // this has to be tuned
1617 : Double_t fgkForwardLay4Rmin = fgkLay4Rmin-9*fgkmm;
1618 : Double_t fgkForwardLay4Rmax = fgkLay4Rmax-5*fgkmm;
1619 :
1620 : TGeoVolumeAssembly* lay4EndLadder = CreateEndLadderCards(4);
1621 : TGeoTube *virtualForward4Shape = new TGeoTube("virtualForward3Shape",
1622 : fgkForwardLay4Rmin, fgkForwardLay4Rmax,
1623 : fgkForwardLay4Length/2.);
1624 : TGeoVolume *virtualForward4Pos = new TGeoVolume("ITSsddForward4Pos",
1625 : virtualForward4Shape, airSDD);
1626 : TGeoVolume *virtualForward4Neg = new TGeoVolume("ITSsddForward4Neg",
1627 : virtualForward4Shape, airSDD);
1628 : // TGeoVolume *virtualForward4Pos = new TGeoVolumeAssembly("ITSsddForward4Pos");
1629 : // TGeoVolume *virtualForward4Neg = new TGeoVolumeAssembly("ITSsddForward4Neg");
1630 :
1631 : TGeoTranslation *virtualForward4TrPos = new TGeoTranslation("virtualForward4TrPos",0,0,
1632 : fgkLay4Length/2+fgkForwardLay4Length/2);
1633 : TGeoTranslation *virtualForward4TrNeg = new TGeoTranslation("virtualForward4TrNeg",0,0,
1634 : -fgkLay4Length/2-fgkForwardLay4Length/2);
1635 :
1636 : for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
1637 :
1638 : Double_t ladderPhi = -5*dPhi + iLadd*dPhi;
1639 : Double_t minRadiusDetBox = fgkLay4DetShortRadius;
1640 : if (iLadd%2 != 0)
1641 : minRadiusDetBox = fgkLay4DetLongRadius;
1642 : minRadiusDetBox += detBoxThickness/2;
1643 :
1644 : sprintf(rotName, "ITSsddLay4EndLadd%i",iLadd);
1645 :
1646 : TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
1647 : -fgkForwardLay4Length/2, ladderPhi, kTRUE);
1648 : TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
1649 : fgkForwardLay4Length/2, ladderPhi, kFALSE);
1650 : virtualForward4Pos->AddNode(lay4EndLadder, iLadd*2, ctEndLaddPos);
1651 : virtualForward4Neg->AddNode(lay4EndLadder, iLadd*2+1, ctEndLaddNeg);
1652 : }
1653 : */
1654 :
1655 1 : if(GetDebug(1)) virtualLayer4->CheckOverlaps(0.01);
1656 :
1657 1 : virtualLayer4->SetVisibility(kFALSE);
1658 : //virtualForward4Pos->SetVisibility(kFALSE);
1659 : //virtualForward4Neg->SetVisibility(kFALSE);
1660 :
1661 1 : moth->AddNode(virtualLayer4,1,0);
1662 : //moth->AddNode(virtualForward4Pos, 1, virtualForward4TrPos);
1663 : //moth->AddNode(virtualForward4Neg, 1, virtualForward4TrNeg);
1664 2 : }
1665 :
1666 :
1667 : // //________________________________________________________________________
1668 : // void AliITSv11GeometrySDD::ForwardLayer4(TGeoVolume *moth) {
1669 : // //
1670 : // // Insert the layer 4 in the mother volume. This is a virtual volume
1671 : // // containing ladders of layer 4 and the supporting rings
1672 : // // (cooling, Carlos, LV, HV ...)
1673 : // //
1674 :
1675 : // if (! moth) {
1676 : // printf("Error::AliITSv11GeometrySDD: Can't insert layer4, mother is null!\n");
1677 : // return;
1678 : // };
1679 :
1680 : // TGeoMedium *airSDD = GetMedium("SDD AIR$");
1681 :
1682 : // if (! fSDDsensor3) CreateBasicObjects();
1683 :
1684 : // Double_t dPhi = 360./fgkLay4Nladd;
1685 : // Double_t detBoxThickness = fgkLadWaferSep + 2*fgkWaferThickness;
1686 :
1687 : // // placing virtual ladder and detectors volumes following ladder
1688 : // // ordering convention
1689 : // char rotName[20];
1690 : // Int_t iLaddMin = 0;
1691 : // Int_t iLaddMax = fgkLay4Nladd;
1692 : // if ((fAddOnlyLadder4min >= 0)&&(fAddOnlyLadder4max < fgkLay4Nladd)) {
1693 : // iLaddMin = fAddOnlyLadder4min;
1694 : // iLaddMax = fAddOnlyLadder4max+1;
1695 : // }
1696 :
1697 : // //=================
1698 : // Double_t fgkForwardLay4Length = fgkEndLadPipeUlengthLay4+10*fgkmm; // this has to be tuned
1699 : // Double_t fgkForwardLay4Rmin = fgkLay4Rmin-9*fgkmm;
1700 : // Double_t fgkForwardLay4Rmax = fgkLay4Rmax-5*fgkmm;
1701 :
1702 : // TGeoVolumeAssembly* lay4EndLadder = CreateEndLadderCards(4);
1703 : // TGeoTube *virtualForward4Shape = new TGeoTube("virtualForward3Shape",
1704 : // fgkForwardLay4Rmin, fgkForwardLay4Rmax,
1705 : // fgkForwardLay4Length/2.);
1706 : // TGeoVolume *virtualForward4Pos = new TGeoVolume("ITSsddForward4Pos",
1707 : // virtualForward4Shape, airSDD);
1708 : // TGeoVolume *virtualForward4Neg = new TGeoVolume("ITSsddForward4Neg",
1709 : // virtualForward4Shape, airSDD);
1710 : // // TGeoVolume *virtualForward4Pos = new TGeoVolumeAssembly("ITSsddForward4Pos");
1711 : // // TGeoVolume *virtualForward4Neg = new TGeoVolumeAssembly("ITSsddForward4Neg");
1712 :
1713 : // TGeoTranslation *virtualForward4TrPos = new TGeoTranslation("virtualForward4TrPos",0,0,
1714 : // fgkLay4Length/2+fgkForwardLay4Length/2);
1715 : // TGeoTranslation *virtualForward4TrNeg = new TGeoTranslation("virtualForward4TrNeg",0,0,
1716 : // -fgkLay4Length/2-fgkForwardLay4Length/2);
1717 :
1718 : // for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
1719 :
1720 : // Double_t ladderPhi = -5*dPhi + iLadd*dPhi;
1721 : // Double_t minRadiusDetBox = fgkLay4DetShortRadius;
1722 : // if (iLadd%2 != 0)
1723 : // minRadiusDetBox = fgkLay4DetLongRadius;
1724 : // minRadiusDetBox += detBoxThickness/2;
1725 :
1726 : // sprintf(rotName, "ITSsddLay4EndLadd%i",iLadd);
1727 :
1728 : // TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
1729 : // -fgkForwardLay4Length/2, ladderPhi, kTRUE);
1730 : // TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, minRadiusDetBox-0.1,
1731 : // fgkForwardLay4Length/2, ladderPhi, kFALSE);
1732 : // virtualForward4Pos->AddNode(lay4EndLadder, iLadd*2, ctEndLaddPos);
1733 : // virtualForward4Neg->AddNode(lay4EndLadder, iLadd*2+1, ctEndLaddNeg);
1734 : // }
1735 :
1736 : // virtualForward4Pos->SetVisibility(kFALSE);
1737 : // virtualForward4Neg->SetVisibility(kFALSE);
1738 :
1739 : // moth->AddNode(virtualForward4Pos, 1, virtualForward4TrPos);
1740 : // moth->AddNode(virtualForward4Neg, 1, virtualForward4TrNeg);
1741 : // }
1742 :
1743 :
1744 : //________________________________________________________________________
1745 : void AliITSv11GeometrySDD::ForwardLayer4(TGeoVolume *moth) {
1746 : //
1747 : // Insert the end-ladder of layer 4 in the mother volume.
1748 : // (cooling, Carlos, LV, HV ...)
1749 : //
1750 :
1751 2 : if (! moth) {
1752 0 : printf("Error::AliITSv11GeometrySDD: Can't insert layer4, mother is null!\n");
1753 0 : return;
1754 : };
1755 :
1756 1 : if (! fSDDsensor3) CreateBasicObjects();
1757 :
1758 : // placing virtual ladder and detectors volumes following ladder
1759 : // ordering convention
1760 : Int_t iLaddMin = 0;
1761 : Int_t iLaddMax = fgkLay4Nladd;
1762 1 : if ((fAddOnlyLadder4min >= 0)&&(fAddOnlyLadder4max < fgkLay4Nladd)) {
1763 : iLaddMin = fAddOnlyLadder4min;
1764 0 : iLaddMax = fAddOnlyLadder4max+1;
1765 0 : }
1766 :
1767 2 : TGeoVolume *virtualForward4Pos = new TGeoVolumeAssembly("ITSsddForward4Pos");
1768 2 : TGeoVolume *virtualForward4Neg = new TGeoVolumeAssembly("ITSsddForward4Neg");
1769 :
1770 1 : char rotName[30];
1771 : Double_t dPhi = 360./fgkLay4Nladd;
1772 1 : TGeoVolume* lay4EndLadder = CreateEndLadderCardsV(4);
1773 :
1774 46 : for (Int_t iLadd = iLaddMin; iLadd < iLaddMax; iLadd++) {
1775 :
1776 22 : Double_t ladderPhi = -5*dPhi + iLadd*dPhi;
1777 : Double_t dR = 0;
1778 22 : if (iLadd%2 != 0)
1779 11 : dR = fgkLay4DetLongRadius-fgkLay4DetShortRadius;
1780 :
1781 22 : snprintf(rotName, 30, "ITSsddLay4EndLadd%i",iLadd);
1782 :
1783 22 : TGeoCombiTrans *ctEndLaddPos = CreateCombiTrans(rotName, dR,
1784 22 : fgkLay4Length/2, ladderPhi, kTRUE);
1785 22 : TGeoCombiTrans *ctEndLaddNeg = CreateCombiTrans(rotName, dR,
1786 22 : -fgkLay4Length/2, ladderPhi, kFALSE);
1787 22 : virtualForward4Pos->AddNode(lay4EndLadder, iLadd*2, ctEndLaddPos);
1788 22 : virtualForward4Neg->AddNode(lay4EndLadder, iLadd*2, ctEndLaddNeg);
1789 : }
1790 :
1791 1 : virtualForward4Pos->GetShape()->ComputeBBox(); //RS: enforce recompting of BBox
1792 1 : virtualForward4Neg->GetShape()->ComputeBBox();
1793 :
1794 : // 180deg Y rotation to compensate the cancellation of ITSD volume
1795 : // (idortm[199] in AliITSv11Hybrid : z---> -z; x ---> -x; y ---> y)
1796 1 : TGeoRotation *y180 = new TGeoRotation();
1797 1 : y180->SetAngles( 90.,180., 90., 90.,180., 0.);
1798 1 : moth->AddNode(virtualForward4Pos, 1, y180);
1799 1 : moth->AddNode(virtualForward4Neg, 1, y180);
1800 2 : }
1801 :
1802 :
1803 : //________________________________________________________________________
1804 : TGeoVolumeAssembly *AliITSv11GeometrySDD::CreateLadder(Int_t iLay) {
1805 : //
1806 : // return an assembly volume containing the CF ladder
1807 : //
1808 :
1809 : Int_t nDetectors = fgkLay3Ndet;
1810 4 : Double_t ladderLength = fgkLay3LadderLength;
1811 2 : Double_t underSegDH = fLay3LadderUnderSegDH;
1812 2 : Double_t *sensorZPos = fLay3sensorZPos;
1813 2 : AliITSv11GeomCableFlat *digitCableA = fDigitCableLay3A;
1814 2 : AliITSv11GeomCableFlat *digitCableB = fDigitCableLay3B;
1815 :
1816 2 : if (iLay==3) {}
1817 1 : else if (iLay==4) {
1818 : nDetectors = fgkLay4Ndet;
1819 1 : ladderLength = fgkLay4LadderLength;
1820 1 : digitCableA = fDigitCableLay4A;
1821 1 : digitCableB = fDigitCableLay4B;
1822 1 : underSegDH = fLay4LadderUnderSegDH;
1823 1 : sensorZPos = fLay4sensorZPos;
1824 1 : }
1825 : else {
1826 0 : printf("AliITSv11GeometrySDD::CreateLadder : error=wrong layer\n");
1827 : };
1828 2 : Double_t ladderBoxDH = fgkLadderHeight+fgkLadderSegBoxDH+underSegDH;
1829 2 : TGeoVolumeAssembly *virtualLadder = new TGeoVolumeAssembly("ITSsddLadder");
1830 :
1831 : // placing virtual ladder segment following detector ordering convention
1832 : //=======================================================================
1833 2 : char transName[30];
1834 :
1835 : // adding segment this way to create cable points in the correct order ...
1836 18 : for (Int_t iSegment = nDetectors/2-1; iSegment >= 0; iSegment-- ) {
1837 :
1838 : //TGeoVolumeAssembly *laddSegment = CreateLadderSegment(iLay, iSegment);
1839 7 : TGeoVolume *laddSegment = CreateLadderSegment(iLay, iSegment);
1840 7 : snprintf(transName, 30, "ITSsddLay%iLaddSeg%i", iLay, iSegment);
1841 7 : Double_t segmentPos = fgkSegmentLength*(nDetectors/2-1-iSegment)
1842 7 : + fgkSegmentLength/2;
1843 14 : TGeoTranslation *segTr = new TGeoTranslation(transName, 0,
1844 7 : underSegDH/2,segmentPos);
1845 : ////
1846 7 : virtualLadder->AddNode(laddSegment, iSegment, segTr);
1847 : };
1848 18 : for (Int_t iSegment = nDetectors/2; iSegment < nDetectors; iSegment++ ) {
1849 :
1850 7 : TGeoVolume *laddSegment = CreateLadderSegment(iLay, iSegment);
1851 : //TGeoVolumeAssembly *laddSegment = CreateLadderSegment(iLay, iSegment);
1852 7 : snprintf(transName, 30, "ITSsddLay%iLaddSeg%i", iLay, iSegment);
1853 7 : Double_t segmentPos = fgkSegmentLength*(nDetectors/2-1-iSegment)
1854 7 : + fgkSegmentLength/2;
1855 14 : TGeoTranslation *segTr = new TGeoTranslation(transName, 0,
1856 7 : underSegDH/2,segmentPos);
1857 : ////
1858 7 : virtualLadder->AddNode(laddSegment, iSegment, segTr);
1859 : };
1860 :
1861 : // putting virtual volume corresponding to the end of ladder
1862 : //=======================================================================
1863 2 : TGeoVolumeAssembly *endLadder = CreateEndLadder( iLay );
1864 2 : Double_t endLength = (ladderLength - nDetectors*fgkSegmentLength)/2.;
1865 4 : TGeoTranslation *endTrZPos = new TGeoTranslation("ITSsddEndTrZPos",0,0,
1866 2 : fgkSegmentLength*(nDetectors/2)+endLength/2.);
1867 : // Euler rotation : about Z, then new X, then new Z
1868 2 : TGeoRotation *endZNegRot = new TGeoRotation("",90, 180, -90);
1869 4 : TGeoCombiTrans *endTrZNeg = new TGeoCombiTrans(0,0,
1870 2 : -fgkSegmentLength*(nDetectors/2)-endLength/2.,endZNegRot);
1871 2 : virtualLadder->AddNode(endLadder, 1, endTrZPos);
1872 2 : virtualLadder->AddNode(endLadder, 2, endTrZNeg);
1873 :
1874 : // creating and inserting cable segments
1875 : // (check points are placed while creating segments)
1876 : //=======================================================================
1877 2 : if (fAddCables)
1878 32 : for (Int_t iSegment = 0; iSegment < nDetectors; iSegment++ ) {
1879 :
1880 14 : digitCableA[iSegment].SetInitialNode(virtualLadder);
1881 14 : digitCableB[iSegment].SetInitialNode(virtualLadder);
1882 :
1883 92 : for (Int_t iPt=1; iPt<digitCableA[iSegment].GetNCheckPoints(); iPt++ ) {
1884 : Double_t rotation = 0;
1885 32 : if (iPt>1) {
1886 : rotation = 90-fgkHybridAngle;
1887 18 : digitCableA[iSegment].CreateAndInsertCableSegment(iPt, rotation);
1888 18 : } else
1889 14 : digitCableA[iSegment].CreateAndInsertCableSegment(iPt);
1890 :
1891 : };
1892 :
1893 92 : for (Int_t iPt=1; iPt<digitCableB[iSegment].GetNCheckPoints(); iPt++ ) {
1894 : Double_t rotation = 0;
1895 32 : if (iPt>1) {
1896 : rotation = fgkHybridAngle-90;
1897 18 : digitCableB[iSegment].CreateAndInsertCableSegment(iPt, rotation);
1898 18 : } else
1899 14 : digitCableB[iSegment].CreateAndInsertCableSegment(iPt);
1900 : };
1901 2 : };
1902 :
1903 : // HV cable
1904 : //=======================================================================
1905 2 : if (fAddHVcables) {
1906 2 : TGeoMedium *polyhamideSDD = GetMedium("SDDKAPTON (POLYCH2)$"); //ITSsddKAPTON_POLYCH2
1907 2 : TGeoMedium *alSDD = GetMedium("AL$"); //ITSal
1908 :
1909 34 : AliITSv11GeomCableFlat cableHV[fgkLay4Ndet]; // temp !!!
1910 2 : char cableHVname[30];
1911 32 : for (Int_t iSegment = 0; iSegment<nDetectors; iSegment++) {
1912 14 : snprintf(cableHVname,30,"ITSsddHVcable%i", iSegment);
1913 14 : cableHV[iSegment].SetName(cableHVname);
1914 14 : cableHV[iSegment].SetThickness(fgkLongHVcablePolyThick+fgkLongHVcableAlThick);
1915 14 : cableHV[iSegment].SetWidth(fgkTransitHVtailWidth);
1916 14 : cableHV[iSegment].SetNLayers(2);
1917 28 : cableHV[iSegment].SetLayer(0, fgkLongHVcablePolyThick, polyhamideSDD,
1918 14 : fColorPolyhamide);
1919 14 : cableHV[iSegment].SetLayer(1, fgkLongHVcableAlThick, alSDD, fColorAl);
1920 14 : cableHV[iSegment].SetInitialNode(virtualLadder);
1921 : };
1922 4 : Double_t x1[3], x2[3], x3[3],
1923 4 : vY[3] = {0,1,0}, vZ[3] = {0,0,1};
1924 :
1925 2 : x1[0] = -fgkTransitHVtailXpos;
1926 2 : x2[0] = -fgkTransitHVtailXpos;
1927 2 : x3[0] = -fgkTransitHVtailXpos;
1928 18 : for (Int_t iSegment = nDetectors/2-1; iSegment >= 0; iSegment-- ) {
1929 7 : Double_t cableSeparation = TMath::Abs(iSegment - (nDetectors/2-1))
1930 7 : *fgkLongHVcableSeparation;
1931 : // adjust where HV long cable starts in Y
1932 : // useful if you want to let some space for alignment
1933 7 : x1[1] = - ladderBoxDH/2 + 2*fgkmm;
1934 14 : x2[1] = - ladderBoxDH/2 + underSegDH - cableSeparation
1935 7 : - (fgkLongHVcablePolyThick+fgkLongHVcableAlThick)/2;
1936 7 : x3[1] = x2[1];
1937 7 : x1[2] = sensorZPos[iSegment]+fgkTransitHVtailLength-5*fgkmm;
1938 7 : x2[2] = x1[2]+5*fgkmm;
1939 7 : x3[2] = ladderLength/2-endLength;
1940 7 : cableHV[iSegment].AddCheckPoint( virtualLadder, 0, x1, vY );
1941 7 : cableHV[iSegment].AddCheckPoint( virtualLadder, 1, x2, vZ ); // vYZ
1942 7 : cableHV[iSegment].AddCheckPoint( virtualLadder, 2, x3, vZ );
1943 :
1944 : //cableHV[iSegment].CreateAndInsertCableSegment(1,0);
1945 7 : cableHV[iSegment].CreateAndInsertCableCylSegment(1, -45+180);
1946 : //cableHV[iSegment].CreateAndInsertCableSegment(2,0);
1947 7 : cableHV[iSegment].CreateAndInsertBoxCableSegment(2,0);
1948 : };
1949 :
1950 : // vYZ[2] = -1;
1951 2 : x1[0] = fgkTransitHVtailXpos;
1952 2 : x2[0] = fgkTransitHVtailXpos;
1953 2 : x3[0] = fgkTransitHVtailXpos;
1954 :
1955 18 : for (Int_t iSegment = nDetectors/2; iSegment < nDetectors; iSegment++ ) {
1956 7 : Double_t cableSeparation = TMath::Abs(iSegment - (nDetectors/2-1))
1957 7 : *fgkLongHVcableSeparation;
1958 7 : x1[1] = - ladderBoxDH/2 + 2*fgkmm; // adjust where HV long cable starts in Y
1959 14 : x2[1] = - ladderBoxDH/2 + underSegDH - cableSeparation
1960 7 : - (fgkLongHVcablePolyThick+fgkLongHVcableAlThick)/2;
1961 7 : x3[1] = x2[1];
1962 7 : x1[2] = sensorZPos[iSegment]-fgkTransitHVtailLength+5*fgkmm;
1963 7 : x2[2] = x1[2]-5*fgkmm;
1964 7 : x3[2] = -ladderLength/2+endLength;
1965 7 : cableHV[iSegment].AddCheckPoint( virtualLadder, 0, x1, vY );
1966 7 : cableHV[iSegment].AddCheckPoint( virtualLadder, 1, x2, vZ ); // vYZ
1967 7 : cableHV[iSegment].AddCheckPoint( virtualLadder, 2, x3, vZ );
1968 :
1969 7 : cableHV[iSegment].CreateAndInsertCableCylSegment(1, -45);
1970 7 : cableHV[iSegment].CreateAndInsertBoxCableSegment(2,0);
1971 : };
1972 20 : };
1973 :
1974 : //**********************************
1975 2 : virtualLadder->GetShape()->ComputeBBox(); //RS: enforce recompting of BBox
1976 :
1977 2 : if(GetDebug(1)) virtualLadder->CheckOverlaps(0.01);
1978 2 : return virtualLadder;
1979 2 : }
1980 :
1981 :
1982 : //________________________________________________________________________
1983 : TGeoArb8 *AliITSv11GeometrySDD::CreateLadderSide(const char *name,
1984 : Double_t dz, Double_t angle, Double_t xSign,
1985 : Double_t L, Double_t H, Double_t l) {
1986 : // Create one half of the V shape corner of CF ladder
1987 :
1988 24 : TGeoArb8 *cfLaddSide = new TGeoArb8(dz);
1989 12 : cfLaddSide->SetName(name);
1990 :
1991 : // Points must be in clockwise order
1992 12 : cfLaddSide->SetVertex(0, 0, 0);
1993 24 : cfLaddSide->SetVertex(2, xSign*(L*TMath::Sin(angle)-l*TMath::Cos(angle)),
1994 12 : -L*TMath::Cos(angle)-l*TMath::Sin(angle));
1995 12 : cfLaddSide->SetVertex(4, 0, 0);
1996 24 : cfLaddSide->SetVertex(6, xSign*(L*TMath::Sin(angle)-l*TMath::Cos(angle)),
1997 12 : -L*TMath::Cos(angle)-l*TMath::Sin(angle));
1998 24 : if (xSign < 0) {
1999 18 : cfLaddSide->SetVertex(1, 0, -H);
2000 6 : cfLaddSide->SetVertex(3, xSign*L*TMath::Sin(angle), -L*TMath::Cos(angle));
2001 6 : cfLaddSide->SetVertex(5, 0, -H);
2002 6 : cfLaddSide->SetVertex(7, xSign*L*TMath::Sin(angle), -L*TMath::Cos(angle));
2003 6 : } else {
2004 6 : cfLaddSide->SetVertex(1, xSign*L*TMath::Sin(angle), -L*TMath::Cos(angle));
2005 6 : cfLaddSide->SetVertex(3, 0, -H);
2006 6 : cfLaddSide->SetVertex(5, xSign*L*TMath::Sin(angle), -L*TMath::Cos(angle));
2007 6 : cfLaddSide->SetVertex(7, 0, -H);
2008 : }
2009 12 : return cfLaddSide;
2010 0 : }
2011 :
2012 :
2013 : //________________________________________________________________________
2014 : TGeoVolume* AliITSv11GeometrySDD::CreateHybrid(Int_t iLRSide) {
2015 : //
2016 : // return a box containing the front-end hybrid
2017 : //
2018 :
2019 2 : Double_t roundHoleX = -fgkHybridWidth/2+fgkHybRndHoleX;
2020 :
2021 1 : Double_t screenTotalThick = fgkHybGlueScrnThick+fgkHybUpThick+fgkHybAlThick;
2022 1 : Double_t lowFLTotalThick = fgkHybGlueLowThick+fgkHybUpThick+fgkHybAlThick;
2023 : // Double_t upFLTotalThick = fgkHybGlueUpThick +fgkHybUpThick+fgkHybAlThick;
2024 1 : Double_t chipsCCTotThick = fgkHybUnderNiThick+fgkHybGlueAgThick
2025 1 : +fgkHybChipThick+2*(fgkHybUpCCThick+fgkHybAlCCThick);
2026 1 : Double_t ccUpLayerTotThick = fgkHybUpCCThick+fgkHybAlCCThick+fgkHybUpCCThick;
2027 : // Double_t volumeThick = (fgkHybridThBridgeThick+screenTotalThick+lowFLTotalThick
2028 : // + upFLTotalThick + ccUpLayerTotThick);
2029 1 : Double_t volumeThick = (fgkHybridThBridgeThick+screenTotalThick+lowFLTotalThick
2030 1 : +fgkHybSMDheight);
2031 1 : Double_t lowLayerYmin = -volumeThick/2+fgkHybridThBridgeThick
2032 1 : +screenTotalThick;
2033 1 : Double_t flUpThick = fgkHybGlueUpThick+fgkHybUpThick;
2034 :
2035 : //**************************************************** media :
2036 1 : TGeoMedium *airSDD = GetMedium("SDD AIR$");
2037 1 : TGeoMedium *carbonFiberLadderStruct = GetMedium("SDDKAPTON (POLYCH2)$"); //ITSsddCarbonM55J
2038 1 : TGeoMedium *alSDD = GetMedium("AL$"); //ITSal
2039 1 : TGeoMedium *alSDD80p100 = GetMedium("AL$"); // to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2040 1 : TGeoMedium *alSDD50p100 = GetMedium("AL$"); // to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2041 1 : TGeoMedium *polyhamideSDD = GetMedium("SDDKAPTON (POLYCH2)$"); //ITSsddKAPTON_POLYCH2
2042 1 : TGeoMedium *niSDD = GetMedium("NICKEL$");
2043 1 : TGeoMedium *glueAG = GetMedium("SDDKAPTON (POLYCH2)$"); // to code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2044 1 : TGeoMedium *siliconSDD = GetMedium("SDD SI CHIP$"); //ITSsddSiChip
2045 1 : TGeoMedium *medSMD = GetMedium("SDD X7R capacitors$"); // SDDX7Rcapacitors
2046 1 : TGeoMedium *medSMDweld = GetMedium("SDD X7R weld$");
2047 :
2048 : //**************************************************** main volume :
2049 : // TGeoBBox *hybridBox = new TGeoBBox("",fgkHybridWidth/2, volumeThick/2,
2050 : // (fgkHybridLength)/2);
2051 1 : Double_t xhybr[6],yhybr[6];
2052 1 : xhybr[0] = -fgkHybridWidth/2;
2053 1 : yhybr[0] = -volumeThick/2;
2054 1 : xhybr[1] = fgkHybridWidth/2;
2055 1 : yhybr[1] = -volumeThick/2;
2056 1 : xhybr[2] = fgkHybridWidth/2;
2057 1 : yhybr[2] = volumeThick/2;
2058 1 : xhybr[3] = -fgkHybridWidth/2;
2059 1 : yhybr[3] = volumeThick/2;
2060 1 : xhybr[4] = xhybr[3] - 1.05*fgkHybCC2SensorLen*SinD(fgkHybCC2SensorAng);
2061 1 : yhybr[4] = yhybr[3] - 1.05*fgkHybCC2SensorLen*CosD(fgkHybCC2SensorAng);
2062 1 : xhybr[5] = xhybr[4];
2063 1 : yhybr[5] = yhybr[4] - volumeThick;
2064 :
2065 1 : TGeoXtru *hybridBox = new TGeoXtru(2);
2066 1 : hybridBox->DefinePolygon(6, xhybr, yhybr);
2067 1 : hybridBox->DefineSection(0,-fgkHybridLength/2);
2068 1 : hybridBox->DefineSection(1, fgkHybridLength/2);
2069 :
2070 1 : TGeoVolume *hybrid = new TGeoVolume("ITSsddHybridVol", hybridBox,
2071 : airSDD);
2072 :
2073 2 : TGeoBBox *sThermalBridge = new TGeoBBox( "", fgkHybridWidth/2,
2074 1 : fgkHybridThBridgeThick/2,
2075 1 : fgkHybridLength/2);
2076 :
2077 : //**************************************************** Thermal bridge :
2078 2 : TGeoVolume *vThermalBridge = new TGeoVolume("ITSsddHybridThBridge",
2079 1 : sThermalBridge,
2080 : carbonFiberLadderStruct);
2081 1 : vThermalBridge->SetLineColor(fColorCarbonFiber);
2082 2 : TGeoTranslation *thBridgeTr = new TGeoTranslation(0, -volumeThick/2
2083 1 : +fgkHybridThBridgeThick/2, 0);
2084 1 : hybrid->AddNode(vThermalBridge, 1, thBridgeTr);
2085 :
2086 : //**************************************************** Screen layer :
2087 2 : TGeoBBox *sAlScreenLayer = new TGeoBBox("sAlScreenLayer", fgkHybridWidth/2,
2088 1 : fgkHybAlThick/2, fgkHybridLength/2);
2089 : //here the upedex and glue layers are both assumed to be polyimide
2090 2 : TGeoBBox *sUpGlueScreenLayer = new TGeoBBox("sUpGlueScreenLayer",
2091 1 : fgkHybridWidth/2,
2092 1 : (fgkHybUpThick+fgkHybGlueScrnThick)/2,
2093 1 : fgkHybridLength/2);
2094 2 : TGeoTube *sRoundHole = new TGeoTube("sRoundHole", 0, fgkHybRndHoleRad,
2095 1 : (screenTotalThick+lowFLTotalThick)/2);
2096 :
2097 2 : TGeoTranslation *upGlueScreenTr = new TGeoTranslation("upGlueScreenTr",0,
2098 1 : -volumeThick/2+fgkHybridThBridgeThick+(fgkHybUpThick+fgkHybGlueScrnThick)/2,0);
2099 :
2100 2 : TGeoTranslation *alScreenTr = new TGeoTranslation("AlScreenTr", 0,
2101 1 : -volumeThick/2+fgkHybridThBridgeThick+fgkHybUpThick+fgkHybGlueScrnThick
2102 1 : +fgkHybAlThick/2, 0);
2103 :
2104 2 : TGeoTranslation hybHolePos1Tr(roundHoleX,
2105 1 : -volumeThick/2+fgkHybridThBridgeThick+(screenTotalThick+lowFLTotalThick)/2,
2106 1 : -fgkHybridLength/2+fgkHybRndHoleZ);
2107 2 : TGeoTranslation hybHolePos2Tr(roundHoleX,
2108 1 : -volumeThick/2+fgkHybridThBridgeThick+(screenTotalThick+lowFLTotalThick)/2,
2109 1 : fgkHybridLength/2-fgkHybRndHoleZ);
2110 :
2111 2 : TGeoRotation *rotHole = new TGeoRotation("", 0, 90, 0);
2112 2 : TGeoCombiTrans *hybHolePos1 = new TGeoCombiTrans(hybHolePos1Tr, *rotHole);
2113 1 : hybHolePos1->SetName("hybHolePos1");
2114 2 : TGeoCombiTrans *hybHolePos2 = new TGeoCombiTrans(hybHolePos2Tr, *rotHole);
2115 1 : hybHolePos2->SetName("hybHolePos2");
2116 :
2117 1 : upGlueScreenTr->RegisterYourself();
2118 1 : alScreenTr->RegisterYourself();
2119 1 : hybHolePos1->RegisterYourself();
2120 1 : hybHolePos2->RegisterYourself();
2121 2 : delete rotHole;
2122 :
2123 2 : TGeoCompositeShape *sScreenAl = new TGeoCompositeShape(
2124 : "sAlScreenLayer:AlScreenTr-(sRoundHole:hybHolePos1"
2125 : "+sRoundHole:hybHolePos2)");
2126 2 : TGeoVolume *vScreenAl = new TGeoVolume("vScreenAl",sScreenAl, alSDD);
2127 1 : vScreenAl->SetLineColor(fColorAl);
2128 2 : TGeoCompositeShape *sScreenUpGlue = new TGeoCompositeShape(
2129 : "sUpGlueScreenLayer:upGlueScreenTr-(sRoundHole:hybHolePos1"
2130 : "+sRoundHole:hybHolePos2)");
2131 3 : TGeoVolume *vScreenUpGlue = new TGeoVolume("vScreenUpGlue",
2132 1 : sScreenUpGlue,polyhamideSDD);
2133 1 : vScreenUpGlue->SetLineColor(fColorPolyhamide);
2134 :
2135 1 : hybrid->AddNode(vScreenUpGlue, 1, 0);
2136 1 : hybrid->AddNode(vScreenAl, 1, 0);
2137 :
2138 : //**************************************************** FL low layer :
2139 1 : Double_t sideWidth1 = fgkHybFLlowChipZ1 - fgkHybFLlowHoleDZ/2;
2140 1 : Double_t sideWidth2 = fgkHybridLength - fgkHybFLlowChipZ4 - fgkHybFLlowHoleDZ/2;
2141 :
2142 : //here the upedex and glue layers are both assumed to be polyimide
2143 3 : TGeoBBox *sUpGlueBar1 = new TGeoBBox("sUpGlueBar1", fgkHybridWidth/2,
2144 1 : (fgkHybGlueLowThick+fgkHybUpThick)/2,
2145 1 : sideWidth1/2);
2146 3 : TGeoBBox *sAlBar1 = new TGeoBBox("sAlBar1", fgkHybridWidth/2,
2147 1 : fgkHybAlThick/2, sideWidth1/2);
2148 :
2149 3 : TGeoTranslation *upGlueBarTr1 = new TGeoTranslation("upGlueBarTr1", 0,
2150 1 : lowLayerYmin+(fgkHybGlueLowThick+fgkHybUpThick)/2,
2151 1 : -(fgkHybridLength-sideWidth1)/2);
2152 3 : TGeoTranslation *alBarTr1 = new TGeoTranslation("alBarTr1", 0,
2153 1 : lowLayerYmin+fgkHybGlueLowThick+fgkHybUpThick+fgkHybAlThick/2,
2154 1 : -(fgkHybridLength-sideWidth1)/2);
2155 1 : upGlueBarTr1->RegisterYourself();
2156 1 : alBarTr1->RegisterYourself();
2157 :
2158 2 : TGeoCompositeShape *sLowUpGlueBar1 = new TGeoCompositeShape(
2159 : "sUpGlueBar1:upGlueBarTr1-sRoundHole:hybHolePos1");
2160 2 : TGeoCompositeShape *sLowAlBar1 = new TGeoCompositeShape(
2161 : "sAlBar1:alBarTr1-sRoundHole:hybHolePos1");
2162 3 : TGeoVolume *vLowUpGlueBar1 = new TGeoVolume("vLowUpGlueBar1",
2163 1 : sLowUpGlueBar1, polyhamideSDD);
2164 3 : TGeoVolume *vLowAlBar1 = new TGeoVolume("vLowAlBar1",
2165 1 : sLowAlBar1, alSDD);
2166 1 : vLowUpGlueBar1->SetLineColor(fColorPolyhamide);
2167 1 : vLowAlBar1->SetLineColor(fColorAl);
2168 1 : hybrid->AddNode(vLowUpGlueBar1,1,0);
2169 1 : hybrid->AddNode(vLowAlBar1,1,0);
2170 :
2171 : //---
2172 : //here the upedex and glue layers are both assumed to be polyimide
2173 3 : TGeoBBox *sUpGlueBar2 = new TGeoBBox("sUpGlueBar2", fgkHybridWidth/2,
2174 1 : (fgkHybGlueLowThick+fgkHybUpThick)/2,
2175 1 : sideWidth2/2);
2176 3 : TGeoBBox *sAlBar2 = new TGeoBBox("sAlBar2", fgkHybridWidth/2,
2177 1 : fgkHybAlThick/2, sideWidth2/2);
2178 :
2179 3 : TGeoTranslation *upGlueBarTr2 = new TGeoTranslation("upGlueBarTr2", 0,
2180 1 : lowLayerYmin+(fgkHybGlueLowThick+fgkHybUpThick)/2,
2181 1 : (fgkHybridLength-sideWidth2)/2);
2182 3 : TGeoTranslation *alBarTr2 = new TGeoTranslation("alBarTr2", 0,
2183 1 : lowLayerYmin+fgkHybGlueLowThick+fgkHybUpThick+fgkHybAlThick/2,
2184 1 : (fgkHybridLength-sideWidth2)/2);
2185 1 : upGlueBarTr2->RegisterYourself();
2186 1 : alBarTr2->RegisterYourself();
2187 :
2188 2 : TGeoCompositeShape *sLowUpGlueBar2 = new TGeoCompositeShape(
2189 : "sUpGlueBar2:upGlueBarTr2-sRoundHole:hybHolePos2");
2190 2 : TGeoCompositeShape *sLowAlBar2 = new TGeoCompositeShape(
2191 : "sAlBar2:alBarTr2-sRoundHole:hybHolePos2");
2192 2 : TGeoVolume *vLowUpGlueBar2 = new TGeoVolume("vLowUpGlueBar2",sLowUpGlueBar2,
2193 : polyhamideSDD);
2194 2 : TGeoVolume *vLowAlBar2 = new TGeoVolume("vLowAlBar2",sLowAlBar2,
2195 : alSDD);
2196 1 : vLowUpGlueBar2->SetLineColor(fColorPolyhamide);
2197 1 : vLowAlBar2->SetLineColor(fColorAl);
2198 1 : hybrid->AddNode(vLowUpGlueBar2, 1, 0);
2199 1 : hybrid->AddNode(vLowAlBar2, 1, 0);
2200 :
2201 1 : if(GetDebug(3)) { // Remove compiler warning.
2202 0 : sAlScreenLayer->InspectShape();
2203 0 : sUpGlueScreenLayer->InspectShape();
2204 0 : sRoundHole->InspectShape();
2205 0 : sUpGlueBar1->InspectShape();
2206 0 : sUpGlueBar2->InspectShape();
2207 0 : sAlBar1->InspectShape();
2208 0 : sAlBar2->InspectShape();
2209 : };
2210 : //---
2211 : //using class AliITSv11GeomCableFlat to add 2-layer segments ...
2212 1 : Double_t piece1width = fgkHybFLlowPasX-fgkHybFLlowHolePasDX/2;
2213 1 : AliITSv11GeomCableFlat lowFLpiece("lowFLpiece1",piece1width,
2214 : lowFLTotalThick);
2215 1 : lowFLpiece.SetNLayers(2);
2216 2 : lowFLpiece.SetLayer(0, fgkHybGlueLowThick+fgkHybUpThick, polyhamideSDD,
2217 1 : fColorPolyhamide);
2218 1 : lowFLpiece.SetLayer(1, fgkHybAlThick, alSDD80p100, fColorAl);
2219 : // alSDD at 80% : mostly to take into account strips of piece 3
2220 :
2221 3 : Double_t x1[3] = { -fgkHybridWidth/2 + piece1width/2,
2222 1 : lowLayerYmin + lowFLTotalThick/2,
2223 1 : -fgkHybridLength/2 + sideWidth1 };
2224 1 : Double_t x2[3] ={ x1[0], x1[1], fgkHybridLength/2 - sideWidth2 };
2225 1 : Double_t vZ[3] = {0,0,1};
2226 1 : lowFLpiece.AddCheckPoint( hybrid, 0, x2, vZ );
2227 1 : lowFLpiece.AddCheckPoint( hybrid, 1, x1, vZ );
2228 1 : lowFLpiece.SetInitialNode(hybrid);
2229 1 : lowFLpiece.CreateAndInsertBoxCableSegment(1);
2230 1 : lowFLpiece.ResetPoints();
2231 :
2232 1 : Double_t piece2width = fgkHybFLlowAmbX-fgkHybFLlowPasX
2233 1 : -fgkHybFLlowHolePasDX/2-fgkHybFLlowHoleAmbDX/2;
2234 :
2235 1 : lowFLpiece.SetWidth(piece2width);
2236 1 : lowFLpiece.SetName("lowFLpiece2");
2237 1 : x1[0] = piece2width/2+fgkHybFLlowPasX+fgkHybFLlowHolePasDX/2-fgkHybridWidth/2;
2238 1 : x2[0] = x1[0];
2239 1 : lowFLpiece.AddCheckPoint( hybrid, 0, x2, vZ );
2240 1 : lowFLpiece.AddCheckPoint( hybrid, 1, x1, vZ );
2241 1 : lowFLpiece.CreateAndInsertBoxCableSegment(1);
2242 1 : lowFLpiece.ResetPoints();
2243 :
2244 1 : Double_t piece3width = fgkHybridWidth - fgkHybFLlowAmbX
2245 1 : - fgkHybFLlowHoleAmbDX/2;
2246 :
2247 1 : lowFLpiece.SetWidth(piece3width);
2248 1 : lowFLpiece.SetName("lowFLpiece3");
2249 1 : x1[0] = fgkHybridWidth/2-piece3width/2;
2250 1 : x2[0] = x1[0];
2251 1 : lowFLpiece.AddCheckPoint( hybrid, 0, x2, vZ );
2252 1 : lowFLpiece.AddCheckPoint( hybrid, 1, x1, vZ );
2253 1 : lowFLpiece.CreateAndInsertBoxCableSegment(1);
2254 :
2255 3 : Double_t zChips[4] = {fgkHybFLlowChipZ1,fgkHybFLlowChipZ2,
2256 2 : fgkHybFLlowChipZ3,fgkHybFLlowChipZ4};
2257 1 : Double_t vX[3] = {1,0,0};
2258 8 : for (Int_t i=0; i<3; i++) {
2259 3 : char ch[20];
2260 3 : snprintf(ch, 20, "lowFLpieceA%i", i+4);
2261 3 : lowFLpiece.SetName(ch);
2262 3 : lowFLpiece.SetWidth(zChips[i+1]-zChips[i]-fgkHybFLlowHoleDZ);
2263 :
2264 3 : lowFLpiece.SetLayer(1, fgkHybAlThick, alSDD, fColorAl);
2265 3 : x1[0] = -fgkHybridWidth/2 + piece1width;
2266 3 : x2[0] = x1[0] + fgkHybFLlowHolePasDX;
2267 3 : Double_t zPiece = (zChips[i+1]+zChips[i])/2 - fgkHybridLength/2;
2268 3 : x1[2] = zPiece; x2[2] = zPiece;
2269 3 : lowFLpiece.AddCheckPoint( hybrid, 0, x2, vX );
2270 3 : lowFLpiece.AddCheckPoint( hybrid, 1, x1, vX );
2271 3 : lowFLpiece.CreateAndInsertBoxCableSegment(1,90);
2272 3 : lowFLpiece.ResetPoints();
2273 :
2274 3 : snprintf(ch, 20, "lowFLpieceB%i", i+4);
2275 3 : lowFLpiece.SetName(ch);
2276 3 : x1[0] = fgkHybridWidth/2 - piece3width;
2277 3 : x2[0] = x1[0] - fgkHybFLlowHoleAmbDX;
2278 3 : lowFLpiece.AddCheckPoint( hybrid, 0, x1, vX );
2279 3 : lowFLpiece.AddCheckPoint( hybrid, 1, x2, vX );
2280 3 : lowFLpiece.CreateAndInsertBoxCableSegment(1,90);
2281 3 : };
2282 :
2283 : //**************************************************** chips+CC:
2284 1 : AliITSv11GeomCableFlat chip("", fgkHybChipsDZ, chipsCCTotThick);
2285 1 : chip.SetInitialNode(hybrid);
2286 1 : chip.SetNLayers(5);
2287 1 : chip.SetLayer(0, fgkHybUnderNiThick, niSDD, 2);
2288 1 : chip.SetLayer(1, fgkHybGlueAgThick, glueAG, 4);
2289 1 : chip.SetLayer(2, fgkHybChipThick, siliconSDD, fColorSilicon);
2290 2 : chip.SetLayer(3, fgkHybUpCCThick+fgkHybUpCCThick, polyhamideSDD,
2291 1 : fColorPolyhamide);
2292 1 : chip.SetLayer(4, fgkHybAlCCThick+fgkHybAlCCThick, alSDD80p100, fColorAl);
2293 : // Here the tho CC (low+up) are merged
2294 : // In fact, the last layer has a smaller surface of Al -> I put 80%
2295 :
2296 1 : x1[1] = lowLayerYmin + chipsCCTotThick/2;
2297 1 : x2[1] = x1[1];
2298 1 : char ch[20];
2299 :
2300 10 : for (Int_t i=0; i<4; i++) {
2301 4 : snprintf(ch, 20, "pascalCC%i", i);
2302 4 : chip.SetName(ch);
2303 4 : x1[0] = fgkHybFLlowPasX - fgkHybridWidth/2 - fgkHybPascalDX/2;
2304 4 : x2[0] = x1[0] + fgkHybPascalDX;
2305 4 : x1[2] = zChips[i] - fgkHybridLength/2;
2306 4 : x2[2] = x1[2];
2307 4 : chip.AddCheckPoint( hybrid, 0, x1, vX );
2308 4 : chip.AddCheckPoint( hybrid, 1, x2, vX );
2309 4 : chip.CreateAndInsertBoxCableSegment(1,-90);
2310 4 : chip.ResetPoints();
2311 :
2312 4 : snprintf(ch, 20, "ambraCC%i", i);
2313 4 : chip.SetName(ch);
2314 4 : x1[0] = fgkHybFLlowAmbX - fgkHybridWidth/2 - fgkHybAmbraDX/2;
2315 4 : x2[0] = x1[0] + fgkHybAmbraDX;
2316 4 : chip.AddCheckPoint( hybrid, 0, x1, vX );
2317 4 : chip.AddCheckPoint( hybrid, 1, x2, vX );
2318 4 : chip.CreateAndInsertBoxCableSegment(1,-90);
2319 4 : chip.ResetPoints();
2320 : };
2321 :
2322 : //**************************************************** CC outside chips:
2323 : // I don't think there is a second aluminium layer here ...
2324 10 : for (Int_t i = 0; i<4; i++) {
2325 4 : snprintf(ch, 20, "ccLayerA%i", i);
2326 :
2327 4 : AliITSv11GeomCableFlat ccLayer1(ch, 6.6*fgkmm, ccUpLayerTotThick);
2328 4 : ccLayer1.SetInitialNode(hybrid);
2329 4 : ccLayer1.SetNLayers(2);
2330 4 : ccLayer1.SetLayer(0, 2*fgkHybUpCCThick, polyhamideSDD, fColorPolyhamide);
2331 4 : ccLayer1.SetLayer(1, fgkHybAlCCThick, alSDD50p100, fColorAl);
2332 : // Al at ~50%
2333 :
2334 4 : x1[0] = -fgkHybridWidth/2;
2335 4 : x2[0] = fgkHybFLlowPasX - fgkHybridWidth/2 - fgkHybPascalDX/2;
2336 8 : x1[1] = lowLayerYmin + fgkHybUnderNiThick + fgkHybGlueAgThick
2337 4 : + fgkHybChipThick + ccUpLayerTotThick/2;
2338 4 : x2[1] = x1[1];
2339 4 : x1[2] = zChips[i] - fgkHybridLength/2;
2340 4 : x2[2] = x1[2];
2341 4 : ccLayer1.AddCheckPoint( hybrid, 0, x1, vX );
2342 4 : ccLayer1.AddCheckPoint( hybrid, 1, x2, vX );
2343 4 : ccLayer1.CreateAndInsertBoxCableSegment(1,-90);
2344 :
2345 4 : snprintf(ch, 20, "ccLayerB%i", i);
2346 4 : AliITSv11GeomCableFlat ccLayer2(ch, fgkHybChipsDZ, ccUpLayerTotThick);
2347 4 : ccLayer2.SetInitialNode(hybrid);
2348 4 : ccLayer2.SetNLayers(2);
2349 4 : ccLayer2.SetLayer(0, 2*fgkHybUpCCThick, polyhamideSDD, fColorPolyhamide);
2350 4 : ccLayer2.SetLayer(1, fgkHybAlCCThick, alSDD50p100, fColorAl);
2351 : // Al at ~50%
2352 :
2353 4 : x1[0] = -fgkHybridWidth/2 + fgkHybFLlowPasX + fgkHybPascalDX/2;
2354 4 : x2[0] = -fgkHybridWidth/2 + fgkHybFLlowAmbX - fgkHybAmbraDX/2;
2355 4 : ccLayer2.AddCheckPoint( hybrid, 0, x1, vX );
2356 4 : ccLayer2.AddCheckPoint( hybrid, 1, x2, vX );
2357 4 : ccLayer2.CreateAndInsertBoxCableSegment(1,-90);
2358 4 : ccLayer2.ResetPoints();
2359 4 : snprintf(ch, 20, "ccLayerC%i", i);
2360 4 : ccLayer2.SetName(ch);
2361 4 : x1[0] = -fgkHybridWidth/2 + fgkHybFLlowAmbX + fgkHybAmbraDX/2;
2362 4 : x2[0] = fgkHybridWidth/2 - fgkHybFLUpperWidth + 3*fgkmm;
2363 8 : x1[1] = lowLayerYmin + lowFLTotalThick + flUpThick + fgkHybAlThick
2364 4 : + ccUpLayerTotThick/2;
2365 4 : x2[1] = x1[1];
2366 :
2367 4 : ccLayer2.AddCheckPoint( hybrid, 0, x1, vX );
2368 4 : ccLayer2.AddCheckPoint( hybrid, 1, x2, vX );
2369 4 : ccLayer2.CreateAndInsertBoxCableSegment(1,-90);
2370 :
2371 : //**************************************************** CC to sensors:
2372 : // (alas, we cannot use GeomCableFlat here because section is not constant)
2373 4 : Double_t xcc[8],ycc[8];
2374 4 : xcc[0] = -0.5*ccLayer1.GetWidth();
2375 4 : ycc[0] = 0;
2376 4 : xcc[1] = 0.5*ccLayer1.GetWidth();
2377 4 : ycc[1] = 0;
2378 4 : xcc[2] = xcc[1];
2379 4 : ycc[2] = -fgkHybCC2SensorLen*0.8;
2380 4 : xcc[3] = xcc[2] + 0.1*fgkHybCC2SensorWid;
2381 4 : ycc[3] = ycc[2];
2382 4 : xcc[4] = xcc[3];
2383 4 : ycc[4] = -fgkHybCC2SensorLen;
2384 4 : xcc[5] = xcc[4] - fgkHybCC2SensorWid;
2385 4 : ycc[5] = ycc[4];
2386 4 : xcc[6] = xcc[5];
2387 4 : ycc[6] = 0.8*ycc[5];
2388 4 : xcc[7] = xcc[0];
2389 4 : ycc[7] = 0.2*ycc[5];
2390 :
2391 8 : TGeoXtru* ccToSensPoliSh = new TGeoXtru(2);
2392 4 : ccToSensPoliSh->DefinePolygon(8, xcc, ycc);
2393 4 : ccToSensPoliSh->DefineSection(0, 0.);
2394 4 : ccToSensPoliSh->DefineSection(1, ccLayer1.GetThickness());
2395 :
2396 4 : snprintf(ch, 20, "ccToSens%i", i);
2397 8 : TGeoVolume* ccToSensPoliVol = new TGeoVolume(ch, ccToSensPoliSh, polyhamideSDD);
2398 4 : ccToSensPoliVol->SetLineColor(fColorPolyhamide);
2399 :
2400 8 : TGeoXtru* ccToSensAlSh = new TGeoXtru(2);
2401 4 : xcc[6] += 0.001;
2402 4 : ycc[7] -= 0.001;
2403 4 : ccToSensAlSh->DefinePolygon(8, xcc, ycc);
2404 4 : ccToSensAlSh->DefineSection(0, 0.);
2405 4 : ccToSensAlSh->DefineSection(1, fgkHybAlCCThick);
2406 :
2407 4 : snprintf(ch, 20, "ccToSensAl%i", i);
2408 8 : TGeoVolume* ccToSensAlVol = new TGeoVolume(ch, ccToSensAlSh, alSDD50p100);
2409 4 : ccToSensAlVol->SetLineColor(fColorAl);
2410 :
2411 4 : ccToSensPoliVol->AddNode(ccToSensAlVol, 1, 0);
2412 :
2413 4 : Double_t coord[3];
2414 4 : ccLayer1.GetPoint(0,coord);
2415 8 : hybrid->AddNode(ccToSensPoliVol, i+1,
2416 16 : new TGeoCombiTrans(coord[0], coord[1], coord[2],
2417 8 : new TGeoRotation("",-90-fgkHybCC2SensorAng, 90, 90)));
2418 4 : };
2419 :
2420 : //**************************************************** FL UP:
2421 : // (last Al layer will be a special triangular shape)
2422 3 : TGeoBBox *sFLupPolyhamide = new TGeoBBox("sFLupPolyhamide",
2423 1 : fgkHybFLUpperWidth/2, flUpThick/2,
2424 1 : fgkHybFLUpperLength/2);
2425 3 : TGeoVolume *vFLupPolyhamide = new TGeoVolume("vFLupPolyhamide",
2426 1 : sFLupPolyhamide, polyhamideSDD);
2427 1 : vFLupPolyhamide->SetLineColor(fColorPolyhamide);
2428 : TGeoTranslation *trFLupPolyhamide =
2429 3 : new TGeoTranslation(fgkHybridWidth/2-fgkHybFLUpperWidth/2,
2430 1 : lowLayerYmin+lowFLTotalThick+flUpThick/2,0);
2431 :
2432 1 : hybrid->AddNode(vFLupPolyhamide, 1, trFLupPolyhamide);
2433 :
2434 2 : TGeoArb8 *aluStrip = new TGeoArb8(fgkHybAlThick/2);
2435 1 : aluStrip->SetVertex( 0,-fgkHybFLUpperAlDZ/2, fgkHybFLUpperWidth);
2436 1 : aluStrip->SetVertex( 1, fgkHybFLUpperAlDZ/2, fgkHybFLUpperWidth);
2437 1 : aluStrip->SetVertex( 2, fgkHybFLUpperAlDZ/2, fgkHybFLUpperWidth-fgkHybFLUpperAldx);
2438 1 : aluStrip->SetVertex( 3,-fgkHybFLUpperAlDZ/2, 0);
2439 1 : aluStrip->SetVertex( 4,-fgkHybFLUpperAlDZ/2, fgkHybFLUpperWidth);
2440 1 : aluStrip->SetVertex( 5, fgkHybFLUpperAlDZ/2, fgkHybFLUpperWidth);
2441 1 : aluStrip->SetVertex( 6, fgkHybFLUpperAlDZ/2, fgkHybFLUpperWidth-fgkHybFLUpperAldx);
2442 1 : aluStrip->SetVertex( 7,-fgkHybFLUpperAlDZ/2, 0);
2443 2 : TGeoVolume *vAluStrip = new TGeoVolume("vAluStrip",aluStrip, alSDD50p100);
2444 : // Al at ~50%
2445 :
2446 1 : vAluStrip->SetLineColor(fColorAl);
2447 : //TGeoRotation rotAluStrip("rotAluStrip",0, -90, 90);
2448 2 : TGeoRotation *rotAluStrip = new TGeoRotation("rotAluStrip",0, -90, 90);
2449 :
2450 : Double_t yRotAluStrip = lowLayerYmin+lowFLTotalThick
2451 1 : +flUpThick+fgkHybAlThick/2;
2452 3 : TGeoCombiTrans *aluStripTr1 = new TGeoCombiTrans(
2453 1 : fgkHybridWidth/2,yRotAluStrip,
2454 1 : fgkHybridLength/2-fgkHybFLlowChipZ1+1*fgkmm, rotAluStrip);
2455 2 : TGeoCombiTrans *aluStripTr2 = new TGeoCombiTrans(*aluStripTr1);
2456 1 : AddTranslationToCombiTrans(aluStripTr2,0,0,
2457 1 : fgkHybFLlowChipZ1-fgkHybFLlowChipZ2);
2458 2 : TGeoCombiTrans *aluStripTr3 = new TGeoCombiTrans(*aluStripTr2);
2459 1 : AddTranslationToCombiTrans(aluStripTr3,0,0,
2460 1 : fgkHybFLlowChipZ2-fgkHybFLlowChipZ3);
2461 2 : TGeoCombiTrans *aluStripTr4 = new TGeoCombiTrans(*aluStripTr3);
2462 1 : AddTranslationToCombiTrans(aluStripTr4,0,0,
2463 1 : fgkHybFLlowChipZ3-fgkHybFLlowChipZ4);
2464 :
2465 1 : hybrid->AddNode(vAluStrip, 1, aluStripTr1);
2466 1 : hybrid->AddNode(vAluStrip, 2, aluStripTr2);
2467 1 : hybrid->AddNode(vAluStrip, 3, aluStripTr3);
2468 1 : hybrid->AddNode(vAluStrip, 4, aluStripTr4);
2469 : //**************************************************** SMD:
2470 3 : TGeoBBox *hybSMD = new TGeoBBox("ITSsddSMDshape",
2471 1 : fgkHybSMDmiddleL/2+fgkHybSMDendL,
2472 1 : fgkHybSMDheight/2,fgkHybSMDendW/2);
2473 2 : TGeoVolume *vHybSMD = new TGeoVolume("ITSsddSMD",hybSMD,airSDD);
2474 :
2475 3 : TGeoBBox *hybSMDmiddle = new TGeoBBox("ITSsddSMDmiddleShape",
2476 1 : fgkHybSMDmiddleL/2,fgkHybSMDheight/2,
2477 1 : fgkHybSMDmiddleW/2);
2478 3 : TGeoVolume *vHybSMDmiddle = new TGeoVolume("ITSsddSMDmiddle",
2479 1 : hybSMDmiddle,medSMD);
2480 1 : vHybSMDmiddle->SetLineColor(fColorSMD);
2481 3 : TGeoBBox *hybSMDend = new TGeoBBox("ITSsddSMDendShape",
2482 1 : fgkHybSMDendL/2,fgkHybSMDheight/2,fgkHybSMDendW/2);
2483 3 : TGeoVolume *vHybSMDend = new TGeoVolume("ITSsddSMDend",
2484 1 : hybSMDend,medSMDweld);
2485 1 : vHybSMDend->SetLineColor(fColorSMDweld);
2486 3 : TGeoTranslation *vHybSMDendTr1 = new TGeoTranslation("",
2487 1 : (fgkHybSMDmiddleL+fgkHybSMDendL)/2,0,0);
2488 3 : TGeoTranslation *vHybSMDendTr2 = new TGeoTranslation("",
2489 1 : -(fgkHybSMDmiddleL+fgkHybSMDendL)/2,0,0);
2490 1 : vHybSMD->AddNode(vHybSMDmiddle,1,0);
2491 1 : vHybSMD->AddNode(vHybSMDend,1,vHybSMDendTr1);
2492 1 : vHybSMD->AddNode(vHybSMDend,2,vHybSMDendTr2);
2493 52 : for (Int_t i=0; i<fgkNHybSMD; i++) {
2494 75 : TGeoTranslation *vHybSMDtr = new TGeoTranslation("",
2495 25 : -fgkHybridWidth/2+fgkHybSMDposX[i],
2496 25 : lowLayerYmin+lowFLTotalThick+fgkHybSMDheight/2,
2497 25 : -fgkHybridLength/2+fgkHybSMDposZ[i]);
2498 25 : hybrid->AddNode(vHybSMD, i+1, vHybSMDtr);
2499 : };
2500 :
2501 : if (iLRSide == 0) {
2502 : };
2503 :
2504 1 : if(GetDebug(1)) hybrid->CheckOverlaps(0.01);
2505 1 : hybrid->SetVisibility(kFALSE);
2506 : return hybrid;
2507 1 : }
2508 :
2509 : //________________________________________________________________________
2510 : TGeoVolume* AliITSv11GeometrySDD::CreateLadderSegment(Int_t iLay, Int_t iSeg) {
2511 : //
2512 : // Return a TGeoVolume* containing a segment of a ladder.
2513 : //
2514 :
2515 28 : TGeoMedium *phynoxSDD = GetMedium("INOX$");
2516 14 : TGeoMedium *coolerMediumSDD = GetMedium("WATER$");
2517 14 : TGeoMedium *airSDD = GetMedium("SDD AIR$");
2518 14 : TGeoMedium *alSDD = GetMedium("AL$");
2519 :
2520 14 : Double_t tDY = fgkLadderSegBoxDH/2; //space left on top of the ladder
2521 14 : Double_t segmentLength = fgkSegmentLength;
2522 14 : Double_t spaceBetweenCables = 500*fgkmicron;
2523 :
2524 : //*****************************************
2525 : // Set parameters according to (iLay,iSeg):
2526 : //*****************************************
2527 : Int_t nDetectors = fgkLay3Ndet;
2528 14 : Double_t coolPipeSuppH = fgkLay3CoolPipeSuppH;
2529 28 : Double_t sensorCenterZPos = fLay3sensorZPos[iSeg]-
2530 28 : (fgkSegmentLength*fgkLay3Ndet/2. -
2531 28 : fgkSegmentLength/2-(iSeg)*fgkSegmentLength);
2532 : // sensorCenterZPos = z in segment local coord syst.
2533 :
2534 14 : AliITSv11GeomCableFlat *digitCableA = fDigitCableLay3A;
2535 14 : AliITSv11GeomCableFlat *digitCableB = fDigitCableLay3B;
2536 :
2537 14 : if (iLay==3) {
2538 8 : } else if (iLay==4) {
2539 : nDetectors = fgkLay4Ndet;
2540 8 : coolPipeSuppH = fgkLay4CoolPipeSuppH;
2541 16 : sensorCenterZPos = fLay4sensorZPos[iSeg]-
2542 8 : (fgkSegmentLength*fgkLay4Ndet/2. -
2543 8 : fgkSegmentLength/2-(iSeg)*fgkSegmentLength);
2544 8 : digitCableA = fDigitCableLay4A;
2545 8 : digitCableB = fDigitCableLay4B;
2546 8 : } else
2547 0 : printf("AliITSv11GeometrySDD::CreateLadderSegment Wrong layer index !");
2548 :
2549 :
2550 : Double_t cableSideSign = -1;
2551 14 : if (iSeg<nDetectors/2) cableSideSign = 1;
2552 14 : Double_t spaceForCables = spaceBetweenCables*
2553 28 : (nDetectors-TMath::Abs(nDetectors-2*iSeg-1)-1)/2
2554 14 : +0.1*fgkmicron;
2555 : // gives [0-1-2-2-1-0]*spaceBetweenCables
2556 : // or [0-1-2-3-3-2-1-0]*spaceBetweenCables
2557 : Int_t iUpdateCableMin;
2558 : Int_t iUpdateCableMax;
2559 14 : if (cableSideSign==-1) {
2560 : iUpdateCableMin = nDetectors/2;
2561 7 : iUpdateCableMax = iSeg-1;
2562 7 : } else {
2563 7 : iUpdateCableMin = iSeg+1;
2564 7 : iUpdateCableMax = nDetectors/2-1;
2565 : };
2566 :
2567 14 : if(GetDebug(1)){
2568 0 : cout << "Segment ("<< iLay <<',' << iSeg
2569 0 : << ") : sensor z shift in local segment coord.="
2570 0 : << sensorCenterZPos << endl;
2571 0 : };
2572 :
2573 : //****************************
2574 : // The segment volume
2575 : //****************************
2576 :
2577 : // Use of TGeoVolumeAssembly increases the calculation time of overlaps and very
2578 : // likely slows down the transport of particles through the geometry
2579 :
2580 : //TGeoVolumeAssembly *virtualSeg = new TGeoVolumeAssembly("ITSsddSegment");
2581 :
2582 : // TGeoBBox *segBox = new TGeoBBox("ITSsddSegBox",
2583 : // fgkLadderWidth/2+fgkPinSuppWidth+fgkLadderSegBoxDW,
2584 : // fgkLadderHeight/2+fgkLadderSegBoxDH/2,
2585 : // segmentLength/2);
2586 : // A shaped Xtru instead of a simple BBox to avoid overlaps and extrusions
2587 14 : TGeoXtru *segBox = new TGeoXtru(2);
2588 14 : segBox->SetName("ITSsddSegBox");
2589 :
2590 14 : Double_t xseg[12],yseg[12];
2591 14 : xseg[ 0] = -(fgkLadderWidth/2+fgkPinSuppWidth+fgkLadderSegBoxDW);
2592 14 : yseg[ 0] = fgkLadderHeight/2+fgkLadderSegBoxDH/2;
2593 14 : xseg[ 1] = xseg[0];
2594 14 : yseg[ 1] = -yseg[0];
2595 14 : xseg[ 2] = 0.87*xseg[1];
2596 14 : yseg[ 2] = yseg[1];
2597 14 : xseg[ 3] = 0.77*xseg[1];
2598 14 : yseg[ 3] = -yseg[0] - 0.62*fgkHybCC2SensorLen;
2599 14 : xseg[ 4] = 0.72*xseg[1];
2600 14 : yseg[ 4] = yseg[3];
2601 14 : xseg[ 5] = 0.83*xseg[1];
2602 14 : yseg[ 5] = yseg[1];
2603 :
2604 196 : for (Int_t j=0; j<6; j++) {
2605 84 : xseg[6+j] = -xseg[5-j];
2606 84 : yseg[6+j] = yseg[5-j];
2607 : }
2608 :
2609 14 : segBox->DefinePolygon(12, xseg, yseg);
2610 14 : segBox->DefineSection(0,-segmentLength/2);
2611 14 : segBox->DefineSection(1, segmentLength/2);
2612 :
2613 28 : TGeoVolume *virtualSeg = new TGeoVolume("ITSsddSegment",
2614 14 : segBox, airSDD);
2615 14 : virtualSeg->SetVisibility(kFALSE);
2616 :
2617 : //******************************
2618 : // Carbon fiber structure :
2619 : //******************************
2620 :
2621 14 : virtualSeg->AddNode(fLaddSegCommonVol[0], 1, fLaddSegCommonTr[0]);
2622 : Int_t volumeIndex = 1;
2623 560 : for (Int_t i = 1; i<fgkNladdSegCommonVol;i++ ) {
2624 266 : if (fLaddSegCommonVol[i]==fLaddSegCommonVol[i-1])
2625 154 : volumeIndex++;
2626 : else
2627 : volumeIndex = 1;
2628 532 : virtualSeg->AddNode(fLaddSegCommonVol[i], volumeIndex,
2629 266 : fLaddSegCommonTr[i]);
2630 : };
2631 :
2632 : //**********************************
2633 : // Pine support of the sensors :
2634 : //**********************************
2635 14 : TGeoRotation *rotPS1 = new TGeoRotation("",0,-90,90);
2636 14 : TGeoRotation *rotPS2 = new TGeoRotation("",0,-90,-90);
2637 :
2638 : // The use of the following constructor type allow to use rotPS1 and rotPS2
2639 : // (and not copy them) therefore we gain some memory
2640 28 : TGeoCombiTrans *transPS1 = new TGeoCombiTrans( fgkPinDYOnSensor,
2641 14 : - fgkLadderHeight/2.-tDY
2642 14 : + fgkPinSuppHeight/2.,
2643 14 : sensorCenterZPos+fgkPinDXminOnSensor,rotPS1);
2644 :
2645 28 : TGeoCombiTrans *transPS2 = new TGeoCombiTrans( fgkPinDYOnSensor,
2646 14 : - fgkLadderHeight/2.-tDY
2647 14 : + fgkPinSuppHeight/2.,
2648 14 : sensorCenterZPos+fgkPinDXminOnSensor,rotPS1);
2649 14 : AddTranslationToCombiTrans(transPS2, 0, 0, fgkPinPinDDXOnSensor);
2650 :
2651 28 : TGeoCombiTrans *transPS3 = new TGeoCombiTrans( fgkPinDYOnSensor,
2652 14 : - fgkLadderHeight/2.-tDY
2653 14 : + fgkPinSuppHeight/2.,
2654 14 : sensorCenterZPos+fgkPinDXminOnSensor,rotPS1);
2655 14 : AddTranslationToCombiTrans(transPS3, 0, 0, -2*fgkPinDXminOnSensor);
2656 :
2657 28 : TGeoCombiTrans *transPS4 = new TGeoCombiTrans( fgkPinDYOnSensor,
2658 14 : - fgkLadderHeight/2.-tDY
2659 14 : + fgkPinSuppHeight/2.,
2660 14 : sensorCenterZPos+fgkPinDXminOnSensor,rotPS1);
2661 14 : AddTranslationToCombiTrans(transPS4, 0, 0, -2*fgkPinDXminOnSensor-fgkPinPinDDXOnSensor);
2662 :
2663 28 : TGeoCombiTrans *transPS5 = new TGeoCombiTrans( -fgkPinDYOnSensor,
2664 14 : - fgkLadderHeight/2. - tDY
2665 14 : + fgkPinSuppHeight/2.,
2666 14 : sensorCenterZPos+fgkPinDXminOnSensor,rotPS2);
2667 :
2668 28 : TGeoCombiTrans *transPS6 = new TGeoCombiTrans( -fgkPinDYOnSensor,
2669 14 : - fgkLadderHeight/2. - tDY
2670 14 : + fgkPinSuppHeight/2.,
2671 14 : sensorCenterZPos+fgkPinDXminOnSensor,rotPS2);
2672 14 : AddTranslationToCombiTrans(transPS6, 0, 0, fgkPinPinDDXOnSensor);
2673 :
2674 28 : TGeoCombiTrans *transPS7 = new TGeoCombiTrans( -fgkPinDYOnSensor,
2675 14 : - fgkLadderHeight/2. - tDY
2676 14 : + fgkPinSuppHeight/2.,
2677 14 : sensorCenterZPos+fgkPinDXminOnSensor,rotPS2);
2678 14 : AddTranslationToCombiTrans(transPS7, 0, 0, -2*fgkPinDXminOnSensor);
2679 :
2680 28 : TGeoCombiTrans *transPS8 = new TGeoCombiTrans( -fgkPinDYOnSensor,
2681 14 : - fgkLadderHeight/2. - tDY
2682 14 : + fgkPinSuppHeight/2.,
2683 14 : sensorCenterZPos+fgkPinDXminOnSensor,rotPS2);
2684 14 : AddTranslationToCombiTrans(transPS8, 0, 0, -2*fgkPinDXminOnSensor-fgkPinPinDDXOnSensor);
2685 :
2686 14 : virtualSeg->AddNode(fPinSupport, 1, transPS1);
2687 14 : virtualSeg->AddNode(fPinSupport, 2, transPS2);
2688 14 : virtualSeg->AddNode(fPinSupport, 3, transPS3);
2689 14 : virtualSeg->AddNode(fPinSupport, 4, transPS4);
2690 14 : virtualSeg->AddNode(fPinSupport, 5, transPS5);
2691 14 : virtualSeg->AddNode(fPinSupport, 6, transPS6);
2692 14 : virtualSeg->AddNode(fPinSupport, 7, transPS7);
2693 14 : virtualSeg->AddNode(fPinSupport, 8, transPS8);
2694 :
2695 14 : TGeoMedium *pinMed = GetMedium("RYTON$");
2696 14 : Double_t fgkPinHeight = 4.5*fgkmm;
2697 28 : TGeoTube *pineS = new TGeoTube("ITSsddPin",0,fgkPinR,
2698 14 : fgkPinHeight/2.);
2699 14 : TGeoVolume *pineV = new TGeoVolume("ITSsddPinVol", pineS, pinMed);
2700 :
2701 28 : TGeoCombiTrans *transPS2b = new TGeoCombiTrans( fgkPinDYOnSensor,
2702 14 : - fgkLadderHeight/2.-tDY
2703 14 : + fgkPinHeight/2.,
2704 14 : sensorCenterZPos+fgkPinDXminOnSensor,rotPS1);
2705 14 : AddTranslationToCombiTrans(transPS2b, 0, 0, fgkPinPinDDXOnSensor);
2706 14 : virtualSeg->AddNode(pineV, 1, transPS2b);
2707 :
2708 28 : TGeoCombiTrans *transPS6b = new TGeoCombiTrans( -fgkPinDYOnSensor,
2709 14 : - fgkLadderHeight/2. - tDY
2710 14 : + fgkPinHeight/2.,
2711 14 : sensorCenterZPos+fgkPinDXminOnSensor,rotPS2);
2712 14 : AddTranslationToCombiTrans(transPS6b, 0, 0, fgkPinPinDDXOnSensor);
2713 14 : virtualSeg->AddNode(pineV, 2, transPS6b);
2714 :
2715 :
2716 28 : TGeoCombiTrans *transPS4b = new TGeoCombiTrans( fgkPinDYOnSensor,
2717 14 : - fgkLadderHeight/2.-tDY
2718 14 : + fgkPinHeight/2.,
2719 14 : sensorCenterZPos+fgkPinDXminOnSensor,rotPS1);
2720 14 : AddTranslationToCombiTrans(transPS4b, 0, 0, -2*fgkPinDXminOnSensor-fgkPinPinDDXOnSensor);
2721 14 : virtualSeg->AddNode(pineV, 3, transPS4b);
2722 :
2723 28 : TGeoCombiTrans *transPS8b = new TGeoCombiTrans( -fgkPinDYOnSensor,
2724 14 : - fgkLadderHeight/2. - tDY
2725 14 : + fgkPinHeight/2.,
2726 14 : sensorCenterZPos+fgkPinDXminOnSensor,rotPS2);
2727 14 : AddTranslationToCombiTrans(transPS8b, 0, 0, -2*fgkPinDXminOnSensor-fgkPinPinDDXOnSensor);
2728 14 : virtualSeg->AddNode(pineV, 4, transPS8b);
2729 :
2730 :
2731 : //******************************
2732 : // Cooling pipe supports :
2733 : //******************************
2734 14 : Double_t triangleHeight = fgkLadderHeight - fgkLadderBeamRadius;
2735 14 : Double_t halfTheta = TMath::ATan( 0.5*fgkLadderWidth/triangleHeight );
2736 28 : Double_t triangleCPaxeDist = fgkCoolPipeSuppAxeDist-fgkCoolPipeSuppWidthExt-
2737 28 : fgkCoolPipeSuppWidthIn+fgkLadderBeamRadius;
2738 :
2739 28 : Double_t coolPipeSuppL = TMath::Tan(halfTheta)*
2740 14 : (triangleHeight+triangleCPaxeDist/
2741 28 : TMath::Sin(halfTheta)-coolPipeSuppH);
2742 14 : if (fAddCoolingSyst) {
2743 14 : TGeoRotation *rotCPS2 = new TGeoRotation("", -halfTheta*TMath::RadToDeg(), -90, 90);
2744 14 : TGeoRotation *rotCPS1 = new TGeoRotation("", halfTheta*TMath::RadToDeg(), -90, -90);
2745 28 : TGeoCombiTrans *transCPS1 = new TGeoCombiTrans(coolPipeSuppL,
2746 14 : -fgkLadderHeight/2. - tDY
2747 14 : +coolPipeSuppH+fgkLadderBeamRadius,
2748 : -segmentLength/2., rotCPS1);
2749 :
2750 28 : TGeoCombiTrans *transCPS3 = new TGeoCombiTrans(coolPipeSuppL,
2751 14 : -fgkLadderHeight/2. - tDY
2752 14 : +coolPipeSuppH+fgkLadderBeamRadius,
2753 : -segmentLength/2., rotCPS1);
2754 14 : AddTranslationToCombiTrans(transCPS3, 0, 0, segmentLength);
2755 :
2756 28 : TGeoCombiTrans *transCPS2 = new TGeoCombiTrans(-coolPipeSuppL,
2757 14 : -fgkLadderHeight/2.- tDY
2758 14 : +coolPipeSuppH+fgkLadderBeamRadius,
2759 : segmentLength/2., rotCPS2);
2760 :
2761 28 : TGeoCombiTrans *transCPS4 = new TGeoCombiTrans(-coolPipeSuppL,
2762 14 : -fgkLadderHeight/2.- tDY
2763 14 : +coolPipeSuppH+fgkLadderBeamRadius,
2764 : segmentLength/2., rotCPS2);
2765 14 : AddTranslationToCombiTrans(transCPS4, 0, 0, -segmentLength);
2766 :
2767 14 : virtualSeg->AddNode(fCoolPipeSupportL, 1, transCPS1);
2768 14 : virtualSeg->AddNode(fCoolPipeSupportL, 2, transCPS2);
2769 14 : virtualSeg->AddNode(fCoolPipeSupportR, 1, transCPS3);
2770 14 : virtualSeg->AddNode(fCoolPipeSupportR, 2, transCPS4);
2771 14 : };
2772 :
2773 : //************************
2774 : // Cooling pipes :
2775 : //************************
2776 28 : TGeoTranslation *pipeTr1 = new TGeoTranslation(coolPipeSuppL,
2777 28 : -fgkLadderHeight/2. - tDY +
2778 28 : fgkLadderBeamRadius+coolPipeSuppH, 0);
2779 28 : TGeoTranslation *pipeTr2 = new TGeoTranslation(-coolPipeSuppL,
2780 28 : -fgkLadderHeight/2.- tDY +
2781 28 : fgkLadderBeamRadius+coolPipeSuppH, 0);
2782 :
2783 14 : if (fAddCoolingSyst) {
2784 28 : TGeoTube *coolingPipeShape = new TGeoTube( fgkCoolPipeInnerDiam/2,
2785 14 : fgkCoolPipeOuterDiam/2,
2786 : segmentLength/2);
2787 14 : TGeoTube *coolerShape = new TGeoTube( 0, fgkCoolPipeInnerDiam/2,
2788 : segmentLength/2);
2789 :
2790 28 : TGeoVolume *coolingPipe = new TGeoVolume("ITSsddCoolingPipe",
2791 14 : coolingPipeShape, phynoxSDD );
2792 14 : coolingPipe->SetLineColor(fColorPhynox);
2793 14 : TGeoVolume *cooler = new TGeoVolume("ITSsddCoolingLiquid",coolerShape,
2794 : coolerMediumSDD );
2795 :
2796 :
2797 14 : virtualSeg->AddNode(coolingPipe, 1, pipeTr1);
2798 14 : virtualSeg->AddNode(coolingPipe, 2, pipeTr2);
2799 14 : if (fCoolingOn) {
2800 14 : virtualSeg->AddNode(cooler, 1, pipeTr1);
2801 14 : virtualSeg->AddNode(cooler, 2, pipeTr2);
2802 14 : };
2803 14 : };
2804 :
2805 : //**********************************
2806 : // Bases of hybrid thermal bridges
2807 : //**********************************
2808 : Double_t shiftHyb = 1.05; // shift between thermal Bridge base and thermal bridge
2809 : // approx !!! not clear on 0752/14-A
2810 14 : if (fAddCoolingSyst) {
2811 14 : TGeoRotation rotHybrid1("", 0, 0, -90 - fgkHybridAngle);
2812 14 : TGeoRotation rotHybrid2("", 0 ,180, 90 - fgkHybridAngle);
2813 28 : TGeoCombiTrans *baseTr1 = new TGeoCombiTrans(*pipeTr2, rotHybrid1);
2814 28 : TGeoCombiTrans *baseTr2 = new TGeoCombiTrans(*pipeTr1, rotHybrid2);
2815 :
2816 14 : virtualSeg->AddNode(fBaseThermalBridge, 1, baseTr1);
2817 14 : virtualSeg->AddNode(fBaseThermalBridge, 2, baseTr2);
2818 14 : };
2819 :
2820 : //*************************
2821 : // the 2 hybrids :
2822 : //*************************
2823 14 : Double_t hybDy = ((TGeoXtru*)fHybrid->GetShape())->GetY(2);
2824 14 : Double_t distAxeToHybridCenter = fgkBTBaxisAtoBase+hybDy;
2825 :
2826 14 : Double_t hybrVolX = ( distAxeToHybridCenter*CosD(fgkHybridAngle)
2827 14 : - shiftHyb*SinD(fgkHybridAngle) );
2828 14 : Double_t hybrVolY = ( distAxeToHybridCenter*SinD(fgkHybridAngle)
2829 14 : + shiftHyb*CosD(fgkHybridAngle) );
2830 14 : if (fAddHybrids) {
2831 14 : TGeoRotation rotHybrid3("", 0, 0, 90. - fgkHybridAngle);
2832 14 : TGeoRotation rotHybrid4("", 0 ,180, -90. - fgkHybridAngle);
2833 28 : TGeoCombiTrans *hybTr1 = new TGeoCombiTrans(*pipeTr2, rotHybrid3);
2834 28 : TGeoCombiTrans *hybTr2 = new TGeoCombiTrans(*pipeTr1, rotHybrid4);
2835 14 : AddTranslationToCombiTrans( hybTr1, -hybrVolX, hybrVolY, 0);
2836 14 : AddTranslationToCombiTrans( hybTr2, hybrVolX, hybrVolY, 0);
2837 :
2838 14 : virtualSeg->AddNode(fHybrid, 1, hybTr1);
2839 14 : virtualSeg->AddNode(fHybrid, 2, hybTr2);
2840 14 : };
2841 :
2842 : //***********
2843 : // cables
2844 : //***********
2845 14 : if (fAddCables) {
2846 : // Starting from this segment
2847 14 : Double_t hybDz = ((TGeoXtru*)fHybrid->GetShape())->GetZ(1);
2848 14 : Double_t hybDx = ((TGeoXtru*)fHybrid->GetShape())->GetX(1);
2849 14 : Double_t posDigitCableAlongHyb = shiftHyb+ hybDx
2850 14 : - digitCableA->GetWidth()/2;
2851 14 : Double_t distAxeToDigitCableCenter = distAxeToHybridCenter+hybDy
2852 14 : - digitCableA->GetThickness()/2;
2853 :
2854 : Double_t digitCableX = ( coolPipeSuppL
2855 14 : + distAxeToDigitCableCenter*CosD(fgkHybridAngle)
2856 14 : - posDigitCableAlongHyb*SinD(fgkHybridAngle) );
2857 14 : Double_t digitCableY = ( - fgkLadderHeight/2.-TMath::Abs(tDY)
2858 14 : + fgkLadderBeamRadius+coolPipeSuppH
2859 14 : + distAxeToDigitCableCenter*SinD(fgkHybridAngle)
2860 14 : + posDigitCableAlongHyb*CosD(fgkHybridAngle) );
2861 :
2862 :
2863 28 : Double_t digitCableCenterA0[3]={ -cableSideSign*digitCableX,
2864 14 : digitCableY, cableSideSign*hybDz };
2865 56 : Double_t digitCableCenterA1[3] = {
2866 14 : -cableSideSign*(digitCableX+spaceForCables*CosD(fgkHybridAngle)),
2867 14 : digitCableY+spaceForCables*SinD(fgkHybridAngle),
2868 14 : cableSideSign*segmentLength/2 };
2869 :
2870 14 : Double_t digitCableCenterB0[3]={ cableSideSign*digitCableX,
2871 : digitCableY,cableSideSign*hybDz};
2872 42 : Double_t digitCableCenterB1[3]={
2873 14 : cableSideSign*(digitCableX+spaceForCables*CosD(fgkHybridAngle)),
2874 14 : digitCableY+spaceForCables*SinD(fgkHybridAngle),
2875 : cableSideSign*segmentLength/2 };
2876 :
2877 14 : Double_t vZ[3] = {0,0,1};
2878 14 : digitCableA[iSeg].AddCheckPoint( virtualSeg, 0, digitCableCenterA0, vZ);
2879 14 : digitCableA[iSeg].AddCheckPoint( virtualSeg, 1, digitCableCenterA1, vZ);
2880 14 : digitCableB[iSeg].AddCheckPoint( virtualSeg, 0, digitCableCenterB0, vZ);
2881 14 : digitCableB[iSeg].AddCheckPoint( virtualSeg, 1, digitCableCenterB1, vZ);
2882 :
2883 : // Updating the other cables
2884 64 : for (Int_t iCable=iUpdateCableMin; iCable<=iUpdateCableMax; iCable++) {
2885 :
2886 18 : Int_t iPoint = TMath::Abs(iCable-iSeg)+1;
2887 18 : Double_t coord[3];
2888 18 : digitCableA[iCable].GetPoint( 1, coord);
2889 18 : digitCableA[iCable].AddCheckPoint( virtualSeg, iPoint, coord, vZ);
2890 18 : digitCableB[iCable].GetPoint( 1, coord);
2891 18 : digitCableB[iCable].AddCheckPoint( virtualSeg, iPoint, coord, vZ);
2892 18 : };
2893 :
2894 : // Now the small Al foil on the same hybrid side
2895 14 : Double_t xfoil[5],yfoil[5];
2896 14 : hybDx *= 0.95;
2897 14 : xfoil[0] = -fgkHybridAlFoilWide/2;
2898 14 : yfoil[0] = hybDx;
2899 14 : xfoil[1] = fgkHybridAlFoilWide/2;
2900 14 : yfoil[1] = yfoil[0];
2901 14 : xfoil[2] = xfoil[1];
2902 14 : yfoil[2] = -hybDx + (fgkHybridAlFoilWide - fgkHybridAlFoilSide);
2903 14 : xfoil[3] = xfoil[0] + fgkHybridAlFoilSide;
2904 14 : yfoil[3] = -hybDx;
2905 14 : xfoil[4] = xfoil[0];
2906 14 : yfoil[4] = yfoil[3];
2907 :
2908 14 : TGeoXtru* alFoilSh = new TGeoXtru(2);
2909 14 : alFoilSh->DefinePolygon(5, xfoil, yfoil);
2910 14 : alFoilSh->DefineSection(0,-fgkHybridAlFoilThick/2);
2911 14 : alFoilSh->DefineSection(1, fgkHybridAlFoilThick/2);
2912 :
2913 14 : TGeoVolume* alFoilVol = new TGeoVolume("ITSsddAlFoilHybSide", alFoilSh, alSDD);
2914 14 : alFoilVol->SetLineColor(fColorAl);
2915 :
2916 14 : Double_t zFoilTrans = cableSideSign*(hybDz + alFoilSh->GetX(1));
2917 14 : TGeoRotation rotFoil3;
2918 14 : TGeoRotation rotFoil4;
2919 14 : if (cableSideSign > 0) {
2920 21 : rotFoil3 = TGeoRotation("", 90-fgkHybridAngle, -90, -90);
2921 21 : rotFoil4 = TGeoRotation("",-90+fgkHybridAngle, 90, 90);
2922 7 : } else {
2923 21 : rotFoil3 = TGeoRotation("", 90-fgkHybridAngle, 90, -90);
2924 21 : rotFoil4 = TGeoRotation("",-90+fgkHybridAngle, -90, 90);
2925 : }
2926 28 : TGeoCombiTrans *foiTr1 = new TGeoCombiTrans(*pipeTr2, rotFoil3);
2927 28 : TGeoCombiTrans *foiTr2 = new TGeoCombiTrans(*pipeTr1, rotFoil4);
2928 14 : AddTranslationToCombiTrans( foiTr1, -hybrVolX, hybrVolY, zFoilTrans);
2929 14 : AddTranslationToCombiTrans( foiTr2, hybrVolX, hybrVolY, zFoilTrans);
2930 :
2931 14 : virtualSeg->AddNode(alFoilVol, 1, foiTr1);
2932 14 : virtualSeg->AddNode(alFoilVol, 2, foiTr2);
2933 14 : };
2934 :
2935 : //**********************************
2936 14 : if(GetDebug(1)) virtualSeg->CheckOverlaps(0.01);
2937 14 : return virtualSeg;
2938 14 : }
2939 :
2940 :
2941 : //________________________________________________________________________
2942 : TGeoVolume* AliITSv11GeometrySDD::CreatePinSupport() {
2943 : //
2944 : // Create a pine support and its pine
2945 : // axis of rotation is the cone axis, center in its middle
2946 : //
2947 2 : TGeoMedium *rytonSDD = GetMedium("RYTON$");
2948 :
2949 2 : TGeoCone *cone = new TGeoCone("ITSsddPinSuppCone",fgkPinSuppHeight/2.,
2950 2 : 0,fgkPinSuppRmax,0,fgkPinSuppRmax-
2951 2 : fgkPinSuppHeight*TanD(fgkPinSuppConeAngle) );
2952 2 : TGeoBBox *tong = new TGeoBBox("ITSsddPinSuppTong",fgkPinSuppRmax,
2953 1 : fgkPinSuppLength/2.,fgkPinSuppThickness/2.);
2954 2 : TGeoTube *hole = new TGeoTube("ITSsddPinSuppHole",0,fgkPinR,
2955 1 : fgkPinSuppHeight/2.+0.00001);
2956 : // 0.00001 is for seing the actual hole (avoid viewer artefact)
2957 :
2958 1 : if(GetDebug(3)){// Remove compiler warning.
2959 0 : cone->InspectShape();
2960 0 : tong->InspectShape();
2961 0 : hole->InspectShape();
2962 0 : };
2963 :
2964 2 : TGeoTranslation *tongTrans = new TGeoTranslation("ITSsddPinSuppTongTr",0,
2965 1 : fgkPinSuppLength/2.,-fgkPinSuppHeight/2.+fgkPinSuppThickness/2.);
2966 1 : tongTrans->RegisterYourself();
2967 1 : TGeoCompositeShape *pinSupportShape = new TGeoCompositeShape(
2968 : "ITSsddPinSupportShape","(ITSsddPinSuppCone+"
2969 : "ITSsddPinSuppTong:ITSsddPinSuppTongTr)-ITSsddPinSuppHole");
2970 :
2971 1 : TGeoVolume *pinSupport = new TGeoVolume("ITSsddPinSupport", pinSupportShape,
2972 : rytonSDD);
2973 1 : pinSupport->SetLineColor(fColorRyton);
2974 :
2975 1 : return pinSupport;
2976 0 : }
2977 :
2978 :
2979 : //________________________________________________________________________
2980 : TGeoVolume* AliITSv11GeometrySDD::CreateCoolPipeSupportL() {
2981 : //
2982 : // Create half of the cooling pipe support (ALR-0752/3)
2983 : //
2984 :
2985 2 : Double_t diffX = fgkCoolPipeSuppHeight*TanD(fgkCoolPipeSuppAngle);
2986 :
2987 1 : TGeoArb8 *side1 = new TGeoArb8(fgkCoolPipeSuppHeight/2.);
2988 1 : side1->SetName("ITSsddCPSside1");
2989 1 : side1->SetVertex( 0, 0, -fgkCoolPipeSuppWidthExt/2.);
2990 1 : side1->SetVertex( 1, 0, fgkCoolPipeSuppWidthExt/2.);
2991 2 : side1->SetVertex( 2, fgkCoolPipeSuppMaxLength/2.-diffX,
2992 1 : fgkCoolPipeSuppWidthExt/2.);
2993 2 : side1->SetVertex( 3, fgkCoolPipeSuppMaxLength/2.-diffX,
2994 1 : -fgkCoolPipeSuppWidthExt/2.);
2995 1 : side1->SetVertex( 4, 0, -fgkCoolPipeSuppWidthExt/2.);
2996 1 : side1->SetVertex( 5, 0, fgkCoolPipeSuppWidthExt/2.);
2997 2 : side1->SetVertex( 6, fgkCoolPipeSuppMaxLength/2.,
2998 1 : fgkCoolPipeSuppWidthExt/2.);
2999 2 : side1->SetVertex( 7, fgkCoolPipeSuppMaxLength/2.,
3000 1 : -fgkCoolPipeSuppWidthExt/2.);
3001 :
3002 2 : TGeoTranslation *side1Tr = new TGeoTranslation("ITSsddCPStr1",0,
3003 1 : - fgkCoolPipeSuppAxeDist
3004 1 : + fgkCoolPipeSuppWidthExt/2., 0);
3005 1 : side1Tr->RegisterYourself();
3006 2 : TGeoTranslation *side2Tr = new TGeoTranslation("ITSsddCPStr2",0,
3007 1 : - fgkCoolPipeSuppAxeDist
3008 1 : + fgkCoolPipeSuppWidthExt*3/2.
3009 1 : + fgkCoolPipeSuppWidthIn,0);
3010 1 : side2Tr->RegisterYourself();
3011 :
3012 2 : TGeoBBox *middle = new TGeoBBox("ITSsddCPSmiddle",
3013 1 : (fgkCoolPipeSuppMaxLength/2.-fgkCoolPipeSuppSlitL)/2.,
3014 1 : fgkCoolPipeSuppWidthIn/2., fgkCoolPipeSuppHeight/2.);
3015 : TGeoTranslation *middleTr =
3016 2 : new TGeoTranslation("ITSsddCPStr3",
3017 1 : (fgkCoolPipeSuppMaxLength/2.-fgkCoolPipeSuppSlitL)/2.,
3018 1 : -fgkCoolPipeSuppAxeDist+fgkCoolPipeSuppWidthExt
3019 1 : +fgkCoolPipeSuppWidthIn/2., 0);
3020 1 : middleTr->RegisterYourself();
3021 :
3022 2 : TGeoBBox *axeBox = new TGeoBBox("ITSsddCPSaxeBox",
3023 1 : fgkCoolPipeSuppTongW/4.,
3024 1 : (fgkCoolPipeSuppFulWidth
3025 1 : - 2*fgkCoolPipeSuppWidthExt
3026 1 : - fgkCoolPipeSuppWidthIn)/2,
3027 1 : fgkCoolPipeSuppHeight/2.);
3028 :
3029 2 : TGeoTranslation *axeBoxTr = new TGeoTranslation("ITSsddCPSAxBoxTr",
3030 1 : fgkCoolPipeSuppTongW/4.,
3031 1 : - fgkCoolPipeSuppAxeDist
3032 1 : + fgkCoolPipeSuppFulWidth
3033 2 : - axeBox->GetDY(), 0);
3034 1 : axeBoxTr->RegisterYourself();
3035 :
3036 2 : TGeoTube *axe = new TGeoTube("ITSsddCPSaxe",0,fgkCoolPipeSuppHoleDiam/2.,
3037 1 : fgkCoolPipeSuppTongW/4.);
3038 :
3039 1 : TGeoRotation *axeRot = new TGeoRotation("ITSsddCPSaxeRot",90,90,0);
3040 2 : TGeoCombiTrans *axeTrans = new TGeoCombiTrans("ITSsddCPSaxeTr",
3041 1 : fgkCoolPipeSuppTongW/4.,0,0,axeRot);
3042 1 : axeTrans->RegisterYourself();
3043 : //delete axeRot; // make the code crash, no idea of why !!!
3044 :
3045 1 : if(GetDebug(3)){
3046 0 : middle->InspectShape();
3047 0 : axe->InspectShape();
3048 0 : };
3049 :
3050 1 : TGeoMedium *rytonSDD = GetMedium("RYTON$");
3051 :
3052 1 : TGeoCompositeShape *coolPipeSuppShape = new TGeoCompositeShape(
3053 : "ITSsddCoolPipeSuppShapeL",
3054 : "ITSsddCPSmiddle:ITSsddCPStr3"
3055 : "+ITSsddCPSside1:ITSsddCPStr1"
3056 : "+ITSsddCPSside1:ITSsddCPStr2"
3057 : "+ITSsddCPSaxeBox:ITSsddCPSAxBoxTr"
3058 : "-ITSsddCPSaxe:ITSsddCPSaxeTr");
3059 2 : TGeoVolume *coolPipeSupp = new TGeoVolume("ITSsddCoolPipeSupportL",
3060 1 : coolPipeSuppShape, rytonSDD);
3061 :
3062 1 : coolPipeSupp->SetLineColor(fColorRyton);
3063 :
3064 1 : return coolPipeSupp;
3065 0 : }
3066 :
3067 :
3068 : //________________________________________________________________________
3069 : TGeoVolume* AliITSv11GeometrySDD::CreateCoolPipeSupportR() {
3070 : //
3071 : //Create half of the cooling pipe support (ALR-0752/3)
3072 : //
3073 :
3074 2 : Double_t diffX = fgkCoolPipeSuppHeight*TanD(fgkCoolPipeSuppAngle);
3075 :
3076 1 : TGeoArb8 *side1 = new TGeoArb8(fgkCoolPipeSuppHeight/2.);
3077 1 : side1->SetName("ITSsddCPSside1R");
3078 1 : side1->SetVertex( 0, 0, -fgkCoolPipeSuppWidthExt/2.);
3079 2 : side1->SetVertex( 1, -(fgkCoolPipeSuppMaxLength/2.-diffX),
3080 1 : -fgkCoolPipeSuppWidthExt/2.);
3081 2 : side1->SetVertex( 2, -(fgkCoolPipeSuppMaxLength/2.-diffX),
3082 1 : fgkCoolPipeSuppWidthExt/2.);
3083 1 : side1->SetVertex( 3, 0, fgkCoolPipeSuppWidthExt/2.);
3084 1 : side1->SetVertex( 4, 0, -fgkCoolPipeSuppWidthExt/2.);
3085 2 : side1->SetVertex( 5, -fgkCoolPipeSuppMaxLength/2.,
3086 1 : -fgkCoolPipeSuppWidthExt/2.);
3087 2 : side1->SetVertex( 6, -fgkCoolPipeSuppMaxLength/2.,
3088 1 : fgkCoolPipeSuppWidthExt/2.);
3089 1 : side1->SetVertex( 7, 0, fgkCoolPipeSuppWidthExt/2.);
3090 :
3091 2 : TGeoTranslation *side1Tr = new TGeoTranslation("ITSsddCPStr1R",0,
3092 1 : - fgkCoolPipeSuppAxeDist
3093 1 : + fgkCoolPipeSuppWidthExt/2., 0);
3094 1 : side1Tr->RegisterYourself();
3095 2 : TGeoTranslation *side2Tr = new TGeoTranslation("ITSsddCPStr2R",0,
3096 1 : - fgkCoolPipeSuppAxeDist
3097 1 : + fgkCoolPipeSuppWidthExt*3/2.
3098 1 : + fgkCoolPipeSuppWidthIn, 0);
3099 1 : side2Tr->RegisterYourself();
3100 :
3101 2 : TGeoBBox *middle = new TGeoBBox("ITSsddCPSmiddleR",
3102 1 : (fgkCoolPipeSuppMaxLength/2.
3103 1 : - fgkCoolPipeSuppSlitL)/2.,
3104 1 : fgkCoolPipeSuppWidthIn/2.,
3105 1 : fgkCoolPipeSuppHeight/2.);
3106 : TGeoTranslation *middleTr =
3107 2 : new TGeoTranslation("ITSsddCPStr3R",
3108 2 : -( fgkCoolPipeSuppMaxLength/2.
3109 2 : -fgkCoolPipeSuppSlitL)/2.,
3110 1 : -fgkCoolPipeSuppAxeDist + fgkCoolPipeSuppWidthExt
3111 1 : + fgkCoolPipeSuppWidthIn/2.,0);
3112 1 : middleTr->RegisterYourself();
3113 :
3114 2 : TGeoBBox *axeBox = new TGeoBBox("ITSsddCPSaxeBoxR",
3115 1 : fgkCoolPipeSuppTongW/4.,
3116 1 : (fgkCoolPipeSuppFulWidth
3117 1 : - 2*fgkCoolPipeSuppWidthExt
3118 1 : - fgkCoolPipeSuppWidthIn)/2,
3119 1 : fgkCoolPipeSuppHeight/2.);
3120 :
3121 2 : TGeoTranslation *axeBoxTr = new TGeoTranslation("ITSsddCPSAxBoxTrR",
3122 1 : - fgkCoolPipeSuppTongW/4.,
3123 1 : - fgkCoolPipeSuppAxeDist
3124 1 : + fgkCoolPipeSuppFulWidth
3125 2 : - axeBox->GetDY(),0);
3126 1 : axeBoxTr->RegisterYourself();
3127 :
3128 2 : TGeoTube *axe = new TGeoTube("ITSsddCPSaxeR",0,fgkCoolPipeSuppHoleDiam/2.,
3129 1 : fgkCoolPipeSuppTongW/4.);
3130 :
3131 1 : TGeoRotation *axeRot = new TGeoRotation("ITSsddCPSaxeRotR",90,90,0);
3132 2 : TGeoCombiTrans *axeTrans = new TGeoCombiTrans("ITSsddCPSaxeTrR",
3133 1 : -fgkCoolPipeSuppTongW/4.,0,0,axeRot);
3134 1 : axeTrans->RegisterYourself();
3135 : //delete axeRot;
3136 :
3137 1 : if(GetDebug(3)){
3138 0 : middle->InspectShape();
3139 0 : axe->InspectShape();
3140 0 : };
3141 :
3142 1 : TGeoCompositeShape *coolPipeSuppShape = new TGeoCompositeShape(
3143 : "ITSsddCoolPipeSuppShapeR",
3144 : "ITSsddCPSmiddleR:ITSsddCPStr3R"
3145 : "+ITSsddCPSside1R:ITSsddCPStr1R"
3146 : "+ITSsddCPSside1R:ITSsddCPStr2R"
3147 : "+ITSsddCPSaxeBoxR:ITSsddCPSAxBoxTrR"
3148 : "-ITSsddCPSaxeR:ITSsddCPSaxeTrR");
3149 :
3150 1 : TGeoMedium *rytonSDD = GetMedium("RYTON$");
3151 2 : TGeoVolume *coolPipeSupp = new TGeoVolume( "ITSsddCoolPipeSupportR",
3152 1 : coolPipeSuppShape, rytonSDD);
3153 1 : coolPipeSupp->SetLineColor(fColorRyton);
3154 :
3155 1 : return coolPipeSupp;
3156 0 : }
3157 :
3158 : //________________________________________________________________________
3159 : TGeoVolume* AliITSv11GeometrySDD::CreateBaseThermalBridge() {
3160 : //
3161 : // based on ALR 0752/8
3162 : //
3163 :
3164 2 : Double_t dy = fgkBTBaxisAtoBase - fgkRadiusBminBTB - fgkBTBthick;
3165 :
3166 1 : Double_t base1width = fgkBTBwidth - fgkBTBaxisAtoBottom - fgkRadiusBminBTB
3167 1 : - (fgkRadiusAminBTB+fgkBTBthick);
3168 2 : TGeoBBox *base1 = new TGeoBBox( "ITSsddBTBbase1", base1width/2.,
3169 1 : fgkBTBthick/2., fgkBTBlength/2.);
3170 2 : TGeoTranslation *base1Tr = new TGeoTranslation("ITSsddBTBtr1",
3171 1 : fgkBTBaxisAtoBottom-fgkBTBwidth+base1width/2.,
3172 1 : -(fgkBTBaxisAtoBase-fgkBTBthick/2.), 0);
3173 1 : base1Tr->RegisterYourself();
3174 :
3175 1 : Double_t base2width = fgkBTBaxisAtoBottom - fgkRadiusAminBTB - fgkBTBthick
3176 1 : - fgkRadiusBminBTB;
3177 2 : TGeoBBox *base2 = new TGeoBBox( "ITSsddBTBbase2", base2width/2.,
3178 1 : fgkBTBthick/2., fgkBTBlength/2.);
3179 2 : TGeoTranslation *base2Tr = new TGeoTranslation("ITSsddBTBtr2",
3180 1 : fgkBTBaxisAtoBottom - base2width/2.,
3181 1 : -(fgkBTBaxisAtoBase-fgkBTBthick/2.), 0);
3182 1 : base2Tr->RegisterYourself();
3183 :
3184 2 : TGeoBBox *side = new TGeoBBox( "ITSsddBTBside",
3185 1 : fgkBTBthick/2., dy/2., fgkBTBlength/2.);
3186 2 : TGeoTranslation *sideTr1 = new TGeoTranslation("ITSsddBTBsideTr1",
3187 1 : -fgkRadiusAminBTB-fgkBTBthick/2., -dy/2., 0);
3188 2 : TGeoTranslation *sideTr2 = new TGeoTranslation("ITSsddBTBsideTr2",
3189 1 : fgkRadiusAminBTB+fgkBTBthick/2., -dy/2., 0);
3190 1 : sideTr1->RegisterYourself();
3191 1 : sideTr2->RegisterYourself();
3192 :
3193 2 : TGeoBBox *hole = new TGeoBBox( "ITSsddBTBhole", fgkBTBHolewidth/2.,
3194 1 : fgkBTBthick/2., fgkBTBHoleLength/2.);
3195 2 : TGeoTranslation *holeTr1 = new TGeoTranslation("ITSsddBTBholeTr1",
3196 1 : - fgkBTBHoleRefX + fgkBTBHolewidth/2.,
3197 1 : - (fgkBTBaxisAtoBase-fgkBTBthick/2.),
3198 1 : fgkBTBHoleRefY+(fgkBTBHoleLength-fgkBTBlength)/2.);
3199 2 : TGeoTranslation *holeTr2 = new TGeoTranslation("ITSsddBTBholeTr2",
3200 1 : - fgkBTBHoleRefX + fgkBTBHolewidth/2.,
3201 1 : - (fgkBTBaxisAtoBase-fgkBTBthick/2.),
3202 1 : - fgkBTBHoleRefY-(fgkBTBHoleLength-fgkBTBlength)/2.);
3203 1 : holeTr1->RegisterYourself();
3204 1 : holeTr2->RegisterYourself();
3205 :
3206 1 : Double_t radiusAmaxBTB = fgkRadiusAminBTB + fgkBTBthick;
3207 2 : TGeoTubeSeg *mainAxis = new TGeoTubeSeg( "ITSsddBTBmainAxis",
3208 1 : fgkRadiusAminBTB, radiusAmaxBTB,
3209 1 : fgkBTBlength/2., 0., 180.);
3210 2 : TGeoTubeSeg *round1 = new TGeoTubeSeg( "ITSsddBTBround1",
3211 1 : fgkRadiusBminBTB, fgkRadiusBminBTB+fgkBTBthick,
3212 1 : fgkBTBlength/2., 270., 360.);
3213 2 : TGeoTranslation *roundTr1 = new TGeoTranslation("ITSsddBTBround1Tr",
3214 1 : -(fgkRadiusAminBTB+fgkBTBthick+fgkRadiusBminBTB),
3215 : -dy, 0);
3216 1 : roundTr1->RegisterYourself();
3217 :
3218 2 : TGeoTubeSeg *round2 = new TGeoTubeSeg( "ITSsddBTBround2",
3219 1 : fgkRadiusBminBTB, fgkRadiusBminBTB+fgkBTBthick,
3220 1 : fgkBTBlength/2., 180., 270.);
3221 2 : TGeoTranslation *roundTr2 = new TGeoTranslation("ITSsddBTBround2Tr",
3222 1 : (fgkRadiusAminBTB+fgkBTBthick+fgkRadiusBminBTB),
3223 : -dy, 0);
3224 1 : roundTr2->RegisterYourself();
3225 :
3226 1 : TGeoCompositeShape *sBaseThermalBridge = new TGeoCompositeShape(
3227 : "ITSsddBaseThermalBridgeShape",
3228 : "ITSsddBTBbase1:ITSsddBTBtr1"
3229 : "+ ITSsddBTBbase2:ITSsddBTBtr2"
3230 : "+ ITSsddBTBround1:ITSsddBTBround1Tr"
3231 : "+ ITSsddBTBround2:ITSsddBTBround2Tr"
3232 : "+ ITSsddBTBside:ITSsddBTBsideTr1"
3233 : "+ ITSsddBTBside:ITSsddBTBsideTr2"
3234 : "- ITSsddBTBhole:ITSsddBTBholeTr1"
3235 : "- ITSsddBTBhole:ITSsddBTBholeTr2"
3236 : "+ ITSsddBTBmainAxis");
3237 :
3238 1 : if(GetDebug(3)){// Remove compiler warning.
3239 0 : base1->InspectShape();
3240 0 : base2->InspectShape();
3241 0 : side->InspectShape();
3242 0 : hole->InspectShape();
3243 0 : mainAxis->InspectShape();
3244 0 : round1->InspectShape();
3245 0 : round2->InspectShape();
3246 0 : };
3247 :
3248 1 : TGeoMedium *carbonFiberLadderStruct = GetMedium("SDD C AL (M55J)$");
3249 2 : TGeoVolume *vBaseThermalBridge = new TGeoVolume( "ITSsddBaseThermalBridge",
3250 1 : sBaseThermalBridge,
3251 : carbonFiberLadderStruct);
3252 :
3253 1 : vBaseThermalBridge->SetLineColor(fColorCarbonFiber);
3254 1 : return vBaseThermalBridge;
3255 0 : }
3256 :
3257 :
3258 : //________________________________________________________________________
3259 : TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateEndLadder(Int_t iLay) {
3260 : //
3261 : // Return an assembly containing a end of a CF ladder.
3262 : //
3263 :
3264 4 : TGeoMedium *carbonFiberLadderStruct = GetMedium("SDD C AL (M55J)$"); // ITSsddCarbonM55J
3265 2 : TGeoMedium *stesalite = GetMedium("G10FR4$");
3266 2 : TGeoMedium *phynoxSDD = GetMedium("INOX$");
3267 2 : TGeoMedium *coolerMediumSDD = GetMedium("WATER$");
3268 :
3269 2 : Double_t length = (fgkLay3LadderLength-fgkLay3Ndet*fgkSegmentLength)/2.;
3270 2 : Double_t coolPipeSuppH = fgkLay3CoolPipeSuppH;
3271 2 : Double_t underSegDH = fLay3LadderUnderSegDH;
3272 2 : Double_t footDZ = fgkRubyZladd3 - fgkLay3Ndet*fgkSegmentLength/2 - length/2;
3273 : // footDZ is also where to place the ruby's center in local Z
3274 2 : Double_t coolPipeEndLen = (fgkCoolPipeLay3Len-fgkSegmentLength*fgkLay3Ndet)/2;
3275 :
3276 2 : if (iLay==3) {
3277 1 : } else if (iLay==4) {
3278 1 : length = (fgkLay4LadderLength-fgkLay4Ndet*fgkSegmentLength)/2.;
3279 1 : coolPipeSuppH = fgkLay4CoolPipeSuppH;
3280 1 : underSegDH = fLay4LadderUnderSegDH;
3281 1 : footDZ = fgkRubyZladd4 - fgkLay4Ndet*fgkSegmentLength/2 - length/2;
3282 1 : coolPipeEndLen = (fgkCoolPipeLay4Len-fgkSegmentLength*fgkLay4Ndet)/2;
3283 : } else {
3284 0 : printf("error in AliITSv11GeometrySDD::CreateEndLadder: Wrong layer");
3285 0 : return 0;
3286 : };
3287 :
3288 2 : Double_t tDY = (- fgkLadderSegBoxDH/2 //space left on top of the ladder
3289 2 : + underSegDH/2); //space under ladder segment
3290 : // here tDY is not the same as for the segment because the end ladder
3291 : // does not have a space under it, inside the general ladder volume.
3292 2 : Double_t segmentLength = fgkSegmentLength;
3293 2 : Double_t topCornerLength = fgkSegmentLength/2.-fgkLay4LaddTopCornerEnd;
3294 :
3295 2 : TGeoVolumeAssembly *virtualEnd = new TGeoVolumeAssembly("ITSsddEnd");
3296 :
3297 : //**********************************
3298 : // coding real matter :
3299 : //**********************************
3300 2 : Double_t triangleHeight = fgkLadderHeight - fgkLadderBeamRadius;
3301 2 : Double_t halfTheta = TMath::ATan( 0.5*fgkLadderWidth/triangleHeight );
3302 2 : Double_t beta = (TMath::Pi()-2.*halfTheta)/4.;
3303 2 : Double_t alpha = TMath::Pi()*3./4. - halfTheta/2.;
3304 :
3305 : //--- The 3 V shape corners of the Carbon Fiber Ladder
3306 : //--- the top V
3307 2 : TGeoArb8 *cfLaddTop1 = CreateLadderSide("CFladdTopCornerV1shape",
3308 2 : topCornerLength/2., halfTheta, -1,
3309 2 : fgkLadderLa, fgkLadderHa, fgkLadderl);
3310 4 : TGeoVolume *cfLaddTopVol1 = new TGeoVolume("ITSsddCFladdTopCornerV1",
3311 2 : cfLaddTop1,carbonFiberLadderStruct);
3312 2 : cfLaddTopVol1->SetLineColor(fColorCarbonFiber);
3313 2 : TGeoArb8 *cfLaddTop2 = CreateLadderSide( "CFladdTopCornerV2shape",
3314 : topCornerLength/2., halfTheta, 1,
3315 2 : fgkLadderLa, fgkLadderHa, fgkLadderl);
3316 4 : TGeoVolume *cfLaddTopVol2 = new TGeoVolume("ITSsddCFladdTopCornerV2",
3317 2 : cfLaddTop2,carbonFiberLadderStruct);
3318 2 : cfLaddTopVol2->SetLineColor(fColorCarbonFiber);
3319 4 : TGeoTranslation *trTop1 = new TGeoTranslation(0, fgkLadderHeight/2+tDY,
3320 2 : -(length-topCornerLength)/2.);
3321 2 : virtualEnd->AddNode(cfLaddTopVol1, 1, trTop1);
3322 2 : virtualEnd->AddNode(cfLaddTopVol2, 1, trTop1);
3323 :
3324 : //--- the 2 side V
3325 2 : TGeoArb8 *cfLaddSide1 = CreateLadderSide( "CFladdSideCornerV1shape",
3326 2 : length/2., beta, -1,
3327 2 : fgkLadderLb, fgkLadderHb, fgkLadderl);
3328 4 : TGeoVolume *cfLaddSideVol1 = new TGeoVolume("ITSsddCFladdSideCornerV1",
3329 2 : cfLaddSide1,carbonFiberLadderStruct);
3330 2 : cfLaddSideVol1->SetLineColor(fColorCarbonFiber);
3331 2 : TGeoArb8 *cfLaddSide2 = CreateLadderSide( "CFladdSideCornerV2shape",
3332 : length/2., beta, 1,
3333 2 : fgkLadderLb, fgkLadderHb, fgkLadderl);
3334 4 : TGeoVolume *cfLaddSideVol2 = new TGeoVolume("ITSsddCFladdSideCornerV2",
3335 2 : cfLaddSide2,carbonFiberLadderStruct);
3336 2 : cfLaddSideVol2->SetLineColor(fColorCarbonFiber);
3337 4 : Double_t dYTranslation = ( fgkLadderHeight/2. - 0.5*fgkLadderWidth*
3338 4 : TMath::Tan(beta) - fgkLadderBeamRadius );
3339 :
3340 : // because center of the triangle doesn't correspond to virtual vol. center
3341 2 : Double_t distCenterSideDown = 0.5*fgkLadderWidth/TMath::Cos(beta);
3342 2 : TGeoCombiTrans *ctSideR = CreateCombiTrans("", distCenterSideDown, 0,
3343 2 : alpha*TMath::RadToDeg());
3344 2 : AddTranslationToCombiTrans(ctSideR, 0, -dYTranslation+tDY, 0);
3345 2 : TGeoCombiTrans *ctSideL = CreateCombiTrans("", distCenterSideDown, 0,
3346 2 : -alpha*TMath::RadToDeg());
3347 2 : AddTranslationToCombiTrans(ctSideL, 0, -dYTranslation+tDY, 0);
3348 2 : virtualEnd->AddNode(cfLaddSideVol1, 1, ctSideR);
3349 2 : virtualEnd->AddNode(cfLaddSideVol2, 1, ctSideR);
3350 2 : virtualEnd->AddNode(cfLaddSideVol1, 2, ctSideL);
3351 2 : virtualEnd->AddNode(cfLaddSideVol2, 2, ctSideL);
3352 :
3353 : //--- The beams
3354 : // Beams on the sides
3355 6 : Double_t beamPhiPrime = TMath::ASin(1./TMath::Sqrt( (1+TMath::Sin(2*beta)*
3356 4 : TMath::Sin(2*beta)/(TanD(fgkBeamSidePhi)*TanD(fgkBeamSidePhi))) ));
3357 :
3358 : //Euler rotation : about Z, then new X, then new Z
3359 4 : TGeoRotation *beamRot1 = new TGeoRotation("", 90-2.*beta*TMath::RadToDeg(),
3360 2 : -beamPhiPrime*TMath::RadToDeg(), -90);
3361 4 : TGeoRotation *beamRot2 = new TGeoRotation("", 90-2.*beta*TMath::RadToDeg(),
3362 2 : beamPhiPrime*TMath::RadToDeg(), -90);
3363 4 : TGeoRotation *beamRot3 = new TGeoRotation("", 90+2.*beta*TMath::RadToDeg(),
3364 2 : beamPhiPrime*TMath::RadToDeg(), -90);
3365 4 : TGeoRotation *beamRot4 = new TGeoRotation("", 90+2.*beta*TMath::RadToDeg(),
3366 2 : -beamPhiPrime*TMath::RadToDeg(), -90);
3367 6 : TGeoCombiTrans *beamTransf1 = new TGeoCombiTrans(0.5*triangleHeight*
3368 2 : TMath::Tan(halfTheta),
3369 2 : fgkLadderBeamRadius/2. + tDY,
3370 2 : -length/2 + segmentLength/8, beamRot1);
3371 6 : TGeoCombiTrans *beamTransf3 = new TGeoCombiTrans( 0.5*triangleHeight*
3372 2 : TMath::Tan(halfTheta),
3373 2 : fgkLadderBeamRadius/2.+tDY,
3374 2 : -length/2 + 3*segmentLength/8, beamRot2);
3375 6 : TGeoCombiTrans *beamTransf5 = new TGeoCombiTrans(-0.5*triangleHeight*
3376 2 : TMath::Tan(halfTheta),
3377 2 : fgkLadderBeamRadius/2.+tDY,
3378 : -length/2 + segmentLength/8, beamRot3);
3379 6 : TGeoCombiTrans *beamTransf7 = new TGeoCombiTrans(-0.5*triangleHeight*
3380 2 : TMath::Tan(halfTheta),
3381 2 : fgkLadderBeamRadius/2. + tDY,
3382 : -length/2+3*segmentLength/8, beamRot4);
3383 :
3384 2 : virtualEnd->AddNode(fLaddSegCommonVol[6], 1, beamTransf1);
3385 2 : virtualEnd->AddNode(fLaddSegCommonVol[6], 2, beamTransf3);
3386 2 : virtualEnd->AddNode(fLaddSegCommonVol[6], 3, beamTransf5);
3387 2 : virtualEnd->AddNode(fLaddSegCommonVol[6], 4, beamTransf7);
3388 :
3389 : //--- Beams of the bottom
3390 2 : TGeoRotation *bottomBeamRot1 = new TGeoRotation("",90, 90, 90);
3391 :
3392 : /* Not there actually
3393 : TGeoTubeSeg *bottomBeam1 = new TGeoTubeSeg(0, fgkLadderBeamRadius,
3394 : fgkLadderWidth/2.-fgkLadderLb/3, 0, 180);
3395 : TGeoVolume *bottomBeam1Vol = new TGeoVolume("ITSsddBottomBeam1Vol",
3396 : bottomBeam1, carbonFiberLadderStruct);
3397 : bottomBeam1Vol->SetLineColor(fColorCarbonFiber);
3398 :
3399 : TGeoCombiTrans *bottomBeamTransf1 = new TGeoCombiTrans(0,
3400 : -(fgkLadderHeight/2-fgkLadderBeamRadius)+tDY,
3401 : -length/2+fgkSegmentLength/2, bottomBeamRot1);
3402 : virtualEnd->AddNode(bottomBeam1Vol, 1, bottomBeamTransf1);
3403 : */
3404 4 : TGeoTubeSeg *bottomBeam2 = new TGeoTubeSeg(0, fgkLadderBeamRadius,
3405 2 : fgkLadderWidth/2.-fgkLadderLb/3, 0, 90);
3406 4 : TGeoVolume *bottomBeam2Vol = new TGeoVolume("ITSsddBottomBeam2Vol",
3407 2 : bottomBeam2, carbonFiberLadderStruct);
3408 2 : bottomBeam2Vol->SetLineColor(fColorCarbonFiber);
3409 4 : TGeoCombiTrans *bottomBeamTransf2 = new TGeoCombiTrans(0,
3410 2 : -(fgkLadderHeight/2-fgkLadderBeamRadius)+tDY,-length/2,bottomBeamRot1);
3411 2 : virtualEnd->AddNode(bottomBeam2Vol, 1, bottomBeamTransf2);
3412 :
3413 : //**********************************
3414 : //the cooling pipe supports
3415 4 : Double_t triangleCPaxeDist = fgkCoolPipeSuppAxeDist-fgkCoolPipeSuppWidthExt-
3416 4 : fgkCoolPipeSuppWidthIn+fgkLadderBeamRadius;
3417 :
3418 4 : Double_t coolPipeSuppL = TMath::Tan(halfTheta)*
3419 2 : (triangleHeight+triangleCPaxeDist/
3420 4 : TMath::Sin(halfTheta)-coolPipeSuppH);
3421 :
3422 2 : if (fAddCoolingSyst) {
3423 2 : TGeoRotation *rotCPS2 = new TGeoRotation("",-halfTheta*TMath::RadToDeg(),-90, 90);
3424 2 : TGeoRotation *rotCPS1 = new TGeoRotation("", halfTheta*TMath::RadToDeg(),-90,-90);
3425 4 : TGeoCombiTrans *transCPS1 = new TGeoCombiTrans(coolPipeSuppL,
3426 2 : -fgkLadderHeight/2.+ tDY +
3427 2 : coolPipeSuppH+fgkLadderBeamRadius,
3428 : -length/2., rotCPS1);
3429 4 : TGeoCombiTrans *transCPS4 = new TGeoCombiTrans(-coolPipeSuppL,
3430 2 : -fgkLadderHeight/2.+ tDY +
3431 2 : coolPipeSuppH+fgkLadderBeamRadius,
3432 : -length/2., rotCPS2);
3433 :
3434 2 : virtualEnd->AddNode(fCoolPipeSupportL, 1, transCPS1);
3435 2 : virtualEnd->AddNode(fCoolPipeSupportR, 1, transCPS4);
3436 2 : };
3437 :
3438 : //**********************************
3439 : //--- The stesalite foot of the ladder
3440 :
3441 2 : Double_t footDY = -(fgkLadderHeight/2-fgkLadderBeamRadius)+tDY
3442 2 : - fgkLadFootY/2+fgkLadFingerPrintY;
3443 :
3444 2 : TGeoTranslation *footTr = new TGeoTranslation("SDDfootTr",0,footDY,footDZ);
3445 2 : virtualEnd->AddNode(fLadderFoot, 1, footTr);
3446 :
3447 : //=====================================
3448 : //--- cooling pipe
3449 :
3450 2 : if (fAddCoolingSyst) {
3451 :
3452 4 : TGeoTranslation *pipeTr1 = new TGeoTranslation(coolPipeSuppL,
3453 2 : -fgkLadderHeight/2.+ tDY +
3454 2 : coolPipeSuppH + fgkLadderBeamRadius,
3455 2 : -length/2.+coolPipeEndLen/2.);
3456 4 : TGeoTranslation *pipeTr2 = new TGeoTranslation(-coolPipeSuppL,
3457 4 : -fgkLadderHeight/2. + tDY +
3458 4 : fgkLadderBeamRadius + coolPipeSuppH,
3459 : -length/2.+coolPipeEndLen/2.);
3460 :
3461 4 : TGeoTube *coolingPipeShape = new TGeoTube( fgkCoolPipeInnerDiam/2,
3462 2 : fgkCoolPipeOuterDiam/2,
3463 : coolPipeEndLen/2);
3464 2 : TGeoTube *coolerShape = new TGeoTube( 0, fgkCoolPipeInnerDiam/2,
3465 : coolPipeEndLen/2);
3466 :
3467 4 : TGeoVolume *coolingPipe = new TGeoVolume("ITSsddCoolingPipeEnd",
3468 2 : coolingPipeShape, phynoxSDD );
3469 2 : coolingPipe->SetLineColor(fColorPhynox);
3470 2 : TGeoVolume *cooler = new TGeoVolume("ITSsddCoolingEndLiquid",coolerShape,
3471 : coolerMediumSDD );
3472 :
3473 2 : virtualEnd->AddNode(coolingPipe, 1, pipeTr1);
3474 2 : virtualEnd->AddNode(coolingPipe, 2, pipeTr2);
3475 2 : if (fCoolingOn) {
3476 2 : virtualEnd->AddNode(cooler, 1, pipeTr1);
3477 2 : virtualEnd->AddNode(cooler, 2, pipeTr2);
3478 2 : };
3479 2 : };
3480 :
3481 : //=====================================
3482 : //--- HV cable guide
3483 :
3484 :
3485 4 : TGeoBBox* guideHVbox = new TGeoBBox("guideHVbox",fgkHVguideX1/2,
3486 2 : fgkHVguideY1/2,fgkHVguideZ1/2);
3487 2 : TGeoVolume *guideHV = new TGeoVolume("guideHV",guideHVbox,stesalite);
3488 :
3489 4 : TGeoTranslation* guideHVtr = new TGeoTranslation(fgkHVguideDX,
3490 2 : -(fgkLadderHeight/2-fgkLadderBeamRadius)+tDY-fgkHVguideY1/2,
3491 2 : footDZ+fgkLadFootZ/2+fgkHVguideZ1/2-(fgkHVguideSuppFullZ-fgkHVguideZ2));
3492 2 : virtualEnd->AddNode(guideHV, 1, guideHVtr);
3493 :
3494 : //=====================================
3495 : //--- raccordo
3496 2 : Double_t raccordFullLen = fgkConnectorCoolTubeL1+fgkConnectorCoolTubeL2+fgkConnectorCoolTubeL3;
3497 4 : TGeoTranslation *trRaccordo1 = new TGeoTranslation("trRaccordo1",-coolPipeSuppL,
3498 2 : -fgkLadderHeight/2.+ tDY +
3499 2 : coolPipeSuppH+fgkLadderBeamRadius,
3500 2 : -length/2.+coolPipeEndLen+raccordFullLen/2);
3501 4 : TGeoTranslation *trRaccordo2 = new TGeoTranslation("trRaccordo2", coolPipeSuppL,
3502 2 : -fgkLadderHeight/2.+ tDY +
3503 2 : coolPipeSuppH+fgkLadderBeamRadius,
3504 : -length/2.+coolPipeEndLen+raccordFullLen/2);
3505 :
3506 2 : virtualEnd->AddNode(fRaccordoL, 1, trRaccordo1);
3507 2 : virtualEnd->AddNode(fRaccordoL, 2, trRaccordo2);
3508 :
3509 2 : virtualEnd->GetShape()->ComputeBBox(); //RS: enforce recompting of BBox
3510 :
3511 2 : if(GetDebug(1)) virtualEnd->CheckOverlaps(0.01);
3512 :
3513 : return virtualEnd;
3514 2 : }
3515 :
3516 : //________________________________________________________________________
3517 : TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateLadderFoot() {
3518 :
3519 : //--- The stesalite foot of the ladder
3520 : // Are missing :
3521 : // The 2 screw holes on the left part
3522 : // the small holes at each corner of the ruby cage (diam 2mm)
3523 : // the really small level difference of 0.3mm on the bottom
3524 :
3525 :
3526 2 : TGeoMedium *stesalite = GetMedium("G10FR4$");
3527 :
3528 1 : TGeoVolumeAssembly *virtualFoot = new TGeoVolumeAssembly("ITSsddFoot");
3529 :
3530 : Double_t epsilon = 2e-10;
3531 2 : TGeoBBox *ladFootBox1 = new TGeoBBox("ladFootBox1",fgkLadBox1X/2, fgkLadFootY/2,
3532 1 : fgkLadFootZ/2);
3533 2 : TGeoTranslation *ladFootBox1Tr = new TGeoTranslation("ladFootBox1Tr",
3534 1 : fgkLadFootX/2-fgkLadBox1X/2,0,0);
3535 2 : TGeoBBox *ladFingerPrint = new TGeoBBox("ladFingerPrint",fgkLadFingerPrintX/2,
3536 1 : fgkLadFingerPrintY/2+epsilon, fgkLadFootZ/2+epsilon);
3537 :
3538 2 : TGeoTranslation *ladFingerPrintTr = new TGeoTranslation("ladFingerPrintTr",
3539 1 : fgkLadFootX/2-fgkLadFingerPrintBorder-fgkLadFingerPrintX/2,
3540 1 : fgkLadFootY/2-fgkLadFingerPrintY/2+epsilon,
3541 : 0);
3542 :
3543 2 : TGeoBBox *rubyCageHole = new TGeoBBox("rubyCageHole",fgkRubyCageHoleX/2,
3544 1 : fgkRubyCageHoleY/2+epsilon, fgkRubyCageHoleZ/2);
3545 :
3546 2 : TGeoTranslation *rubyCageHoleTr = new TGeoTranslation("rubyCageHoleTr",
3547 1 : fgkLadFootX/2-(fgkLadFootX/2-fgkRubyDX)+fgkRubyCageAxisShift,
3548 1 : fgkLadFootY/2-fgkRubyCageHoleY/2,0);
3549 :
3550 1 : double rubyScrewHoleLen = fgkLadFootX/2-fgkRubyDX;
3551 2 : TGeoTube *rubyScrewHole = new TGeoTube("rubyScrewHole", 0,fgkScrewM4diam/2,
3552 1 : rubyScrewHoleLen/2);
3553 :
3554 1 : TGeoRotation *rot9090 = new TGeoRotation("",90,90,0);
3555 2 : TGeoCombiTrans *rubyScrewHoleTr = new TGeoCombiTrans("rubyScrewHoleTr",
3556 1 : fgkLadFootX/2-rubyScrewHoleLen/2,
3557 : -fgkRubyScrewShiftToCenterY, 0, rot9090);
3558 :
3559 1 : Double_t rubyHoleLen = fgkLadFootY-fgkRubyCageHoleY;
3560 2 : TGeoTube *rubyHole = new TGeoTube("rubyHole", 0,fgkRubyHoleDiam/2,
3561 1 : rubyHoleLen/2);
3562 :
3563 1 : TGeoRotation *rot90 = new TGeoRotation("",0,90,0);
3564 2 : TGeoCombiTrans *rubyHoleTr = new TGeoCombiTrans("rubyHoleTr", fgkRubyDX,
3565 1 : -(fgkLadFootY-rubyHoleLen)/2, 0, rot90);
3566 :
3567 1 : ladFootBox1Tr->RegisterYourself();
3568 1 : ladFingerPrintTr->RegisterYourself();
3569 1 : rubyCageHoleTr->RegisterYourself();
3570 1 : rubyScrewHoleTr->RegisterYourself();
3571 1 : rubyHoleTr->RegisterYourself();
3572 :
3573 1 : TGeoCompositeShape *footRightPart = new TGeoCompositeShape(
3574 : "ladFootBox1:ladFootBox1Tr-(ladFingerPrint:ladFingerPrintTr"
3575 : "+rubyCageHole:rubyCageHoleTr+rubyScrewHole:rubyScrewHoleTr"
3576 : "+rubyHole:rubyHoleTr)");
3577 2 : TGeoVolume *vFootRightPart = new TGeoVolume("vFootRightPart",
3578 1 : footRightPart,stesalite);
3579 1 : vFootRightPart->SetLineColor(fColorStesalite);
3580 :
3581 1 : virtualFoot->AddNode(vFootRightPart, 1, 0);
3582 :
3583 :
3584 : //--- This was the right part of the foot, now let's do the middle
3585 : //--- and the right parts
3586 :
3587 1 : Double_t middleX = fgkLadFootX-fgkLadBox1X-fgkLadFingerPrintX-fgkLadFingerPrintBorder;
3588 2 : TGeoBBox *footMiddle = new TGeoBBox("footMiddle", middleX/2, fgkLadFootMiddleY/2,
3589 1 : fgkLadFootZ/2);
3590 2 : TGeoTranslation *middleXTr = new TGeoTranslation("middleXTr",
3591 1 : fgkLadFootX/2-fgkLadBox1X-middleX/2,
3592 1 : fgkLadFootY/2-fgkLadFootMiddleY/2, 0);
3593 :
3594 1 : TGeoVolume *vFootMiddle = new TGeoVolume("vFootMiddle", footMiddle,stesalite);
3595 1 : vFootMiddle->SetLineColor(fColorStesalite);
3596 1 : virtualFoot->AddNode(vFootMiddle, 1, middleXTr);
3597 :
3598 : //--
3599 2 : TGeoBBox *footLeftLadFinger = new TGeoBBox("footLeftLadFinger", fgkLadFingerPrintX/2,
3600 1 : (fgkLadFootY-fgkLadFingerPrintY)/2,
3601 1 : fgkLadFootZ/2);
3602 2 : TGeoTranslation *footLeftLadFingerTr = new TGeoTranslation("footLeftLadFingerTr",
3603 1 : -fgkLadFootX/2+fgkLadFingerPrintBorder+fgkLadFingerPrintX/2,
3604 1 : -fgkLadFingerPrintY/2, 0);
3605 1 : TGeoVolume *vFootLeftLadFinger = new TGeoVolume("vFootLeftLadFinger",footLeftLadFinger,
3606 : stesalite);
3607 1 : vFootLeftLadFinger->SetLineColor(fColorStesalite);
3608 1 : virtualFoot->AddNode(vFootLeftLadFinger, 1, footLeftLadFingerTr);
3609 :
3610 : //--
3611 2 : TGeoBBox *footLeft = new TGeoBBox("footLeft", fgkLadFingerPrintBorder/2,
3612 1 : fgkLadFootY/2,
3613 1 : fgkLadFootZ/2);
3614 2 : TGeoTranslation *footLeftTr = new TGeoTranslation("footLeftTr",
3615 1 : -fgkLadFootX/2+fgkLadFingerPrintBorder/2,
3616 : 0, 0);
3617 1 : TGeoVolume *vFootLeft = new TGeoVolume("vFootLeft",footLeft,stesalite);
3618 1 : vFootLeft->SetLineColor(fColorStesalite);
3619 1 : virtualFoot->AddNode(vFootLeft, 1, footLeftTr);
3620 :
3621 1 : virtualFoot->GetShape()->ComputeBBox(); //RS: enforce recompting of BBox
3622 :
3623 1 : if(GetDebug(3)){ // Remove compiler warning.
3624 0 : ladFingerPrint->InspectShape();
3625 0 : ladFootBox1->InspectShape();
3626 0 : rubyCageHole->InspectShape();
3627 0 : rubyScrewHole->InspectShape();
3628 0 : rubyHole->InspectShape();
3629 0 : }
3630 :
3631 1 : return virtualFoot;
3632 0 : }
3633 :
3634 : //________________________________________________________________________
3635 : TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateCarlosCard(Int_t iLay) {
3636 : //
3637 : // return an assembly containing the CARLOS end-ladder board
3638 : // and the heat bridge
3639 : //
3640 :
3641 : (void) iLay;
3642 2 : TGeoMedium *glassFiber = GetMedium("GLASS FIBER$");// glassFiber
3643 1 : TGeoMedium *siliconChip = GetMedium("SDD SI CHIP$");// ITSsddSiChip
3644 1 : TGeoMedium *plastiChip = GetMedium("SDDKAPTON (POLYCH2)$"); // ITSsddKAPTON_POLYCH2
3645 1 : TGeoMedium *copper = GetMedium("COPPER$");
3646 1 : TGeoMedium *alCu12SDD = GetMedium("ALCU12$"); // ITSsddAlCu12
3647 1 : TGeoMedium *stainless = GetMedium("AISI304L$"); // for screws
3648 :
3649 : //=========================================
3650 : // cooling support of the Carlos card (HeatBridge):
3651 1 : TGeoVolumeAssembly *assemblySupCarlos = new TGeoVolumeAssembly("assemblySupCarlos");
3652 :
3653 2 : TGeoBBox *supCarlosBoard1 = new TGeoBBox("",fgkCarlosSuppX1/2,fgkCarlosSuppY1/2,
3654 1 : fgkCarlosSuppZ/2);
3655 2 : TGeoBBox *supCarlosBoard2 = new TGeoBBox("",fgkCarlosSuppX2/2,fgkCarlosSuppY2/2,
3656 1 : fgkCarlosSuppZ/2);
3657 2 : TGeoVolume *vSupCarlosBoard1 = new TGeoVolume("vSupCarlosBoard1",
3658 1 : supCarlosBoard1, alCu12SDD);
3659 2 : TGeoVolume *vSupCarlosBoard2 = new TGeoVolume("vSupCarlosBoard2",
3660 1 : supCarlosBoard2, alCu12SDD);
3661 1 : vSupCarlosBoard1->SetLineColor(4);
3662 1 : vSupCarlosBoard2->SetLineColor(4);
3663 :
3664 :
3665 1 : Double_t shiftGlob = -fgkCarlosSuppZ/2+fgkCarlosSuppTopLen;
3666 : // shift of the main planes in the direction of their width
3667 : // the center is fixed at the center of the 2 small fixing arms on each sides.
3668 : //shiftGlob=0.5;
3669 :
3670 1 : shiftGlob+= 0.5*fgkCarlosSuppY3/cos((90-fgkCarlosSuppAngle)*TMath::DegToRad());
3671 1 : shiftGlob-= 0.5*fgkCarlosSuppY2*tan((90-fgkCarlosSuppAngle)*TMath::DegToRad());
3672 1 : Double_t shiftGlobY = shiftGlob*sin(fgkCarlosSuppAngle*TMath::DegToRad());
3673 1 : Double_t shiftGlobZ = shiftGlob*cos(fgkCarlosSuppAngle*TMath::DegToRad());
3674 :
3675 2 : TGeoTranslation *carlosSupTr1 = new TGeoTranslation( -fgkCarlosSuppX2/2,
3676 1 : (-fgkCarlosSuppY1+fgkCarlosSuppY2)/2+shiftGlobY,
3677 : +shiftGlobZ);
3678 :
3679 1 : TGeoTranslation *carlosSupTr2 = new TGeoTranslation( fgkCarlosSuppX1/2,
3680 : shiftGlobY,
3681 : shiftGlobZ);
3682 :
3683 1 : assemblySupCarlos->AddNode(vSupCarlosBoard1, 0, carlosSupTr1);
3684 1 : assemblySupCarlos->AddNode(vSupCarlosBoard2, 0, carlosSupTr2);
3685 :
3686 : //=========================================
3687 : // fixing arm of the cooling support :
3688 2 : TGeoBBox *supCarlosBoard3 = new TGeoBBox("",fgkCarlosSuppX3/2,fgkCarlosSuppY3/2,
3689 1 : fgkCarlosSuppZ3/2);
3690 2 : TGeoVolume *vSupCarlosBoard3 = new TGeoVolume("vSupCarlosBoard3",
3691 1 : supCarlosBoard3, alCu12SDD);
3692 1 : vSupCarlosBoard3->SetLineColor(4);
3693 :
3694 : // screw inside :
3695 2 : TGeoTube *littleScrew = new TGeoTube("littleScrew", 0, fgkLittleScrewR,
3696 1 : fgkCarlosSuppY3/2);
3697 2 : TGeoVolume *vLittleScrew = new TGeoVolume("vLittleScrew",
3698 1 : littleScrew, stainless);
3699 1 : TGeoRotation *rotScrew = new TGeoRotation("",0,90,0);
3700 3 : TGeoCombiTrans *cbScrew1 = new TGeoCombiTrans(0, 0, fgkCarlosSuppZ3/2 -
3701 2 : fgkLittleScrewHeadR-0.07, rotScrew);
3702 3 : TGeoCombiTrans *cbScrew2 = new TGeoCombiTrans(0, 0, -fgkCarlosSuppZ3/2 +
3703 2 : fgkLittleScrewHeadR+0.07, rotScrew);
3704 1 : vSupCarlosBoard3->AddNode(vLittleScrew,1, cbScrew1);
3705 1 : vSupCarlosBoard3->AddNode(vLittleScrew,2, cbScrew2);
3706 :
3707 1 : TGeoRotation *carlosSupRot = new TGeoRotation("carlosSuppInvertAngle",
3708 : 0, fgkCarlosSuppAngle, 0);
3709 3 : TGeoCombiTrans *carlosSupTr3 = new TGeoCombiTrans((fgkCarlosSuppX1+
3710 2 : fgkCarlosSuppX2+fgkCarlosSuppX3)/2,0,0, carlosSupRot);
3711 4 : TGeoCombiTrans *carlosSupTr4 = new TGeoCombiTrans(-(fgkCarlosSuppX1+
3712 3 : fgkCarlosSuppX2+fgkCarlosSuppX3)/2,0,0, carlosSupRot);
3713 1 : assemblySupCarlos->AddNode(vSupCarlosBoard3, 0, carlosSupTr3);
3714 1 : assemblySupCarlos->AddNode(vSupCarlosBoard3, 1, carlosSupTr4);
3715 :
3716 :
3717 : //=========================================
3718 : // screws fixing the board on the U tube
3719 1 : Double_t aaa = fgkCarlosSuppY3; // ???
3720 : //Double_t aaa = fgkCarlosSuppY3/2 + fgkLittleScrewHeadH/2;
3721 1 : Double_t bbb = fgkCarlosSuppZ3/2 - fgkLittleScrewHeadR;
3722 2 : Double_t screw1y = ( aaa*cos(TMath::DegToRad()*fgkCarlosSuppAngle) -
3723 1 : bbb*sin(TMath::DegToRad()*fgkCarlosSuppAngle) );
3724 2 : Double_t screw1z = ( aaa*sin(TMath::DegToRad()*fgkCarlosSuppAngle) +
3725 2 : bbb*cos(TMath::DegToRad()*fgkCarlosSuppAngle) )-0.07;
3726 :
3727 1 : TGeoRotation *carlosSuppRot = (TGeoRotation *)fCommonTr[0];
3728 :
3729 3 : TGeoCombiTrans* lScrewTr1 = new TGeoCombiTrans((fgkCarlosSuppX1+
3730 2 : fgkCarlosSuppX2+fgkCarlosSuppX3)/2,
3731 : screw1y,screw1z, carlosSuppRot);
3732 :
3733 3 : TGeoCombiTrans* lScrewTr2 = new TGeoCombiTrans((fgkCarlosSuppX1+
3734 2 : fgkCarlosSuppX2+fgkCarlosSuppX3)/2,
3735 : screw1z,screw1y, carlosSuppRot);
3736 :
3737 4 : TGeoCombiTrans *lScrewTr3 = new TGeoCombiTrans(-(fgkCarlosSuppX1+
3738 3 : fgkCarlosSuppX2+fgkCarlosSuppX3)/2,
3739 : screw1y,screw1z, carlosSuppRot);
3740 :
3741 4 : TGeoCombiTrans *lScrewTr4 = new TGeoCombiTrans(-(fgkCarlosSuppX1+
3742 3 : fgkCarlosSuppX2+fgkCarlosSuppX3)/2,
3743 : screw1z,screw1y, carlosSuppRot);
3744 :
3745 1 : assemblySupCarlos->AddNode(fCommonVol[0], 1, lScrewTr1);
3746 1 : assemblySupCarlos->AddNode(fCommonVol[0], 2, lScrewTr2);
3747 1 : assemblySupCarlos->AddNode(fCommonVol[0], 3, lScrewTr3);
3748 1 : assemblySupCarlos->AddNode(fCommonVol[0], 4, lScrewTr4);
3749 :
3750 : //=========================================
3751 : // board
3752 1 : Double_t p1[3], p2[3], vX[3] = {1,0,0};
3753 1 : AliITSv11GeomCableFlat card1("cardCarlos1", fgkCarlosCardZ1, fgkCarlosCardY1); // name, width, thickness
3754 1 : card1.SetNLayers(2);
3755 1 : card1.SetLayer(0, fgkCarlosCardCuY, copper, kOrange); // index, thickness, material, color
3756 1 : card1.SetLayer(1, fgkCarlosCardY1-fgkCarlosCardCuY, glassFiber, 30);
3757 1 : card1.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
3758 1 : p1[0] = -fgkCarlosCardX1/2;
3759 1 : p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge;
3760 1 : p1[2] = fgkCarlosCardShift;
3761 1 : p2[0] = fgkCarlosCardX1/2;
3762 1 : p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge;
3763 1 : p2[2] = fgkCarlosCardShift;
3764 1 : card1.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
3765 1 : card1.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
3766 1 : card1.CreateAndInsertBoxCableSegment(1,90);
3767 :
3768 1 : AliITSv11GeomCableFlat card2("cardCarlos2", fgkCarlosCardZ2, fgkCarlosCardY1); // name, width, thickness
3769 1 : card2.SetNLayers(2);
3770 1 : card2.SetLayer(0, fgkCarlosCardCuY, copper, kOrange); // index, thickness, material, color
3771 1 : card2.SetLayer(1, fgkCarlosCardY1-fgkCarlosCardCuY, glassFiber, 30);
3772 1 : card2.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
3773 :
3774 1 : p1[0] = -fgkCarlosCardX1/2;
3775 1 : p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge;
3776 1 : p1[2] = fgkCarlosCardShift + fgkCarlosCardZ1/2 + fgkCarlosCardZ2/2;
3777 :
3778 1 : p2[0] = -fgkCarlosCardX1/2 + fgkCarlosCardX2;
3779 1 : p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge;
3780 1 : p2[2] = fgkCarlosCardShift + fgkCarlosCardZ1/2 + fgkCarlosCardZ2/2;
3781 1 : card2.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
3782 1 : card2.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
3783 1 : card2.CreateAndInsertBoxCableSegment(1,90);
3784 :
3785 : //=========================================
3786 : // some chips on the board
3787 :
3788 1 : AliITSv11GeomCableFlat u1("carlosCardU1", fgkCarlosU1Z, fgkCarlosU1Y); // name, width, thickness
3789 1 : u1.SetNLayers(2);
3790 1 : u1.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
3791 1 : u1.SetLayer(1, fgkCarlosU1Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
3792 1 : u1.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
3793 :
3794 1 : p1[0] = fgkCarlosU1posX - fgkCarlosU1X/2;
3795 1 : p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU1Y/2;
3796 1 : p1[2] = fgkCarlosCardShift + fgkCarlosU1posZ;
3797 :
3798 1 : p2[0] = fgkCarlosU1posX + fgkCarlosU1X/2;
3799 1 : p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU1Y/2;
3800 1 : p2[2] = fgkCarlosCardShift + fgkCarlosU1posZ;
3801 1 : u1.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
3802 1 : u1.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
3803 1 : u1.CreateAndInsertBoxCableSegment(1,90);
3804 :
3805 : //---
3806 1 : AliITSv11GeomCableFlat u2("carlosCardU2", fgkCarlosU2Z, fgkCarlosU2Y); // name, width, thickness
3807 1 : u2.SetNLayers(2);
3808 1 : u2.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
3809 1 : u2.SetLayer(1, fgkCarlosU2Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
3810 1 : u2.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
3811 :
3812 1 : p1[0] = fgkCarlosU2posX - fgkCarlosU2X/2;
3813 1 : p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU2Y/2;
3814 1 : p1[2] = fgkCarlosCardShift + fgkCarlosU2posZ;
3815 :
3816 1 : p2[0] = fgkCarlosU2posX + fgkCarlosU2X/2;
3817 1 : p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU2Y/2;
3818 1 : p2[2] = fgkCarlosCardShift + fgkCarlosU2posZ;
3819 1 : u2.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
3820 1 : u2.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
3821 1 : u2.CreateAndInsertBoxCableSegment(1,90);
3822 :
3823 : //---
3824 1 : AliITSv11GeomCableFlat u3("carlosCardU3", fgkCarlosU3Z, fgkCarlosU3Y); // name, width, thickness
3825 1 : u3.SetNLayers(2);
3826 1 : u3.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
3827 1 : u3.SetLayer(1, fgkCarlosU3Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
3828 1 : u3.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
3829 :
3830 1 : Double_t u3Y = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU3Y/2;
3831 1 : p1[0] = fgkCarlosU3posX - fgkCarlosU3X/2;
3832 1 : p1[1] = u3Y;
3833 1 : p1[2] = fgkCarlosCardShift + fgkCarlosU3posZ;
3834 :
3835 1 : p2[0] = fgkCarlosU3posX + fgkCarlosU3X/2;
3836 1 : p2[1] = u3Y;
3837 1 : p2[2] = fgkCarlosCardShift + fgkCarlosU3posZ;
3838 1 : u3.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
3839 1 : u3.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
3840 1 : TGeoVolume *u3Vol = u3.CreateAndInsertBoxCableSegment(1,90);
3841 :
3842 : //--- U4 is like U3 (?)
3843 2 : TGeoCombiTrans *u4Trans = new TGeoCombiTrans;
3844 1 : u4Trans->RotateX(90);
3845 2 : u4Trans->SetTranslation(fgkCarlosU4posX, u3Y,
3846 1 : fgkCarlosCardShift + fgkCarlosU4posZ);
3847 1 : assemblySupCarlos->AddNode(u3Vol, 2, u4Trans);
3848 :
3849 : //---
3850 1 : AliITSv11GeomCableFlat u17("carlosCardU17", fgkCarlosU17Z, fgkCarlosU17Y); // name, width, thickness
3851 1 : u17.SetNLayers(2);
3852 1 : u17.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
3853 1 : u17.SetLayer(1, fgkCarlosU17Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
3854 1 : u17.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
3855 :
3856 1 : p1[0] = fgkCarlosU17posX - fgkCarlosU17X/2;
3857 1 : p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU17Y/2;
3858 1 : p1[2] = fgkCarlosCardShift + fgkCarlosU17posZ;
3859 :
3860 1 : p2[0] = fgkCarlosU17posX + fgkCarlosU17X/2;
3861 1 : p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU17Y/2;
3862 1 : p2[2] = fgkCarlosCardShift + fgkCarlosU17posZ;
3863 1 : u17.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
3864 1 : u17.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
3865 1 : u17.CreateAndInsertBoxCableSegment(1,90);
3866 :
3867 : //---
3868 1 : AliITSv11GeomCableFlat u35("carlosCardU35", fgkCarlosU35Z, fgkCarlosU35Y); // name, width, thickness
3869 1 : u35.SetNLayers(2);
3870 1 : u35.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
3871 1 : u35.SetLayer(1, fgkCarlosU35Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
3872 1 : u35.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
3873 :
3874 1 : p1[0] = fgkCarlosU35posX - fgkCarlosU35X/2;
3875 1 : p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU35Y/2;
3876 1 : p1[2] = fgkCarlosCardShift + fgkCarlosU35posZ;
3877 :
3878 1 : p2[0] = fgkCarlosU35posX + fgkCarlosU35X/2;
3879 1 : p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU35Y/2;
3880 1 : p2[2] = fgkCarlosCardShift + fgkCarlosU35posZ;
3881 1 : u35.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
3882 1 : u35.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
3883 1 : u35.CreateAndInsertBoxCableSegment(1,90);
3884 :
3885 : //---
3886 1 : AliITSv11GeomCableFlat u36("carlosCardU36", fgkCarlosU36Z, fgkCarlosU36Y); // name, width, thickness
3887 1 : u36.SetNLayers(2);
3888 1 : u36.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
3889 1 : u36.SetLayer(1, fgkCarlosU36Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
3890 1 : u36.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
3891 :
3892 1 : p1[0] = fgkCarlosU36posX - fgkCarlosU36X/2;
3893 1 : p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU36Y/2;
3894 1 : p1[2] = fgkCarlosCardShift + fgkCarlosU36posZ;
3895 :
3896 1 : p2[0] = fgkCarlosU36posX + fgkCarlosU36X/2;
3897 1 : p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosU36Y/2;
3898 1 : p2[2] = fgkCarlosCardShift + fgkCarlosU36posZ;
3899 1 : u36.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
3900 1 : u36.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
3901 1 : u36.CreateAndInsertBoxCableSegment(1,90);
3902 :
3903 : //--- QZ1
3904 1 : AliITSv11GeomCableFlat qz1("carlosCardQZ1", fgkCarlosQZ1Z, fgkCarlosQZ1Y); // name, width, thickness
3905 1 : qz1.SetNLayers(2);
3906 1 : qz1.SetLayer(0, fgkCarlosCardChipSiThick, siliconChip, kGreen); // index, thickness, material, color
3907 1 : qz1.SetLayer(1, fgkCarlosQZ1Y - fgkCarlosCardChipSiThick, plastiChip, kGray+3);
3908 1 : qz1.SetInitialNode( (TGeoVolume *) assemblySupCarlos);
3909 :
3910 1 : p1[0] = fgkCarlosQZ1posX - fgkCarlosQZ1X/2;
3911 1 : p1[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosQZ1Y/2;
3912 1 : p1[2] = fgkCarlosCardShift + fgkCarlosQZ1posZ;
3913 :
3914 1 : p2[0] = fgkCarlosQZ1posX + fgkCarlosQZ1X/2;
3915 1 : p2[1] = shiftGlobY - fgkCarlosCard2HeatBridge + fgkCarlosCardY1/2 + fgkCarlosQZ1Y/2;
3916 1 : p2[2] = fgkCarlosCardShift + fgkCarlosQZ1posZ;
3917 1 : qz1.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 0, p1, vX);
3918 1 : qz1.AddCheckPoint( (TGeoVolume *) assemblySupCarlos, 1, p2, vX);
3919 1 : qz1.CreateAndInsertBoxCableSegment(1,90);
3920 :
3921 1 : assemblySupCarlos->GetShape()->ComputeBBox(); //RS: enforce recompting of BBox
3922 :
3923 : return assemblySupCarlos;
3924 1 : }
3925 :
3926 : //________________________________________________________________________
3927 : Int_t AliITSv11GeometrySDD::CreateLVCard() {
3928 : //
3929 : // Creates the assemblies containing the LV cards (left and right)
3930 : //
3931 :
3932 2 : TGeoMedium *glassFiber = GetMedium("GLASS FIBER$");// glassFiber
3933 1 : TGeoMedium *siliconChip = GetMedium("SDD SI CHIP$");// ITSsddSiChip
3934 1 : TGeoMedium *plastiChip = GetMedium("SDDKAPTON (POLYCH2)$"); // ITSsddKAPTON_POLYCH2
3935 1 : TGeoMedium *copper = GetMedium("COPPER$");
3936 1 : TGeoMedium *alCu12SDD = GetMedium("ALCU12$"); // ITSsddAlCu12
3937 1 : TGeoMedium *stainless = GetMedium("AISI304L$"); // for screws
3938 :
3939 2 : fCardLVL = new TGeoVolumeAssembly("ITSsddLVCardLeft");
3940 2 : fCardLVR = new TGeoVolumeAssembly("ITSsddLVCardRight");
3941 :
3942 : // we are going to use flat cable class to create multilayer box,
3943 : // then we can use the pointers to created volumes to place them elsewhere
3944 1 : Double_t p1[3], p2[3], vX[3] = {1,0,0};
3945 :
3946 1 : Double_t carLVfullThick = fgkLVcardZ+fgkLVcardCuZ;
3947 1 : AliITSv11GeomCableFlat cardLV("cardLV", fgkLVcardY, carLVfullThick); // name, width, thickness
3948 1 : cardLV.SetNLayers(2);
3949 1 : cardLV.SetLayer(0, fgkLVcardCuZ, copper, 30); // index, thickness, material, color
3950 1 : cardLV.SetLayer(1, fgkLVcardZ, glassFiber, 30);
3951 1 : cardLV.SetInitialNode( (TGeoVolume *) fCardLVL);
3952 1 : p1[0] = 0;
3953 1 : p1[1] = fgkLVcardY/2;
3954 1 : p1[2] = 0;
3955 1 : p2[0] = fgkLVcardX;
3956 1 : p2[1] = fgkLVcardY/2;
3957 1 : p2[2] = 0;
3958 1 : cardLV.AddCheckPoint( (TGeoVolume *) fCardLVL, 0, p1, vX);
3959 1 : cardLV.AddCheckPoint( (TGeoVolume *) fCardLVL, 1, p2, vX);
3960 1 : TGeoVolume* boxVol = cardLV.CreateAndInsertBoxCableSegment(1);
3961 2 : TGeoRotation *rotAdd = new TGeoRotation("",90,0,0);
3962 2 : TGeoCombiTrans *trCard = new TGeoCombiTrans(-fgkLVcardX/2,fgkLVcardY/2,0,rotAdd);
3963 1 : fCardLVR->AddNode(boxVol, 1, trCard);
3964 :
3965 1 : Double_t chip0fullThick = fgkLVChip0Z + fgkLVChip0SiZ;
3966 1 : AliITSv11GeomCableFlat chipO("chipO", fgkLVChip0Y, chip0fullThick); // name, width, thickness
3967 1 : chipO.SetNLayers(2);
3968 1 : chipO.SetLayer(0, fgkLVChip0SiZ, siliconChip, 8); // index, thickness, material, color
3969 1 : chipO.SetLayer(1, fgkLVChip0Z, plastiChip, 12);
3970 1 : chipO.SetInitialNode( (TGeoVolume *) fCardLVL);
3971 1 : p1[0] = (fgkLVChip0PosX - fgkLVChip0X/2);
3972 1 : p1[1] = fgkLVChip0PosY;
3973 1 : p1[2] = carLVfullThick/2 + chip0fullThick/2;
3974 :
3975 1 : p2[0] = (fgkLVChip0PosX + fgkLVChip0X/2);
3976 1 : p2[1] = fgkLVChip0PosY;
3977 1 : p2[2] = carLVfullThick/2 + chip0fullThick/2;
3978 1 : chipO.AddCheckPoint( (TGeoVolume *) fCardLVL, 0, p1, vX);
3979 1 : chipO.AddCheckPoint( (TGeoVolume *) fCardLVL, 1, p2, vX);
3980 1 : boxVol = chipO.CreateAndInsertBoxCableSegment(1);
3981 3 : trCard = new TGeoCombiTrans( -fgkLVChip0PosX,
3982 1 : fgkLVChip0PosY,
3983 : carLVfullThick/2+chip0fullThick/2, rotAdd);
3984 1 : fCardLVR->AddNode(boxVol, 1, trCard);
3985 :
3986 : // put also this chip on the other side of the card
3987 3 : trCard = new TGeoCombiTrans( fgkLVChip0PosX,
3988 1 : fgkLVChip0PosY,
3989 1 : -carLVfullThick/2-chip0fullThick/2, rotAdd);
3990 1 : fCardLVL->AddNode(boxVol, 2, trCard);
3991 3 : trCard = new TGeoCombiTrans( -fgkLVChip0PosX,
3992 1 : fgkLVChip0PosY,
3993 : -carLVfullThick/2-chip0fullThick/2, rotAdd);
3994 1 : fCardLVR->AddNode(boxVol, 2, trCard);
3995 :
3996 1 : Double_t chip1fullThick = fgkLVChip1Z + fgkLVChip1SiZ;
3997 1 : AliITSv11GeomCableFlat chip1("chip1", fgkLVChip1Y, chip1fullThick);
3998 1 : chip1.SetNLayers(2);
3999 1 : chip1.SetLayer(0, fgkLVChip1SiZ, siliconChip, 8);
4000 1 : chip1.SetLayer(1, fgkLVChip1Z, plastiChip, 12);
4001 1 : chip1.SetInitialNode( (TGeoVolume *) fCardLVL);
4002 1 : p1[0] = (fgkLVChip1PosX-fgkLVChip1X/2);
4003 1 : p1[1] = fgkLVChip1PosY;
4004 1 : p1[2] = carLVfullThick/2 + chip1fullThick/2;
4005 :
4006 1 : p2[0] = (fgkLVChip1PosX+fgkLVChip1X/2);
4007 1 : p2[1] = fgkLVChip1PosY;
4008 1 : p2[2] = carLVfullThick/2 + chip1fullThick/2;
4009 1 : chip1.AddCheckPoint( (TGeoVolume *) fCardLVL, 0, p1, vX);
4010 1 : chip1.AddCheckPoint( (TGeoVolume *) fCardLVL, 1, p2, vX);
4011 1 : boxVol = chip1.CreateAndInsertBoxCableSegment(1);
4012 3 : trCard = new TGeoCombiTrans( -fgkLVChip1PosX,
4013 1 : fgkLVChip1PosY,
4014 : carLVfullThick/2 + chip1fullThick/2, rotAdd);
4015 1 : fCardLVR->AddNode(boxVol, 1, trCard);
4016 :
4017 1 : Double_t chip2fullThick = fgkLVChip2Z + fgkLVChip2SiZ;
4018 1 : AliITSv11GeomCableFlat chip2("chip2", fgkLVChip2Y, chip2fullThick);
4019 1 : chip2.SetNLayers(2);
4020 1 : chip2.SetLayer(0, fgkLVChip2SiZ, siliconChip, 8);
4021 1 : chip2.SetLayer(1, fgkLVChip2Z, plastiChip, 12);
4022 1 : chip2.SetInitialNode( (TGeoVolume *) fCardLVL);
4023 1 : p1[0] = (fgkLVChip2PosX-fgkLVChip2X/2);
4024 1 : p1[1] = fgkLVChip2PosY;
4025 1 : p1[2] = carLVfullThick/2 + chip2fullThick/2;
4026 1 : p2[0] = (fgkLVChip2PosX+fgkLVChip2X/2);
4027 1 : p2[1] = fgkLVChip2PosY;
4028 1 : p2[2] = carLVfullThick/2 + chip2fullThick/2;
4029 1 : chip2.AddCheckPoint( (TGeoVolume *) fCardLVL, 0, p1, vX);
4030 1 : chip2.AddCheckPoint( (TGeoVolume *) fCardLVL, 1, p2, vX);
4031 1 : boxVol = chip2.CreateAndInsertBoxCableSegment(1);
4032 3 : trCard = new TGeoCombiTrans( -fgkLVChip2PosX,
4033 1 : fgkLVChip2PosY,
4034 : carLVfullThick/2 + chip2fullThick/2, rotAdd);
4035 1 : fCardLVR->AddNode(boxVol, 1, trCard);
4036 :
4037 1 : Double_t chip3fullThick = fgkLVChip3Z + fgkLVChip3SiZ;
4038 1 : AliITSv11GeomCableFlat chip3("chip3", fgkLVChip3Y, chip3fullThick);
4039 1 : chip3.SetNLayers(2);
4040 1 : chip3.SetLayer(0, fgkLVChip3Z, plastiChip, 12);
4041 1 : chip3.SetLayer(1, fgkLVChip3SiZ, siliconChip, 8);
4042 1 : chip3.SetInitialNode( (TGeoVolume *) fCardLVL);
4043 1 : p1[0] = (fgkLVChip3PosX-fgkLVChip3X/2);
4044 1 : p1[1] = fgkLVChip3PosY;
4045 1 : p1[2] = -carLVfullThick/2 - chip3fullThick/2;
4046 1 : p2[0] = (fgkLVChip3PosX+fgkLVChip3X/2);
4047 1 : p2[1] = fgkLVChip3PosY;
4048 1 : p2[2] = -carLVfullThick/2 - chip3fullThick/2;
4049 1 : chip3.AddCheckPoint( (TGeoVolume *) fCardLVL, 0, p1, vX);
4050 1 : chip3.AddCheckPoint( (TGeoVolume *) fCardLVL, 1, p2, vX);
4051 1 : boxVol = chip3.CreateAndInsertBoxCableSegment(1);
4052 3 : trCard = new TGeoCombiTrans( -fgkLVChip3PosX,
4053 1 : fgkLVChip3PosY,
4054 : -carLVfullThick/2 - chip3fullThick/2, rotAdd);
4055 1 : fCardLVR->AddNode(boxVol, 1, trCard);
4056 :
4057 : // the Al pieces for heat exchange :
4058 3 : TGeoBBox *alLVcooling1 = new TGeoBBox("alLVcooling1" ,
4059 1 : fgkLVcoolX1/2, fgkLVcoolY1/2, fgkLVcoolZ1/2);
4060 :
4061 3 : TGeoTranslation *alLVcooling1Tr = new TGeoTranslation("alLVcooling1Tr",
4062 1 : (fgkLVcoolX1/2+fgkLVcoolX2),
4063 1 : fgkLVcoolPosY+fgkLVcoolY1/2,
4064 1 : carLVfullThick/2+chip0fullThick+fgkLVcoolZ1/2);
4065 3 : TGeoTranslation *alLVcooling1TrB = new TGeoTranslation("alLVcooling1TrB",
4066 1 : (fgkLVcoolX1/2+fgkLVcoolX2),
4067 1 : fgkLVcoolPosY+fgkLVcoolY1/2,
4068 1 : -(carLVfullThick/2+chip0fullThick+fgkLVcoolZ1/2));
4069 :
4070 2 : TGeoVolume *vAlLVcooling1 = new TGeoVolume("vAlLVcooling1",alLVcooling1,
4071 : alCu12SDD);
4072 1 : vAlLVcooling1->SetLineColor(2);
4073 :
4074 : //--
4075 3 : TGeoBBox * alLVcooling2 = new TGeoBBox("lLVcooling2" ,
4076 1 : fgkLVcoolX2/2, fgkLVcoolY2/2, fgkLVcoolZ2/2);
4077 3 : TGeoTranslation *alLVcooling2Tr = new TGeoTranslation("alLVcooling2Tr",
4078 1 : (fgkLVcoolX2/2),
4079 1 : fgkLVcoolPosY+fgkLVcoolY1/2,
4080 1 : carLVfullThick/2+chip0fullThick+fgkLVcoolZ1-fgkLVcoolZ2/2);
4081 3 : TGeoTranslation *alLVcooling2TrB = new TGeoTranslation("alLVcooling2TrB",
4082 1 : (fgkLVcoolX2/2),
4083 1 : fgkLVcoolPosY+fgkLVcoolY1/2,
4084 1 : -(carLVfullThick/2+chip0fullThick+fgkLVcoolZ1-fgkLVcoolZ2/2));
4085 :
4086 2 : TGeoVolume *vAlLVcooling2 = new TGeoVolume("vAlLVcooling2",alLVcooling2,
4087 : alCu12SDD);
4088 1 : vAlLVcooling2->SetLineColor(2);
4089 :
4090 : //--
4091 1 : Double_t alLVcoolZ3 = (fgkLVcardCuZ+fgkLVcardZ+2.*(fgkLVChip0SiZ+fgkLVChip0Z)
4092 1 : +fgkLVcoolZ1*2.);
4093 3 : TGeoBBox * alLVcooling3 = new TGeoBBox("lLVcooling3" ,
4094 1 : fgkLVcoolX3/2, fgkLVcoolY3/2, alLVcoolZ3/2);
4095 3 : TGeoTranslation *alLVcooling3Tr = new TGeoTranslation("alLVcooling3Tr",
4096 1 : (-fgkLVcoolX3/2),
4097 1 : fgkLVcoolPosY+fgkLVcoolY1-fgkLVcoolY3/2,
4098 : 0);
4099 2 : TGeoVolume *vAlLVcooling3 = new TGeoVolume("vAlLVcooling3",alLVcooling3,alCu12SDD);
4100 1 : vAlLVcooling3->SetLineColor(2);
4101 :
4102 : //=== screw fixing th LV card to the U cooling tube :
4103 3 : TGeoTube *littleScrew = new TGeoTube("littleScrewLV", 0, fgkLittleScrewR,
4104 1 : fgkLVcoolY3/2);
4105 3 : TGeoVolume *vLittleScrew = new TGeoVolume("vLittleScrewLV",
4106 1 : littleScrew, stainless);
4107 2 : TGeoRotation *rotScrew = new TGeoRotation("",0,90,0);
4108 :
4109 2 : TGeoCombiTrans *cbScrew = new TGeoCombiTrans(0,0,fgkShiftLittleScrewLV,
4110 : rotScrew);
4111 1 : vAlLVcooling3->AddNode(vLittleScrew, 1, cbScrew);
4112 :
4113 3 : TGeoTube *littleScrewHead = new TGeoTube("littleScrewLVhead",
4114 1 : 0, fgkLittleLVScrewHeadR,
4115 1 : fgkLittleScrewHeadH/2);
4116 3 : TGeoVolume *vLittleScrewHead = new TGeoVolume("vLittleScrewLVhead",
4117 1 : littleScrewHead, stainless);
4118 1 : vLittleScrewHead->SetLineColor(kGray);
4119 3 : TGeoCombiTrans *cbScrewHeadL = new TGeoCombiTrans( -fgkLVcoolX3/2,
4120 1 : fgkLVcoolPosY+fgkLVcoolY1 + fgkLittleScrewHeadH/2,
4121 1 : fgkShiftLittleScrewLV,
4122 : rotScrew);
4123 1 : fCardLVL->AddNode(vLittleScrewHead, 1, cbScrewHeadL);
4124 :
4125 3 : TGeoCombiTrans *cbScrewHeadR = new TGeoCombiTrans( fgkLVcoolX3/2,
4126 1 : fgkLVcoolPosY+fgkLVcoolY1 + fgkLittleScrewHeadH/2,
4127 1 : fgkShiftLittleScrewLV,
4128 : rotScrew);
4129 1 : fCardLVR->AddNode(vLittleScrewHead, 1, cbScrewHeadR);
4130 :
4131 : // adding the cooling pieces to the left card
4132 1 : fCardLVL->AddNode(vAlLVcooling1, 1,alLVcooling1Tr);
4133 1 : fCardLVL->AddNode(vAlLVcooling1, 2,alLVcooling1TrB);
4134 1 : fCardLVL->AddNode(vAlLVcooling2, 1,alLVcooling2Tr);
4135 1 : fCardLVL->AddNode(vAlLVcooling2, 2,alLVcooling2TrB);
4136 1 : fCardLVL->AddNode(vAlLVcooling3, 1,alLVcooling3Tr);
4137 :
4138 3 : TGeoTranslation *alLVcooling1TrR = new TGeoTranslation("alLVcooling1TrR",
4139 1 : -(fgkLVcoolX1/2+fgkLVcoolX2),
4140 1 : fgkLVcoolPosY+fgkLVcoolY1/2,
4141 1 : carLVfullThick/2+chip0fullThick+fgkLVcoolZ1/2);
4142 3 : TGeoTranslation *alLVcooling1TrBR = new TGeoTranslation("alLVcooling1TrBR",
4143 1 : -(fgkLVcoolX1/2+fgkLVcoolX2),
4144 1 : fgkLVcoolPosY+fgkLVcoolY1/2,
4145 1 : -(carLVfullThick/2+chip0fullThick+fgkLVcoolZ1/2));
4146 3 : TGeoTranslation *alLVcooling2TrR = new TGeoTranslation("alLVcooling2TrR",
4147 1 : -(fgkLVcoolX2/2),
4148 1 : fgkLVcoolPosY+fgkLVcoolY1/2,
4149 1 : carLVfullThick/2+chip0fullThick+fgkLVcoolZ1-fgkLVcoolZ2/2);
4150 3 : TGeoTranslation *alLVcooling2TrBR = new TGeoTranslation("alLVcooling2TrBR",
4151 1 : -(fgkLVcoolX2/2),
4152 1 : fgkLVcoolPosY+fgkLVcoolY1/2,
4153 1 : -(carLVfullThick/2+chip0fullThick+fgkLVcoolZ1-fgkLVcoolZ2/2));
4154 :
4155 3 : TGeoTranslation *alLVcooling3TrR = new TGeoTranslation("alLVcooling3TrR",
4156 1 : fgkLVcoolX3/2,
4157 1 : fgkLVcoolPosY+fgkLVcoolY1-fgkLVcoolY3/2,
4158 : 0);
4159 : // and to the right card
4160 1 : fCardLVR->AddNode(vAlLVcooling1, 1,alLVcooling1TrR);
4161 1 : fCardLVR->AddNode(vAlLVcooling1, 2,alLVcooling1TrBR);
4162 1 : fCardLVR->AddNode(vAlLVcooling2, 1,alLVcooling2TrR);
4163 1 : fCardLVR->AddNode(vAlLVcooling2, 2,alLVcooling2TrBR);
4164 1 : fCardLVR->AddNode(vAlLVcooling3, 1,alLVcooling3TrR);
4165 :
4166 1 : fCardLVL->GetShape()->ComputeBBox(); //RS: enforce recompting of BBox
4167 1 : fCardLVR->GetShape()->ComputeBBox();
4168 :
4169 : return kTRUE;
4170 1 : }
4171 :
4172 : //________________________________________________________________________
4173 : TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateHVCard(){
4174 : //
4175 : // return an assembly containing the HV card
4176 : //
4177 :
4178 2 : TGeoMedium *ceramic = GetMedium("CERAMICS$"); // ceramicHVcard
4179 1 : TGeoMedium *medSMDcapaMiddle = GetMedium("SDD X7R capacitors$"); // check if different
4180 1 : TGeoMedium *medSMDcapaEnd = GetMedium("SDD X7R capacitors$"); // check if different
4181 1 : TGeoMedium *stainless = GetMedium("INOX$"); // ITSspdStainlesSteal ???????????
4182 1 : TGeoMedium *plastic = GetMedium("SDDKAPTON (POLYCH2)$"); // ITS_ITSsddKAPTON_POLYCH2 ???????????
4183 1 : TGeoMedium *alCu12SDD = GetMedium("ALCU12$"); // ITSsddAlCu12
4184 :
4185 1 : TGeoVolumeAssembly *highVCard = new TGeoVolumeAssembly("ITSsddHVCard");
4186 :
4187 : //====================================
4188 : //--- the card itself
4189 2 : TGeoBBox *ceramicCard = new TGeoBBox("ceramCard", fgkHVCardCeramX/2,
4190 1 : fgkHVCardCeramY/2, fgkHVCardCeramZ/2);
4191 1 : TGeoVolume *vCeramicCard = new TGeoVolume("vCeramCard", ceramicCard, ceramic);
4192 1 : vCeramicCard->SetLineColor(38);// or 9 blue slightly dark
4193 :
4194 1 : highVCard->AddNode(vCeramicCard, 1, 0);
4195 :
4196 :
4197 : //====================================
4198 : //--- capacitors
4199 :
4200 : // capa1
4201 2 : TGeoBBox *capa1Middle = new TGeoBBox("cardHVCapa1Middle", fgkHVCardCapa1X/2,
4202 1 : fgkHVCardCapa1Ymid/2, fgkHVCardCapa1Z/2);
4203 1 : TGeoVolume *vCapa1Middle = new TGeoVolume("vCardHVCapa1Middle",capa1Middle,
4204 : medSMDcapaMiddle);
4205 :
4206 2 : TGeoBBox *capa1End = new TGeoBBox("cardHVCapa1End", fgkHVCardCapa1X/2,
4207 1 : fgkHVCardCapa1Yend/2, fgkHVCardCapa1Z/2);
4208 1 : TGeoVolume *vCapa1End = new TGeoVolume("vCardHVCapa1End",capa1End,
4209 : medSMDcapaEnd);
4210 1 : vCapa1End->SetLineColor(18);// grey silver
4211 2 : TGeoTranslation *capa1EndTr1 = new TGeoTranslation("cardHVcapa1EndTr1", 0,
4212 1 : (fgkHVCardCapa1Ymid+fgkHVCardCapa1Yend)/2,0);
4213 2 : TGeoTranslation *capa1EndTr2 = new TGeoTranslation("cardHVcapa1EndTr2", 0,
4214 1 : -(fgkHVCardCapa1Ymid+fgkHVCardCapa1Yend)/2,0);
4215 :
4216 2 : TGeoTranslation *capa1PosTr = new TGeoTranslation("cardHVcapa1PosTr",
4217 1 : fgkHVCardCapa1PosX, fgkHVCardCapa1PosY,
4218 1 : -fgkHVCardCeramZ/2-fgkHVCardCapa1Z/2);
4219 :
4220 1 : TGeoVolumeAssembly *capa1 = new TGeoVolumeAssembly("cardHVCapa1");
4221 1 : capa1->AddNode(vCapa1Middle, 1,0);
4222 1 : capa1->AddNode(vCapa1End, 1, capa1EndTr1);
4223 1 : capa1->AddNode(vCapa1End, 2, capa1EndTr2);
4224 :
4225 1 : capa1->GetShape()->ComputeBBox(); //RS: enforce recompting of BBox
4226 :
4227 :
4228 1 : highVCard->AddNode(capa1, 1, capa1PosTr);
4229 :
4230 : // capa2
4231 2 : TGeoBBox *capa2Middle = new TGeoBBox("cardHVCapa2Middle", fgkHVCardCapa2X/2,
4232 1 : fgkHVCardCapa2Ymid/2, fgkHVCardCapa2Z/2);
4233 1 : TGeoVolume *vCapa2Middle = new TGeoVolume("vCardHVCapa2Middle",capa2Middle,
4234 : medSMDcapaMiddle);
4235 :
4236 2 : TGeoBBox *capa2End = new TGeoBBox("cardHVCapa2End", fgkHVCardCapa2X/2,
4237 1 : fgkHVCardCapa2Yend/2, fgkHVCardCapa2Z/2);
4238 1 : TGeoVolume *vCapa2End = new TGeoVolume("vCardHVCapa2End",capa2End,
4239 : medSMDcapaEnd);
4240 1 : vCapa2End->SetLineColor(18);// grey silver
4241 2 : TGeoTranslation *capa2EndTr1 = new TGeoTranslation("cardHVcapa2EndTr1", 0,
4242 1 : (fgkHVCardCapa2Ymid+fgkHVCardCapa2Yend)/2,0);
4243 2 : TGeoTranslation *capa2EndTr2 = new TGeoTranslation("cardHVcapa2EndTr2", 0,
4244 1 : -(fgkHVCardCapa2Ymid+fgkHVCardCapa2Yend)/2,0);
4245 :
4246 2 : TGeoTranslation *capa2PosTr = new TGeoTranslation("cardHVcapa2PosTr",
4247 1 : fgkHVCardCapa2PosX, fgkHVCardCapa2PosY,
4248 1 : -fgkHVCardCeramZ/2-fgkHVCardCapa2Z/2);
4249 :
4250 1 : TGeoVolumeAssembly *capa2 = new TGeoVolumeAssembly("cardHVCapa2");
4251 1 : capa2->AddNode(vCapa2Middle, 1,0);
4252 1 : capa2->AddNode(vCapa2End, 1, capa2EndTr1);
4253 1 : capa2->AddNode(vCapa2End, 2, capa2EndTr2);
4254 :
4255 1 : capa2->GetShape()->ComputeBBox(); //RS: enforce recompting of BBox
4256 :
4257 :
4258 1 : highVCard->AddNode(capa2, 1, capa2PosTr);
4259 :
4260 : // capa3
4261 2 : TGeoBBox *capa3Middle = new TGeoBBox("cardHVCapa3Middle", fgkHVCardCapa3Xmid/2,
4262 1 : fgkHVCardCapa3Y/2, fgkHVCardCapa3Z/2);
4263 1 : TGeoVolume *vCapa3Middle = new TGeoVolume("vCardHVCapa3Middle",capa3Middle,
4264 : medSMDcapaMiddle);
4265 :
4266 2 : TGeoBBox *capa3End = new TGeoBBox("cardHVCapa3End", fgkHVCardCapa3Xend/2,
4267 1 : fgkHVCardCapa3Y/2, fgkHVCardCapa3Z/2);
4268 1 : TGeoVolume *vCapa3End = new TGeoVolume("vCardHVCapa3End",capa3End,
4269 : medSMDcapaEnd);
4270 1 : vCapa3End->SetLineColor(18);// grey silver
4271 :
4272 2 : TGeoTranslation *capa3EndTr1 = new TGeoTranslation("cardHVcapa3EndTr1",
4273 1 : (fgkHVCardCapa3Xmid+fgkHVCardCapa3Xend)/2, 0, 0);
4274 2 : TGeoTranslation *capa3EndTr2 = new TGeoTranslation("cardHVcapa2EndTr2",
4275 1 : -(fgkHVCardCapa3Xmid+fgkHVCardCapa3Xend)/2, 0, 0);
4276 :
4277 1 : TGeoVolumeAssembly *capa3 = new TGeoVolumeAssembly("cardHVCapa3");
4278 1 : capa3->AddNode(vCapa3Middle, 1,0);
4279 1 : capa3->AddNode(vCapa3End, 1, capa3EndTr1);
4280 1 : capa3->AddNode(vCapa3End, 2, capa3EndTr2);
4281 :
4282 2 : TGeoTranslation *capa3PosTr1 = new TGeoTranslation("cardHVcapa3PosTr1",
4283 1 : fgkHVCardCapa3PosX1, fgkHVCardCapa3PosY1,
4284 1 : -fgkHVCardCeramZ/2-fgkHVCardCapa3Z/2);
4285 :
4286 2 : TGeoTranslation *capa3PosTr2 = new TGeoTranslation("cardHVcapa3PosTr2",
4287 1 : fgkHVCardCapa3PosX2, fgkHVCardCapa3PosY1,
4288 1 : -fgkHVCardCeramZ/2-fgkHVCardCapa3Z/2);
4289 :
4290 2 : TGeoTranslation *capa3PosTr3 = new TGeoTranslation("cardHVcapa3PosTr3",
4291 1 : fgkHVCardCapa3PosX3, fgkHVCardCapa3PosY2,
4292 1 : -fgkHVCardCeramZ/2-fgkHVCardCapa3Z/2);
4293 :
4294 2 : TGeoTranslation *capa3PosTr4 = new TGeoTranslation("cardHVcapa3PosTr4",
4295 1 : fgkHVCardCapa3PosX4, fgkHVCardCapa3PosY2,
4296 1 : -fgkHVCardCeramZ/2-fgkHVCardCapa3Z/2);
4297 :
4298 2 : TGeoTranslation *capa3PosTr5 = new TGeoTranslation("cardHVcapa3PosTr5",
4299 1 : fgkHVCardCapa3PosX5, fgkHVCardCapa3PosY3,
4300 1 : -fgkHVCardCeramZ/2-fgkHVCardCapa3Z/2);
4301 :
4302 1 : highVCard->AddNode(capa3, 1, capa3PosTr1);
4303 1 : highVCard->AddNode(capa3, 2, capa3PosTr2);
4304 1 : highVCard->AddNode(capa3, 3, capa3PosTr3);
4305 1 : highVCard->AddNode(capa3, 4, capa3PosTr4);
4306 1 : highVCard->AddNode(capa3, 5, capa3PosTr5);
4307 :
4308 1 : capa3->GetShape()->ComputeBBox(); //RS: enforce recompting of BBox
4309 : //====================================
4310 : //--- connexions to LV card
4311 :
4312 1 : Double_t fgkConnexLVHVdiam1 = 0.8*fgkmm;
4313 1 : Double_t fgkConnexLVHVdiam2 = 2*fgkmm;
4314 1 : Double_t fgkConnexLVHVlen = 6.2*fgkmm;
4315 1 : Double_t fgkConnexLVHVx = 3*fgkmm;
4316 1 : Double_t fgkConnexLVHVy1 = 8*fgkmm;
4317 1 : Double_t fgkConnexLVHVdy = 2.5*fgkmm;
4318 :
4319 2 : TGeoTube *connexLVHVmetal = new TGeoTube("connexLVHVmetal",0,
4320 1 : fgkConnexLVHVdiam1/2,fgkConnexLVHVlen/2);
4321 2 : TGeoTube *connexLVHVplastic = new TGeoTube("connexLVHVplastic",
4322 : fgkConnexLVHVdiam1/2,
4323 1 : fgkConnexLVHVdiam2/2,
4324 : fgkConnexLVHVlen/2);
4325 2 : TGeoVolume *vConnexLVHVmetal = new TGeoVolume("ITSsddConnexLVHVmetal",
4326 1 : connexLVHVmetal, stainless);
4327 2 : TGeoVolume *vConnexLVHVplast = new TGeoVolume("ITSsddConnexLVHVplast",
4328 1 : connexLVHVplastic, plastic);
4329 1 : vConnexLVHVmetal->SetLineColor(10);// white
4330 1 : vConnexLVHVplast->SetLineColor(12); // dark grey
4331 :
4332 1 : TGeoVolumeAssembly *connexion = new TGeoVolumeAssembly("ITSsddConnexLVHV");
4333 1 : connexion->AddNode(vConnexLVHVmetal, 1, 0);
4334 1 : connexion->AddNode(vConnexLVHVplast, 1, 0);
4335 :
4336 2 : TGeoTranslation *trConnexion1 = new TGeoTranslation(-fgkConnexLVHVx,fgkConnexLVHVy1,
4337 1 : -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 );
4338 2 : TGeoTranslation *trConnexion2 = new TGeoTranslation( fgkConnexLVHVx,fgkConnexLVHVy1,
4339 1 : -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 );
4340 :
4341 2 : TGeoTranslation *trConnexion3 = new TGeoTranslation(-fgkConnexLVHVx,
4342 1 : fgkConnexLVHVy1+fgkConnexLVHVdy,
4343 1 : -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 );
4344 2 : TGeoTranslation *trConnexion4 = new TGeoTranslation( fgkConnexLVHVx,
4345 : fgkConnexLVHVy1+fgkConnexLVHVdy,
4346 1 : -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 );
4347 :
4348 2 : TGeoTranslation *trConnexion5 = new TGeoTranslation(-fgkConnexLVHVx,
4349 1 : fgkConnexLVHVy1+2*fgkConnexLVHVdy,
4350 1 : -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 );
4351 2 : TGeoTranslation *trConnexion6 = new TGeoTranslation( fgkConnexLVHVx,
4352 : fgkConnexLVHVy1+2*fgkConnexLVHVdy,
4353 1 : -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 );
4354 :
4355 2 : TGeoTranslation *trConnexion7 = new TGeoTranslation(-fgkConnexLVHVx,
4356 1 : fgkConnexLVHVy1+3*fgkConnexLVHVdy,
4357 1 : -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 );
4358 2 : TGeoTranslation *trConnexion8 = new TGeoTranslation( fgkConnexLVHVx,
4359 : fgkConnexLVHVy1+3*fgkConnexLVHVdy,
4360 1 : -fgkHVCardCeramZ/2-fgkConnexLVHVlen/2 );
4361 :
4362 1 : connexion->GetShape()->ComputeBBox(); //RS: enforce recompting of BBox
4363 :
4364 :
4365 1 : highVCard->AddNode(connexion, 1, trConnexion1);
4366 1 : highVCard->AddNode(connexion, 2, trConnexion2);
4367 1 : highVCard->AddNode(connexion, 3, trConnexion3);
4368 1 : highVCard->AddNode(connexion, 4, trConnexion4);
4369 1 : highVCard->AddNode(connexion, 5, trConnexion5);
4370 1 : highVCard->AddNode(connexion, 6, trConnexion6);
4371 1 : highVCard->AddNode(connexion, 7, trConnexion7);
4372 1 : highVCard->AddNode(connexion, 8, trConnexion8);
4373 :
4374 : //====================================
4375 : //--- cooling pieces
4376 :
4377 2 : TGeoBBox *cardHVcool1 = new TGeoBBox("cardHVcool1",fgkHVCardCool1X/2,
4378 1 : fgkHVCardCool1Y/2, fgkHVCardCool1Z/2);
4379 :
4380 :
4381 2 : TGeoBBox *cardHVcool2 = new TGeoBBox("cardHVcool2",fgkHVCardCool2X/2,
4382 1 : fgkHVCardCool2Y/2, fgkHVCardCool2Z/2);
4383 :
4384 2 : TGeoBBox *cardHVcool3 = new TGeoBBox("cardHVcool3",fgkHVCardCool3X/2,
4385 1 : fgkHVCardCool3Y/2, fgkHVCardCool3Z/2);
4386 :
4387 1 : TGeoVolume *vCardHVcool1 = new TGeoVolume("vCardHVcool1",cardHVcool1,
4388 : alCu12SDD);
4389 1 : TGeoVolume *vCardHVcool2 = new TGeoVolume("vCardHVcool2",cardHVcool2,
4390 : alCu12SDD);
4391 1 : TGeoVolume *vCardHVcool3 = new TGeoVolume("vCardHVcool3",cardHVcool3,
4392 : alCu12SDD);
4393 : // This last volume contains the screw used for fixing
4394 : // the card to the cooling tube ...
4395 2 : TGeoTube *littleScrewHV = new TGeoTube("littleScrewHV", 0, fgkLittleScrewR,
4396 1 : fgkHVCardCool3Y/2);
4397 2 : TGeoVolume *vLittleScrewHV = new TGeoVolume("vLittleScrewHV",
4398 1 : littleScrewHV, stainless);
4399 :
4400 1 : TGeoRotation *rotScrewHead = new TGeoRotation("",0,90,0);
4401 1 : vCardHVcool3->AddNode(vLittleScrewHV, 1,rotScrewHead);
4402 :
4403 1 : vCardHVcool1->SetLineColor(2); //red
4404 1 : vCardHVcool2->SetLineColor(2); //red
4405 1 : vCardHVcool3->SetLineColor(2); //red
4406 :
4407 2 : TGeoTranslation *cool1Tr1 = new TGeoTranslation("cardHVcool1Tr1",
4408 1 : fgkHVCardCeramX/2-fgkHVCardCool1X/2,
4409 1 : -fgkHVCardCoolDY+fgkHVCardCool1Y/2,
4410 1 : fgkHVCardCeramZ/2+fgkHVCardCool1Z/2);
4411 2 : TGeoTranslation *cool1Tr2 = new TGeoTranslation("cardHVcool1Tr2",
4412 1 : -fgkHVCardCeramX/2+fgkHVCardCool1X/2,
4413 1 : -fgkHVCardCoolDY+fgkHVCardCool1Y/2,
4414 1 : fgkHVCardCeramZ/2+fgkHVCardCool1Z/2);
4415 :
4416 1 : highVCard->AddNode(vCardHVcool1, 1, cool1Tr1);
4417 1 : highVCard->AddNode(vCardHVcool1, 2, cool1Tr2);
4418 :
4419 2 : TGeoTranslation *cool2Tr1 = new TGeoTranslation("cardHVcool2Tr1",
4420 1 : fgkHVCardCeramX/2-fgkHVCardCool1X+fgkHVCardCool2X/2,
4421 1 : -fgkHVCardCoolDY-fgkHVCardCool2Y/2,
4422 1 : fgkHVCardCeramZ/2+fgkHVCardCool2Z/2);
4423 :
4424 2 : TGeoTranslation *cool2Tr2 = new TGeoTranslation("cardHVcool2Tr2",
4425 1 : -fgkHVCardCeramX/2+fgkHVCardCool1X-fgkHVCardCool2X/2,
4426 1 : -fgkHVCardCoolDY-fgkHVCardCool2Y/2,
4427 1 : fgkHVCardCeramZ/2+fgkHVCardCool2Z/2);
4428 :
4429 1 : highVCard->AddNode(vCardHVcool2, 1, cool2Tr1);
4430 1 : highVCard->AddNode(vCardHVcool2, 2, cool2Tr2);
4431 :
4432 2 : TGeoTranslation *cool3Tr1 = new TGeoTranslation("cardHVcool2Tr1",
4433 1 : fgkHVCardCeramX/2-fgkHVCardCool1X+fgkHVCardCool2X+fgkHVCardCool3X/2,
4434 1 : -fgkHVCardCoolDY-fgkHVCardCool3Y/2,
4435 1 : fgkHVCardCeramZ/2+fgkHVCardCool2Z-fgkHVCardCool3Z/2);
4436 :
4437 2 : TGeoTranslation *cool3Tr2 = new TGeoTranslation("cardHVcool2Tr2",
4438 1 : -fgkHVCardCeramX/2+fgkHVCardCool1X-fgkHVCardCool2X-fgkHVCardCool3X/2,
4439 1 : -fgkHVCardCoolDY-fgkHVCardCool3Y/2,
4440 1 : fgkHVCardCeramZ/2+fgkHVCardCool2Z-fgkHVCardCool3Z/2);
4441 :
4442 1 : highVCard->AddNode(vCardHVcool3, 1, cool3Tr1);
4443 1 : highVCard->AddNode(vCardHVcool3, 2, cool3Tr2);
4444 :
4445 : //====================================
4446 : //--- screws
4447 2 : TGeoCombiTrans *cbScrewHead1 = new TGeoCombiTrans("cardHVscrewHeadTr1",
4448 1 : fgkHVCardCeramX/2-fgkHVCardCool1X+fgkHVCardCool2X+fgkHVCardCool3X/2,
4449 1 : -fgkHVCardCoolDY+fgkLittleScrewHeadH/2,
4450 1 : fgkHVCardCeramZ/2+fgkHVCardCool2Z-fgkHVCardCool3Z/2,
4451 : rotScrewHead);
4452 2 : TGeoCombiTrans *cbScrewHead2 = new TGeoCombiTrans("cardHVscrewHeadTr2",
4453 1 : -fgkHVCardCeramX/2+fgkHVCardCool1X-fgkHVCardCool2X-fgkHVCardCool3X/2,
4454 1 : -fgkHVCardCoolDY+fgkLittleScrewHeadH/2,
4455 1 : fgkHVCardCeramZ/2+fgkHVCardCool2Z-fgkHVCardCool3Z/2,
4456 : rotScrewHead);
4457 :
4458 1 : highVCard->AddNode(fCommonVol[0], 1, cbScrewHead1);
4459 1 : highVCard->AddNode(fCommonVol[0], 2, cbScrewHead2);
4460 :
4461 1 : highVCard->GetShape()->ComputeBBox(); //RS: enforce recompting of BBox
4462 :
4463 1 : return highVCard;
4464 0 : }
4465 :
4466 : //________________________________________________________________________
4467 : TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateEndLadderCards(Int_t iLay) {
4468 : //
4469 : // return an assembly containing the LV, HV and Carlos cards of one ladder
4470 : // and their cooling system
4471 : //
4472 :
4473 0 : TGeoMedium *alCu12SDD = GetMedium("ALCU12$"); // ITSsddAlCu12
4474 0 : TGeoMedium *phynoxSDD = GetMedium("INOX$");
4475 0 : TGeoMedium *coolerMediumSDD = GetMedium("WATER$");
4476 :
4477 0 : TGeoVolumeAssembly *endLadderCards = new TGeoVolumeAssembly("endLadderCards");
4478 :
4479 : //=*********************************
4480 : //--- The rounded pipe for the end ladder card coooling
4481 :
4482 0 : Double_t endLadPipeUlength = fgkEndLadPipeUlengthLay3;
4483 0 : Double_t endLadPipeArmZ = fgkEndLadPipeArmZLay3;
4484 : Int_t nCards = 3;
4485 :
4486 0 : if (iLay==4) {
4487 0 : endLadPipeUlength = fgkEndLadPipeUlengthLay4;
4488 0 : endLadPipeArmZ = fgkEndLadPipeArmZLay4;
4489 : nCards = 4;
4490 0 : }
4491 :
4492 0 : AliITSv11GeomCableRound endLadderPipe("endLadderPipe", fgkEndLadPipeOuterDiam/2);
4493 0 : endLadderPipe.SetNLayers(2);
4494 0 : endLadderPipe.SetLayer(0, fgkEndLadPipeInnerDiam/2, coolerMediumSDD, 4);
4495 0 : endLadderPipe.SetLayer(1, (fgkEndLadPipeOuterDiam-fgkEndLadPipeInnerDiam)/2, phynoxSDD, fColorPhynox);
4496 :
4497 0 : Double_t coolUzPos = fgkEndLadPipeOuterDiam/2+2.*fgkmm; //it is the x coord of the axis
4498 : // of the U colling pipe in its center
4499 :
4500 0 : Double_t coordA[3] = { fgkEndLadPipeUwidth/2, 0, endLadPipeUlength+coolUzPos};
4501 0 : Double_t vectA[3] = {0,0,1};
4502 :
4503 0 : Double_t coordB[3] = { fgkEndLadPipeUwidth/2,0, fgkEndLadPipeRadius+coolUzPos};
4504 0 : Double_t vectB[3] = {0,0,1};
4505 :
4506 0 : Double_t coordC[3] = { fgkEndLadPipeUwidth/2-fgkEndLadPipeRadius, 0, coolUzPos};
4507 0 : Double_t vectC[3] = {1,0,0};
4508 :
4509 0 : Double_t coordD[3] = {-fgkEndLadPipeUwidth/2+fgkEndLadPipeRadius, 0, coolUzPos};
4510 0 : Double_t vectD[3] = {-1,0,0};
4511 :
4512 0 : Double_t coordE[3] = {-fgkEndLadPipeUwidth/2, 0, fgkEndLadPipeRadius+coolUzPos};
4513 0 : Double_t vectE[3] = {0,0,-1};
4514 :
4515 0 : Double_t coordF[3] = {-fgkEndLadPipeUwidth/2,0, endLadPipeUlength+coolUzPos};
4516 0 : Double_t vectF[3] = {0,0,-1};
4517 :
4518 0 : endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 0, coordA, vectA);
4519 0 : endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 1, coordB, vectB);
4520 0 : endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 2, coordC, vectC);
4521 0 : endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 3, coordD, vectD);
4522 0 : endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 4, coordE, vectE);
4523 0 : endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 5, coordF, vectF);
4524 :
4525 0 : endLadderPipe.SetInitialNode((TGeoVolume *) endLadderCards); //Set the root node
4526 : //endLadderPipe.CreateAndInsertCableSegment( 1);
4527 0 : endLadderPipe.CreateAndInsertTubeSegment( 1);
4528 : //endLadderPipe.CreateAndInsertCableSegment( 2);
4529 0 : endLadderPipe.CreateAndInsertTorusSegment( 2);
4530 : //endLadderPipe.CreateAndInsertCableSegment( 3);
4531 0 : endLadderPipe.CreateAndInsertTubeSegment( 3);
4532 : //endLadderPipe.CreateAndInsertCableSegment( 4);
4533 0 : endLadderPipe.CreateAndInsertTorusSegment( 4);
4534 : //endLadderPipe.CreateAndInsertCableSegment( 5);
4535 0 : endLadderPipe.CreateAndInsertTubeSegment( 5);
4536 :
4537 0 : TGeoBBox *endLadPipeArmBox = new TGeoBBox("endLadPipeArmBox",fgkEndLadPipeArmX/2,
4538 0 : fgkEndLadPipeArmY/2, endLadPipeArmZ/2);
4539 0 : TGeoTube *endLadPipeArmTube = new TGeoTube("endLadPipeArmTube", 0,
4540 0 : fgkEndLadPipeOuterDiam/2, endLadPipeArmZ/2);
4541 :
4542 0 : TGeoTranslation *endLadPipeArmBoxDY1 = new TGeoTranslation("endLadPipeArmBoxDY1",
4543 0 : - fgkEndLadPipeArmBoxDX,
4544 0 : fgkEndLadPipeArmBoxDY,0);
4545 0 : TGeoTranslation *endLadPipeArmBoxDY2 = new TGeoTranslation("endLadPipeArmBoxDY2",
4546 0 : fgkEndLadPipeArmBoxDX,
4547 0 : fgkEndLadPipeArmBoxDY,0);
4548 0 : endLadPipeArmBoxDY1->RegisterYourself();
4549 0 : endLadPipeArmBoxDY2->RegisterYourself();
4550 :
4551 0 : if(GetDebug(3)) { // Remove compiler warning.
4552 0 : endLadPipeArmBox->InspectShape();
4553 0 : endLadPipeArmTube->InspectShape();
4554 : }
4555 :
4556 0 : TGeoCompositeShape *endLadPipeArm1 = new TGeoCompositeShape("ITSsddEndLadPipeArm1",
4557 : "endLadPipeArmBox:endLadPipeArmBoxDY1"
4558 : "- endLadPipeArmTube");
4559 0 : TGeoCompositeShape *endLadPipeArm2 = new TGeoCompositeShape("ITSsddEndLadPipeArm2",
4560 : "endLadPipeArmBox:endLadPipeArmBoxDY2"
4561 : "- endLadPipeArmTube");
4562 :
4563 0 : TGeoVolume *vEndLadPipeArm1 = new TGeoVolume("ITSsddVolEndLadPipeArm1",
4564 0 : endLadPipeArm1, alCu12SDD);
4565 0 : TGeoVolume *vEndLadPipeArm2 = new TGeoVolume("ITSsddVolEndLadPipeArm2",
4566 0 : endLadPipeArm2, alCu12SDD);
4567 0 : vEndLadPipeArm1->SetLineColor(2);
4568 0 : vEndLadPipeArm2->SetLineColor(2);
4569 :
4570 0 : Double_t armZ = (coolUzPos-fgkEndLadPipeOuterDiam/2+endLadPipeArmZ/2
4571 0 : +fgkEndLadPipeArmZpos);
4572 :
4573 0 : TGeoTranslation *trEndLadPipeArm1 = new TGeoTranslation("trEndLadPipeArm1",
4574 0 : -fgkEndLadPipeUwidth/2,0,armZ);
4575 0 : TGeoTranslation *trEndLadPipeArm2 = new TGeoTranslation("trEndLadPipeArm2",
4576 0 : fgkEndLadPipeUwidth/2,0,armZ);
4577 :
4578 0 : endLadderCards->AddNode(vEndLadPipeArm1, 1, trEndLadPipeArm1);
4579 0 : endLadderCards->AddNode(vEndLadPipeArm2, 1, trEndLadPipeArm2);
4580 :
4581 : //=*********************************
4582 : //--- LV cards
4583 0 : TGeoVolumeAssembly *cardLVassemblyR = fCardLVR;
4584 0 : TGeoVolumeAssembly *cardLVassemblyL = fCardLVL;
4585 :
4586 0 : Double_t spaceBetweenCards = 0.2*fgkmm;
4587 :
4588 0 : Double_t cardLVxShift = (fgkEndLadPipeUwidth/2-fgkEndLadPipeArmX/2
4589 0 : +fgkEndLadPipeArmBoxDX);
4590 0 : Double_t cardLVyShift = (-fgkLVcoolPosY-fgkLVcoolY1+fgkLVcoolY3
4591 0 : +fgkEndLadPipeArmY/2+fgkEndLadPipeArmBoxDY);
4592 :
4593 0 : Double_t alLVcoolZ3 = (fgkLVcardCuZ+fgkLVcardZ+2.*(fgkLVChip0SiZ+fgkLVChip0Z)
4594 0 : +fgkLVcoolZ1*2.);
4595 :
4596 0 : Double_t firstLVCardZ = fgkEndLadPipeArmZpos-fgkEndLadPipeOuterDiam/2.+alLVcoolZ3/2
4597 0 : +coolUzPos+1.25*fgkmm;
4598 : // Position in z of the first LVB with respect to the start of the cooling
4599 : // rectangular arm, coming (from inside of the ladder)
4600 : // The cards are added one after the other
4601 :
4602 0 : for (Int_t iCard=0; iCard<nCards; iCard++) {
4603 :
4604 0 : Double_t cardLVzShift = firstLVCardZ +
4605 0 : Double_t(iCard)*(alLVcoolZ3 + 2.*spaceBetweenCards+fgkHVCardCool3Z);
4606 :
4607 0 : TGeoTranslation *trCardLVassemblyR = new TGeoTranslation(cardLVxShift,
4608 : cardLVyShift, cardLVzShift);
4609 0 : TGeoTranslation *trCardLVassemblyL = new TGeoTranslation(-cardLVxShift,
4610 : cardLVyShift, cardLVzShift);
4611 :
4612 0 : endLadderCards->AddNode(cardLVassemblyR, iCard+1, trCardLVassemblyR);
4613 0 : endLadderCards->AddNode(cardLVassemblyL, iCard+1, trCardLVassemblyL);
4614 : }
4615 :
4616 : //=*********************************
4617 : //--- HV cards
4618 0 : TGeoVolumeAssembly *cardHV = fCardHV;
4619 :
4620 0 : Double_t coolHVdy = (fgkHVCardCoolDY + fgkHVCardCool3Y
4621 0 : + fgkEndLadPipeArmY/2 + fgkEndLadPipeArmBoxDY);
4622 :
4623 0 : Double_t coolHVCenterShift = (fgkHVCardCool3Z/2-fgkHVCardCool2Z
4624 0 : -(fgkHVCardCeramZ)/2);
4625 :
4626 0 : for (Int_t iCard=0; iCard<nCards; iCard++) {
4627 :
4628 0 : Double_t fact = iCard*2.+1.;
4629 0 : Double_t coolHVdz = (firstLVCardZ + alLVcoolZ3*fact/2 + spaceBetweenCards*fact
4630 0 : + fgkHVCardCool3Z*fact/2. + coolHVCenterShift);
4631 0 : TGeoTranslation *trCardHV = new TGeoTranslation(0,coolHVdy, coolHVdz);
4632 0 : endLadderCards->AddNode(cardHV, iCard+1, trCardHV);
4633 : }
4634 :
4635 : //=*********************************
4636 : //--- Carlos card
4637 :
4638 0 : TGeoVolumeAssembly *assemblySupCarlos = fCardCarlos;
4639 : // TGeoRotation *carlosSupRot1 = new TGeoRotation("carlosSuppAngle",
4640 : // 0, -fgkCarlosSuppAngle, 0);
4641 :
4642 0 : Double_t spaceBetweenCarlsoCards = 0.1*fgkmm;
4643 0 : Double_t firstCarlosCardZ = (firstLVCardZ - alLVcoolZ3/2 + alLVcoolZ3*4 +
4644 0 : fgkHVCardCool3Z*4 + spaceBetweenCards*7 + 2*fgkmm);
4645 : // position in z of the first Carlos board, coming from inside of the ladder
4646 :
4647 0 : Double_t coolCarlosDy = (fgkCarlosSuppY3/2 + fgkEndLadPipeArmY/2 +
4648 0 : fgkEndLadPipeArmBoxDY);
4649 :
4650 0 : for (Int_t iCard=0; iCard<nCards; iCard++) {
4651 :
4652 0 : Double_t carloszPos = ( firstCarlosCardZ + fgkCarlosSuppZ3/2 +
4653 0 : iCard*(fgkCarlosSuppZ3+spaceBetweenCarlsoCards) );
4654 0 : TGeoCombiTrans *carlosPos = new TGeoCombiTrans(0,coolCarlosDy,carloszPos,
4655 0 : (TGeoRotation*) fCommonTr[0]);
4656 :
4657 0 : endLadderCards->AddNode(assemblySupCarlos, iCard, carlosPos);
4658 : }
4659 :
4660 0 : endLadderCards->GetShape()->ComputeBBox(); //RS: enforce recompting of BBox
4661 :
4662 : return endLadderCards;
4663 0 : }
4664 :
4665 :
4666 : //________________________________________________________________________
4667 : TGeoVolume* AliITSv11GeometrySDD::CreateEndLadderCardsV(Int_t iLay) {
4668 : //
4669 : // return an Pcon containing the LV, HV and Carlos cards of one ladder
4670 : // and their cooling system
4671 : // This is the code actually used for the end ladder cards
4672 : //
4673 :
4674 4 : TGeoMedium *alCu12SDD = GetMedium("ALCU12$"); // ITSsddAlCu12
4675 2 : TGeoMedium *phynoxSDD = GetMedium("INOX$");
4676 2 : TGeoMedium *coolerMediumSDD = GetMedium("WATER$");
4677 2 : TGeoMedium *copper = GetMedium("COPPER$");
4678 2 : TGeoMedium *plastic = GetMedium("SDDKAPTON (POLYCH2)$"); // ???
4679 2 : TGeoMedium *airSDD = GetMedium("SDD AIR$");
4680 2 : TGeoMedium *opticalFiber = GetMedium("SDD OPTICFIB$");
4681 2 : TGeoMedium *polyurethane = GetMedium("POLYURETHANE$");
4682 :
4683 2 : Double_t endLadPipeUlength = fgkEndLadPipeUlengthLay3;
4684 2 : Double_t endLadPipeArmZ = fgkEndLadPipeArmZLay3;
4685 : Int_t nCards = 3;
4686 2 : Double_t rREF = fgkEndLaddCardsShortRadiusLay3;
4687 : Double_t deltaZcables = 0;
4688 : // reference radius corresponding to local y=0
4689 :
4690 2 : if (iLay==4) {
4691 1 : endLadPipeUlength = fgkEndLadPipeUlengthLay4;
4692 1 : endLadPipeArmZ = fgkEndLadPipeArmZLay4;
4693 : nCards = 4;
4694 1 : rREF = fgkEndLaddCardsShortRadiusLay4;
4695 1 : deltaZcables = 2.8*fgkmm;
4696 1 : }
4697 :
4698 2 : Double_t cardLVxShift = (fgkEndLadPipeUwidth/2-fgkEndLadPipeArmX/2
4699 2 : +fgkEndLadPipeArmBoxDX);
4700 2 : Double_t cardLVyShift = (-fgkLVcoolPosY-fgkLVcoolY1+fgkLVcoolY3
4701 2 : +fgkEndLadPipeArmY/2+fgkEndLadPipeArmBoxDY);
4702 :
4703 2 : Double_t rMin = rREF + cardLVyShift;
4704 : // (The LV card is defining rMin because it is the lower object)
4705 :
4706 : Double_t thickTotCable = 0.5;
4707 :
4708 : //==================================
4709 : //--- The Pcon container
4710 :
4711 : // minimum angle of the Pcon :
4712 4 : Double_t tanDPhi = ((fgkEndLadPipeUwidth/2+fgkEndLadPipeArmX/2) /
4713 2 : (rREF-fgkEndLadPipeArmY/2) );
4714 2 : Double_t dphi = 2*TMath::ATan(tanDPhi)*TMath::RadToDeg();
4715 2 : Double_t phi0 = 90-dphi/2;
4716 2 : Double_t coolUzPos = fgkEndLadPipeOuterDiam/2 + fgkDistEndLaddCardsLadd; // it is the z coord of the axis
4717 : // of the U colling pipe in its center
4718 2 : Double_t zMax = endLadPipeUlength+coolUzPos;
4719 2 : Double_t rMax = rMin + fgkLVcardY;
4720 2 : rMax = TMath::Sqrt(rMax*rMax + cardLVxShift*cardLVxShift);
4721 2 : Double_t cablesRadius = rMax-0.5;
4722 :
4723 2 : TGeoPcon *containerShape = new TGeoPcon("EndLadderCcontainerShape", phi0, dphi, 10);
4724 : //DefineSection(Int_t snum, Double_t z, Double_t rmin, Double_t rmax);
4725 : // hard coded numbers are fine tuning to avoid overlaps with other volume in the old geometry
4726 2 : containerShape->DefineSection(0, fgkDistEndLaddCardsLadd, rREF-fgkEndLadPipeOuterDiam/2-0.2, rMax);
4727 2 : containerShape->DefineSection(1, fgkDistEndLaddCardsLadd+1.4, rREF-fgkEndLadPipeOuterDiam/2-0.2, rMax);
4728 2 : containerShape->DefineSection(2, fgkDistEndLaddCardsLadd+1.4, rMin, rMax);
4729 2 : containerShape->DefineSection(3, endLadPipeArmZ+2*fgkEndLadPipeRadius, rMin, rMax);
4730 2 : containerShape->DefineSection(4, endLadPipeArmZ+2*fgkEndLadPipeRadius, rREF-1.*fgkmm, rMax);
4731 2 : containerShape->DefineSection(5, zMax, rREF-1.*fgkmm, rMax);
4732 : // the following is quite dirty but works for the moment ...
4733 2 : containerShape->DefineSection(6, zMax, rREF+fgkCarlosCardZ1/2, rMax);
4734 2 : containerShape->DefineSection(7, zMax+1, cablesRadius-thickTotCable/2, rMax);
4735 :
4736 : // The next parameters define the shape of the Pcon at its end and where cables
4737 : // are escaping...
4738 : Double_t cableSectionR1 = cablesRadius-thickTotCable/2;
4739 : Double_t cableSectionR2 = rMax;
4740 2 : Double_t cableSectionZ1 = zMax + 23.6*fgkmm + 3.0*fgkcm + deltaZcables;
4741 2 : Double_t cableSectionZ2 = zMax + 23.6*fgkmm + 4.0*fgkcm + deltaZcables;
4742 : // Those numbers are to be fixed to stick the maximum to the SDD cone
4743 : // (hardcoded numbers are ugly, but it's easier to find where to stop)
4744 :
4745 2 : containerShape->DefineSection(8, cableSectionZ1, cableSectionR1, rMax);
4746 2 : containerShape->DefineSection(9, cableSectionZ2, cableSectionR2, rMax);
4747 :
4748 2 : TGeoVolume *endLadderCards = new TGeoVolume("endLadderCards",containerShape,airSDD);
4749 : //endLadderCards->SetVisibility(kFALSE);
4750 :
4751 : //=*********************************
4752 : //--- The rounded pipe for the end ladder card cooling
4753 :
4754 2 : AliITSv11GeomCableRound endLadderPipe("endLadderPipe", fgkEndLadPipeOuterDiam/2);
4755 2 : endLadderPipe.SetNLayers(2);
4756 2 : endLadderPipe.SetLayer(0, fgkEndLadPipeInnerDiam/2, coolerMediumSDD, 4);
4757 2 : endLadderPipe.SetLayer(1, (fgkEndLadPipeOuterDiam-fgkEndLadPipeInnerDiam)/2, phynoxSDD, fColorPhynox);
4758 :
4759 2 : Double_t coordA[3] = { fgkEndLadPipeUwidth/2, rREF, endLadPipeUlength+coolUzPos};
4760 2 : Double_t vectA[3] = {0,0,1};
4761 :
4762 2 : Double_t coordB[3] = { fgkEndLadPipeUwidth/2,rREF, fgkEndLadPipeRadius+coolUzPos};
4763 2 : Double_t vectB[3] = {0,0,1};
4764 :
4765 2 : Double_t coordC[3] = { fgkEndLadPipeUwidth/2-fgkEndLadPipeRadius, rREF, coolUzPos};
4766 2 : Double_t vectC[3] = {1,0,0};
4767 :
4768 2 : Double_t coordD[3] = {-fgkEndLadPipeUwidth/2+fgkEndLadPipeRadius, rREF, coolUzPos};
4769 2 : Double_t vectD[3] = {-1,0,0};
4770 :
4771 2 : Double_t coordE[3] = {-fgkEndLadPipeUwidth/2, rREF, fgkEndLadPipeRadius+coolUzPos};
4772 2 : Double_t vectE[3] = {0,0,-1};
4773 :
4774 2 : Double_t coordF[3] = {-fgkEndLadPipeUwidth/2,rREF, endLadPipeUlength+coolUzPos};
4775 2 : Double_t vectF[3] = {0,0,-1};
4776 :
4777 2 : endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 0, coordA, vectA);
4778 2 : endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 1, coordB, vectB);
4779 2 : endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 2, coordC, vectC);
4780 2 : endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 3, coordD, vectD);
4781 2 : endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 4, coordE, vectE);
4782 2 : endLadderPipe.AddCheckPoint( (TGeoVolume *) endLadderCards, 5, coordF, vectF);
4783 :
4784 2 : endLadderPipe.SetInitialNode((TGeoVolume *) endLadderCards); //Set the root node
4785 : //endLadderPipe.CreateAndInsertCableSegment( 1);
4786 2 : endLadderPipe.CreateAndInsertTubeSegment( 1);
4787 : //endLadderPipe.CreateAndInsertCableSegment( 2);
4788 2 : endLadderPipe.CreateAndInsertTorusSegment( 2);
4789 : //endLadderPipe.CreateAndInsertCableSegment( 3);
4790 2 : endLadderPipe.CreateAndInsertTubeSegment( 3);
4791 : //endLadderPipe.CreateAndInsertCableSegment( 4);
4792 2 : endLadderPipe.CreateAndInsertTorusSegment( 4);
4793 : //endLadderPipe.CreateAndInsertCableSegment( 5);
4794 2 : endLadderPipe.CreateAndInsertTubeSegment( 5);
4795 :
4796 6 : TGeoBBox *endLadPipeArmBox = new TGeoBBox("endLadPipeArmBox",fgkEndLadPipeArmX/2,
4797 2 : fgkEndLadPipeArmY/2, endLadPipeArmZ/2);
4798 6 : TGeoTube *endLadPipeArmTube = new TGeoTube("endLadPipeArmTube", 0,
4799 2 : fgkEndLadPipeOuterDiam/2, endLadPipeArmZ/2);
4800 :
4801 6 : TGeoTranslation *endLadPipeArmBoxDY1 = new TGeoTranslation("endLadPipeArmBoxDY1",
4802 2 : - fgkEndLadPipeArmBoxDX,
4803 2 : fgkEndLadPipeArmBoxDY,0);
4804 6 : TGeoTranslation *endLadPipeArmBoxDY2 = new TGeoTranslation("endLadPipeArmBoxDY2",
4805 2 : fgkEndLadPipeArmBoxDX,
4806 2 : fgkEndLadPipeArmBoxDY,0);
4807 2 : endLadPipeArmBoxDY1->RegisterYourself();
4808 2 : endLadPipeArmBoxDY2->RegisterYourself();
4809 :
4810 2 : if(GetDebug(3)) { // Remove compiler warning.
4811 0 : endLadPipeArmBox->InspectShape();
4812 0 : endLadPipeArmTube->InspectShape();
4813 : }
4814 :
4815 4 : TGeoCompositeShape *endLadPipeArm1 = new TGeoCompositeShape("ITSsddEndLadPipeArm1",
4816 : "endLadPipeArmBox:endLadPipeArmBoxDY1"
4817 : "- endLadPipeArmTube");
4818 4 : TGeoCompositeShape *endLadPipeArm2 = new TGeoCompositeShape("ITSsddEndLadPipeArm2",
4819 : "endLadPipeArmBox:endLadPipeArmBoxDY2"
4820 : "- endLadPipeArmTube");
4821 :
4822 6 : TGeoVolume *vEndLadPipeArm1 = new TGeoVolume("ITSsddVolEndLadPipeArm1",
4823 2 : endLadPipeArm1, alCu12SDD);
4824 6 : TGeoVolume *vEndLadPipeArm2 = new TGeoVolume("ITSsddVolEndLadPipeArm2",
4825 2 : endLadPipeArm2, alCu12SDD);
4826 2 : vEndLadPipeArm1->SetLineColor(2);
4827 2 : vEndLadPipeArm2->SetLineColor(2);
4828 :
4829 2 : Double_t armZ = (coolUzPos-fgkEndLadPipeOuterDiam/2+endLadPipeArmZ/2
4830 2 : +fgkEndLadPipeArmZpos);
4831 :
4832 6 : TGeoTranslation *trEndLadPipeArm1 = new TGeoTranslation("trEndLadPipeArm1",
4833 2 : -fgkEndLadPipeUwidth/2,rREF,armZ);
4834 6 : TGeoTranslation *trEndLadPipeArm2 = new TGeoTranslation("trEndLadPipeArm2",
4835 2 : fgkEndLadPipeUwidth/2,rREF,armZ);
4836 :
4837 2 : endLadderCards->AddNode(vEndLadPipeArm1, 1, trEndLadPipeArm1);
4838 2 : endLadderCards->AddNode(vEndLadPipeArm2, 1, trEndLadPipeArm2);
4839 :
4840 : //=*********************************
4841 : //--- LV cards
4842 2 : TGeoVolumeAssembly *cardLVassemblyR = fCardLVR;
4843 2 : TGeoVolumeAssembly *cardLVassemblyL = fCardLVL;
4844 :
4845 2 : Double_t spaceBetweenCards = 0.2*fgkmm;
4846 :
4847 :
4848 2 : Double_t alLVcoolZ3 = (fgkLVcardCuZ+fgkLVcardZ+2.*(fgkLVChip0SiZ+fgkLVChip0Z)
4849 2 : +fgkLVcoolZ1*2.);
4850 :
4851 2 : Double_t firstLVCardZ = fgkEndLadPipeArmZpos-fgkEndLadPipeOuterDiam/2.+alLVcoolZ3/2
4852 2 : +coolUzPos+1.25*fgkmm;
4853 : // Position in z of the first LVB with respect to the start of the cooling
4854 : // rectangular arm, coming (from inside of the ladder)
4855 : // The cards are added one after the other
4856 :
4857 18 : for (Int_t iCard=0; iCard<nCards; iCard++) {
4858 :
4859 7 : Double_t cardLVzShift = firstLVCardZ +
4860 7 : Double_t(iCard)*(alLVcoolZ3 + 2.*spaceBetweenCards+fgkHVCardCool3Z);
4861 :
4862 14 : TGeoTranslation *trCardLVassemblyR = new TGeoTranslation(cardLVxShift,
4863 : cardLVyShift+rREF, cardLVzShift);
4864 14 : TGeoTranslation *trCardLVassemblyL = new TGeoTranslation(-cardLVxShift,
4865 : cardLVyShift+rREF, cardLVzShift);
4866 :
4867 7 : endLadderCards->AddNode(cardLVassemblyR, iCard+1, trCardLVassemblyR);
4868 7 : endLadderCards->AddNode(cardLVassemblyL, iCard+1, trCardLVassemblyL);
4869 : }
4870 :
4871 : //=*********************************
4872 : //--- HV cards
4873 2 : TGeoVolumeAssembly *cardHV = fCardHV;
4874 :
4875 2 : Double_t coolHVdy = (fgkHVCardCoolDY + fgkHVCardCool3Y
4876 2 : + fgkEndLadPipeArmY/2 + fgkEndLadPipeArmBoxDY);
4877 : // shift of the HV card in local y w.r.t the local y=0 (center of cooling tube)
4878 :
4879 2 : Double_t coolHVCenterShift = (fgkHVCardCool3Z/2-fgkHVCardCool2Z
4880 2 : -(fgkHVCardCeramZ)/2);
4881 :
4882 18 : for (Int_t iCard=0; iCard<nCards; iCard++) {
4883 :
4884 7 : Double_t fact = iCard*2.+1.;
4885 7 : Double_t coolHVdz = (firstLVCardZ + alLVcoolZ3*fact/2 + spaceBetweenCards*fact
4886 7 : + fgkHVCardCool3Z*fact/2. + coolHVCenterShift);
4887 14 : TGeoTranslation *trCardHV = new TGeoTranslation(0,coolHVdy+rREF, coolHVdz);
4888 7 : endLadderCards->AddNode(cardHV, iCard+1, trCardHV);
4889 : }
4890 :
4891 : //=*********************************
4892 : //--- Carlos card
4893 :
4894 2 : TGeoVolumeAssembly *assemblySupCarlos = fCardCarlos;
4895 : // TGeoRotation *carlosSupRot1 = new TGeoRotation("carlosSuppAngle",
4896 : // 0, -fgkCarlosSuppAngle, 0);
4897 :
4898 2 : Double_t spaceBetweenCarlsoCards = 0.1*fgkmm;
4899 4 : Double_t firstCarlosCardZ = (firstLVCardZ - alLVcoolZ3/2 + alLVcoolZ3*4 +
4900 4 : fgkHVCardCool3Z*4 + spaceBetweenCards*7 + 2*fgkmm);
4901 : // position in z of the first Carlos board, coming from inside of the ladder
4902 :
4903 4 : Double_t coolCarlosDy = (fgkCarlosSuppY3/2 + fgkEndLadPipeArmY/2 +
4904 2 : fgkEndLadPipeArmBoxDY);
4905 :
4906 18 : for (Int_t iCard=0; iCard<nCards; iCard++) {
4907 :
4908 14 : Double_t carloszPos = ( firstCarlosCardZ + fgkCarlosSuppZ3/2 +
4909 7 : iCard*(fgkCarlosSuppZ3+spaceBetweenCarlsoCards) );
4910 21 : TGeoCombiTrans *carlosPos = new TGeoCombiTrans(0,coolCarlosDy+rREF,carloszPos,
4911 7 : (TGeoRotation*) fCommonTr[0]);
4912 :
4913 7 : endLadderCards->AddNode(assemblySupCarlos, iCard, carlosPos);
4914 : }
4915 :
4916 :
4917 : //=*********************************
4918 : //--- Cables
4919 :
4920 :
4921 2 : Double_t sectionV = (fgkSectionCuPerMod+fgkSectionPlastPerMod
4922 2 : + fgkSectionGlassPerMod)*nCards
4923 2 : + fgkSectionCoolPolyuEL + fgkSectionCoolWaterEL;
4924 : // We fix thickness, then width is calculated accordingly
4925 2 : Double_t width = sectionV/thickTotCable;
4926 : Double_t thickCu = thickTotCable*fgkSectionCuPerMod
4927 2 : / (fgkSectionCuPerMod+fgkSectionPlastPerMod+fgkSectionGlassPerMod+fgkSectionCoolPolyuEL+fgkSectionCoolWaterEL);
4928 2 : Double_t thickPlast = thickTotCable*fgkSectionPlastPerMod
4929 2 : / (fgkSectionCuPerMod+fgkSectionPlastPerMod+fgkSectionGlassPerMod+fgkSectionCoolPolyuEL+fgkSectionCoolWaterEL);
4930 : Double_t thickGlass = thickTotCable*fgkSectionGlassPerMod
4931 2 : / (fgkSectionCuPerMod+fgkSectionPlastPerMod+fgkSectionGlassPerMod+fgkSectionCoolPolyuEL+fgkSectionCoolWaterEL);
4932 :
4933 : Double_t thickCoolPolyu = thickTotCable*fgkSectionCoolPolyuEL
4934 2 : / (fgkSectionCuPerMod+fgkSectionPlastPerMod+fgkSectionGlassPerMod+fgkSectionCoolPolyuEL+fgkSectionCoolWaterEL);
4935 : Double_t thickCoolWater = thickTotCable*fgkSectionCoolWaterEL
4936 2 : / (fgkSectionCuPerMod+fgkSectionPlastPerMod+fgkSectionGlassPerMod+fgkSectionCoolPolyuEL+fgkSectionCoolWaterEL);
4937 :
4938 2 : AliITSv11GeomCableFlat cable("SDDcableEndLadder",width,thickTotCable);
4939 2 : cable.SetNLayers(5);
4940 2 : cable.SetLayer(0, thickCu, copper, kRed);
4941 2 : cable.SetLayer(1, thickPlast, plastic, kYellow);
4942 2 : cable.SetLayer(2, thickGlass, opticalFiber, kGreen);
4943 2 : cable.SetLayer(3, thickCoolPolyu, polyurethane, kGray);
4944 2 : cable.SetLayer(4, thickCoolWater, coolerMediumSDD, kBlue);
4945 :
4946 2 : Double_t zVect[3]={0,0,1};
4947 6 : Double_t xMinCable = firstCarlosCardZ+nCards*(fgkCarlosSuppZ3
4948 6 : +spaceBetweenCarlsoCards)/2 + 2.9;
4949 : // the 2.9cm is for taking into account carlos card angle...
4950 :
4951 2 : Double_t zEndCable = GetConeZ(cablesRadius-thickTotCable/2, cableSectionR1,
4952 : cableSectionR2,cableSectionZ1,cableSectionZ2);
4953 :
4954 2 : Double_t pos1[3] = {0, cablesRadius, xMinCable};
4955 2 : Double_t pos2[3] = {0, cablesRadius, zEndCable};
4956 2 : cable.AddCheckPoint( endLadderCards, 0, pos1, zVect );
4957 2 : cable.AddCheckPoint( endLadderCards, 1, pos2, zVect );
4958 2 : cable.SetInitialNode(endLadderCards);
4959 2 : cable.CreateAndInsertCableSegment(1);
4960 :
4961 : // The earth cable
4962 4 : TGeoTorus *earthShape = new TGeoTorus(rMax-fgkEndLadderEarthCableR,
4963 : 0., fgkEndLadderEarthCableR,
4964 : phi0, dphi); // same as containerShape
4965 :
4966 6 : TGeoVolume *earthCable = new TGeoVolume("SDDcableEndLadderEarthCable",
4967 2 : earthShape, copper);
4968 :
4969 4 : endLadderCards->AddNode(earthCable, 1,
4970 6 : new TGeoTranslation(0, 0, fgkDistEndLaddCardsLadd+1));
4971 :
4972 : return endLadderCards;
4973 2 : }
4974 :
4975 : //________________________________________________________________________
4976 : TGeoVolumeAssembly* AliITSv11GeometrySDD::CreateSupportRing() {
4977 : //
4978 : // return an assembly of the support rings, attaching the ladders to the cone
4979 : //
4980 :
4981 :
4982 :
4983 0 : TGeoMedium *stainless = GetMedium("INOX$"); // To code !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
4984 0 : TGeoVolumeAssembly *supportRing = new TGeoVolumeAssembly("supportRing");
4985 :
4986 :
4987 : //**********************************
4988 : // ruby cage
4989 :
4990 0 : Double_t fgkRubyCageX = 9*fgkmm;
4991 0 : Double_t fgkRubyCageY = 5.5*fgkmm;
4992 0 : Double_t fgkRubyCageZ = 8*fgkmm;
4993 0 : Double_t fgkRubyCageInternSide = 5.*fgkmm; //side of the internal square
4994 0 : Double_t fgkRubyCageHoleDX = 2.*fgkmm;
4995 0 : Double_t fgkRubyCageVIntern = 5.42*fgkmm;
4996 0 : Double_t fgkRubyCageScrewHoleR = 4.5/2*fgkmm;
4997 0 : Double_t fgkRubyCageScrewHoleY = 1.5*fgkmm;
4998 :
4999 0 : TGeoBBox *rubyCageBox = new TGeoBBox("rubyCageBox",fgkRubyCageX/2,fgkRubyCageY/2,
5000 0 : fgkRubyCageZ/2);
5001 :
5002 : Double_t epsilon = 1e-10; //dummy epsilon to force the gl viewer to show holes
5003 :
5004 : // pieces common to both square and V cages
5005 0 : TGeoBBox *rubyCageInternBox = new TGeoBBox("rubyCageInternBox",fgkRubyCageInternSide/2,
5006 0 : fgkRubyCageY/2+epsilon, fgkRubyCageInternSide/2);
5007 :
5008 0 : TGeoTube *screwHole = new TGeoTube("screwHole", 0, fgkRubyCageScrewHoleR,
5009 0 : fgkRubyCageHoleDX/2+epsilon);
5010 :
5011 0 : TGeoRotation *rotV = new TGeoRotation("", 90,90,-90);
5012 0 : TGeoCombiTrans *trScrewHole = new TGeoCombiTrans("trScrewHole",
5013 0 : fgkRubyCageX/2-fgkRubyCageHoleDX/2,
5014 0 : -fgkRubyCageY/2+fgkRubyCageScrewHoleY,0,rotV);
5015 0 : trScrewHole->RegisterYourself();
5016 :
5017 0 : TGeoBBox *screwHoleFoot = new TGeoBBox("screwHoleFoot",fgkRubyCageHoleDX/2+epsilon,
5018 0 : fgkRubyCageScrewHoleY/2+epsilon, fgkRubyCageScrewHoleR);
5019 0 : TGeoTranslation *trScrewHoleFoot = new TGeoTranslation("trScrewHoleFoot",
5020 : fgkRubyCageX/2-fgkRubyCageHoleDX/2,
5021 0 : -fgkRubyCageY/2+fgkRubyCageScrewHoleY/2, 0);
5022 0 : trScrewHoleFoot->RegisterYourself();
5023 :
5024 :
5025 : // pieces which differ
5026 0 : Double_t rubyCageVInternBoxX = fgkRubyCageVIntern - fgkRubyCageInternSide/2;
5027 :
5028 0 : TGeoBBox *rubyCageVInternBox = new TGeoBBox("rubyCageVInternBox",rubyCageVInternBoxX/2,
5029 : fgkRubyCageY/2+epsilon, fgkRubyCageInternSide/2);
5030 :
5031 0 : TGeoTranslation *trRubyCageVInternBox = new TGeoTranslation("trRubyCageVInternB",
5032 0 : fgkRubyCageX/2-fgkRubyCageHoleDX-rubyCageVInternBoxX/2,0,0);
5033 0 : trRubyCageVInternBox->RegisterYourself();
5034 :
5035 0 : TGeoTrd1 *rubyCageVInternTriangl = new TGeoTrd1("rubyCageVInternTriangl", 0,
5036 : fgkRubyCageInternSide/2, fgkRubyCageY/2+epsilon,
5037 0 : fgkRubyCageInternSide/4);
5038 :
5039 0 : TGeoCombiTrans *trRubyCageVInternTriangl = new TGeoCombiTrans("trRubyCageVInternTriangl",
5040 0 : fgkRubyCageX/2-fgkRubyCageHoleDX-rubyCageVInternBoxX-fgkRubyCageInternSide/4
5041 0 : +epsilon,0,0, rotV );
5042 0 : trRubyCageVInternTriangl->RegisterYourself();
5043 :
5044 : //---
5045 0 : TGeoCompositeShape *rubyCageSquare = new TGeoCompositeShape("rubyCageSquare",
5046 : "rubyCageBox-(rubyCageInternBox"
5047 : "+screwHole:trScrewHole+screwHoleFoot:trScrewHoleFoot)");
5048 :
5049 0 : TGeoVolume *vRubyCageSquare = new TGeoVolume("vRubyCageSquare",
5050 0 : rubyCageSquare, stainless);
5051 0 : vRubyCageSquare->SetLineColor(10);
5052 :
5053 0 : TGeoCompositeShape *rubyCageV = new TGeoCompositeShape("rubyCageV",
5054 : "rubyCageBox-(rubyCageVInternBox:trRubyCageVInternB"
5055 : "+rubyCageVInternTriangl:trRubyCageVInternTriangl"
5056 : "+screwHole:trScrewHole+screwHoleFoot:trScrewHoleFoot)");
5057 0 : TGeoVolume *vRubyCageV = new TGeoVolume("vRubyCageV", rubyCageV, stainless);
5058 0 : vRubyCageV->SetLineColor(10);
5059 :
5060 0 : if(GetDebug(3)) { // Remove compiler warning.
5061 0 : rubyCageBox->InspectShape();
5062 0 : rubyCageInternBox->InspectShape();
5063 0 : screwHole->InspectShape();
5064 0 : screwHoleFoot->InspectShape();
5065 0 : rubyCageVInternBox->InspectShape();
5066 0 : rubyCageVInternTriangl->InspectShape();
5067 0 : }
5068 :
5069 0 : supportRing->AddNode(vRubyCageSquare, 0, 0);
5070 : //supportRing->AddNode(vRubyCageV, 0, 0);
5071 :
5072 0 : supportRing->GetShape()->ComputeBBox(); //RS: enforce recompting of BBox
5073 :
5074 0 : return supportRing;
5075 0 : }
5076 :
5077 :
5078 :
5079 : //________________________________________________________________________
5080 : void AliITSv11GeometrySDD::CreateSDDsensor() {
5081 : //
5082 : // return a box containing the SDD sensor
5083 : //
5084 :
5085 2 : TGeoMedium *airSDD = GetMedium("SDD AIR$");
5086 1 : TGeoMedium *siliconSDD = GetMedium("SDD SI insensitive$"); // ITSsddSi
5087 1 : TGeoMedium *siliconSDDsens = GetMedium("SI$"); // ITSsddSi
5088 1 : TGeoMedium *alSDD = GetMedium("AL$"); // ITSal
5089 1 : TGeoMedium *polyhamideSDD = GetMedium("SDDKAPTON (POLYCH2)$"); // ITSsddKAPTON_POLYCH2
5090 1 : TGeoMedium *glassSDD = GetMedium("STDGLASS$"); // StdGlass
5091 :
5092 :
5093 1 : Double_t rWraping = fgkWaferThickness/2+fgkWaHVcableAlThick+fgkWaHVcablePolyThick;
5094 1 : Double_t witdhCableBox = (fgkWaHVcableWitdh - TMath::Pi()*rWraping)/2;
5095 : // width : in the beam direction !
5096 :
5097 2 : Double_t sensoxBoxLength = ( fgkWaferLength +
5098 1 : 2*(rWraping+witdhCableBox-fgkWaHVcableDW) );
5099 : // Makes life easier to include the space for the WA HV cable on both sides
5100 2 : Double_t sensoxBoxThick = fgkWaferThickness +
5101 1 : 2*(fgkWaHVcableAlThick+fgkWaHVcablePolyThick);
5102 :
5103 : // cout << "fgkWaferLength=" << fgkWaferLength << " sensoxBoxLength="<< sensoxBoxLength <<endl;
5104 : // cout << "fgkWaferThickness=" << fgkWaferThickness << " sensoxBoxThick=" << sensoxBoxThick << endl;
5105 :
5106 2 : TGeoBBox *box = new TGeoBBox("ITSsddSensorBox",
5107 1 : fgkWaferWidth/2, sensoxBoxThick/2, sensoxBoxLength/2);
5108 :
5109 2 : fSDDsensor3 = new TGeoVolume("ITSsddSensor3", box, airSDD);
5110 2 : fSDDsensor4 = new TGeoVolume("ITSsddSensor4", box, airSDD);
5111 :
5112 :
5113 : //****************************
5114 : // silicon wafer
5115 : //****************************
5116 1 : if (fAddSensors) {
5117 : // we need 2 different sensor objects, because they have to have different names
5118 : // This is required for the step manager
5119 :
5120 2 : TGeoBBox *waferShape = new TGeoBBox("ITSsddWaferShape",
5121 1 : fgkWaferWidth/2, fgkWaferThickness/2, fgkWaferLength/2);
5122 :
5123 :
5124 1 : TGeoVolume *wafer3 = new TGeoVolume("ITSsddWafer3", waferShape, siliconSDD);
5125 1 : wafer3->SetLineColor(fColorSilicon);
5126 2 : TGeoBBox *sensBox3 = new TGeoBBox("ITSsddSensorSensBox3",
5127 1 : fgkWaferWidthSens/2, fgkWaferThickSens/2, fgkWaferLengthSens/2);
5128 1 : TGeoVolume *sensVol3 = new TGeoVolume(fgkSDDsensitiveVolName3,sensBox3, siliconSDDsens);
5129 1 : sensVol3->SetLineColor(fColorSilicon+5);
5130 1 : wafer3->AddNode(sensVol3, 1, 0);
5131 1 : fSDDsensor3->AddNode(wafer3, 1, 0);
5132 :
5133 1 : TGeoVolume *wafer4 = new TGeoVolume("ITSsddWafer4", waferShape, siliconSDD);
5134 1 : wafer4->SetLineColor(fColorSilicon);
5135 2 : TGeoBBox *sensBox4 = new TGeoBBox("ITSsddSensorSensBox4",
5136 1 : fgkWaferWidthSens/2, fgkWaferThickSens/2, fgkWaferLengthSens/2);
5137 1 : TGeoVolume *sensVol4 = new TGeoVolume(fgkSDDsensitiveVolName4,sensBox4, siliconSDDsens);
5138 1 : sensVol4->SetLineColor(fColorSilicon+5);
5139 1 : wafer4->AddNode(sensVol4, 1, 0);
5140 1 : fSDDsensor4->AddNode(wafer4, 1, 0);
5141 1 : };
5142 :
5143 : //****************************
5144 : // glass
5145 : //****************************
5146 2 : TGeoBBox *glass = new TGeoBBox("ITSsddGlassBox", fgkSensorGlassLX/2,
5147 1 : fgkSensorGlassLY/2, fgkSensorGlassLZ/2);
5148 1 : TGeoVolume *vGlass = new TGeoVolume("ITSsddGlass",glass, glassSDD);
5149 1 : vGlass->SetLineColor(fColorGlass);
5150 2 : TGeoTranslation *glassTr1 = new TGeoTranslation("",fgkGlassDXOnSensor,
5151 1 : fgkWaferThickness/2+fgkSensorGlassLY/2,
5152 1 : fgkGlassDZOnSensor);
5153 2 : TGeoTranslation *glassTr2 = new TGeoTranslation("",-fgkGlassDXOnSensor,
5154 1 : fgkWaferThickness/2+fgkSensorGlassLY/2,
5155 1 : fgkGlassDZOnSensor);
5156 2 : TGeoTranslation *glassTr3 = new TGeoTranslation("",fgkGlassDXOnSensor,
5157 1 : fgkWaferThickness/2+fgkSensorGlassLY/2,
5158 1 : -fgkGlassDZOnSensor);
5159 2 : TGeoTranslation *glassTr4 = new TGeoTranslation("",-fgkGlassDXOnSensor,
5160 1 : fgkWaferThickness/2+fgkSensorGlassLY/2,
5161 1 : -fgkGlassDZOnSensor);
5162 1 : fSDDsensor3->AddNode(vGlass, 1, glassTr1);
5163 1 : fSDDsensor3->AddNode(vGlass, 2, glassTr2);
5164 1 : fSDDsensor3->AddNode(vGlass, 3, glassTr3);
5165 1 : fSDDsensor3->AddNode(vGlass, 4, glassTr4);
5166 :
5167 1 : fSDDsensor4->AddNode(vGlass, 1, glassTr1);
5168 1 : fSDDsensor4->AddNode(vGlass, 2, glassTr2);
5169 1 : fSDDsensor4->AddNode(vGlass, 3, glassTr3);
5170 1 : fSDDsensor4->AddNode(vGlass, 4, glassTr4);
5171 :
5172 : //****************************
5173 : // Wrap-around cable
5174 : //****************************
5175 1 : if (fAddHVcables) {
5176 2 : AliITSv11GeomCableFlat waHVCable("ITSsddWaHVCableU",witdhCableBox,
5177 1 : fgkWaHVcableAlThick+fgkWaHVcablePolyThick);
5178 1 : waHVCable.SetNLayers(2);
5179 1 : waHVCable.SetLayer(0, fgkWaHVcablePolyThick,polyhamideSDD,fColorPolyhamide);
5180 1 : waHVCable.SetLayer(1, fgkWaHVcableAlThick, alSDD, fColorAl);
5181 1 : waHVCable.SetInitialNode(fSDDsensor3);
5182 :
5183 1 : Double_t x1[3], x2[3], vX[3] = {1,0,0};
5184 1 : x1[0] = -fgkWaHVcableLength/2;
5185 1 : x2[0] = -x1[0];
5186 1 : x1[1] = (fgkWaferThickness + waHVCable.GetThickness())/2;
5187 1 : x2[1] = x1[1];
5188 1 : x1[2] = fgkWaferLength/2+waHVCable.GetWidth()/2-fgkWaHVcableDW;
5189 1 : x2[2] = x1[2];
5190 :
5191 1 : waHVCable.AddCheckPoint(fSDDsensor3, 0, x1, vX);
5192 1 : waHVCable.AddCheckPoint(fSDDsensor3, 1, x2, vX);
5193 1 : TGeoCombiTrans *ctSegment = 0;
5194 1 : TGeoVolume* segment = waHVCable.CreateAndInsertBoxCableSegment(1,-90, &ctSegment);
5195 1 : fSDDsensor4->AddNode(segment, 1, ctSegment);
5196 :
5197 1 : x1[1] = -x1[1];
5198 1 : x2[1] = x1[1];
5199 1 : waHVCable.SetName("ITSsddWaHVCableD");
5200 1 : waHVCable.ResetPoints();
5201 1 : waHVCable.AddCheckPoint(fSDDsensor3, 0, x1, vX);
5202 1 : waHVCable.AddCheckPoint(fSDDsensor3, 1, x2, vX);
5203 1 : segment = waHVCable.CreateAndInsertBoxCableSegment(1, 90, &ctSegment);
5204 1 : fSDDsensor4->AddNode(segment, 1, ctSegment);
5205 :
5206 1 : AliITSv11GeomCableRound waHVCableFold("ITSsddWaHVCableFold",
5207 : rWraping);
5208 1 : waHVCableFold.SetPhi(180,360);
5209 1 : waHVCableFold.SetNLayers(2);
5210 2 : waHVCableFold.SetLayer(0, fgkWaferThickness/2+fgkWaHVcablePolyThick,
5211 1 : polyhamideSDD, fColorPolyhamide);
5212 1 : waHVCableFold.SetLayer(1, fgkWaHVcableAlThick, alSDD, fColorAl);
5213 1 : waHVCableFold.SetInitialNode(fSDDsensor3);
5214 1 : x1[1] = 0;
5215 1 : x2[1] = 0;
5216 1 : x1[2] = fgkWaferLength/2-fgkWaHVcableDW+witdhCableBox;
5217 1 : x2[2] = x1[2];
5218 1 : waHVCableFold.AddCheckPoint(fSDDsensor3, 0, x1, vX);
5219 1 : waHVCableFold.AddCheckPoint(fSDDsensor3, 1, x2, vX);
5220 1 : segment = waHVCableFold.CreateAndInsertCableSegment(1, &ctSegment);
5221 1 : fSDDsensor4->AddNode(segment, 1, ctSegment);
5222 :
5223 :
5224 : //****************************
5225 : // transition cable
5226 : //****************************
5227 2 : Double_t headRadius = (fgkTransitHVHeadLX*fgkTransitHVHeadLX/4.+
5228 1 : fgkTransitHVHeadLZ*fgkTransitHVHeadLZ)
5229 1 : /(2.*fgkTransitHVHeadLZ);
5230 2 : Double_t theta = TMath::ATan2(fgkTransitHVHeadLX/2,
5231 1 : headRadius-fgkTransitHVHeadLZ)
5232 1 : *TMath::RadToDeg();
5233 :
5234 3 : TGeoTubeSeg *headPoly = new TGeoTubeSeg(0,headRadius,
5235 1 : fgkTransitHVPolyThick/2,
5236 1 : 90-theta,90+theta);
5237 1 : headPoly->SetName("headPoly");
5238 3 : TGeoTranslation *headPolyTr = new TGeoTranslation(0,0,
5239 1 : -fgkTransitHVPolyThick/2);
5240 1 : headPolyTr->SetName("headPolyTr");
5241 1 : headPolyTr->RegisterYourself();
5242 :
5243 3 : TGeoTubeSeg *headAl = new TGeoTubeSeg(0,headRadius,
5244 1 : fgkTransitHVAlThick/2,
5245 : 90-theta,90+theta);
5246 1 : headAl->SetName("headAl");
5247 3 : TGeoTranslation *headAlTr = new TGeoTranslation(0,0,
5248 1 : -fgkTransitHVPolyThick
5249 1 : -fgkTransitHVAlThick/2);
5250 1 : headAlTr->SetName("headAlTr");
5251 1 : headAlTr->RegisterYourself();
5252 :
5253 3 : TGeoBBox *cache = new TGeoBBox(fgkTransitHVHeadLX/2,
5254 1 : (headRadius-fgkTransitHVHeadLZ)/2,
5255 1 : (fgkTransitHVPolyThick+fgkTransitHVAlThick)/2);
5256 1 : cache->SetName("cache");
5257 :
5258 3 : TGeoTranslation *headCacheTr = new TGeoTranslation(0,
5259 1 : (headRadius-fgkTransitHVHeadLZ)/2,
5260 2 : -(fgkTransitHVPolyThick
5261 2 : +fgkTransitHVAlThick)/2);
5262 1 : headCacheTr->SetName("cacheTr");
5263 1 : headCacheTr->RegisterYourself();
5264 :
5265 2 : TGeoCompositeShape *headPolyComp = new TGeoCompositeShape(
5266 : "headPoly:headPolyTr-cache:cacheTr");
5267 3 : TGeoVolume *vHeadPolyComp = new TGeoVolume(
5268 1 : "ITSsddHVtransitHeadPoly",headPolyComp, polyhamideSDD);
5269 1 : vHeadPolyComp->SetLineColor(fColorPolyhamide);
5270 2 : TGeoCompositeShape *headAlComp = new TGeoCompositeShape(
5271 : "headAl:headAlTr-cache:cacheTr");
5272 3 : TGeoVolume *vHeadAlComp = new TGeoVolume(
5273 1 : "ITSsddHVtransitHeadAl",headAlComp, alSDD);
5274 1 : vHeadAlComp->SetLineColor(fColorAl);
5275 :
5276 :
5277 : // TGeoRotation rotHead("",0,90,0);
5278 : // TGeoCombiTrans *rotHeadTr = new TGeoCombiTrans(0,fgkWaferThickness/2,
5279 : // -headRadius+fgkTransitHVHeadLZ+fgkTransitHVBondingLZ/2,
5280 : // &rotHead);
5281 2 : TGeoRotation *rotHead = new TGeoRotation("",0,90,0);
5282 3 : TGeoCombiTrans *rotHeadTr = new TGeoCombiTrans(0,fgkWaferThickness/2,
5283 1 : -headRadius+fgkTransitHVHeadLZ+fgkTransitHVBondingLZ/2,
5284 : rotHead);
5285 :
5286 1 : fSDDsensor3->AddNode(vHeadPolyComp,1,rotHeadTr);
5287 1 : fSDDsensor3->AddNode(vHeadAlComp,1,rotHeadTr);
5288 1 : fSDDsensor4->AddNode(vHeadPolyComp,1,rotHeadTr);
5289 1 : fSDDsensor4->AddNode(vHeadAlComp,1,rotHeadTr);
5290 :
5291 : //---
5292 2 : AliITSv11GeomCableFlat transitHVCable("ITSsddHVtransitCenter",
5293 1 : fgkTransitHVBondingLZ,
5294 1 : fgkTransitHVPolyThick+fgkTransitHVAlThick);
5295 1 : transitHVCable.SetNLayers(2);
5296 2 : transitHVCable.SetLayer(0, fgkTransitHVPolyThick,polyhamideSDD,
5297 1 : fColorPolyhamide);
5298 1 : transitHVCable.SetLayer(1, fgkTransitHVAlThick, alSDD, fColorAl);
5299 1 : transitHVCable.SetInitialNode(fSDDsensor3);
5300 :
5301 1 : x1[0] = -fgkTransitHVHeadLX/2;
5302 1 : x2[0] = -x1[0];
5303 1 : x1[1] = (fgkWaferThickness+fgkTransitHVPolyThick+fgkTransitHVAlThick)/2;
5304 1 : x2[1] = x1[1];
5305 1 : x1[2] = 0;
5306 1 : x2[2] = 0;
5307 1 : transitHVCable.AddCheckPoint(fSDDsensor3, 0, x1, vX);
5308 1 : transitHVCable.AddCheckPoint(fSDDsensor3, 1, x2, vX);
5309 1 : segment = transitHVCable.CreateAndInsertBoxCableSegment(1,-90,&ctSegment);
5310 1 : fSDDsensor4->AddNode(segment, 1, ctSegment);
5311 :
5312 1 : transitHVCable.ResetPoints();
5313 1 : transitHVCable.SetName("ITSsddHVtransitTail");
5314 1 : transitHVCable.SetWidth(fgkTransitHVtailWidth);
5315 1 : x1[0] = fgkTransitHVtailXpos;
5316 1 : x2[0] = fgkTransitHVtailXpos;
5317 1 : x1[2] = -fgkTransitHVBondingLZ/2;
5318 1 : x2[2] = -fgkTransitHVBondingLZ/2-fgkTransitHVtailLength;
5319 1 : Double_t vZ[3] = {0,0,1};
5320 1 : transitHVCable.AddCheckPoint(fSDDsensor3, 0, x1, vZ);
5321 1 : transitHVCable.AddCheckPoint(fSDDsensor3, 1, x2, vZ);
5322 1 : segment = transitHVCable.CreateAndInsertBoxCableSegment(1,0, &ctSegment);
5323 1 : fSDDsensor4->AddNode(segment, 1, ctSegment);
5324 :
5325 : //---
5326 2 : TGeoArb8 *sideLeft = new TGeoArb8( fgkTransitHVPolyThick/2 );
5327 1 : sideLeft->SetVertex(0, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,0);
5328 2 : sideLeft->SetVertex(1, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,
5329 1 : fgkTransitHVsideLZ);
5330 1 : sideLeft->SetVertex(2, fgkTransitHVHeadLX/2, fgkTransitHVsideLeftZ);
5331 1 : sideLeft->SetVertex(3, fgkTransitHVHeadLX/2, 0);
5332 1 : sideLeft->SetVertex(4, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,0);
5333 2 : sideLeft->SetVertex(5, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,
5334 1 : fgkTransitHVsideLZ);
5335 1 : sideLeft->SetVertex(6, fgkTransitHVHeadLX/2, fgkTransitHVsideLeftZ);
5336 1 : sideLeft->SetVertex(7, fgkTransitHVHeadLX/2, 0);
5337 :
5338 2 : TGeoArb8 *sideLeftAl = new TGeoArb8( fgkTransitHVAlThick/2 );
5339 1 : sideLeftAl->SetVertex(0, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,0);
5340 2 : sideLeftAl->SetVertex(1, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,
5341 1 : fgkTransitHVsideLZ);
5342 1 : sideLeftAl->SetVertex(2, fgkTransitHVHeadLX/2, fgkTransitHVsideLeftZ);
5343 1 : sideLeftAl->SetVertex(3, fgkTransitHVHeadLX/2, 0);
5344 1 : sideLeftAl->SetVertex(4, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,0);
5345 2 : sideLeftAl->SetVertex(5, fgkTransitHVtailXpos+fgkTransitHVtailWidth/2,
5346 1 : fgkTransitHVsideLZ);
5347 1 : sideLeftAl->SetVertex(6, fgkTransitHVHeadLX/2, fgkTransitHVsideLeftZ);
5348 1 : sideLeftAl->SetVertex(7, fgkTransitHVHeadLX/2, 0);
5349 :
5350 : // sideRight is not there actually
5351 : // TGeoArb8 *sideRight = new TGeoArb8( fgkTransitHVPolyThick/2 );
5352 : // sideRight->SetVertex(0, fgkTransitHVtailXpos-fgkTransitHVtailWidth/2,0);
5353 : // sideRight->SetVertex(1, fgkTransitHVtailXpos-fgkTransitHVtailWidth/2,
5354 : // fgkTransitHVsideLZ);
5355 : // sideRight->SetVertex(2, -fgkTransitHVHeadLX/2, fgkTransitHVsideRightZ);
5356 : // sideRight->SetVertex(3, -fgkTransitHVHeadLX/2, 0);
5357 : // sideRight->SetVertex(4, fgkTransitHVtailXpos-fgkTransitHVtailWidth/2,0);
5358 : // sideRight->SetVertex(5, fgkTransitHVtailXpos-fgkTransitHVtailWidth/2,
5359 : // fgkTransitHVsideLZ);
5360 : // sideRight->SetVertex(6, -fgkTransitHVHeadLX/2, fgkTransitHVsideRightZ);
5361 : // sideRight->SetVertex(7, -fgkTransitHVHeadLX/2, 0);
5362 :
5363 : // TGeoRotation rotSide("",0,-90,0);
5364 : // TGeoCombiTrans *sideRightTr = new TGeoCombiTrans(0,
5365 : // (fgkWaferThickness+fgkTransitHVPolyThick)/2,
5366 : // -fgkTransitHVBondingLZ/2,&rotSide);
5367 : // TGeoCombiTrans *sideLeftTr = new TGeoCombiTrans(0,
5368 : // (fgkWaferThickness+fgkTransitHVPolyThick)/2,
5369 : // -fgkTransitHVBondingLZ/2, &rotSide);
5370 : // TGeoCombiTrans *sideLeftAlTr = new TGeoCombiTrans(0,
5371 : // fgkTransitHVPolyThick+(fgkWaferThickness+fgkTransitHVAlThick)/2,
5372 : // -fgkTransitHVBondingLZ/2, &rotSide);
5373 2 : TGeoRotation *rotSide = new TGeoRotation("",0,-90,0);
5374 : // TGeoCombiTrans *sideRightTr = new TGeoCombiTrans(0,
5375 : // (fgkWaferThickness+fgkTransitHVPolyThick)/2,
5376 : // -fgkTransitHVBondingLZ/2,rotSide);
5377 3 : TGeoCombiTrans *sideLeftTr = new TGeoCombiTrans(0,
5378 1 : (fgkWaferThickness+fgkTransitHVPolyThick)/2,
5379 1 : -fgkTransitHVBondingLZ/2, rotSide);
5380 3 : TGeoCombiTrans *sideLeftAlTr = new TGeoCombiTrans(0,
5381 1 : fgkTransitHVPolyThick+(fgkWaferThickness+fgkTransitHVAlThick)/2,
5382 1 : -fgkTransitHVBondingLZ/2, rotSide);
5383 :
5384 3 : TGeoVolume *vSideLeft = new TGeoVolume("ITSsddHVtransitSideLeft",
5385 1 : sideLeft,polyhamideSDD);
5386 1 : vSideLeft->SetLineColor(fColorPolyhamide);
5387 3 : TGeoVolume *vSideLeftAl = new TGeoVolume("ITSsddHVtransitSideLeftAl",
5388 1 : sideLeftAl,alSDD);
5389 1 : vSideLeftAl->SetLineColor(fColorAl);
5390 :
5391 : // TGeoVolume *vSideRight = new TGeoVolume("ITSsddHVtransitSideRight",
5392 : // sideRight,polyhamideSDD);
5393 : // vSideRight->SetLineColor(fColorPolyhamide);
5394 :
5395 1 : fSDDsensor3->AddNode(vSideLeft, 1, sideLeftTr);
5396 1 : fSDDsensor3->AddNode(vSideLeftAl, 1, sideLeftAlTr);
5397 : // fSDDsensor3->AddNode(vSideRight, 1, sideRightTr);
5398 :
5399 1 : fSDDsensor4->AddNode(vSideLeft, 1, sideLeftTr);
5400 1 : fSDDsensor4->AddNode(vSideLeftAl, 1, sideLeftAlTr);
5401 : // fSDDsensor4->AddNode(vSideRight, 1, sideRightTr);
5402 1 : };
5403 :
5404 : //****************************
5405 1 : if(GetDebug(1)) {
5406 0 : fSDDsensor3->CheckOverlaps(0.01);
5407 0 : fSDDsensor4->CheckOverlaps(0.01);
5408 0 : }
5409 :
5410 1 : fSDDsensor3->SetVisibility(kFALSE);
5411 1 : fSDDsensor4->SetVisibility(kFALSE);
5412 1 : }
5413 :
5414 : /*
5415 : //________________________________________________________________________
5416 : TGeoVolume *AliITSv11GeometrySDD::CreateDetectors(Int_t iLay) {
5417 : //
5418 : // return a box volume containing the detectors
5419 : //
5420 :
5421 : TGeoMedium *airSDD = GetMedium("SDD AIR$");
5422 :
5423 : Int_t nDetectors = fgkLay3Ndet;
5424 : Double_t ladderLength = fgkLay3LadderLength;
5425 : Double_t *sensorZPos = fLay3sensorZPos;
5426 :
5427 : if (iLay==3) {}
5428 : else if (iLay==4) {
5429 : nDetectors = fgkLay4Ndet;
5430 : ladderLength = fgkLay4LadderLength;
5431 : sensorZPos = fLay4sensorZPos;
5432 : } else {
5433 : printf("AliITSv11GeometrySDD::CreateDetectors: Error : Wrong layer");
5434 : };
5435 :
5436 : char name[30];
5437 : Double_t volThickness = ( fgkLadWaferSep + 2*fgkWaferThickness +
5438 : 2*(fgkWaHVcableAlThick+fgkWaHVcablePolyThick));
5439 :
5440 : sprintf(name,"ITSsddDetBox%i",iLay);
5441 : TGeoBBox *detBox = new TGeoBBox(name, fgkWaferWidth/2, volThickness/2,
5442 : ladderLength*((nDetectors-0.5)/nDetectors)/2);
5443 : TGeoVolume *virtualDet = new TGeoVolume("ITSsddLadd",detBox, airSDD);
5444 :
5445 : for (Int_t i=0; i<nDetectors; i++) {
5446 : Double_t localZ = sensorZPos[i];
5447 : Double_t localY = fgkLadWaferSep/2+fgkWaferThickness/2;
5448 : if (iLay==3) if (i%2!=0) localY = -localY;
5449 : if (iLay==4) if (i%2==0) localY = -localY;
5450 : sprintf(name, "ITSsddLay%iSensorPos%i",iLay, i);
5451 :
5452 : if (i >= nDetectors/2) {
5453 : TGeoTranslation *sensorPos = new TGeoTranslation(0,localY,localZ);
5454 : sensorPos->SetName(name);
5455 : virtualDet->AddNode(fSDDsensor, i, sensorPos);
5456 : }
5457 : else {
5458 : TGeoRotation *rotSensor = new TGeoRotation("",0, 180, 180);
5459 : TGeoCombiTrans *sensorPos = new TGeoCombiTrans(0,localY,
5460 : localZ, rotSensor);
5461 : sensorPos->SetName(name);
5462 : virtualDet->AddNode(fSDDsensor, i, sensorPos);
5463 : };
5464 : }
5465 :
5466 : if(GetDebug(1)) virtualDet->CheckOverlaps(0.01);
5467 : virtualDet->SetVisibility(kFALSE);
5468 : return virtualDet;
5469 : }
5470 : */
5471 :
5472 : //________________________________________________________________________
5473 : TGeoVolumeAssembly *AliITSv11GeometrySDD::CreateDetectorsAssembly(Int_t iLay) {
5474 : //
5475 : // return a box volume containing the detectors
5476 : //
5477 :
5478 : Int_t nDetectors = fgkLay3Ndet;
5479 : // Double_t ladderLength = fgkLay3LadderLength;
5480 4 : Double_t *sensorZPos = fLay3sensorZPos;
5481 2 : TGeoVolume *sensorSDD = fSDDsensor3;
5482 :
5483 2 : if (iLay==3) {}
5484 1 : else if (iLay==4) {
5485 : nDetectors = fgkLay4Ndet;
5486 : // ladderLength = fgkLay4LadderLength;
5487 1 : sensorZPos = fLay4sensorZPos;
5488 1 : sensorSDD = fSDDsensor4;
5489 1 : } else {
5490 0 : printf("AliITSv11GeometrySDD::CreateDetectorsAssembly: Error:Wrong layer");
5491 : };
5492 :
5493 2 : char name[30];
5494 2 : snprintf(name,30,"ITSsddDetBox%i",iLay);
5495 :
5496 2 : TGeoVolumeAssembly *virtualDet = new TGeoVolumeAssembly("ITSsddLadd");
5497 :
5498 32 : for (Int_t i=0; i<nDetectors; i++) {
5499 14 : Double_t localZ = sensorZPos[i];
5500 14 : Double_t localY = fgkLadWaferSep/2+fgkWaferThickness/2;
5501 23 : if (iLay==3) if (i%2!=0) localY = -localY;
5502 26 : if (iLay==4) if (i%2==0) localY = -localY;
5503 14 : snprintf(name, 30, "ITSsddLay%iSensorPos%i",iLay, i);
5504 :
5505 14 : if (i >= nDetectors/2) {
5506 7 : TGeoTranslation *sensorPos = new TGeoTranslation(0,localY,localZ);
5507 7 : sensorPos->SetName(name);
5508 7 : virtualDet->AddNode(sensorSDD, i, sensorPos);
5509 7 : }
5510 : else {
5511 7 : TGeoRotation *rotSensor = new TGeoRotation("",0, 180, 180);
5512 7 : TGeoCombiTrans *sensorPos = new TGeoCombiTrans(0,localY,
5513 : localZ, rotSensor);
5514 7 : sensorPos->SetName(name);
5515 7 : virtualDet->AddNode(sensorSDD, i, sensorPos);
5516 : };
5517 : }
5518 :
5519 2 : virtualDet->GetShape()->ComputeBBox(); //RS: enforce recompting of BBox
5520 :
5521 2 : if(GetDebug(1)) virtualDet->CheckOverlaps(0.01);
5522 2 : return virtualDet;
5523 2 : }
5524 :
5525 :
5526 : //________________________________________________________________________
5527 : TGeoVolumeAssembly *AliITSv11GeometrySDD::CreateDetectorsAssemblyLadd2() {
5528 : //
5529 : // return a box volume containing the detectors
5530 : // Special case for Layer 3 Ladder 2 which is rotated (cannot simply
5531 : // rotate the standard volume, because the module numbering would be wrong)
5532 : // M.Sitta 25 Nov 2009
5533 : //
5534 :
5535 : Int_t nDetectors = fgkLay3Ndet;
5536 2 : Double_t *sensorZPos = fLay3sensorZPos;
5537 1 : TGeoVolume *sensorSDD = fSDDsensor3;
5538 :
5539 1 : char name[30];
5540 1 : snprintf(name,30,"ITSsddDetBoxLadd2");
5541 :
5542 1 : TGeoVolumeAssembly *virtualDet = new TGeoVolumeAssembly("ITSsddLadd");
5543 :
5544 14 : for (Int_t i=0; i<nDetectors; i++) {
5545 6 : Double_t localZ = (-1.)*sensorZPos[nDetectors-1-i];
5546 6 : Double_t localY = fgkLadWaferSep/2+fgkWaferThickness/2;
5547 9 : if (i%2==0) localY = -localY;
5548 6 : snprintf(name, 30, "ITSsddLayLadd2SensorPos%i", i);
5549 :
5550 6 : if (i >= nDetectors/2) {
5551 3 : TGeoTranslation *sensorPos = new TGeoTranslation(0,localY,localZ);
5552 3 : sensorPos->SetName(name);
5553 3 : virtualDet->AddNode(sensorSDD, i, sensorPos);
5554 3 : }
5555 : else {
5556 3 : TGeoRotation *rotSensor = new TGeoRotation("",0, 180, 180);
5557 3 : TGeoCombiTrans *sensorPos = new TGeoCombiTrans(0,localY,
5558 : localZ, rotSensor);
5559 3 : sensorPos->SetName(name);
5560 3 : virtualDet->AddNode(sensorSDD, i, sensorPos);
5561 : };
5562 : }
5563 :
5564 1 : virtualDet->GetShape()->ComputeBBox(); //RS: enforce recompting of BBox
5565 :
5566 1 : if(GetDebug(1)) virtualDet->CheckOverlaps(0.01);
5567 1 : return virtualDet;
5568 1 : }
5569 :
5570 :
5571 : //________________________________________________________________________
5572 : Int_t AliITSv11GeometrySDD::
5573 : GetCurrentLayLaddDet(Int_t &lay, Int_t &ladd, Int_t&det) const {
5574 : //
5575 : // Function which gives the layer, ladder and det.
5576 : // index of the current volume. To be used in
5577 : // AliITS::StepManager()
5578 : //
5579 :
5580 0 : if (gGeoManager->GetLevel()<3) return kFALSE;
5581 : // Get the det index :
5582 0 : TGeoNode *node = gGeoManager->GetMother(2);
5583 0 : if (!node) return kFALSE;
5584 0 : det = node->GetNumber()+1;
5585 :
5586 : // Get the ladder index :
5587 0 : node = gGeoManager->GetMother(3);
5588 0 : if (!node) return kFALSE;
5589 0 : ladd = node->GetNumber()+1;
5590 :
5591 : // Get the layer index :
5592 0 : if (node->GetNdaughters()==fgkLay3Ndet)
5593 0 : lay = 3;
5594 0 : else lay = 4;
5595 :
5596 0 : return kTRUE;
5597 0 : }
5598 :
5599 :
5600 : //________________________________________________________________________
5601 : TGeoPcon* AliITSv11GeometrySDD::CreateConeConstSection(Double_t r1max, Double_t z1,
5602 : Double_t r2max, Double_t z2,
5603 : Double_t section, Int_t nDiv)
5604 : {
5605 : // Creates a cone along z where the section is approximately constant
5606 : // with z. This is for simulation of cables, because a cone with a constant
5607 : // radius difference would show a quantity of matter increasing with z...
5608 : // The max radius of the created Pcon is evolving linearly, the min radius
5609 : // is calculated at several steps (nDiv).
5610 : // z2 > z1 (required by the Pcon)
5611 :
5612 24 : TGeoPcon *myPcon = new TGeoPcon(0, 360, 1+nDiv);
5613 :
5614 12 : Double_t dr = (r2max-r1max)/nDiv;
5615 12 : Double_t dz = (z2-z1)/nDiv;
5616 : Double_t r1minI, r2minI, r1maxI, r2maxI;
5617 : Double_t z1I, z2I;
5618 :
5619 12 : Double_t lZ = TMath::Sqrt((r2max-r1max)*(r2max-r1max) + (z2-z1)*(z2-z1));
5620 12 : Double_t cosAlpha = (z2-z1)/lZ;
5621 :
5622 12 : r1minI = TMath::Sqrt(r1max*r1max-section/(TMath::Pi()*cosAlpha));
5623 12 : myPcon->DefineSection(0, z1, r1minI, r1max);
5624 :
5625 84 : for (Int_t i=0; i<nDiv; i++) {
5626 :
5627 30 : z1I = z1 + i*dz;
5628 30 : z2I = z1I + dz;
5629 30 : r1maxI = r1max + i*dr;
5630 30 : r2maxI = r1maxI + dr;
5631 :
5632 30 : r2minI = TMath::Sqrt(r2maxI*r2maxI-section/(TMath::Pi()*cosAlpha));
5633 30 : myPcon->DefineSection(i+1, z2I, r2minI, r2maxI);
5634 : }
5635 12 : return myPcon;
5636 0 : }
5637 :
5638 :
5639 : //________________________________________________________________________
5640 : Double_t AliITSv11GeometrySDD::GetConeZ(Double_t r, Double_t refR1, Double_t refR2,
5641 : Double_t refZ1, Double_t refZ2) const {
5642 : // just a helping function
5643 10 : return refZ1+(refZ2-refZ1)*(r-refR1)/(refR2-refR1);
5644 : }
5645 :
5646 : //________________________________________________________________________
5647 : Int_t AliITSv11GeometrySDD::CreateAndInsetConeCablePart(TGeoVolume *mother, Double_t angle,
5648 : Int_t nLay3, Int_t nLay4,
5649 : Double_t r1, Double_t z1,
5650 : Double_t r2, Double_t z2) {
5651 :
5652 : // Create some cables portions from SDD modules grouped
5653 : // and attached at the border of the SSD cone
5654 :
5655 26 : TGeoMedium *copper = GetMedium("COPPER$");
5656 13 : TGeoMedium *plastic = GetMedium("SDDKAPTON (POLYCH2)$");
5657 13 : TGeoMedium *opticalFiber = GetMedium("SDD OPTICFIB$");
5658 :
5659 13 : char titleCable[30];
5660 13 : snprintf(titleCable,30,"cableSDDport%i",(Int_t)angle);
5661 :
5662 : //---
5663 13 : Double_t section = (fgkSectionCuPerMod+fgkSectionPlastPerMod+fgkSectionGlassPerMod)*(nLay3+nLay4);
5664 : Double_t thickness = 1.; // let's fix the thickness, then calculate the width
5665 13 : Double_t width = section/thickness;
5666 13 : Double_t thickCu = thickness*fgkSectionCuPerMod/(fgkSectionCuPerMod+fgkSectionPlastPerMod
5667 : +fgkSectionGlassPerMod);
5668 :
5669 13 : Double_t thickPlast = thickness*fgkSectionPlastPerMod/(fgkSectionCuPerMod+fgkSectionPlastPerMod
5670 : +fgkSectionGlassPerMod);
5671 :
5672 13 : Double_t thickGlass = thickness*fgkSectionGlassPerMod/(fgkSectionCuPerMod+fgkSectionPlastPerMod
5673 : +fgkSectionGlassPerMod);
5674 :
5675 13 : Double_t hypothenus = TMath::Sqrt( (r2-r1)*(r2-r1) + (z2-z1)*(z2-z1) );
5676 13 : Double_t cosAlpha = (z2-z1)/hypothenus;
5677 13 : Double_t radius1Cable = TMath::Sqrt(r1*r1 - width*width/4) - 0.5*thickness/cosAlpha;
5678 13 : Double_t radius2Cable = TMath::Sqrt(r2*r2 - width*width/4) - 0.5*thickness/cosAlpha;
5679 13 : angle *= TMath::DegToRad();
5680 13 : Double_t x1 = radius1Cable*TMath::Cos(angle), y1 = radius1Cable*TMath::Sin(angle);
5681 13 : Double_t x2 = radius2Cable*TMath::Cos(angle), y2 = radius2Cable*TMath::Sin(angle);
5682 13 : Double_t pos1[3] = {x1,y1,z1};
5683 13 : Double_t pos2[3] = {x2,y2,z2};
5684 13 : Double_t zVect[3] = {0,0,1};
5685 :
5686 13 : AliITSv11GeomCableFlat cable(titleCable,width,thickness);
5687 13 : cable.SetNLayers(3);
5688 13 : cable.SetLayer(0, thickPlast, plastic, kYellow);
5689 13 : cable.SetLayer(1, thickCu, copper, kRed);
5690 13 : cable.SetLayer(2, thickGlass, opticalFiber, kGreen);
5691 :
5692 13 : cable.AddCheckPoint( mother, 0, pos1, zVect );
5693 13 : cable.AddCheckPoint( mother, 1, pos2, zVect );
5694 13 : cable.SetInitialNode(mother);
5695 13 : cable.CreateAndInsertCableSegment(1);
5696 :
5697 : return kTRUE;
5698 13 : }
5699 :
5700 :
5701 :
5702 : //________________________________________________________________________
5703 : void AliITSv11GeometrySDD::SDDCables(TGeoVolume *moth)
5704 : {
5705 : //
5706 : // Creates and inserts the SDD cables running on SDD and SSD cones
5707 : //
5708 : // Input:
5709 : // moth : the TGeoVolume owing the volume structure
5710 : // Output:
5711 : //
5712 : // Created: ??? Ludovic Gaudichet
5713 : // Updated: 15 Mar 2008 Mario Sitta
5714 : // Updated: 14 Apr 2008 Mario Sitta Overlap fixes
5715 : // Updated: 09 May 2008 Mario Sitta SSD overlap fixes
5716 : //
5717 :
5718 2 : TGeoMedium *copper = GetMedium("COPPER$");
5719 1 : TGeoMedium *plastic = GetMedium("SDDKAPTON (POLYCH2)$");
5720 1 : TGeoMedium *opticalFiber = GetMedium("SDD OPTICFIB$");
5721 1 : TGeoMedium *airSDD = GetMedium("SDD AIR$");
5722 :
5723 :
5724 : //==================================
5725 : //
5726 : //==================================
5727 :
5728 : Double_t nModLay3 = fgkLay3Nladd*fgkLay3Ndet;
5729 : Double_t nModLay4 = fgkLay4Nladd*fgkLay4Ndet;
5730 :
5731 1 : Double_t sectionLay3Cu = fgkCableBendRatio*fgkSectionCuPerMod*nModLay3/2;
5732 1 : Double_t sectionLay3Plastic = fgkCableBendRatio*fgkSectionPlastPerMod*nModLay3/2;
5733 1 : Double_t sectionLay3Glass = fgkCableBendRatio*fgkSectionGlassPerMod*nModLay3/2;
5734 :
5735 1 : Double_t sectionLay4Cu = fgkCableBendRatio*fgkSectionCuPerMod*nModLay4/2;
5736 1 : Double_t sectionLay4Plastic = fgkCableBendRatio*fgkSectionPlastPerMod*nModLay4/2;
5737 1 : Double_t sectionLay4Glass = fgkCableBendRatio*fgkSectionGlassPerMod*nModLay4/2;
5738 :
5739 : // Do not use hardcoded numbers, get them from real shapes - M.S. 15/03/08
5740 1 : TGeoVolume *sddCone = gGeoManager->GetVolume("SDDCarbonFiberCone");
5741 1 : TGeoPcon *sddConeShape = (TGeoPcon*)sddCone->GetShape();
5742 :
5743 1 : TGeoVolume *sddCylinder = gGeoManager->GetVolume("SDDCarbonFiberCylinder");
5744 1 : TGeoTube *sddCylinderShape = (TGeoTube*)sddCylinder->GetShape();
5745 :
5746 : // (were fgkConeSDDr1, fgkConeSDDr2, fgkConeSDDz1, fgkConeSDDz2 hardcoded)
5747 1 : Double_t coneSDDr1 = sddConeShape->GetRmin(5);
5748 1 : Double_t coneSDDr2 = sddConeShape->GetRmin(3);
5749 :
5750 2 : Double_t coneSDDz1 = sddConeShape->GetZ(9) - sddConeShape->GetZ(5) +
5751 1 : sddCylinderShape->GetDz();
5752 2 : Double_t coneSDDz2 = sddConeShape->GetZ(9) - sddConeShape->GetZ(3) +
5753 1 : sddCylinderShape->GetDz();
5754 :
5755 : // Calculate z1, z2 thanks to R1 and R2
5756 1 : Double_t sddCableZ1 = GetConeZ(fgkSDDCableR1, coneSDDr1, coneSDDr2,
5757 : coneSDDz1, coneSDDz2);
5758 1 : Double_t sddCableZ2 = GetConeZ(fgkSDDCableR2, coneSDDr1, coneSDDr2,
5759 : coneSDDz1, coneSDDz2);
5760 1 : Double_t sddCableZ3 = GetConeZ(fgkSDDCableR3, coneSDDr1, coneSDDr2,
5761 : coneSDDz1, coneSDDz2);
5762 :
5763 1 : TGeoRotation *rotCableSDD = new TGeoRotation("rotCableSDD",0,180,0);
5764 :
5765 : //==================================
5766 : // first set of cones : cables from layer 3
5767 : //==================================
5768 :
5769 2 : TGeoPcon* pcon1all = CreateConeConstSection(fgkSDDCableR1, sddCableZ1,
5770 1 : fgkSDDCableR2, sddCableZ2,
5771 1 : sectionLay3Plastic+sectionLay3Cu+sectionLay3Glass, 1);
5772 :
5773 1 : TGeoPcon* pcon1container = new TGeoPcon(0,360,2);
5774 2 : pcon1container->DefineSection(0, sddCableZ1, pcon1all->GetRmin(0),
5775 1 : pcon1all->GetRmax(0));
5776 :
5777 1 : Double_t drMax = pcon1all->GetRmax(0)- pcon1all->GetRmin(0);
5778 2 : pcon1container->DefineSection(1, sddCableZ2, pcon1all->GetRmax(1)-drMax,
5779 1 : pcon1all->GetRmax(1));
5780 :
5781 2 : TGeoVolume *vpcon1container = new TGeoVolume("vpcon1container",
5782 1 : pcon1container, airSDD);
5783 1 : vpcon1container->SetVisibility(kFALSE);
5784 :
5785 2 : TGeoPcon* pcon1plast = CreateConeConstSection(fgkSDDCableR1, sddCableZ1,
5786 1 : fgkSDDCableR2, sddCableZ2,
5787 : sectionLay3Plastic, 3);
5788 :
5789 2 : TGeoVolume *vpcon1plast = new TGeoVolume("ITScablesSDDpcon1Plast",
5790 1 : pcon1plast, plastic);
5791 1 : vpcon1plast->SetLineColor(kYellow);
5792 1 : vpcon1container->AddNode(vpcon1plast, 0);
5793 :
5794 1 : Double_t dr1a = fgkSDDCableR1 - pcon1plast->GetRmin(0);
5795 2 : TGeoPcon* pcon1Cu = CreateConeConstSection(fgkSDDCableR1 - dr1a, sddCableZ1,
5796 1 : fgkSDDCableR2 - dr1a, sddCableZ2,
5797 : sectionLay3Cu, 3);
5798 :
5799 2 : TGeoVolume *vpcon1Cu = new TGeoVolume("ITScablesSDDpcon1Cu",
5800 1 : pcon1Cu, copper);
5801 1 : vpcon1Cu->SetLineColor(kRed);
5802 1 : vpcon1container->AddNode(vpcon1Cu, 0);
5803 :
5804 1 : Double_t dr1b = pcon1Cu->GetRmax(0) - pcon1Cu->GetRmin(0);
5805 2 : TGeoPcon* pcon1glass = CreateConeConstSection(fgkSDDCableR1-dr1a-dr1b, sddCableZ1,
5806 1 : fgkSDDCableR2-dr1a-dr1b, sddCableZ2,
5807 : sectionLay3Glass, 3);
5808 :
5809 2 : TGeoVolume *vpcon1glass = new TGeoVolume("ITScablesSDDpcon1glass",
5810 1 : pcon1glass, opticalFiber);
5811 1 : vpcon1glass->SetLineColor(kGreen);
5812 1 : vpcon1container->AddNode(vpcon1glass, 0);
5813 :
5814 1 : moth->AddNode(vpcon1container, 1);
5815 1 : moth->AddNode(vpcon1container, 2, rotCableSDD);
5816 :
5817 : //==================================
5818 : // 2nd set of cones : cables from layer 3 and layer 4
5819 : //==================================
5820 :
5821 2 : TGeoPcon* pcon2all = CreateConeConstSection(fgkSDDCableR2, sddCableZ2,
5822 1 : fgkSDDCableR3, sddCableZ3,
5823 1 : sectionLay3Plastic+sectionLay4Plastic+
5824 1 : sectionLay3Cu+sectionLay4Cu+
5825 1 : sectionLay3Glass+sectionLay4Glass, 1);
5826 :
5827 1 : TGeoPcon* pcon2container = new TGeoPcon(0,360,2);
5828 2 : pcon2container->DefineSection(0, sddCableZ2, pcon2all->GetRmin(0),
5829 1 : pcon2all->GetRmax(0));
5830 :
5831 1 : drMax = pcon2all->GetRmax(0)- pcon2all->GetRmin(0);
5832 2 : pcon2container->DefineSection(1, sddCableZ3, pcon2all->GetRmax(1)-drMax,
5833 1 : pcon2all->GetRmax(1));
5834 :
5835 :
5836 2 : TGeoVolume *vpcon2container = new TGeoVolume("vpcon2container",
5837 1 : pcon2container, airSDD);
5838 1 : vpcon2container->SetVisibility(kFALSE);
5839 :
5840 2 : TGeoPcon* pcon2plast = CreateConeConstSection(fgkSDDCableR2, sddCableZ2,
5841 1 : fgkSDDCableR3, sddCableZ3,
5842 : sectionLay3Plastic+
5843 : sectionLay4Plastic, 3);
5844 :
5845 2 : TGeoVolume *vpcon2plast = new TGeoVolume("ITScablesSDDpcon2Plast",
5846 1 : pcon2plast, plastic);
5847 1 : vpcon2plast->SetLineColor(kYellow);
5848 1 : vpcon2container->AddNode(vpcon2plast, 0);
5849 :
5850 1 : Double_t dr2a = fgkSDDCableR2 - pcon2plast->GetRmin(0);
5851 2 : TGeoPcon* pcon2Cu = CreateConeConstSection(fgkSDDCableR2 - dr2a, sddCableZ2,
5852 1 : fgkSDDCableR3 - dr2a, sddCableZ3,
5853 1 : sectionLay3Cu+sectionLay4Cu, 3);
5854 :
5855 2 : TGeoVolume *vpcon2Cu = new TGeoVolume("ITScablesSDDpcon2Cu",
5856 1 : pcon2Cu, copper);
5857 1 : vpcon2Cu->SetLineColor(kRed);
5858 1 : vpcon2container->AddNode(vpcon2Cu, 0);
5859 :
5860 1 : Double_t dr2b = pcon2Cu->GetRmax(0) - pcon2Cu->GetRmin(0);
5861 2 : TGeoPcon* pcon2glass = CreateConeConstSection(fgkSDDCableR2-dr2a-dr2b, sddCableZ2,
5862 1 : fgkSDDCableR3-dr2a-dr2b, sddCableZ3,
5863 1 : sectionLay3Glass+
5864 : sectionLay4Glass, 3);
5865 :
5866 2 : TGeoVolume *vpcon2glass = new TGeoVolume("ITScablesSDDpcon2glass",
5867 1 : pcon2glass, opticalFiber);
5868 1 : vpcon2glass->SetLineColor(kGreen);
5869 1 : vpcon2container->AddNode(vpcon2glass, 0);
5870 :
5871 1 : moth->AddNode(vpcon2container, 1);
5872 1 : moth->AddNode(vpcon2container, 2, rotCableSDD);
5873 :
5874 : //==================================
5875 : // intermediate cylinder
5876 : //==================================
5877 :
5878 : // (was fgkSDDCableDZint hardcoded)
5879 2 : Double_t sddCableDZint = (sddConeShape->GetZ(9) - sddConeShape->GetZ(0) +
5880 2 : sddCylinderShape->GetDz()) - sddCableZ3;
5881 :
5882 2 : TGeoTube *interCyl = new TGeoTube("sddCableInterCyl",
5883 1 : pcon2container->GetRmin(1),
5884 1 : pcon2container->GetRmax(1),
5885 1 : sddCableDZint/2);
5886 :
5887 2 : TGeoVolume *vInterCyl = new TGeoVolume("vSddCableInterCyl",
5888 1 : interCyl, airSDD);
5889 1 : vInterCyl->SetVisibility(kFALSE);
5890 :
5891 1 : Double_t rmaxCylPlast = pcon2container->GetRmax(1);
5892 2 : Double_t rminCylPlast = TMath::Sqrt(rmaxCylPlast*rmaxCylPlast -
5893 1 : (sectionLay3Plastic+sectionLay4Plastic)/TMath::Pi() );
5894 :
5895 1 : TGeoTube *interCylPlast = new TGeoTube("sddCableInterCylPlast", rminCylPlast,
5896 : rmaxCylPlast, sddCableDZint/2);
5897 :
5898 2 : TGeoVolume *vInterCylPlast = new TGeoVolume("vSddCableInterCylPlast",
5899 1 : interCylPlast, plastic);
5900 1 : vInterCylPlast->SetLineColor(kYellow);
5901 1 : vInterCyl->AddNode(vInterCylPlast, 0);
5902 :
5903 1 : Double_t rmaxCylCu = pcon2Cu->GetRmax(3);
5904 2 : Double_t rminCylCu = TMath::Sqrt(rmaxCylCu*rmaxCylCu -
5905 1 : (sectionLay3Cu+sectionLay4Cu)/TMath::Pi() );
5906 :
5907 1 : TGeoTube *interCylCu = new TGeoTube("sddCableInterCylCu", rminCylCu,
5908 : rmaxCylCu, sddCableDZint/2);
5909 :
5910 2 : TGeoVolume *vInterCylCu = new TGeoVolume("vSddCableInterCylCu",
5911 1 : interCylCu, copper);
5912 1 : vInterCylCu->SetLineColor(kRed);
5913 1 : vInterCyl->AddNode(vInterCylCu, 0);
5914 :
5915 1 : Double_t rmaxCylGlass = pcon2glass->GetRmax(3);
5916 2 : Double_t rminCylGlass = TMath::Sqrt(rmaxCylGlass*rmaxCylGlass -
5917 1 : (sectionLay3Glass+sectionLay4Glass)/TMath::Pi() );
5918 :
5919 1 : TGeoTube *interCylGlass = new TGeoTube("sddCableInterCylGlass", rminCylGlass,
5920 : rmaxCylGlass, sddCableDZint/2);
5921 :
5922 2 : TGeoVolume *vInterCylGlass = new TGeoVolume("vSddCableInterCylGlass",
5923 1 : interCylGlass,opticalFiber);
5924 1 : vInterCylGlass->SetLineColor(kGreen);
5925 1 : vInterCyl->AddNode(vInterCylGlass, 0);
5926 :
5927 3 : moth->AddNode(vInterCyl, 1, new TGeoTranslation(0, 0,
5928 1 : sddCableZ3+sddCableDZint/2));
5929 3 : moth->AddNode(vInterCyl, 2, new TGeoTranslation(0, 0,
5930 1 : -sddCableZ3-sddCableDZint/2));
5931 :
5932 : //==================================
5933 : // cable cone on the SSD cone
5934 : //==================================
5935 :
5936 : Double_t sddCableR4 = rmaxCylPlast;
5937 1 : Double_t sddCableZ4 = sddCableZ3 + sddCableDZint;
5938 :
5939 1 : TGeoPcon* pcon3all = CreateConeConstSection(sddCableR4, sddCableZ4,
5940 1 : fgkSDDCableR5, fgkSDDCableZ5,
5941 : sectionLay3Plastic+
5942 : sectionLay4Plastic+
5943 : sectionLay3Cu+sectionLay4Cu+
5944 : sectionLay3Glass+sectionLay4Glass, 1);
5945 :
5946 1 : TGeoPcon* pcon3container = new TGeoPcon(0,360,2);
5947 2 : pcon3container->DefineSection(0, sddCableZ4, pcon3all->GetRmin(0),
5948 1 : pcon3all->GetRmax(0));
5949 :
5950 1 : drMax = pcon3all->GetRmax(0) - pcon3all->GetRmin(0);
5951 2 : pcon3container->DefineSection(1, fgkSDDCableZ5, pcon3all->GetRmax(1)-drMax,
5952 1 : pcon3all->GetRmax(1));
5953 :
5954 :
5955 2 : TGeoVolume *vpcon3container = new TGeoVolume("vpcon3container",
5956 1 : pcon3container, airSDD);
5957 1 : vpcon3container->SetVisibility(kFALSE);
5958 :
5959 1 : TGeoPcon* pcon3plast = CreateConeConstSection(sddCableR4, sddCableZ4,
5960 1 : fgkSDDCableR5, fgkSDDCableZ5,
5961 : sectionLay3Plastic+
5962 : sectionLay4Plastic, 3);
5963 :
5964 2 : TGeoVolume *vpcon3plast = new TGeoVolume("ITScablesSDDpcon3Plast",
5965 1 : pcon3plast, plastic);
5966 1 : vpcon3plast->SetLineColor(kYellow);
5967 1 : vpcon3container->AddNode(vpcon3plast, 0);
5968 :
5969 1 : Double_t dr3a = sddCableR4 - pcon3plast->GetRmin(0);
5970 2 : TGeoPcon* pcon3Cu = CreateConeConstSection(sddCableR4 - dr3a, sddCableZ4,
5971 1 : fgkSDDCableR5 - dr3a, fgkSDDCableZ5,
5972 : sectionLay3Cu+sectionLay4Cu, 3);
5973 :
5974 2 : TGeoVolume *vpcon3Cu = new TGeoVolume("ITScablesSDDpcon3Cu",
5975 1 : pcon3Cu, copper);
5976 1 : vpcon3Cu->SetLineColor(kRed);
5977 1 : vpcon3container->AddNode(vpcon3Cu, 0);
5978 :
5979 1 : Double_t dr3b = pcon3Cu->GetRmax(0) - pcon3Cu->GetRmin(0);
5980 2 : TGeoPcon* pcon3glass = CreateConeConstSection(sddCableR4-dr3a-dr3b, sddCableZ4,
5981 1 : fgkSDDCableR5-dr3a-dr3b, fgkSDDCableZ5,
5982 : sectionLay3Glass+sectionLay4Glass, 3);
5983 :
5984 2 : TGeoVolume *vpcon3glass = new TGeoVolume("ITScablesSDDpcon3glass",
5985 1 : pcon3glass,opticalFiber);
5986 1 : vpcon3glass->SetLineColor(kGreen);
5987 1 : vpcon3container->AddNode(vpcon3glass, 0);
5988 :
5989 1 : moth->AddNode(vpcon3container, 1);
5990 1 : moth->AddNode(vpcon3container, 2, rotCableSDD);
5991 :
5992 : //==================================
5993 : // cables that are grouped at the end of SSD cones
5994 : //==================================
5995 :
5996 : // Double_t fgkSDDCableR6 = fgkSDDCableR5+9;
5997 : // Double_t fgkSDDCableZ6 = fgkSDDCableZ5+8.8;
5998 1 : Double_t fgkSDDCableR6 = fgkSDDCableR5+8;
5999 1 : Double_t fgkSDDCableZ6 = fgkSDDCableZ5+8;
6000 :
6001 1 : TGeoVolumeAssembly *endConeSDDCable = new TGeoVolumeAssembly("endConeSDDCable");
6002 :
6003 : // Add some hardcoded shifts to avoid overlaps with SSD pathc panels
6004 2 : CreateAndInsetConeCablePart(endConeSDDCable, 20, 1*3,2*4, fgkSDDCableR5,
6005 1 : fgkSDDCableZ5,fgkSDDCableR6-2.6,fgkSDDCableZ6-2.6);
6006 :
6007 2 : CreateAndInsetConeCablePart(endConeSDDCable, 50, 1*3,1*4, fgkSDDCableR5,
6008 1 : fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
6009 :
6010 2 : CreateAndInsetConeCablePart(endConeSDDCable, 85, 2*3,1*4, fgkSDDCableR5,
6011 1 : fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
6012 :
6013 2 : CreateAndInsetConeCablePart(endConeSDDCable, 95, 0*3,1*4, fgkSDDCableR5,
6014 1 : fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
6015 :
6016 2 : CreateAndInsetConeCablePart(endConeSDDCable, 105, 2*3,3*4, fgkSDDCableR5,
6017 1 : fgkSDDCableZ5,fgkSDDCableR6-2.6,fgkSDDCableZ6-2.6);
6018 :
6019 2 : CreateAndInsetConeCablePart(endConeSDDCable, 129, 0*3,3*4, fgkSDDCableR5,
6020 1 : fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
6021 :
6022 2 : CreateAndInsetConeCablePart(endConeSDDCable, 176, 0*3,1*4, fgkSDDCableR5,
6023 1 : fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
6024 :
6025 2 : CreateAndInsetConeCablePart(endConeSDDCable, 190, 2*3,0*4, fgkSDDCableR5,
6026 1 : fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
6027 :
6028 2 : CreateAndInsetConeCablePart(endConeSDDCable, 210, 1*3,2*4, fgkSDDCableR5,
6029 1 : fgkSDDCableZ5,fgkSDDCableR6-2.6,fgkSDDCableZ6-2.6);
6030 :
6031 2 : CreateAndInsetConeCablePart(endConeSDDCable, 230, 1*3,2*4, fgkSDDCableR5,
6032 1 : fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
6033 :
6034 2 : CreateAndInsetConeCablePart(endConeSDDCable, 277, 2*3,2*4, fgkSDDCableR5,
6035 1 : fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
6036 :
6037 2 : CreateAndInsetConeCablePart(endConeSDDCable, 306, 1*3,1*4, fgkSDDCableR5,
6038 1 : fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
6039 :
6040 2 : CreateAndInsetConeCablePart(endConeSDDCable, 353, 1*3,3*4, fgkSDDCableR5,
6041 1 : fgkSDDCableZ5,fgkSDDCableR6,fgkSDDCableZ6);
6042 :
6043 1 : endConeSDDCable->GetShape()->ComputeBBox(); //RS: enforce recompting of BBox
6044 :
6045 1 : moth->AddNode(endConeSDDCable, 1, 0);
6046 :
6047 1 : TGeoRotation* reflect = new TGeoRotation("reflectEndConeSDDCable");
6048 1 : reflect->ReflectZ(kTRUE);
6049 1 : moth->AddNode(endConeSDDCable, 2, reflect);
6050 :
6051 :
6052 : return;
6053 1 : }
|
