]>
Commit | Line | Data |
---|---|---|
aa9bc63b | 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 | $Log$ | |
18 | $Id$ | |
19 | */ | |
20 | ||
21 | #include <Riostream.h> | |
22 | #include <stdio.h> | |
23 | #include <stdlib.h> | |
24 | #include <TMath.h> | |
25 | #include <TGeometry.h> | |
26 | #include <TNode.h> | |
27 | #include <TTUBE.h> | |
28 | #include <TTUBS.h> | |
29 | #include <TPCON.h> | |
30 | #include <TFile.h> // only required for Tracking function? | |
31 | #include <TCanvas.h> | |
32 | #include <TObjArray.h> | |
33 | #include <TLorentzVector.h> | |
34 | #include <TObjString.h> | |
35 | #include <TClonesArray.h> | |
36 | #include <TBRIK.h> | |
37 | #include <TSystem.h> | |
38 | #include <TVector3.h> | |
39 | ||
40 | #include "AliITSGeometrySSDCone.h" | |
41 | ||
42 | ClassImp(AliITSGeometrySSDCone) | |
43 | ||
44 | //______________________________________________________________________ | |
45 | AliITSGeometrySSDCone::AliITSGeometrySSDCone(){ | |
46 | //Default Constructor for SSD Cone geometry | |
47 | ||
48 | SetScalemm(); | |
49 | } | |
50 | //______________________________________________________________________ | |
51 | AliITSGeometrySSDCone::AliITSGeometrySSDCone(TVector3 *&tran, | |
52 | const char moth[3],Int_t mat0){ | |
53 | //Standard Constructor for SSD Cone geometry | |
54 | // Inputs: | |
55 | // Double_t z0 Z-axis shift of this volume | |
56 | // Outputs: | |
57 | // none. | |
58 | // Return: | |
59 | // none. | |
60 | Double_t t; // some general angle and coordinates [degrees]. | |
61 | ||
62 | th = 13.0; //mm, Thickness of Rohacell+carbon fiber | |
63 | ct=1.5; //mm, Carbon finber thickness | |
64 | r=15.0; // mm, Radius of curvature. | |
65 | tc=51.0; // angle of SSD cone [degrees]. | |
66 | sintc=Sind(tc);costc=Cosd(tc);tantc=Tand(tc); | |
67 | z0=0.0;zcylinder=170.0;zpost=196.0; | |
68 | Routmax=0.5*985.0;RoutHole=0.5*965.0;Routmin=0.5*945.0; | |
69 | Rholemax=0.5*890.0;Rholemin=0.5*740.0; | |
70 | RPostmin=316.0;dRPost=23.0;zpostmax=196.0;phi0post=30.0; | |
71 | Rinmax=0.5*590.0;Rincylinder=0.5*597.0;RinHole=0.5*575.0; | |
72 | Rinmin=0.5*562.0;dzin=15.0; | |
73 | nspoaks=12;ninscrews=40;npost=4;nmounts=4; | |
74 | SSDcf=mat0+1; // SSD support cone Carbon Fiber materal number. | |
75 | SSDfs=mat0+2; // SSD support cone inserto stesalite 4411w. | |
76 | SSDfo=mat0+3; // SSD support cone foam, Rohacell 50A. | |
77 | SSDsw=mat0+4; // SSD support cone screw material,Stainless steal | |
78 | ncse=0; // number of screw ends (copy number) | |
79 | ncpe=0; // number of pin end (copy number) | |
80 | ncst=0; // number of screw tops (copy number) | |
81 | ||
82 | SetScalemm(); | |
83 | // Lets start with the upper left outer carbon fiber surface. | |
84 | // Between za[2],rmaxa[2] and za[4],rmaxa[4] there is a curved section | |
85 | // given by rmaxa = rmaxa[2]-r*Sind(t) for 0<=t<=tc and | |
86 | // za = za[2] + r*Cosd(t) for 0<=t<=tc. Simularly between za[1],rmina[1 | |
87 | // and za[3],rmina[3] there is a curve section given by | |
88 | // rmina = rmina[1]-r*Sind(t) for 0<=t<=tc and za = za[1]+r&Sind(t) | |
89 | // for t<=0<=tc. These curves have been replaced by straight lines | |
90 | // between the equivelent points for simplicity. | |
91 | Double_t dza = th/sintc-(Routmax-Routmin)/tantc; | |
92 | if(dza<=0){ // The number or order of the points are in error for a proper | |
93 | // call to pcons! | |
94 | Error("SSDcone","The definition of the points for a call to PCONS is" | |
95 | " in error. abort."); | |
96 | return; | |
97 | } // end if | |
98 | dphia=360.0; | |
99 | phi0a= 0.0; | |
100 | za[0] = z0; | |
101 | rmina[0] = Routmin; | |
102 | rmaxa[0] = Routmax; | |
103 | za[1] = za[0]+13.5-5.0 - dza; // za[2] - dza. | |
104 | rmina[1] = rmina[0]; | |
105 | rmaxa[1] =rmaxa[0]; | |
106 | za[2] = za[0]+13.5-5.0; // From Drawing ALR-0767 and ALR-0767/3 | |
107 | rmaxa[2] = rmaxa[0]; | |
108 | za[3] = za[1]+r*sintc; | |
109 | rmina[3] = rmina[1]-r*sintc; | |
110 | rmina[2] = rmina[1]+(rmina[3]-rmina[1])*(za[2]-za[1])/(za[3]-za[1]); | |
111 | za[4] = za[2]+r*sintc; | |
112 | rmaxa[4] = rmaxa[2]-r*sintc; | |
113 | rmaxa[3] = rmaxa[2]+(rmaxa[4]-rmaxa[2])*(za[3]-za[2])/(za[4]-za[2]); | |
114 | rmina[5] = Rholemax; | |
115 | za[5] = za[3]+(za[4]-za[3])*(rmina[5]-rmina[3])/(rmina[4]-rmina[3]); | |
116 | rmina[4] = rmina[3]+(rmina[5]-rmina[3])*(za[4]-za[3])/(za[5]-za[3]); | |
117 | za[6] = th/sintc+za[5]; | |
118 | rmina[6] = Rholemax; | |
119 | rmaxa[6] = rmina[6]; | |
120 | rmaxa[5] = rmaxa[4]+(rmaxa[6]-rmaxa[4])*(za[5]-za[4])/(za[6]-za[4]); | |
121 | // | |
122 | // Now lets define the Inserto Stesalite 4411w material volume. | |
123 | dphib=360.0; | |
124 | phi0b= 0.0; | |
125 | zb[0] = z0; | |
126 | rminb[0] = rmina[0]+ct; | |
127 | rmaxb[0] = rmaxa[0]-ct; | |
128 | zb[1] = za[1]; | |
129 | rminb[1] = rminb[0]; | |
130 | rmaxb[1] = rmaxb[0]; | |
131 | zb[2] = za[2]; | |
132 | rmaxb[2] = rmaxb[1]; | |
133 | zb[3] = za[4] - ct/sintc; | |
134 | rmaxb[3] = rmaxb[2] - (r-ct)*sintc; | |
135 | zb[4] = za[3]+ct/sintc; | |
136 | rminb[4] = rminb[1]-(r-ct)*sintc; | |
137 | rminb[2] = rminb[1]+(rminb[4]-rminb[1])*(zb[2]-zb[1])/(zb[4]-zb[1]); | |
138 | rminb[3] = rminb[1]+(rminb[4]-rminb[1])*(zb[3]-zb[1])/(zb[4]-zb[1]); | |
139 | zb[5] = zb[4]+(ct-2.*ct)/sintc; | |
140 | rminb[5] = rminb[4]+(ct-2.*ct)*tantc; | |
141 | rmaxb[5] = rminb[5]; | |
142 | rmaxb[4] = rmaxb[3]+(rmaxb[5]-rmaxb[3])*(zb[4]-zb[3])/(zb[5]-zb[3]); | |
143 | // | |
144 | // Now lets define the Rohacell foam material volume. | |
145 | dphic=360.0; | |
146 | phi0c= 0.0; | |
147 | zc[0] = zb[4]; | |
148 | rminc[0] = rminb[4]; | |
149 | rmaxc[0] = rminc[0]; | |
150 | zc[1] = zb[5]; | |
151 | rmaxc[1] = rminb[5]; | |
152 | zc[2] = za[5] + ct/sintc; | |
153 | rminc[2] = rmina[5]+ct; // leave space for carbon fiber covering hole. | |
154 | rminc[1] = rminc[0] +(rminc[2]-rminc[0])*(zc[1]-zc[0])/(zc[2]-zc[0]); | |
155 | zc[3] = za[6] - ct/sintc; | |
156 | rminc[3] = rmina[6]+ct; | |
157 | rmaxc[3] = rminc[3]; | |
158 | rmaxc[2] = rmaxc[1]+(rmaxc[3]-rmaxc[1])*(zc[2]-zc[1])/(zc[3]-zc[1]); | |
159 | // | |
160 | // In volume SCB, th Inserto Stesalite 4411w material volume, there | |
161 | // are a number of Stainless steel screw and pin studs which will be | |
162 | // filled with screws/studs. | |
163 | rmine=0.0,rmaxe=6.0,dze=0.5*10.0; // mm | |
164 | rmine2=0.0;rmaxe2=6.0;dze2=0.5*12.0; // mm | |
165 | // | |
166 | // There is no carbon fiber between this upper left section and the | |
167 | // SSD spoaks. We remove it by replacing it with Rohacell foam. | |
168 | t = ct/(0.5*(Rholemax+Rholemin));// It is not posible to get the | |
169 | // carbon fiber thickness uniform in this phi direction. We can only | |
170 | // make it a fixed angular thickness. | |
171 | t *= 180.0/TMath::Pi(); | |
172 | dphif = 5.0 - 2.0*t; // degrees | |
173 | phi0f = 12.5+t; // degrees see drawing ALR-0767. | |
174 | zf[0] = zc[2]; | |
175 | rminf[0] = rminc[3]; | |
176 | rmaxf[0] = rminf[0]; | |
177 | rminf[1] = rmina[5]; | |
178 | rmaxf[1] = rminf[0]; | |
179 | zf[1] = zc[0]+(zc[2]-zc[0])*(rminf[1]-rminc[0])/(rminc[2]-rminc[0]); | |
180 | zf[2] = zc[3]; | |
181 | rminf[2] = rminf[1]; | |
182 | rmaxf[2] = rmaxf[1]; | |
183 | zf[3] = zc[1]+(zc[3]-zc[1])*(rmaxf[3]-rmaxc[1])/(rmaxc[3]-rmaxc[1]); | |
184 | rminf[3] = rmina[5]; | |
185 | rmaxf[3] = rminf[3]; | |
186 | //================================================================= | |
187 | // Now for the spoak part of the SSD cone. | |
188 | // It is not posible to inclue the radius of curvature between | |
189 | // the spoak part and the upper left part of the SSD cone or lowwer right | |
190 | // part. This would be discribed by the following curves. | |
191 | // R = Rmax - (5mm)*Sin(t) phi = phi0+(5mm*180/(Pi*RoutHole))*Sin(t) | |
192 | // where 0<=t<=90 For the inner curve a simular equiation holds. | |
193 | phi0g = 12.5; // degrees see drawing ALR-0767. | |
194 | dphig = 5.0; // degrees | |
195 | zg[0] = zb[5]; | |
196 | rming[0] = rmina[5]; | |
197 | rmaxg[0] = rming[0]; | |
198 | zg[1] = za[6]; | |
199 | rming[1] = -tantc*(zg[1]-za[3])+rmina[3]; | |
200 | rmaxg[1] = rmaxg[0]; | |
201 | rming[2] = Rholemin; | |
202 | zg[2] = za[3]-(rming[2]-rmina[3])/tantc; | |
203 | rmaxg[2] = -tantc*(zg[2]-za[4])+rmaxa[4]; | |
204 | rming[3] = rming[2]; | |
205 | rmaxg[3] = rming[3]; | |
206 | zg[3] = za[4]-(rmaxg[3]-rmaxa[4])/tantc; | |
207 | // For the foam core. | |
208 | t = ct/(0.5*(Rholemax+Rholemin));// It is not posible to get the | |
209 | // carbon fiber thickness uniform in this phi direction. We can only | |
210 | // make it a fixed angular thickness. | |
211 | t *= 180.0/TMath::Pi(); | |
212 | dphih = 5.0 - 2.0*t; // degrees | |
213 | phi0h = 12.5+t; // degrees see drawing ALR-0767. | |
214 | zh[0] = zf[2]; | |
215 | rminh[0] = rming[0]; | |
216 | rmaxh[0] = rmaxg[0]; | |
217 | zh[1] = zf[3]; | |
218 | rminh[1] = rming[1]-(ct/sintc-(zg[1]-zh[1]))*tantc; | |
219 | rmaxh[1] = rmaxh[0]; | |
220 | zh[2] = zg[2]+ct/tantc; | |
221 | rminh[2] = rming[2]; | |
222 | rmaxh[2] = rmaxg[2]-(ct/sintc-(zg[2]-zh[2]))*tantc; | |
223 | zh[3] = zg[3]-ct/sintc; | |
224 | rminh[3] = rminh[2]; | |
225 | rmaxh[3] = rminh[3]; | |
226 | // | |
227 | //================================================================== | |
228 | // Now for the Inner most part of the SSD cone. | |
229 | phi0i = 0.0; | |
230 | dphii = 360.0; | |
231 | Double_t za,rmina,rmaxa; // additional point not needed in call to pcons. | |
232 | zi[0] = zg[2]; | |
233 | rmini[0] = rming[2]; | |
234 | rmaxi[0] = rmini[0]; | |
235 | zi[1] = zg[3]; | |
236 | rmini[1] = -tantc*(zi[1]-za[3])+rmina[3]; | |
237 | rmaxi[1] = rmaxi[0]; | |
238 | rmini[5] = Rinmin; | |
239 | rmaxi[5] = Rinmax+r*sintc; | |
240 | zi[5] =za[4]+(rmaxa[4]-rmaxi[5])/tantc; | |
241 | za = zi[5]+r*costc; | |
242 | rmina = rmini[5]; | |
243 | rmaxa = Rinmax; | |
244 | zi[3] = za-dzin; | |
245 | zi[2] = zi[3] -r*costc; | |
246 | rmini[2] = -tantc*(zi[2]-za[3])+rmina[3]; | |
247 | rmaxi[2] = -tantc*(zi[2]-za[4])+rmaxa[4]; | |
248 | rmini[3] = rmini[2] -r*costc; | |
249 | zi[4] = zi[3]; | |
250 | rmini[4] = Rinmin; | |
251 | rmaxi[4] = -tantc*(zi[4]-za[4])+rmaxa[4]; | |
252 | rmaxi[3] = rmaxi[4]; | |
253 | zi[6] = zcylinder; | |
254 | rmini[6] = Rinmin; | |
255 | rmaxi[6] = rmaxi[5] - (zi[5]-zi[6])*(rmaxi[5]-rmaxa)/(zi[5]-za); | |
256 | zi[7] = zi[6]; | |
257 | rmini[7] = Rincylinder; | |
258 | rmaxi[7] = rmaxi[6]; | |
259 | rmini[8] = Rincylinder; | |
260 | rmaxi[8] = rmini[8]; | |
261 | zi[8] = zi[5]+(rmaxi[8]-rmaxi[5])*(za-zi[5])/(rmaxa-rmaxi[5]); | |
262 | // Now for Inserto volume at the inner most radius. | |
263 | phi0k = 0.0; | |
264 | dphik = 360.0; | |
265 | zk[1] = zi[3]+ct; | |
266 | zk[0] = zk[1]-(r+ct)*costc; | |
267 | rmink[0] = rmini[3]+(r+ct)*sintc; | |
268 | rmaxk[0] = rmink[0]; | |
269 | rmink[1] = rmini[3]; | |
270 | zk[2] = zk[1]; | |
271 | rmink[2] = rmini[6]; | |
272 | rmaxk[2] = rmaxk[1]; | |
273 | zk[3] = zk[0]+(th+2.0*ct)*costc; | |
274 | rmink[3] = rmini[6]; | |
275 | rmaxk[3] = rmaxk[0]+(th+2.0*ct)*sintc; | |
276 | rmaxk[1] = rmaxk[0]+(rmaxk[3]-rmaxk[0])*(zk[1]-zk[0])/(zk[3]-zk[0]); | |
277 | rmink[4] = rmini[6]; | |
278 | rmaxk[4] = rmaxi[5]-ct*sintc; | |
279 | zk[4] = zc[1]+(zc3[3]-zc[1])*(rmaxk[4]-rmaxc[1])/(rmaxc[3]-rmaxc[1]); | |
280 | zk[5] = zi[5]-r*costc-ct; | |
281 | rmink[5] = rmini[6]; | |
282 | rmaxk[5] = rmini[8]; | |
283 | zk[6] = zi[6]; | |
284 | rmink[6] = rmini[6]; | |
285 | rmaxk[6] = rmaxi[6]; | |
286 | // Now for foam core at the inner most radius. | |
287 | phi0j = 0.0; | |
288 | dphij = 360.0; | |
289 | rminj[0] = rmini[0]-ct; | |
290 | zj[0] = zc[0]+(zc[2]-zc[0])*(rminj[0]-rminc[0])/(rminc[2]-rminc[0]); | |
291 | rmaxj[0] = rminj[0]; | |
292 | rmaxj[1] = rmaxj[0]; | |
293 | zj[1] = zc[1]+(zc[3]-zc[1])*(rmaxj[1]-rmaxc[1])/(rmaxc[3]-rmaxc[1]); | |
294 | rminj[1] = rminc[0]+(rminc[2]-rminc[0])*(zj[1]-zc[0])/(zc[2]-zc[0]); | |
295 | zj[2] = zk[0]; | |
296 | rminj[2] = rmink[0]; | |
297 | rmaxj[2] = rmaxc[1]+(rmaxc[3]-rmaxc[1])*(zj[2]-zc[1])/(zc[3]-zc[1]); | |
298 | zj[3] = zk[3]; | |
299 | rminj[3] = rmaxk[3]; | |
300 | rmaxj[3] = rminj[3]; | |
301 | // Now for foam core at the top of the inner most radius where | |
302 | // the spoaks are. | |
303 | t = ct/(0.5*(Rholemax+Rholemin));// It is not posible to get the | |
304 | // carbon fiber thickness uniform in this phi direction. We can only | |
305 | // make it a fixed angular thickness. | |
306 | t *= 180.0/TMath::Pi(); | |
307 | dphil = 5.0 - 2.0*t; // degrees | |
308 | phi0l = 12.5+t; // degrees see drawing ALR-0767. | |
309 | zl[0] = zh[2]; | |
310 | rminl[0] = rmini[0]; | |
311 | rmaxl[0] = rminl[0]; | |
312 | zl[1] = zj[0]; | |
313 | rminl[1] = rminj[1]; | |
314 | rmaxl[1] = rmaxi[0]; | |
315 | zl[2] = zh[3]; | |
316 | rminl[2] = rminl[1]; | |
317 | rmaxl[2] = rmaxl[1]; | |
318 | zl[3] = zj[1]; | |
319 | rminl[3] = rminl[2]; | |
320 | rmaxl[3] = rminl[3]; | |
321 | // Now for the SSD mounting posts | |
322 | dphio = 180.0*dRPost/(RPostmin+0.5*dRPost)/TMath::Pi(); // degrees | |
323 | phi0o = phi0post; // | |
324 | rmino[0] = RPostmin+dRPost; | |
325 | rmaxo[0] = rmino[0]; | |
326 | zo[0] = za[4]+(rmaxa[4]-rmaxo[0])/tantc; | |
327 | rmino[1] = RPostmin; | |
328 | zo[1] = za[4]+(rmaxa[4]-rmino[1])/tantc; | |
329 | rmaxo[1] = rmaxo[0]; | |
330 | zo[2] = z0+zpostmax; | |
331 | rmino[2] = RPostmin; | |
332 | rmaxo[2] = rmino[2]+dRPost; | |
333 | // Now for the SSD mounting posts | |
334 | t = 180.0*ct/(RPostmin+0.5*dRPost)/TMath::Pi(); | |
335 | dphip = dphio-2.0*t; // degrees | |
336 | phi0p = phio0+t; // | |
337 | rminp[0] = rmino[0]-ct; | |
338 | rmaxp[0] = rminp[0]; | |
339 | zp[0] = za[4]+(rmaxa[4]-rmaxp[0])/tantc; | |
340 | rminp[1] = rmino[0]+ct; | |
341 | rmaxp[1] = rmino[0]-ct; | |
342 | zp[1] = za[4]+(rmaxa[4]-rminp[1])/tantc; | |
343 | rminp[2] = rminp[1]; | |
344 | rmaxp[2] = rmaxp[1]; | |
345 | zp[2] = z0-zpostmax; | |
346 | // This insrto continues into the SSD cone displacing the foam | |
347 | // and the carbon fiber surface at those points where the posts are. | |
348 | dphim=360.0; | |
349 | phi0m= 0.0; | |
350 | rminm[0] = RPostmin+dRPost-ct; | |
351 | rmaxm[0] = rminm[0]; | |
352 | zm[0] = zj[0]+(zj[2]-zj[0])*(rminm[0]-rminj[0])/(rminj[2]-rminj[0]); | |
353 | rmaxm[1] = rmaxm[0]; | |
354 | zm[1] = zj[1]+(zj[3]-zj[1])*(rmaxm[1]-rmaxj[1])/(rmaxj[3]-rmaxj[1]); | |
355 | rminm[2] = RPostmin+ct; | |
356 | zm[2] = zj[0]+(zj[2]-zj[0])*(rminm[2]-rminj[0])/(rminj[2]-rminm[0]); | |
357 | rmaxm[2] = rmaxj[1]+(rmaxj[3]-rmaxm[1])*(zm[2]-zj[1])/(zj[3]-zj[1]); | |
358 | rminm[3] = rminm[2]; | |
359 | rmaxm[3] = rminm[3]; | |
360 | dphin=360.0; | |
361 | phi0n= 0.0; | |
362 | zn[0] = zm[1]; | |
363 | rminn[0] = rmaxm[1]; | |
364 | rmaxn[0] = rminn[0]; | |
365 | rmaxn[1] = rmaxn[0]; | |
366 | zn[1] = za[4]+(rmaxa[4]-rmaxn[1])/tantc; | |
367 | rminn[1] = rmaxj[1]+(rmaxj[3]-rmaxj[1])*(zn[1]-zj[1])/(zj[3]-zj[1]); | |
368 | zn[2] = zm[3]; | |
369 | rminn[2] = rminm[3]; | |
370 | rmaxn[2] = -tantc*(zn[2]-za[4])+rmaxa[4]; | |
371 | rminn[3] = rminn[2]; | |
372 | rmaxn[3] = rminn[3]; | |
373 | zn[3] = za[4]+(rmaxa[4]-rmaxn[3])/tantc; | |
374 | } | |
375 | //______________________________________________________________________ | |
376 | void AliITSGeometrySSDCone::CreateG3Geometry(const char moth[3], | |
377 | TVector3 &trans){ | |
378 | // Calls Geant 3 geometry inilization routines with the information | |
379 | // stored in this class. | |
380 | // Inputs: | |
381 | // none. | |
382 | // Outputs: | |
383 | // none. | |
384 | // Return: | |
385 | // none. | |
386 | ||
387 | PolyCone("SCA","SSD Suport cone Carbon Fiber Surface outer left", | |
388 | phi0a,dphia,nza,za,rmina,rmaxa,SSDcf); | |
389 | Pos("SCA",1,moth,trans.x(),trans.y(),trans.z(),0); | |
390 | XMatrix(1,180.0); | |
391 | Pos("SCA",2,moth,trans.x(),trans.y(),-trans.z(),1); | |
392 | PolyCone("SCB","SSD Suport cone Inserto Stesalite left edge", | |
393 | phi0b,dphib,nzb,zb,rminb,rmaxb,SSDfs); | |
394 | Pos("SCB",1,"SCA",0.0,.0,0.0,0); | |
395 | PolyCone("SCC","SSD Suport cone Rohacell foam left edge", | |
396 | phi0,dphi,nz,zc,rminc,rmaxc,SSDfo); | |
397 | Pos("SCC",1,"SCA",0.0,.0,0.0,0); | |
398 | Tube("SCD","Screw+stud used to mount things to the SSD support cone", | |
399 | rmine,rmaxe,dze,SSDsw); | |
400 | Tube("SCE","pin used to mount things to the SSD support cone", | |
401 | rmine2,rmaxe2,dze2,SSDsw); | |
402 | k=l=0; | |
403 | for(i=0;i<2;i++){ // position for ITS-TPC mounting brackets | |
404 | for(j=0;j<2;j++){ // 2 screws per bracket | |
405 | ncse++; | |
406 | t = -5.0+10.0*((Double_t)j)+180.*((Double_t)i); | |
407 | x = RoutHole*Sind(t); | |
408 | y = RoutHole*Cosd(t); | |
409 | z = dz; | |
410 | Pos("SCD",ncse,"SCB",x,y,z,0); | |
411 | } // end for j | |
412 | for(j=0;j<3;j++){ // 3 pins per bracket | |
413 | ncpe++; | |
414 | t = -3.0+3.0*((Double_t)j)+180.*((Double_t)i); | |
415 | x = RoutHole*Sind(t); | |
416 | y = RoutHole*Cosd(t); | |
417 | z = dz; | |
418 | Pos("SCE",ncpe,"SCB",x,y,z,0); | |
419 | } // end for j | |
420 | } // end for i | |
421 | for(i=0;i<2;i++){ // position for ITS-rail mounting brackets | |
422 | for(j=0;j<4;j++){ // 4 screws per bracket | |
423 | a[4]={0.0,2.0,5.0,7.0}; // Relative angles. | |
424 | ncse++; | |
425 | t = 90.0-a[j]+187.*((Double_t)i); | |
426 | x = RoutHole*Sind(t); | |
427 | y = RoutHole*Cosd(t); | |
428 | z = dz; | |
429 | Pos("SCD",kncs,"SCB",x,y,z,0); | |
430 | } // end for j | |
431 | for(j=0;j<2;j++){ // 2 pins per bracket | |
432 | ncpe++; | |
433 | t = 88+7.0*((Double_t)j)+184.*((Double_t)i); | |
434 | x = RoutHole*Sind(t); | |
435 | y = RoutHole*Cosd(t); | |
436 | z = dz; | |
437 | Pos("SCE",ncse,"SCB",x,y,z,0); | |
438 | } // end for j | |
439 | } // end for i | |
440 | for(i=0;i<nmounts;i++){ // mounting holes/screws for beam pipe support | |
441 | // and SPD cone support (dump side,non-dump side has them to). | |
442 | for(j=0;j<2;j++){ // 2 screws per bracket | |
443 | ncse++; | |
444 | t = 180.*20./(RoutHole*TMath::Pi()); | |
445 | t = 45.0+((Doulbe_t)(j-1))*t+90.*((Double_t)i); | |
446 | x = RoutHole*Sind(t); | |
447 | y = RoutHole*Cosd(t); | |
448 | z = dz; | |
449 | Pos("SCD",ncse,"SCB",x,y,z,0); | |
450 | } // end for j | |
451 | for(j=0;j<1;j++){ // 1 pins per bracket | |
452 | ncpe++; | |
453 | t = 45.0+90.*((Double_t)i); | |
454 | x = RoutHole*Sind(t); | |
455 | y = RoutHole*Cosd(t); | |
456 | z = dz; | |
457 | Pos("SCE",ncpe,"SCB",x,y,z,0); | |
458 | } // end for j | |
459 | } // end for i | |
460 | PolyCone("SCF","SSD Suport cone Rohacell foam left edge", | |
461 | phi0f,dphif,nzf,zf,rminf,rmaxf,SSDfo); | |
462 | Pos("SCF",1,"SCA",0.0,.0,0.0,0); | |
463 | for(i=1;i<nspoaks;i++){ | |
464 | Zmatrix(irot+i,360./((Double_t)nspoaks)); | |
465 | Pos("SCG",i+1,"SCA",0.0,.0,0.0,irot+i); | |
466 | } // end for i | |
467 | PolyCone("SCG","SSD spoak carbon fiber surfaces", | |
468 | phi0g,dphig,nzg,zg,rming,rmaxc,SSDcf); | |
469 | Pos("SCG",i+1,"SCA",0.0,.0,0.0,0); | |
470 | for(i=1;i<nspoaks;i++){ | |
471 | Pos("SCG",i+1,"SCA",0.0,.0,0.0,irot+i); | |
472 | } // end for i | |
473 | PolyCone("SCH","SSD spoak foam core", | |
474 | phi0h,dphih,nzh,zh,rminh,rmaxh,SSDfo); | |
475 | Pos("SCH",1,"SCG",0.0,.0,0.0,0); | |
476 | PolyCone("SCI","SSD lower/inner right part of SSD cone", | |
477 | phi0i,dphii,nzi,zci,rminci,rmaxci,SSDcf); | |
478 | Pos("SCI",1,moth,0.0,.0,0.0,0); | |
479 | PolyCone("SCK","SSD inner most inserto material", | |
480 | phi0k,dphik,nzk,zk,rmink,rmaxk,SSDfs); | |
481 | Pos("SCK",1,"SCI",0.0,.0,0.0,0); | |
482 | PolyCone("SCJ","SSD inner most foam core", | |
483 | phi0j,dphij,nzj,zj,rminj,rmaxj,SSDfo); | |
484 | Pos("SCJ",1,"SCI",0.0,.0,0.0,0); | |
485 | PolyCone("SCL","SSD inner most foam core", | |
486 | phi0l,dphil,nzl,zl,rminl,rmaxl,SSDfo); | |
487 | Pos("SCL",1,"SCI",0.0,.0,0.0,0); | |
488 | for(i=1;i<nspoaks;i++){ | |
489 | Pos("SCG",i+1,"SCA",0.0,.0,0.0,irot+i); | |
490 | } // end for i | |
491 | PolyCone("SCO","SSD mounting post, carbon fiber", | |
492 | phi0,dphi,nz,zc,rminc,rmaxc,SSDcf); | |
493 | Pos("SCO",1,moth,0.0,.0,0.0,0); | |
494 | for(i=1;i<nposts;i++){ | |
495 | Zmatrix(irot+i,360./((Double_t)nposts)); | |
496 | Pos("SCO",i+1,moth,0.0,.0,0.0,irot+i); | |
497 | } // end for | |
498 | PolyCone("SCP","SSD mounting post, Inserto", | |
499 | phi0p,dphip,nzp,zp,rminp,rmaxp,SSDfs); | |
500 | Pos("SCP",1,"SCO",0.0,.0,0.0,0); | |
501 | Pos("SCM",1,"SCJ",0.0,.0,0.0,0); | |
502 | Pos("SCN",1,"SCI",0.0,.0,0.0,0); | |
503 | for(i=1;i<nposts;i++){ | |
504 | Pos("SCN",i+1,"SCJ",0.0,.0,0.0,irot+i); | |
505 | Pos("SCM",i+1,"SCI",0.0,.0,0.0,irot+i); | |
506 | } // end for i | |
507 | return; | |
508 | } | |
509 | //______________________________________________________________________ | |
510 | void CreateG3Materials(){ | |
511 | // Fills the Geant 3 banks with Material and Medium definisions. | |
512 | // Inputs: | |
513 | // none. | |
514 | // Outputs: | |
515 | // none. | |
516 | // Returns: | |
517 | // none. | |
518 | Double_t Z[5],W[5],dens; | |
519 | ||
520 | Z[0] = 1.; W[0] = 0.5; // Hydrogen Content | |
521 | Z[1] = 6.; W[1] = 0.5; // Carbon Content | |
522 | MixtureByWeight(SSDcf,"Carbon Fiber for SSD support cone",Z,W,dens,2); | |
523 | Z[0] = 1.; W[0] = 0.5; // Hydrogen Content | |
524 | Z[1] = 6.; W[1] = 0.5; // Carbon Content | |
525 | MixtureByWeight(SSDfs,"Inserto stealite 4411w for SSD support cone", | |
526 | Z,W,dens,2); | |
527 | Z[0] = 1.; W[0] = 0.5; // Hydrogen Content | |
528 | Z[1] = 6.; W[1] = 0.5; // Carbon Content | |
529 | MixtureByWeight(SSDfo,"Foam core (Rohacell 50A) for SSD support cone", | |
530 | Z,W,dens,2); | |
531 | Z[0] = 6.; W[0] = 0.5; // Carbon Content | |
532 | Z[1] = 25.; W[1] = 0.5; // Iron Content | |
533 | MixtureByWeight(SSDsw,"Stainless steal screw, pin, and stud material", | |
534 | Z,W,dens,2); | |
535 | } | |
536 | //______________________________________________________________________ | |
537 | void AliITSGeometrySSDCone::BuildDisplayGeometry(){ | |
538 | // Fill Root geometry banks for fast simple ITS simulation event | |
539 | // display. See Display.C, and related code, for more details. | |
540 | // Inputs: | |
541 | // none. | |
542 | // Outputs: | |
543 | // none. | |
544 | // Return: | |
545 | // none. | |
546 | ||
547 | // No need to display ITS cones. | |
548 | } |