ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
XrayTelDetectorConstruction.cc
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file XrayTelDetectorConstruction.cc
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 
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::XrayTelDetectorConstruction()
75 {
76  world_x = 2500.*cm;
77  world_y = 2500.*cm;
78  world_z = 2500.*cm;
79 }
80 
81 XrayTelDetectorConstruction::~XrayTelDetectorConstruction()
82 {;}
83 
84 G4VPhysicalVolume* XrayTelDetectorConstruction::Construct( )
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
105  physicalWorld= new G4PVPlacement( 0,
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::GetInvisible());
115 
116  // Construct geometry
117  ConstructTelescope();
118  ConstructFocalPlane();
119 
120  return physicalWorld;
121 }
122 
123 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
124 
125 // Construct Telescope
126 
127 void XrayTelDetectorConstruction::ConstructTelescope()
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 
207  for ( i=0; i<4; i++ ) {
208  new G4PVPlacement(
209  rotateMatrix,
210  G4ThreeVector( MirrorPosition[i], 0.0*cm, 0.0*cm ),
211  "Mirror_P",
212  MirrorLogicalVolume[i],
213  physicalWorld, false, 0 );
214  new G4PVPlacement(
215  rotateMatrix,
216  G4ThreeVector( MirrorPosition[i], 0.0*cm, 0.0*cm ),
217  "MirrorAuCoating_P",
218  MirrorAuCoatingLogicalVolume[i],
219  physicalWorld, false, 0 );
220  new G4PVPlacement(
221  rotateMatrix,
222  G4ThreeVector( MirrorPosition[i], 0.0*cm, 0.0*cm ),
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] -> SetVisAttributes(G4VisAttributes::GetInvisible());
232  // MirrorAuCoatingLogicalVolume[i] -> SetVisAttributes(G4VisAttributes::GetInvisible());
233  BaffleLogicalVolume[i] -> SetVisAttributes(G4VisAttributes::GetInvisible());
234  }
235 
236 
237  // Construct Optical Bench
238  // Main Telescope carbon fibre tube and two aluminium end caps
239 
240  G4int nel;
241  G4String symbol;
242 
243  // Elements
244  G4Element* C = new G4Element("Carbon", symbol="C", 6., 12.011*g/mole);
245  G4Element* H = new G4Element("Hydrogen",symbol="H", 1., 1.00794*g/mole);
246 
247  // Materials from Combination
248  G4Material* Cf = new G4Material("Carbon Fibre", 2.0*g/cm3, nel=2);
249  Cf->AddElement(C,1);
250  Cf->AddElement(H,2);
251 
252  // Visualization attributes
253  G4VisAttributes* VisAttBench = new G4VisAttributes(
254  G4Colour(0/255., 200/255., 0/255.));
255 
256  // Construct Optical bench
257  G4double BenchThickness = 1.0*cm;
258  G4double BenchFrontEndMinRadiusOut = MirrorEnd[4] +
259  ( MirrorEnd[3] - MirrorEnd[4] )*7.5/15
260  + MirrorNiThickness;
261  G4double BenchFrontEndMinRadiusIn = MirrorEnd[4] +
262  ( MirrorEnd[3] - MirrorEnd[4] )*7.4/15
263  + MirrorNiThickness;
264  G4double BenchFrontEndMaxRadius = MirrorEnd[4] + MirrorNiThickness + 25.*cm;
265  G4double BenchBackEndMinRadius = 0.0*cm;
266  G4double BenchBackEndMaxRadius = MirrorEnd[4] + MirrorNiThickness + 5.*cm;
267  G4double BenchMainLength;
268 
269  BenchMainLength = MirrorPosition[3] - BenchThickness;
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( "BenchFrontEnd_S",
280  BenchFrontEndMinRadiusOut, BenchFrontEndMaxRadius,
281  BenchFrontEndMinRadiusIn, BenchFrontEndMaxRadius,
282  BenchThickness/2, 0*deg, 360.*deg );
283  BenchFrontEndLogicalVolume = new G4LogicalVolume(
284  BenchFrontEndSolid, Al, "BenchFrontEnd_L", 0, 0, 0 );
285  BenchFrontEndLogicalVolume->SetVisAttributes(VisAttBench);
286 
287  BenchBackEndSolid = new G4Tubs( "BenchBackEnd_S",
288  BenchBackEndMinRadius, BenchBackEndMaxRadius,
289  BenchThickness/2, 0*deg, 360.*deg );
290  BenchBackEndLogicalVolume = new G4LogicalVolume(
291  BenchBackEndSolid, Al, "BenchBackEnd_L", 0, 0, 0 );
292  BenchBackEndLogicalVolume->SetVisAttributes(VisAttBench);
293 
294  BenchMainSolid = new G4Cons( "BenchMain_S",
295  BenchFrontEndMaxRadius - BenchThickness,
296  BenchFrontEndMaxRadius,
297  BenchBackEndMaxRadius - BenchThickness,
298  BenchBackEndMaxRadius,
299  BenchMainLength/2, 0*deg, 360.*deg);
300  BenchMainLogicalVolume = new G4LogicalVolume(
301  BenchMainSolid, Cf, "BenchMain_L", 0, 0, 0 );
302  BenchMainLogicalVolume -> SetVisAttributes(VisAttBench);
303 
304  // Physical volume
305 
306  new G4PVPlacement(
307  rotateMatrix,
308  G4ThreeVector( MirrorPosition[3] - BenchThickness/2,
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/2, 0.0*cm, 0.0*cm ),
317  "BenchBackEnd_P",
318  BenchBackEndLogicalVolume,
319  physicalWorld, false, 0 );
320 
321  new G4PVPlacement(
322  rotateMatrix,
323  G4ThreeVector( BenchMainLength/2, 0.0*cm, 0.0*cm ),
324  "BenchMain_P",
325  BenchMainLogicalVolume,
326  physicalWorld, false, 0 );
327 
328  //--- Make Bench Invisible
329 
330  // BenchFrontEndLogicalVolume -> SetVisAttributes(G4VisAttributes::GetInvisible())
331 
332  // BenchBackEndLogicalVolume -> SetVisAttributes(G4VisAttributes::GetInvisible());
333  BenchMainLogicalVolume -> SetVisAttributes(G4VisAttributes::GetInvisible());
334 
335  return;
336 }
337 
338 // Construct Focal Plane
339 // Conical Titanium baffle and silicon detector
340 
341 void XrayTelDetectorConstruction::ConstructFocalPlane()
342 {
343 
344  // Elements
345  G4Material* Ti = new G4Material("Titanium", 22., 47.867*g/mole, 4.54*g/cm3);
346  G4Material* Si = new G4Material("Silicon", 14., 28.090*g/mole, 2.33*g/cm3);
347 
348  // Visualization attributes
349  G4VisAttributes* VisDetectorBaffle = new G4VisAttributes(
350  G4Colour(190/255., 255/255., 0/255.) );
351  G4VisAttributes* VisDetector = new G4VisAttributes(
352  G4Colour(255/255., 0/255., 0/255.) );
353 
354  // Rotation Matrix
355  G4RotationMatrix *rotateMatrix = new G4RotationMatrix();
356  rotateMatrix -> rotateY(90.*deg);
357 
358  // Construct Detector Baffle
359  G4double DetectorBaffleLength = 57.2*cm;
360  G4double DetectorBaffleOuterRadiusIn = 7.1*cm;
361  G4double DetectorBaffleOuterRadiusOut = 7.35*cm;
362  G4double DetectorBaffleInnerRadiusIn = 4.55*cm;
363  G4double DetectorBaffleInnerRadiusOut = 5.75*cm;
364 
365  G4Cons* DetectorBaffleSolid;
366 
367  G4LogicalVolume* DetectorBaffleLogicalVolume;
368 
369  DetectorBaffleSolid = new G4Cons( "DetectorBaffle_S",
370  DetectorBaffleOuterRadiusIn,
371  DetectorBaffleOuterRadiusOut,
372  DetectorBaffleInnerRadiusIn,
373  DetectorBaffleInnerRadiusOut,
374  DetectorBaffleLength/2, 0*deg, 360.*deg);
375  DetectorBaffleLogicalVolume = new G4LogicalVolume(
376  DetectorBaffleSolid, Ti, "DetectorBaffle_L", 0, 0, 0 );
377  DetectorBaffleLogicalVolume -> SetVisAttributes( VisDetectorBaffle );
378 
379  // Physical volume
380 
381  /* G4VPhysicalVolume* DetectorBafflePhysicalVolume = */
382  new G4PVPlacement(
383  rotateMatrix,
384  G4ThreeVector( DetectorBaffleLength/2, 0.0*cm, 0.0*cm),
385  "DetectorBaffle_P",
386  DetectorBaffleLogicalVolume,
387  physicalWorld, false, 0 );
388 
389  //--- Make Invisible
390 
391  // DetectorBaffleLogicalVolume -> SetVisAttributes( G4VisAttributes::GetInvisible() );
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.*deg);
405  DetectorLogicalVolume = new G4LogicalVolume(
406  DetectorSolid, Si, "Detector_L", 0, 0, 0 );
407  DetectorLogicalVolume -> SetVisAttributes( VisDetector );
408 
409  // Physical volume
410  /*G4VPhysicalVolume* DetectorPhysicalVolume = */
411  new G4PVPlacement(
412  rotateMatrix,
413  G4ThreeVector( DetectorThickness/2, 0.0*cm, 0.0*cm),
414  "Detector_P",
415  DetectorLogicalVolume,
416  physicalWorld, false, 0 );
417 
418  //--- Make Invisible
419  // DetectorLogicalVolume -> SetVisAttributes( G4VisAttributes::GetInvisible() );
420 
421  return;
422 }