Geant4  10.00.p01
XrayTelDetectorConstruction.cc
Go to the documentation of this file.
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 //
27 // **********************************************************************
28 // * *
29 // * GEANT 4 xray_telescope advanced example *
30 // * *
31 // * MODULE: XrayTelDetectorConstruction.cc *
32 // * ------- *
33 // * *
34 // * Version: 0.4 *
35 // * Date: 06/11/00 *
36 // * Author: R Nartallo *
37 // * Organisation: ESA/ESTEC, Noordwijk, THe Netherlands *
38 // * *
39 // **********************************************************************
40 //
41 // CHANGE HISTORY
42 // --------------
43 //
44 // 06.11.2000 R.Nartallo
45 // - First implementation of xray_telescope geometry
46 // - Based on Chandra and XMM models by R Nartallo, P Truscott, F Lei
47 // and P Arce
48 //
49 //
50 // **********************************************************************
51 
53 
54 #include "globals.hh"
55 #include "G4PhysicalConstants.hh"
56 #include "G4SystemOfUnits.hh"
57 #include "G4UnitsTable.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 
75 {
76  world_x = 2500.*cm;
77  world_y = 2500.*cm;
78  world_z = 2500.*cm;
79 }
80 
82 {;}
83 
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*pascal );
91 
92  // Visualization attributes
93  G4VisAttributes* VisAttWorld= new G4VisAttributes( G4Colour(204/255.,255/255.,255/255.));
94 
95  // World
96  G4Box * solidWorld = new G4Box( "world_S", world_x, world_y, world_z );
97  G4LogicalVolume * logicalWorld = new G4LogicalVolume( solidWorld, // solid
98  Vacuum, // material
99  "world_L", // name
100  0,0,0);
101 
102  logicalWorld -> SetVisAttributes(VisAttWorld);
103 
104  // Physical volume
106  G4ThreeVector(),
107  "world_P", // name (2nd constructor)
108  logicalWorld, // logical volume
109  NULL, // mother volume
110  false, // no boolean operation
111  0); // copy number
112 
113  // Make Invisible
114  logicalWorld -> SetVisAttributes(G4VisAttributes::Invisible);
115 
116  // Construct geometry
119 
120  return physicalWorld;
121 }
122 
123 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
124 
125 // Construct Telescope
126 
128 {
129  // Construct Mirror
130  // Single shell mirror made of Nickel with thin Gold coating
131  // Mirror made up of two cones approximating the parabolic section and
132  // two cones approximating the hyperbolic section
133  // The centre of the mirror is filled wiith a solid aluminium rod shaped as the
134  // mirrors, so as to leave a constant BaffleGap distance from the mirror surface
135 
136  // Build materials
137  G4Material* Ni = new G4Material("Nickel", 28., 58.6934*g/mole, 8.902*g/cm3);
138  G4Material* Au = new G4Material("Gold", 79., 196.96654*g/mole, 19.300*g/cm3);
139  G4Material* Al = new G4Material("Aluminium", 13., 26.98*g/mole, 2.700*g/cm3);
140 
141  // Visualization attributes
142  G4VisAttributes* VisAttMirror = new G4VisAttributes(
143  G4Colour(0/255., 0/255.,255/255.));
144  G4VisAttributes* VisAttAuCoating = new G4VisAttributes(
145  G4Colour(255/255., 255/255., 0/255.));
146  G4VisAttributes* VisAttBaffle = new G4VisAttributes(
147  G4Colour(128/255., 128/255., 128/255.));
148 
149  // Rotation Matrix
150  G4RotationMatrix *rotateMatrix = new G4RotationMatrix();
151  rotateMatrix -> rotateY(90.*deg);
152 
153  // Construct cones to make Mirror sections
154  G4int i;
155  G4double MirrorEnd[5] = { 34.9995975*cm, 34.8277209*cm, 34.6549918*cm,
156  34.1347834*cm, 33.6137753*cm };
157  G4double MirrorPosition[4] = { 772.5*cm, 757.5*cm, 742.5*cm, 727.5*cm };
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* MirrorAuCoatingLogicalVolume[4];
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] + MirrorNiThickness,
176  MirrorEnd[i+1], MirrorEnd[i+1] + MirrorNiThickness,
177  MirrorSectionLength/2, 0*deg, 360.*deg);
178  MirrorLogicalVolume[i] = new G4LogicalVolume(
179  MirrorSolid[i], Ni, "Mirror_L", 0, 0, 0 );
180  MirrorLogicalVolume[i]->SetVisAttributes(VisAttMirror);
181 
182  // Gold coating on mirror
183  MirrorAuCoatingSolid[i] = new G4Cons(
184  "MirrorAuCoating_S",
185  MirrorEnd[i] - MirrorAuCoating, MirrorEnd[i],
186  MirrorEnd[i+1] - MirrorAuCoating, MirrorEnd[i+1],
187  MirrorSectionLength/2, 0*deg, 360.*deg);
188  MirrorAuCoatingLogicalVolume[i] = new G4LogicalVolume(
189  MirrorAuCoatingSolid[i],
190  Au,
191  "MirrorAuCoating_L",
192  0, 0, 0 );
193  MirrorAuCoatingLogicalVolume[i]->SetVisAttributes(VisAttAuCoating);
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.*deg);
200  BaffleLogicalVolume[i] = new G4LogicalVolume(
201  BaffleSolid[i], Al, "Baffle_L", 0, 0, 0 );
202  BaffleLogicalVolume[i]-> SetVisAttributes(VisAttBaffle);
203  }
204 
205  // Physical volume
206  G4VPhysicalVolume* MirrorPhysicalVolume[4];
207  G4VPhysicalVolume* MirrorAuCoatingPhysicalVolume[4];
208  G4VPhysicalVolume* BafflePhysicalVolume[4];
209 
210  for ( i=0; i<4; i++ ) {
211  MirrorPhysicalVolume[i] = new G4PVPlacement(
212  rotateMatrix,
213  G4ThreeVector( MirrorPosition[i], 0.0*cm, 0.0*cm ),
214  "Mirror_P",
215  MirrorLogicalVolume[i],
216  physicalWorld, false, 0 );
217  MirrorAuCoatingPhysicalVolume[i] = new G4PVPlacement(
218  rotateMatrix,
219  G4ThreeVector( MirrorPosition[i], 0.0*cm, 0.0*cm ),
220  "MirrorAuCoating_P",
221  MirrorAuCoatingLogicalVolume[i],
222  physicalWorld, false, 0 );
223  BafflePhysicalVolume[i] = new G4PVPlacement(
224  rotateMatrix,
225  G4ThreeVector( MirrorPosition[i], 0.0*cm, 0.0*cm ),
226  "Baffle_P",
227  BaffleLogicalVolume[i],
228  physicalWorld, false, 0 );
229  }
230 
231  // Make Mirror Invisible
232 
233  for ( i=0; i<4; i++ ) {
234  // MirrorLogicalVolume[i] -> SetVisAttributes(G4VisAttributes::Invisible);
235  // MirrorAuCoatingLogicalVolume[i] -> SetVisAttributes(G4VisAttributes::Invisible);
236  BaffleLogicalVolume[i] -> SetVisAttributes(G4VisAttributes::Invisible);
237  }
238 
239 
240  // Construct Optical Bench
241  // Main Telescope carbon fibre tube and two aluminium end caps
242 
243  G4int nel;
245 
246  // Elements
247  G4Element* C = new G4Element("Carbon", symbol="C", 6., 12.011*g/mole);
248  G4Element* H = new G4Element("Hydrogen",symbol="H", 1., 1.00794*g/mole);
249 
250  // Materials from Combination
251  G4Material* Cf = new G4Material("Carbon Fibre", 2.0*g/cm3, nel=2);
252  Cf->AddElement(C,1);
253  Cf->AddElement(H,2);
254 
255  // Visualization attributes
256  G4VisAttributes* VisAttBench = new G4VisAttributes(
257  G4Colour(0/255., 200/255., 0/255.));
258 
259  // Construct Optical bench
260  G4double BenchThickness = 1.0*cm;
261  G4double BenchFrontEndMinRadiusOut = MirrorEnd[4] +
262  ( MirrorEnd[3] - MirrorEnd[4] )*7.5/15
263  + MirrorNiThickness;
264  G4double BenchFrontEndMinRadiusIn = MirrorEnd[4] +
265  ( MirrorEnd[3] - MirrorEnd[4] )*7.4/15
266  + MirrorNiThickness;
267  G4double BenchFrontEndMaxRadius = MirrorEnd[4] + MirrorNiThickness + 25.*cm;
268  G4double BenchBackEndMinRadius = 0.0*cm;
269  G4double BenchBackEndMaxRadius = MirrorEnd[4] + MirrorNiThickness + 5.*cm;
270  G4double BenchMainLength;
271 
272  BenchMainLength = MirrorPosition[3] - BenchThickness;
273 
274  G4Cons* BenchFrontEndSolid;
275  G4Tubs* BenchBackEndSolid;
276  G4Cons* BenchMainSolid;
277 
278  G4LogicalVolume* BenchFrontEndLogicalVolume;
279  G4LogicalVolume* BenchBackEndLogicalVolume;
280  G4LogicalVolume* BenchMainLogicalVolume;
281 
282  BenchFrontEndSolid = new G4Cons( "BenchFrontEnd_S",
283  BenchFrontEndMinRadiusOut, BenchFrontEndMaxRadius,
284  BenchFrontEndMinRadiusIn, BenchFrontEndMaxRadius,
285  BenchThickness/2, 0*deg, 360.*deg );
286  BenchFrontEndLogicalVolume = new G4LogicalVolume(
287  BenchFrontEndSolid, Al, "BenchFrontEnd_L", 0, 0, 0 );
288  BenchFrontEndLogicalVolume->SetVisAttributes(VisAttBench);
289 
290  BenchBackEndSolid = new G4Tubs( "BenchBackEnd_S",
291  BenchBackEndMinRadius, BenchBackEndMaxRadius,
292  BenchThickness/2, 0*deg, 360.*deg );
293  BenchBackEndLogicalVolume = new G4LogicalVolume(
294  BenchBackEndSolid, Al, "BenchBackEnd_L", 0, 0, 0 );
295  BenchBackEndLogicalVolume->SetVisAttributes(VisAttBench);
296 
297  BenchMainSolid = new G4Cons( "BenchMain_S",
298  BenchFrontEndMaxRadius - BenchThickness,
299  BenchFrontEndMaxRadius,
300  BenchBackEndMaxRadius - BenchThickness,
301  BenchBackEndMaxRadius,
302  BenchMainLength/2, 0*deg, 360.*deg);
303  BenchMainLogicalVolume = new G4LogicalVolume(
304  BenchMainSolid, Cf, "BenchMain_L", 0, 0, 0 );
305  BenchMainLogicalVolume -> SetVisAttributes(VisAttBench);
306 
307  // Physical volume
308  G4VPhysicalVolume* BenchFrontEndPhysicalVolume;
309  G4VPhysicalVolume* BenchBackEndPhysicalVolume;
310  G4VPhysicalVolume* BenchMainPhysicalVolume;
311 
312  BenchFrontEndPhysicalVolume = new G4PVPlacement(
313  rotateMatrix,
314  G4ThreeVector( MirrorPosition[3] - BenchThickness/2,
315  0.0*cm, 0.0*cm ),
316  "BenchFrontEnd_P",
317  BenchFrontEndLogicalVolume,
318  physicalWorld, false, 0 );
319 
320  BenchBackEndPhysicalVolume = new G4PVPlacement(
321  rotateMatrix,
322  G4ThreeVector(0.0*cm - BenchThickness/2, 0.0*cm, 0.0*cm ),
323  "BenchBackEnd_P",
324  BenchBackEndLogicalVolume,
325  physicalWorld, false, 0 );
326 
327  BenchMainPhysicalVolume = new G4PVPlacement(
328  rotateMatrix,
329  G4ThreeVector( BenchMainLength/2, 0.0*cm, 0.0*cm ),
330  "BenchMain_P",
331  BenchMainLogicalVolume,
332  physicalWorld, false, 0 );
333 
334  //--- Make Bench Invisible
335 
336  // BenchFrontEndLogicalVolume -> SetVisAttributes(G4VisAttributes::Invisible);
337  // BenchBackEndLogicalVolume -> SetVisAttributes(G4VisAttributes::Invisible);
338  BenchMainLogicalVolume -> SetVisAttributes(G4VisAttributes::Invisible);
339 
340  return;
341 }
342 
343 // Construct Focal Plane
344 // Conical Titanium baffle and silicon detector
345 
347 {
348 
349  // Elements
350  G4Material* Ti = new G4Material("Titanium", 22., 47.867*g/mole, 4.54*g/cm3);
351  G4Material* Si = new G4Material("Silicon", 14., 28.090*g/mole, 2.33*g/cm3);
352 
353  // Visualization attributes
354  G4VisAttributes* VisDetectorBaffle = new G4VisAttributes(
355  G4Colour(190/255., 255/255., 0/255.) );
356  G4VisAttributes* VisDetector = new G4VisAttributes(
357  G4Colour(255/255., 0/255., 0/255.) );
358 
359  // Rotation Matrix
360  G4RotationMatrix *rotateMatrix = new G4RotationMatrix();
361  rotateMatrix -> rotateY(90.*deg);
362 
363  // Construct Detector Baffle
364  G4double DetectorBaffleLength = 57.2*cm;
365  G4double DetectorBaffleOuterRadiusIn = 7.1*cm;
366  G4double DetectorBaffleOuterRadiusOut = 7.35*cm;
367  G4double DetectorBaffleInnerRadiusIn = 4.55*cm;
368  G4double DetectorBaffleInnerRadiusOut = 5.75*cm;
369 
370  G4Cons* DetectorBaffleSolid;
371 
372  G4LogicalVolume* DetectorBaffleLogicalVolume;
373 
374  DetectorBaffleSolid = new G4Cons( "DetectorBaffle_S",
375  DetectorBaffleOuterRadiusIn,
376  DetectorBaffleOuterRadiusOut,
377  DetectorBaffleInnerRadiusIn,
378  DetectorBaffleInnerRadiusOut,
379  DetectorBaffleLength/2, 0*deg, 360.*deg);
380  DetectorBaffleLogicalVolume = new G4LogicalVolume(
381  DetectorBaffleSolid, Ti, "DetectorBaffle_L", 0, 0, 0 );
382  DetectorBaffleLogicalVolume -> SetVisAttributes( VisDetectorBaffle );
383 
384  // Physical volume
385  G4VPhysicalVolume* DetectorBafflePhysicalVolume;
386 
387  DetectorBafflePhysicalVolume = new G4PVPlacement(
388  rotateMatrix,
389  G4ThreeVector( DetectorBaffleLength/2, 0.0*cm, 0.0*cm),
390  "DetectorBaffle_P",
391  DetectorBaffleLogicalVolume,
392  physicalWorld, false, 0 );
393 
394  //--- Make Invisible
395 
396  // DetectorBaffleLogicalVolume -> SetVisAttributes( G4VisAttributes::Invisible );
397 
398  // Construct Detector
399 
400  G4double DetectorRadius = 32.5*mm;
401  G4double DetectorThickness = 50e-6*m;
402 
403  G4Tubs* DetectorSolid;
404 
405  G4LogicalVolume* DetectorLogicalVolume;
406 
407  DetectorSolid = new G4Tubs( "Detector_S",
408  0, DetectorRadius,
409  DetectorThickness/2, 0*deg, 360.*deg);
410  DetectorLogicalVolume = new G4LogicalVolume(
411  DetectorSolid, Si, "Detector_L", 0, 0, 0 );
412  DetectorLogicalVolume -> SetVisAttributes( VisDetector );
413 
414  // Physical volume
415  G4VPhysicalVolume* DetectorPhysicalVolume;
416 
417  DetectorPhysicalVolume = new G4PVPlacement(
418  rotateMatrix,
419  G4ThreeVector( DetectorThickness/2, 0.0*cm, 0.0*cm),
420  "Detector_P",
421  DetectorLogicalVolume,
422  physicalWorld, false, 0 );
423 
424  //--- Make Invisible
425  // DetectorLogicalVolume -> SetVisAttributes( G4VisAttributes::Invisible );
426 
427  return;
428 }
static const double cm
Definition: G4SIunits.hh:106
G4String symbol
Definition: TRTMaterials.hh:40
CLHEP::Hep3Vector G4ThreeVector
CLHEP::HepRotation G4RotationMatrix
Definition: G4Box.hh:63
Definition: G4Tubs.hh:84
int G4int
Definition: G4Types.hh:78
static const double deg
Definition: G4SIunits.hh:133
Definition: G4Cons.hh:82
G4Material * Si
Definition: TRTMaterials.hh:78
static const double cm3
Definition: G4SIunits.hh:108
static const double kelvin
Definition: G4SIunits.hh:260
#define pascal
Definition: G4SIunits.hh:213
static const double g
Definition: G4SIunits.hh:162
static const G4VisAttributes Invisible
static const double mole
Definition: G4SIunits.hh:265
static const double m
Definition: G4SIunits.hh:110
void AddElement(G4Element *element, G4int nAtoms)
Definition: G4Material.cc:345
double G4double
Definition: G4Types.hh:76
static const double mm
Definition: G4SIunits.hh:102
void SetVisAttributes(const G4VisAttributes *pVA)
G4int nel
Definition: TRTMaterials.hh:41
G4Material * Al
Definition: TRTMaterials.hh:74