| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 //
27 // *******************************************
28 // *
29 // * GEANT 4 xray_telescope
30 // *
31 // * MODULE: XrayTelDetectorConstru
32 // * -------
33 // *
34 // * Version: 0.4
35 // * Date: 06/11/00
36 // * Author: R Nartallo
37 // * Organisation: ESA/ESTEC, Noordwijk,
38 // *
39 // *******************************************
40 //
41 // CHANGE HISTORY
42 // --------------
43 //
44 // 06.11.2000 R.Nartallo
45 // - First implementation of xray_telescope ge
46 // - Based on Chandra and XMM models by R Nart
47 // and P Arce
48 //
49 //
50 // *******************************************
51
52 #include "XrayTelDetectorConstruction.hh"
53
54 #include "globals.hh"
55 #include "G4PhysicalConstants.hh"
56 #include "G4SystemOfUnits.hh"
57 #include "G4UnitsTable.hh"
58 #include "G4VUserDetectorConstruction.hh"
59 #include "G4Material.hh"
60 #include "G4MaterialTable.hh"
61 #include "G4Element.hh"
62 #include "G4ElementTable.hh"
63 #include "G4Box.hh"
64 #include "G4Cons.hh"
65 #include "G4Tubs.hh"
66 #include "G4LogicalVolume.hh"
67 #include "G4ThreeVector.hh"
68 #include "G4PVPlacement.hh"
69 #include "G4PVReplica.hh"
70 #include "G4SDManager.hh"
71 #include "G4VisAttributes.hh"
72 #include "G4Colour.hh"
73
74 XrayTelDetectorConstruction::XrayTelDetectorCo
75 {
76 world_x = 2500.*cm;
77 world_y = 2500.*cm;
78 world_z = 2500.*cm;
79 }
80
81 XrayTelDetectorConstruction::~XrayTelDetectorC
82 {;}
83
84 G4VPhysicalVolume* XrayTelDetectorConstruction
85 {
86
87 // Material: Vacuum
88 G4Material* Vacuum = new G4Material("Vacuum"
89 1.0 , 1.01*g/mole, 1.0E-25*g/cm3
90 kStateGas, 2.73*kelvin, 3.0E-18*
91
92 // Visualization attributes
93 G4VisAttributes* VisAttWorld= new G4VisAttri
94
95 // World
96 G4Box * solidWorld = new G4Box( "world_S", w
97 G4LogicalVolume * logicalWorld = new G4Logic
98 Vacuum,
99 "world_L",
100 0,0,0);
101
102 logicalWorld -> SetVisAttributes(VisAttWorld
103
104 // Physical volume
105 physicalWorld= new G4PVPlacement( 0,
106 G4ThreeVector(),
107 "world_P", // name (2nd con
108 logicalWorld, // logical volum
109 NULL, // mother volume
110 false, // no boolean op
111 0); // copy number
112
113 // Make Invisible
114 logicalWorld -> SetVisAttributes(G4VisAttrib
115
116 // Construct geometry
117 ConstructTelescope();
118 ConstructFocalPlane();
119
120 return physicalWorld;
121 }
122
123 //....oooOO0OOooo........oooOO0OOooo........oo
124
125 // Construct Telescope
126
127 void XrayTelDetectorConstruction::ConstructTel
128 {
129 // Construct Mirror
130 // Single shell mirror made of Nickel with t
131 // Mirror made up of two cones approximating
132 // two cones approximating the hyperbolic se
133 // The centre of the mirror is filled wiith
134 // mirrors, so as to leave a constant Baffle
135
136 // Build materials
137 G4Material* Ni = new G4Material("Nickel", 28
138 G4Material* Au = new G4Material("Gold", 79.,
139 G4Material* Al = new G4Material("Aluminium",
140
141 // Visualization attributes
142 G4VisAttributes* VisAttMirror = new G4VisAtt
143 G4Colour(0/255., 0/255.,255/
144 G4VisAttributes* VisAttAuCoating = new G4Vis
145 G4Colour(255/255., 255/255., 0/
146 G4VisAttributes* VisAttBaffle = new G4VisAtt
147 G4Colour(128/255., 128/255.,
148
149 // Rotation Matrix
150 G4RotationMatrix *rotateMatrix = new G4Rotat
151 rotateMatrix -> rotateY(90.*deg);
152
153 // Construct cones to make Mirror sections
154 G4int i;
155 G4double MirrorEnd[5] = { 34.9995975*cm, 34.
156 34.1347834*cm, 33.6137753*cm };
157 G4double MirrorPosition[4] = { 772.5*cm, 757
158 G4double MirrorSectionLength = 15.0*cm;
159 G4double MirrorNiThickness = 1.07*mm;
160 G4double MirrorAuCoating = 50.0e-6*mm;
161 G4double BaffleGap = 4.0*mm;
162
163 G4Cons* MirrorSolid[4];
164 G4Cons* MirrorAuCoatingSolid[4];
165 G4Cons* BaffleSolid[4];
166
167 G4LogicalVolume* MirrorLogicalVolume[4];
168 G4LogicalVolume* MirrorAuCoatingLogicalVolum
169 G4LogicalVolume* BaffleLogicalVolume[4];
170
171 for ( i=0; i<4; i++ ) {
172
173 // Mirror Nickel base
174 MirrorSolid[i] = new G4Cons( "Mirror_S",
175 MirrorEnd[i], MirrorEnd[i] + MirrorNi
176 MirrorEnd[i+1], MirrorEnd[i+1] + Mirr
177 MirrorSectionLength/2, 0*deg, 360.*de
178 MirrorLogicalVolume[i] = new G4LogicalVolu
179 MirrorSolid[i], Ni, "Mirror_L", 0
180 MirrorLogicalVolume[i]->SetVisAttributes(V
181
182 // Gold coating on mirror
183 MirrorAuCoatingSolid[i] = new G4Cons(
184 "MirrorAuCoating_S",
185 MirrorEnd[i] - MirrorAuCoating, Mir
186 MirrorEnd[i+1] - MirrorAuCoating, M
187 MirrorSectionLength/2, 0*deg, 360.*
188 MirrorAuCoatingLogicalVolume[i] = new G4Lo
189 MirrorAuCoatingSolid[i],
190 Au,
191 "MirrorAuCoating_L",
192 0, 0, 0 );
193 MirrorAuCoatingLogicalVolume[i]->SetVisAtt
194
195 // Aluminium baffle inside mirror
196 BaffleSolid[i] = new G4Cons( "Baffle_S",
197 0, MirrorEnd[i] - BaffleGap,
198 0, MirrorEnd[i+1] - BaffleGap,
199 MirrorSectionLength/2, 0*deg, 360.*de
200 BaffleLogicalVolume[i] = new G4LogicalVolu
201 BaffleSolid[i], Al, "Baffle_L", 0
202 BaffleLogicalVolume[i]-> SetVisAttributes(
203 }
204
205 // Physical volume
206
207 for ( i=0; i<4; i++ ) {
208 new G4PVPlacement(
209 rotateMatrix,
210 G4ThreeVector( MirrorPosition[i], 0
211 "Mirror_P",
212 MirrorLogicalVolume[i],
213 physicalWorld, false, 0 );
214 new G4PVPlacement(
215 rotateMatrix,
216 G4ThreeVector( MirrorPosition[i], 0
217 "MirrorAuCoating_P",
218 MirrorAuCoatingLogicalVolume[i],
219 physicalWorld, false, 0 );
220 new G4PVPlacement(
221 rotateMatrix,
222 G4ThreeVector( MirrorPosition[i], 0.
223 "Baffle_P",
224 BaffleLogicalVolume[i],
225 physicalWorld, false, 0 );
226 }
227
228 // Make Mirror Invisible
229
230 for ( i=0; i<4; i++ ) {
231 // MirrorLogicalVolume[i] -> SetVisAttri
232 // MirrorAuCoatingLogicalVolume[i] -> Se
233 BaffleLogicalVolume[i] -> SetVisAttributes
234 }
235
236
237 // Construct Optical Bench
238 // Main Telescope carbon fibre tube and two
239
240 G4int nel;
241 G4String symbol;
242
243 // Elements
244 G4Element* C = new G4Element("Carbon", symbo
245 G4Element* H = new G4Element("Hydrogen",symb
246
247 // Materials from Combination
248 G4Material* Cf = new G4Material("Carbon Fibr
249 Cf->AddElement(C,1);
250 Cf->AddElement(H,2);
251
252 // Visualization attributes
253 G4VisAttributes* VisAttBench = new G4VisAttr
254 G4Colour(0/255., 200/255., 0/
255
256 // Construct Optical bench
257 G4double BenchThickness = 1.0*cm;
258 G4double BenchFrontEndMinRadiusOut = MirrorE
259 ( MirrorEnd[3] - MirrorEnd[4] )*7.5/15
260 + MirrorNiThickness;
261 G4double BenchFrontEndMinRadiusIn = MirrorE
262 ( MirrorEnd[3] - MirrorEnd[4] )*7.4/15
263 + MirrorNiThickness;
264 G4double BenchFrontEndMaxRadius = MirrorEnd[
265 G4double BenchBackEndMinRadius = 0.0*cm;
266 G4double BenchBackEndMaxRadius = MirrorEnd[
267 G4double BenchMainLength;
268
269 BenchMainLength = MirrorPosition[3] - BenchT
270
271 G4Cons* BenchFrontEndSolid;
272 G4Tubs* BenchBackEndSolid;
273 G4Cons* BenchMainSolid;
274
275 G4LogicalVolume* BenchFrontEndLogicalVolume;
276 G4LogicalVolume* BenchBackEndLogicalVolume;
277 G4LogicalVolume* BenchMainLogicalVolume;
278
279 BenchFrontEndSolid = new G4Cons( "BenchFront
280 BenchFrontEndMinRadiusOut, BenchFro
281 BenchFrontEndMinRadiusIn, BenchFron
282 BenchThickness/2, 0*deg, 360.*deg )
283 BenchFrontEndLogicalVolume = new G4LogicalVo
284 BenchFrontEndSolid, Al, "BenchF
285 BenchFrontEndLogicalVolume->SetVisAttributes
286
287 BenchBackEndSolid = new G4Tubs( "BenchBackE
288 BenchBackEndMinRadius, BenchBackEnd
289 BenchThickness/2, 0*deg, 360.*deg )
290 BenchBackEndLogicalVolume = new G4LogicalVol
291 BenchBackEndSolid, Al, "BenchBac
292 BenchBackEndLogicalVolume->SetVisAttributes(
293
294 BenchMainSolid = new G4Cons( "BenchMain_
295 BenchFrontEndMaxRadius - BenchThick
296 BenchFrontEndMaxRadius,
297 BenchBackEndMaxRadius - BenchThickn
298 BenchBackEndMaxRadius,
299 BenchMainLength/2, 0*deg, 360.*deg)
300 BenchMainLogicalVolume = new G4LogicalVolume
301 BenchMainSolid, Cf, "BenchMai
302 BenchMainLogicalVolume -> SetVisAttributes(V
303
304 // Physical volume
305
306 new G4PVPlacement(
307 rotateMatrix,
308 G4ThreeVector( MirrorPosition[3] - Ben
309 0.0*cm, 0.0*cm ),
310 "BenchFrontEnd_P",
311 BenchFrontEndLogicalVolume,
312 physicalWorld, false, 0 );
313
314 new G4PVPlacement(
315 rotateMatrix,
316 G4ThreeVector(0.0*cm - BenchThickness/
317 "BenchBackEnd_P",
318 BenchBackEndLogicalVolume,
319 physicalWorld, false, 0 );
320
321 new G4PVPlacement(
322 rotateMatrix,
323 G4ThreeVector( BenchMainLength/2, 0.0*
324 "BenchMain_P",
325 BenchMainLogicalVolume,
326 physicalWorld, false, 0 );
327
328 //--- Make Bench Invisible
329
330 // BenchFrontEndLogicalVolume -> SetVisAttri
331
332 // BenchBackEndLogicalVolume -> SetVisAttrib
333 BenchMainLogicalVolume -> SetVisAttributes(G
334
335 return;
336 }
337
338 // Construct Focal Plane
339 // Conical Titanium baffle and silicon detecto
340
341 void XrayTelDetectorConstruction::ConstructFoc
342 {
343
344 // Elements
345 G4Material* Ti = new G4Material("Titanium",
346 G4Material* Si = new G4Material("Silicon", 1
347
348 // Visualization attributes
349 G4VisAttributes* VisDetectorBaffle = new G4V
350 G4Colour(190/255., 255/255.,
351 G4VisAttributes* VisDetector = new G4VisAttr
352 G4Colour(255/255., 0/255., 0/
353
354 // Rotation Matrix
355 G4RotationMatrix *rotateMatrix = new G4Rotat
356 rotateMatrix -> rotateY(90.*deg);
357
358 // Construct Detector Baffle
359 G4double DetectorBaffleLength = 57.2*cm;
360 G4double DetectorBaffleOuterRadiusIn = 7.1*c
361 G4double DetectorBaffleOuterRadiusOut = 7.35
362 G4double DetectorBaffleInnerRadiusIn = 4.55*
363 G4double DetectorBaffleInnerRadiusOut = 5.75
364
365 G4Cons* DetectorBaffleSolid;
366
367 G4LogicalVolume* DetectorBaffleLogicalVolume
368
369 DetectorBaffleSolid = new G4Cons( "DetectorB
370 DetectorBaffleOuterRadiusIn,
371 DetectorBaffleOuterRadiusOut,
372 DetectorBaffleInnerRadiusIn,
373 DetectorBaffleInnerRadiusOut,
374 DetectorBaffleLength/2, 0*deg, 360
375 DetectorBaffleLogicalVolume = new G4LogicalV
376 DetectorBaffleSolid, Ti, "Dete
377 DetectorBaffleLogicalVolume -> SetVisAttribu
378
379 // Physical volume
380
381 /* G4VPhysicalVolume* DetectorBafflePhysical
382 new G4PVPlacement(
383 rotateMatrix,
384 G4ThreeVector( DetectorBaffleLength/2,
385 "DetectorBaffle_P",
386 DetectorBaffleLogicalVolume,
387 physicalWorld, false, 0 );
388
389 //--- Make Invisible
390
391 // DetectorBaffleLogicalVolume -> SetVisAttr
392
393 // Construct Detector
394
395 G4double DetectorRadius = 32.5*mm;
396 G4double DetectorThickness = 50e-6*m;
397
398 G4Tubs* DetectorSolid;
399
400 G4LogicalVolume* DetectorLogicalVolume;
401
402 DetectorSolid = new G4Tubs( "Detector_S",
403 0, DetectorRadius,
404 DetectorThickness/2, 0*deg, 360.*d
405 DetectorLogicalVolume = new G4LogicalVolume(
406 DetectorSolid, Si, "Detector_L
407 DetectorLogicalVolume -> SetVisAttributes( V
408
409 // Physical volume
410 /*G4VPhysicalVolume* DetectorPhysicalVolume
411 new G4PVPlacement(
412 rotateMatrix,
413 G4ThreeVector( DetectorThickness/2, 0.
414 "Detector_P",
415 DetectorLogicalVolume,
416 physicalWorld, false, 0 );
417
418 //--- Make Invisible
419 // DetectorLogicalVolume -> SetVisAttributes
420
421 return;
422 }
423