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