source: trunk/source/geometry/solids/test/fred/src/FredDetectorConstruction.cc@ 1350

Last change on this file since 1350 was 1316, checked in by garnier, 15 years ago

update geant4-09-04-beta-cand-01 interfaces-V09-03-09 vis-V09-03-08
File size: 29.5 KB
Line 
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// FredDetectorConstruction.cc
28//
29// Implementation of fred's detector
30//
31
32#include "FredDetectorConstruction.hh"
33#include "FredSensitive.hh"
34#include "FredSensMother.hh"
35
36#include "G4LogicalVolume.hh"
37#include "G4ThreeVector.hh"
38#include "G4PVPlacement.hh"
39#include "G4RotationMatrix.hh"
40
41#include "G4SDManager.hh"
42
43#include "G4Material.hh"
44#include "G4Box.hh"
45#include "G4Tubs.hh"
46#include "G4Orb.hh"
47#include "G4Sphere.hh"
48#include "G4Torus.hh"
49#include "G4Trap.hh"
50#include "G4Trd.hh"
51#include "G4Para.hh"
52#include "G4Cons.hh"
53#include "G4Sphere.hh"
54#include "G4BREPSolidPCone.hh"
55#include "G4Polyhedra.hh"
56#include "G4Polycone.hh"
57#include "G4Ellipsoid.hh"
58#include "G4EllipticalCone.hh"
59#include "G4EllipticalTube.hh"
60#include "G4ExtrudedSolid.hh"
61#include "G4Hype.hh"
62#include "G4QuadrangularFacet.hh"
63#include "G4Tet.hh"
64#include "G4TwistedBox.hh"
65#include "G4TwistedTrap.hh"
66#include "G4TwistedTrd.hh"
67#include "G4TwistedTubs.hh"
68
69#include "G4SubtractionSolid.hh"
70
71#include "G4Color.hh"
72#include "G4VisAttributes.hh"
73
74#include "globals.hh"
75
76#include <cmath>
77
78//
79// Constructor
80//
81FredDetectorConstruction::FredDetectorConstruction( FredMessenger *ourMessenger )
82{
83 messenger = ourMessenger;
84}
85
86FredDetectorConstruction::~FredDetectorConstruction()
87{;}
88
89
90//
91// Private methods
92//
93G4ExtrudedSolid* FredDetectorConstruction::CreateExtrudedSolid1() const
94{
95 // Extruded solid with triangular polygon
96 std::vector<G4TwoVector> polygon;
97 polygon.push_back(G4TwoVector(-30.*cm, -30.*cm));
98 polygon.push_back(G4TwoVector( 0.*cm, 30.*cm));
99 polygon.push_back(G4TwoVector( 30.*cm, -30.*cm));
100
101
102 return new G4ExtrudedSolid("test_xtru1", polygon, 30.*cm,
103 G4TwoVector(), 1.0, G4TwoVector(), 1.0);
104}
105
106G4ExtrudedSolid* FredDetectorConstruction::CreateExtrudedSolid2() const
107{
108 // Box defined as Extruded solid
109 std::vector<G4TwoVector> polygon;
110 polygon.push_back(G4TwoVector(-30.*cm, -30.*cm));
111 polygon.push_back(G4TwoVector(-30.*cm, 30.*cm));
112 polygon.push_back(G4TwoVector( 30.*cm, 30.*cm));
113 polygon.push_back(G4TwoVector( 30.*cm, -30.*cm));
114
115 return new G4ExtrudedSolid("test_xtru2", polygon, 30.*cm,
116 G4TwoVector(), 1.0, G4TwoVector(), 1.0);
117}
118
119G4ExtrudedSolid* FredDetectorConstruction::CreateExtrudedSolid3() const
120{
121 // Extruded solid with 4 z-sections
122 std::vector<G4TwoVector> polygon;
123 polygon.push_back(G4TwoVector(-30.*cm, -30.*cm));
124 polygon.push_back(G4TwoVector(-30.*cm, 30.*cm));
125 polygon.push_back(G4TwoVector( 30.*cm, 30.*cm));
126 polygon.push_back(G4TwoVector( 30.*cm, -30.*cm));
127 polygon.push_back(G4TwoVector( 15.*cm, -30.*cm));
128 polygon.push_back(G4TwoVector( 15.*cm, 15.*cm));
129 polygon.push_back(G4TwoVector(-15.*cm, 15.*cm));
130 polygon.push_back(G4TwoVector(-15.*cm, -30.*cm));
131
132 std::vector<G4ExtrudedSolid::ZSection> zsections;
133 zsections.push_back(G4ExtrudedSolid::ZSection(-40.*cm, G4TwoVector(-20.*cm, 10.*cm), 1.5));
134 zsections.push_back(G4ExtrudedSolid::ZSection( 10.*cm, G4TwoVector( 0.*cm, 0.*cm), 0.5));
135 zsections.push_back(G4ExtrudedSolid::ZSection( 15.*cm, G4TwoVector( 0.*cm, 0.*cm), 0.7));
136 zsections.push_back(G4ExtrudedSolid::ZSection( 40.*cm, G4TwoVector( 20.*cm, 20.*cm), 0.9));
137
138 return new G4ExtrudedSolid("test_xtru3", polygon, zsections);
139}
140
141G4ExtrudedSolid* FredDetectorConstruction::CreateExtrudedSolid4() const
142{
143 // Another extruded solid, where polygon decomposition was failing
144 // in Geant4 9.1
145 std::vector<G4TwoVector> polygon;
146 polygon.push_back( G4TwoVector(-20.*cm, 10.*cm) );
147 polygon.push_back( G4TwoVector(-20.*cm, 25.*cm) );
148 polygon.push_back( G4TwoVector( 10.*cm, 25.*cm) );
149 polygon.push_back( G4TwoVector( 10.*cm, -10.*cm) );
150 polygon.push_back( G4TwoVector( 20.*cm, -10.*cm) );
151 polygon.push_back( G4TwoVector( 20.*cm, -25.*cm) );
152 polygon.push_back( G4TwoVector(-10.*cm, -25.*cm) );
153 polygon.push_back( G4TwoVector(-10.*cm, 10.*cm) );
154
155 return new G4ExtrudedSolid("test_xtru3", polygon, 20.*cm,
156 G4TwoVector(), 1.0, G4TwoVector(), 1.0);
157}
158
159//
160// Construct: Build the detector
161//
162G4VPhysicalVolume* FredDetectorConstruction::Construct()
163{
164 G4VisAttributes *redStuff = new G4VisAttributes( G4Color(1,0,0) );
165
166 //
167 // Vaccuum would do fine for materials right now
168 //
169 G4Material *Vaccuum = new G4Material( "Vaccuum", 18.0, 39.95*g/mole, 1.782e-03*g/cm3 );
170
171
172 //
173 // At the moment, I want something really simple:
174 // how about a "hall" containing a single box
175 //
176
177 /*
178 MEDERNACH Emmanuel
179 Aug 2000,
180
181 BEWARE :
182 If World is too small for test then Segmentation Fault !!
183 */
184
185 G4Box *hallBox = new G4Box( "hall_box", 8*m, 8*m, 8*m );
186 G4LogicalVolume *hallLog = new G4LogicalVolume( hallBox, Vaccuum, "hall_log", 0, 0, 0 );
187 G4VPhysicalVolume *hall = new G4PVPlacement( 0, G4ThreeVector(), hallLog,
188 "hall", 0, false, 0 );
189
190 //
191 // We usually don't care much about the main volume: just
192 // make it invisible
193 //
194 hallLog->SetVisAttributes( G4VisAttributes::Invisible );
195
196 //
197 // For the test volume, we have some run-time choices:
198 //
199 G4RotationMatrix *rot = new G4RotationMatrix();
200
201 G4double startPhi = messenger->StartPhi()*deg,
202 deltaPhi = messenger->DeltaPhi()*deg;
203 G4int numSide = messenger->NumSide();
204
205 switch ( messenger->SelectedVolume() ) {
206
207 //
208 // special tests
209 //
210
211 case NATALIA: {
212 G4double z_values[3] = { -60.76*mm, -49.14*mm, 102.68*mm };
213 G4double rmin[3] = { 6.24*mm, 0*mm, 0*mm };
214 G4double rmax[3] = { 6.24*mm, 6.24*mm, 6.24*mm };
215 // Rib thickness 0.41, height 6.42
216 startPhi = -std::atan2( 0.5*0.41, 6.42 );
217 deltaPhi = -2.0*startPhi;
218 testVolume = new G4Polyhedra("natalia",
219 startPhi, deltaPhi, 1, 3, z_values, rmin, rmax );
220 }
221 break;
222
223 case VOXEL:
224 testVolume = new G4Box( "test_voxel", 1*m, 1*m, 1*m );
225 break;
226
227 //
228 // CSG solids
229 //
230
231 case BOX:
232 testVolume = new G4Box( "test_box", 1*m, 1*m, 1*m );
233 break;
234
235 case CONE:
236 testVolume = new G4Cons("test_cone",
237 1*m, 1.2*m, 0.4*m, 0.6*m, 1*m, startPhi, deltaPhi );
238 // SBT test - case c
239 // testVolume = new G4Cons("test_cone",
240 // 0.0*m, 1.0*m, 0.5*m, 1.0*m, 1*m, 0.0, 360.0*deg );
241 // SBT test - case d
242 // testVolume = new G4Cons("test_cone",
243 // 0.0*m, 1.0*m, 0.0*m, 1.0*m, 1*m, 0.0, 90.0*deg );
244 // SBT test - case e
245 // testVolume = new G4Cons("test_cone",
246 // 0.0*m, 1.0*m, 0.0*m, 1.0*m, 1*m, 20.0*deg, 181.0*deg );
247 // SBT test - case f
248 // testVolume = new G4Cons("test_cone",
249 // 0.5*m, 1.0*m, 0.7*m, 1.2*m, 1*m, 20.0*deg, 350.0*deg );
250 // SBT test - case g
251 // testVolume = new G4Cons("test_cone",
252 // 0.0*m, 0.2*m, 0.8*m, 1.0*m, 0.0001*m, 10.0*deg, 90.0*deg );
253 fprintf(stderr,"OK defining a Cone \n");
254 break;
255
256 case CONE2:
257 // try to do a cone with a 'pick'
258 testVolume = new G4Cons( "test_cone2",
259 1*m, 1.2*m, 0.0*m, 0.2*m, 1*m, startPhi, deltaPhi );
260 fprintf(stderr,"OK defining a Cone2 \n");
261 break;
262
263 case ORB:
264 testVolume = new G4Orb ("test_orb", 1.0*m);
265 fprintf(stderr,"OK defining an Orb\n");
266 break;
267
268 case PARA:
269 // SBT test case b
270 testVolume = new G4Para("test_para",
271 1.0*m, 1.0*m, 1.0*m, 30.0*deg, 0.0*deg, 0.0*deg);
272 // SBT test case c
273 // testVolume = new G4Para("test_para",
274 // 1.0*m, 1.0*m, 1.0*m, 30.0*deg, 30.0*deg, 0.0*deg);
275 // SBT test case d
276 // testVolume = new G4Para("test_para",
277 // 1.0*m, 1.0*m, 1.0*m, 30.0*deg, 30.0*deg, 30.0*deg);
278 // SBT test case e
279 // testVolume = new G4Para("test_para",
280 // 0.001*m, 1.0*m, 2.0*m, 30.0*deg, 30.0*deg, 30.0*deg);
281 fprintf(stderr,"OK defining a Para \n");
282 break;
283
284 case SPHERE:
285 testVolume = new G4Sphere ("test_sphere", 0.8*m, 1.0*m, startPhi, deltaPhi, 0.0, pi);
286 // SBT test case a
287 // testVolume = new G4Sphere ("test_sphere", 0.0*m, 1.0*m, 0.0*deg, 360.0*deg, 0.0*deg, 180.0*deg);
288 // SBT test case b
289 // testVolume = new G4Sphere ("test_sphere", 0.5*m, 1.0*m, 0.0*deg, 360.0*deg, 0.0*deg, 180.0*deg);
290 // SBT test case c
291 // testVolume = new G4Sphere ("test_sphere", 0.0*m, 1.0*m, 0.0*deg, 90.0*deg, 0.0*deg, 180.0*deg);
292 // SBT test case d
293 // testVolume = new G4Sphere ("test_sphere", 0.5*m, 1.0*m, 0.0*deg, 90.0*deg, 0.0*deg, 180.0*deg);
294 // SBT test case e
295 // testVolume = new G4Sphere ("test_sphere", 0.0*m, 1.0*m, 0.0*deg, 360.0*deg, 0.0*deg, 90.0*deg);
296 // SBT test case e
297 // testVolume = new G4Sphere ("test_sphere", 0.5*m, 1.0*m, 0.0*deg, 360.0*deg, 0.0*deg, 90.0*deg);
298 // SBT test case f
299 // testVolume = new G4Sphere ("test_sphere", 0.0*m, 1.0*m, 0.0*deg, 90.0*deg, 0.0*deg, 90.0*deg);
300 // SBT test case g
301 // testVolume = new G4Sphere ("test_sphere", 0.5*m, 1.0*m, 0.0*deg, 90.0*deg, 0.0*deg, 90.0*deg);
302 fprintf(stderr,"OK defining a Sphere \n");
303 break;
304
305 case TORUS1:
306 testVolume = new G4Torus("test_torus1",
307 0.2*m, 0.4*m, 1.2*m, startPhi, deltaPhi);
308 // SBT test case a
309 // testVolume = new G4Torus("test_torus1",
310 // 0.0*m, 0.4*m, 1.0*m, 0.0*deg, 360.0*deg);
311 // SBT test case b
312 // testVolume = new G4Torus("test_torus1",
313 // 0.2*m, 0.4*m, 1.0*m, 0.0*deg, 360.0*deg);
314 // SBT test case c
315 // testVolume = new G4Torus("test_torus1",
316 // 0.0*m, 0.4*m, 1.0*m, 0.0*deg, 90.0*deg);
317 // SBT test case d
318 // testVolume = new G4Torus("test_torus1",
319 // 0.2*m, 0.4*m, 1.0*m, 0.0*deg, 90.0*deg);
320 // SBT test case e
321 // testVolume = new G4Torus("test_torus1",
322 // 0.399*m, 0.4*m, 1.0*m, 0.0*deg, 90.0*deg);
323 fprintf(stderr,"OK defining a Torus1 \n");
324 break;
325
326 case TORUS2:
327 testVolume = new G4Torus("test_torus2",
328 0.8*m, 1.4*m, 1.8*m, startPhi, deltaPhi);
329 fprintf(stderr,"OK defining a Torus2 \n");
330 break;
331
332 case TRAP:
333 testVolume = new G4Trap ("test_trap",
334 1.0*m, 0.0, pi,
335 2.4*m,1.0*m,2.0*m, 0.0,
336 2.4*m,1.0*m,2.0*m, pi);
337 fprintf(stderr,"OK defining a Trap \n");
338 break;
339
340 case TRD:
341 testVolume = new G4Trd("test_trd",
342 0.2*m, 0.8*m, 0.8*m, 1.2*m, 4*m) ;
343 fprintf(stderr,"OK defining a Trd \n");
344 break;
345
346 case TUBS:
347 testVolume = new G4Tubs( "test_tubs", 1.0*m, 1.2*m, 1*m, startPhi, deltaPhi );
348
349 // SBT test - case c
350 // testVolume = new G4Tubs( "test_tubs", 0.0*m, 1.0*m, 1.0*m, 0.0*deg, 90.0*deg );
351 // SBT test - case e
352 // testVolume = new G4Tubs( "test_tubs", 0.00999*m, 0.01001*m, 1*m, 10.0*deg, 260.0*deg );
353 fprintf(stderr,"OK defining a Tubs \n");
354 break;
355
356 //
357 // specific solids
358 //
359
360
361 case ELLIPS:
362 testVolume = new G4Ellipsoid( "test_ellipsoid",
363 0.5*m, 0.8*m, 1.0*m, -0.4*m, 0.8*m );
364 // SBT test - case a
365 // testVolume = new G4Ellipsoid( "test_ellipsoid",
366 // 1.0*m, 1.0*m, 1.0*m, 0.0*m, 0.0*m );
367 // SBT test - case b
368 // testVolume = new G4Ellipsoid( "test_ellipsoid",
369 // 0.5*m, 0.8*m, 1.0*m, 0.0*m, 0.0*m );
370 // SBT test - case c
371 // testVolume = new G4Ellipsoid( "test_ellipsoid",
372 // 0.5*m, 0.8*m, 1.0*m, -0.4*m, 10.0*m );
373 // SBT test - case d
374 // testVolume = new G4Ellipsoid( "test_ellipsoid",
375 // 0.5*m, 0.8*m, 1.0*m, -10.0*m, 0.8*m );
376 // SBT test - case e
377 // testVolume = new G4Ellipsoid( "test_ellipsoid",
378 // 0.5*m, 0.8*m, 1.0*m, -0.4*m, 0.8*m );
379 break;
380
381 case ELCONE:
382 testVolume = new G4EllipticalCone( "test_elcone", 0.3, 0.6, 0.75*m, 0.25*m);
383 // SBT test - case a
384 // testVolume = new G4EllipticalCone( "test_elcone", 0.3, 0.3, 0.75*m, 0.25*m);
385 // SBT test - case b
386 // testVolume = new G4EllipticalCone( "test_elcone", 0.3, 0.3, 0.75*m, 0.75*m);
387 // SBT test - case c
388 // testVolume = new G4EllipticalCone( "test_elcone", 0.3, 0.6, 0.75*m, 0.25*m);
389 // SBT test - case d
390 //testVolume = new G4EllipticalCone( "test_elcone", 0.3, 0.6, 0.75*m, 0.75*m);
391 break;
392
393 case ELTUBE:
394 testVolume = new G4EllipticalTube( "test_eltube", 0.4*m, 0.8*m, 1.0*m );
395 // SBT test - case a
396 //testVolume = new G4EllipticalTube( "test_eltube", 1.0*m, 1.0*m, 1.0*m );
397 break;
398
399 case EXTRU1:
400 testVolume = CreateExtrudedSolid1();
401 break;
402
403 case EXTRU2:
404 testVolume = CreateExtrudedSolid2();
405 break;
406
407 case EXTRU3:
408 testVolume = CreateExtrudedSolid3();
409 break;
410
411 case EXTRU4:
412 testVolume = CreateExtrudedSolid4();
413 break;
414
415 case HYPE:
416 testVolume = new G4Hype("test_hype", 0.2*m, 0.3*m, 0.7*rad, 0.7*rad, 0.5*m);
417 // SBT test - case c
418 testVolume = new G4Hype("test_hype", 0.5*m, 1.0*m, 2.0*rad, 2.0*rad, 1.0*m);
419 break;
420
421 case PCON: {
422 G4double z_values[2] = { -1.0*m, 1.0*m };
423 G4double rmin[2] = { 1.0*m, 1.2*m };
424 G4double rmax[2] = { 1.2*m, 1.4*m };
425 testVolume = new G4Polycone( "test_pcon",
426 startPhi, deltaPhi, 2, z_values, rmin, rmax );
427/*
428 // SBT test case d
429 G4double rv[17] = { 0.0*m, 0.2*m, 0.3*m, 0.32*m, 0.32*m, 0.4*m, 0.4*m, 0.5*m, 0.5*m, 0.8*m,
430 0.8*m, 0.9*m, 0.9*m, 0.8*m, 0.8*m, 0.3*m, 0.0*m };
431 G4double zv[17] = { -0.5*m, -0.5*m, -1.1*m, -1.1*m, -0.4*m, -0.4*m, -1.0*m, -1.0*m, -0.4*m,
432 -1.0*m, 0.0*m, 0.0*m, 0.2*m, 0.2*m, 1.0*m, 0.0*m, 1.0 };
433 testVolume = new G4Polycone ("test_pcon4", 0.0*deg, 90.0*deg, 17, rv, zv );
434
435 // SBT test case e
436 G4double rv[17] = { 0.0*m, 0.2*m, 0.3*m, 0.32*m, 0.32*m, 0.4*m, 0.4*m, 0.5*m, 0.5*m, 0.8*m,
437 0.8*m, 0.9*m, 0.9*m, 0.8*m, 0.8*m, 0.3*m, 0.0*m };
438 G4double zv[17] = { -0.5*m, -0.5*m, -1.1*m, -1.1*m, -0.4*m, -0.4*m, -1.0*m, -1.0*m, -0.4*m,
439 -1.0*m, 0.0*m, 0.0*m, 0.2*m, 0.2*m, 1.0*m, 0.0*m, 1.0*m };
440 testVolume = new G4Polycone ("test_pcon4", -1.0*deg, 2.0*deg, 17, rv, zv );
441
442 // SBT test case f
443 G4double rv[10] = { 0.6*m, 0.6*m, 1.0*m, 1.0*m, 1.1*m, 0.9*m, 0.0*m, 0.0*m, 0.4*m, 0.5*m };
444 G4double zv[10] = { -1.0*m, 0.0*m, 0.0*m, 0.8*m, 1.0*m, 1.0*m, 0.8*m, 0.0*m, 0.0*m, -1.0*m };
445 testVolume = new G4Polycone ("test_pcon4", 10.0*deg, 250.0*deg, 10, rv, zv );
446*/
447 }
448 break;
449
450 case PCON2: {
451 G4double z_values[5] = { -1.0*m, 0.0*m, 0.0*m, 0.8*m, 1.0*m };
452 G4double rmin[5] = { 0.5*m, 0.4*m, 0.0*m, 0.0*m, 0.9*m };
453 G4double rmax[5] = { 0.6*m, 0.6*m, 1.0*m, 1.0*m, 1.1*m };
454 testVolume = new G4Polycone( "test_pcon2",
455 startPhi, deltaPhi, 5, z_values, rmin, rmax );
456 }
457 break;
458
459 case PCON3: {
460 G4double z_values[8] = { -1.0*m, -0.5*m, -0.5*m, -1.0*m, -1.0*m, 0.7*m, 0.7*m, 1.0*m };
461 G4double rmin[8] = { 0.6*m, 0.6*m, 0.5*m, 0.5*m, 0.4*m, 0.4*m, 0.4*m, 0.0*m };
462 G4double rmax[8] = { 0.7*m, 0.7*m, 0.8*m, 0.9*m, 1.0*m, 1.0*m, 0.5*m, 0.5*m };
463 testVolume = new G4Polycone( "test_pcon3",
464 startPhi, deltaPhi, 8, z_values, rmin, rmax );
465 }
466 break;
467
468 case PCON4: {
469 G4double RMINVec[8];
470 RMINVec[0] = 30*cm;
471 RMINVec[1] = 30*cm;
472 RMINVec[2] = 0*cm;
473 RMINVec[3] = 0*cm;
474 RMINVec[4] = 0*cm;
475 RMINVec[5] = 0*cm;
476 RMINVec[6] = 40*cm;
477 RMINVec[7] = 40*cm;
478
479 G4double RMAXVec[8];
480 RMAXVec[0] = 70*cm;
481 RMAXVec[1] = 70*cm;
482 RMAXVec[2] = 70*cm;
483 RMAXVec[3] = 40*cm;
484 RMAXVec[4] = 40*cm;
485 RMAXVec[5] = 80*cm;
486 RMAXVec[6] = 80*cm;
487 RMAXVec[7] = 60*cm;
488
489 G4double Z_Values[8];
490 Z_Values[0] =-20*cm;
491 Z_Values[1] =-10*cm;
492 Z_Values[2] =-10*cm;
493 Z_Values[3] = 0*cm;
494 Z_Values[4] = 10*cm;
495 Z_Values[5] = 20*cm;
496 Z_Values[6] = 30*cm;
497 Z_Values[7] = 40*cm;
498
499 testVolume = new G4Polycone ("test_pcon4",
500 startPhi, deltaPhi, 8, Z_Values, RMINVec, RMAXVec );
501 }
502 break;
503
504 case PGON: {
505 G4double z_values[2] = { -1.0*m, 1.0*m };
506 G4double rmin[2] = { 0.8*m, 1.0*m };
507 G4double rmax[2] = { 1.0*m, 1.2*m };
508 testVolume = new G4Polyhedra( "test_pgon",
509 startPhi, deltaPhi, numSide, 2, z_values, rmin, rmax );
510/*
511 // SBT test case c
512 G4double rv[17] = { 0.0*m, 0.2*m, 0.3*m, 0.32*m, 0.32*m, 0.4*m, 0.4*m, 0.5*m, 0.5*m, 0.8*m,
513 0.8*m, 0.9*m, 0.9*m, 0.8*m, 0.8*m, 0.3*m, 0.0*m };
514 G4double zv[17] = { -0.5*m, -0.5*m, -1.1*m, -1.1*m, -0.4*m, -0.4*m, -1.0*m, -1.0*m, -0.4*m,
515 -1.0*m, 0.0*m, 0.0*m, 0.2*m, 0.2*m, 1.0*m, 0.0*m, 1.0*m };
516 testVolume = new G4Polyhedra ("test_pgon", 0.0*deg, 360.0*deg, 6, 17, rv, zv );
517
518 // SBT test case d
519 G4double rv[17] = { 0.0*m, 0.2*m, 0.3*m, 0.32*m, 0.32*m, 0.4*m, 0.4*m, 0.5*m, 0.5*m, 0.8*m,
520 0.8*m, 0.9*m, 0.9*m, 0.8*m, 0.8*m, 0.3*m, 0.0*m };
521 G4double zv[17] = { -0.5*m, -0.5*m, -1.1*m, -1.1*m, -0.4*m, -0.4*m, -1.0*m, -1.0*m, -0.4*m,
522 -1.0*m, 0.0*m, 0.0*m, 0.2*m, 0.2*m, 1.0*m, 0.0*m, 1.0*m };
523 testVolume = new G4Polyhedra ("test_pgon", 0.0*deg, 90.0*deg, 2, 17, rv, zv );
524
525 // SBT test case f
526 G4double zv[6] = { -0.6*m, 0.0*m, -1.0*m, 0.5*m, 0.5*m, 1.0*m };
527 G4double rmin[6] = { 0.5*m, 0.5*m, 0.4*m, 0.4*m, 0.8*m, 0.8*m};
528 G4double rmax[6] = { 0.6*m, 0.6*m, 1.0*m, 1.0*m, 1.0*m, 1.1*m };
529 testVolume = new G4Polyhedra ("test_pgon", 0.0*deg, 270.0*deg, 6, 6, zv, rmin, rmax );
530*/
531 }
532 break;
533
534 case PGON2: {
535 G4double z_values[5] = { -1.0*m, 0.0*m, 0.0*m, 0.8*m, 1.0*m };
536 G4double rmin[5] = { 0.5*m, 0.4*m, 0.0*m, 0.0*m, 0.9*m };
537 G4double rmax[5] = { 0.6*m, 0.6*m, 1.0*m, 1.0*m, 1.1*m };
538 testVolume = new G4Polyhedra( "test_pgon2",
539 startPhi, deltaPhi, numSide, 5, z_values, rmin, rmax );
540 }
541 break;
542
543 case PGON3: {
544 G4double z_values[6] = { -0.6*m, 0.0*m,-1.0*m, 0.5*m, 0.5*m, 1.0*m };
545 G4double rmin[6] = { 0.5*m, 0.5*m, 0.4*m, 0.4*m, 0.8*m, 0.8*m };
546 G4double rmax[6] = { 0.6*m, 0.6*m, 1.0*m, 1.0*m, 1.0*m, 1.1*m };
547 testVolume = new G4Polyhedra( "test_pgon3",
548 startPhi, deltaPhi, numSide, 6, z_values, rmin, rmax );
549 }
550 break;
551
552 case TESSEL1: {
553 // Extruded solid with triangular polygon
554 // (the same as test_xtru1, but redefined via tessels
555
556 G4TessellatedSolid* tessel = new G4TessellatedSolid("test_tessel1");
557
558 tessel->AddFacet(
559 new G4TriangularFacet(G4ThreeVector(-0.3*m,-0.3*m,-0.3*m),
560 G4ThreeVector( 0.0*m, 0.3*m,-0.3*m),
561 G4ThreeVector( 0.3*m,-0.3*m,-0.3*m),
562 ABSOLUTE));
563 tessel->AddFacet(
564 new G4TriangularFacet(G4ThreeVector( 0.3*m,-0.3*m, 0.3*m),
565 G4ThreeVector( 0.0*m, 0.3*m, 0.3*m),
566 G4ThreeVector(-0.3*m,-0.3*m, 0.3*m),
567 ABSOLUTE));
568 tessel->AddFacet(
569 new G4QuadrangularFacet(G4ThreeVector( 0.0*m, 0.3*m,-0.3*m),
570 G4ThreeVector(-0.3*m,-0.3*m,-0.3*m),
571 G4ThreeVector(-0.3*m,-0.3*m, 0.3*m),
572 G4ThreeVector( 0.0*m, 0.3*m, 0.3*m),
573 ABSOLUTE));
574 tessel->AddFacet(
575 new G4QuadrangularFacet(G4ThreeVector( 0.3*m,-0.3*m,-0.3*m),
576 G4ThreeVector( 0.0*m, 0.3*m,-0.3*m),
577 G4ThreeVector( 0.0*m, 0.3*m, 0.3*m),
578 G4ThreeVector( 0.3*m,-0.3*m, 0.3*m),
579 ABSOLUTE));
580 tessel->AddFacet(
581 new G4QuadrangularFacet(G4ThreeVector(-0.3*m,-0.3*m,-0.3*m),
582 G4ThreeVector( 0.3*m,-0.3*m,-0.3*m),
583 G4ThreeVector( 0.3*m,-0.3*m, 0.3*m),
584 G4ThreeVector(-0.3*m,-0.3*m, 0.3*m),
585 ABSOLUTE));
586 tessel->SetSolidClosed(true);
587 testVolume = tessel;
588 G4cout << *tessel << G4endl;
589/*
590 G4ExtrudedSolid* xtru1 = CreateExtrudedSolid1();
591 testVolume = new G4TessellatedSolid(*xtru1);
592 testVolume->SetName("test_tessel1");
593 G4cout << *((G4TessellatedSolid*)testVolume) << G4endl;
594*/
595 }
596 break;
597
598 case TESSEL2: {
599 G4ExtrudedSolid* xtru2 = CreateExtrudedSolid2();
600 testVolume = new G4TessellatedSolid(*xtru2);
601 testVolume->SetName("test_tessel2");
602 delete xtru2;
603 }
604 break;
605
606 case TESSEL3: {
607 G4ExtrudedSolid* xtru3 = CreateExtrudedSolid3();
608 testVolume = new G4TessellatedSolid(*xtru3);
609 testVolume->SetName("test_tessel3");
610 delete xtru3;
611 }
612 break;
613
614 case TESSEL4: {
615 G4ExtrudedSolid* xtru4 = CreateExtrudedSolid4();
616 testVolume = new G4TessellatedSolid(*xtru4);
617 testVolume->SetName("test_tessel4");
618 delete xtru4;
619 }
620 break;
621
622 case TET:
623 testVolume = new G4Tet( "test_tet",
624 G4ThreeVector( 0.0*m, 0.0*m, 1.0*m),
625 G4ThreeVector(-1.0*m, -1.0*m, -1.0*m),
626 G4ThreeVector(+1.0*m, -1.0*m, -1.0*m),
627 G4ThreeVector( 0.0*m, 1.0*m, -1.0*m));
628/*
629 // SBT test case d
630 testVolume = new G4Tet( "test_tet",
631 G4ThreeVector( 0.0*m, 0.0*m, 1.73205080756887719*m),
632 G4ThreeVector( 0.0*m, 1.63299316185545207*m, -0.577350269189625842*m),
633 G4ThreeVector(-1.41421356237309515*m, -0.816496580927726034*m, -0.577350269189625842*m),
634 G4ThreeVector( 1.41421356237309515*m, -0.816496580927726034*m, -0.577350269189625842*m));
635*/
636 break;
637
638 case TWBOX:
639 // SBT test case a
640 testVolume = new G4TwistedBox( "test_twbox", 30.0*deg, 1.0*m, 1.0*m, 1.0*m);
641 break;
642
643 case TWTRAP1:
644 testVolume = new G4TwistedTrap( "test_twtrap1",
645 30.0*deg, 0.8*m, 1.0*m, 1.0*m, 1.0*m );
646 break;
647
648 case TWTRAP2:
649 // SBT test case a
650 testVolume = new G4TwistedTrap( "test_twtrap2",
651 30.0*deg, 1268.0*mm, 0.0*deg, 0.0*deg,
652 295.0*mm, 1712.2*mm, 1870.29*mm,
653 295.0*mm, 1712.2*mm, 1870.29*mm, 0.0*deg );
654 break;
655
656 case TWTRD:
657 // SBT test case c
658 testVolume = new G4TwistedTrd( "test_twtrd",
659 0.5*m, 1.5*m, 0.25*m, 1.0*m, 1.0*m, 30.0*deg );
660 break;
661
662 case TWTUBS:
663 // SBT test case a
664 testVolume = new G4TwistedTubs( "test_twtubs",
665 30.0*deg, 0.8*m, 1.0*m, -1.0*m, 1.0*m, 1, 90.0*deg );
666 break;
667
668
669 //
670 // Boolean solids
671 //
672
673 case BOOL1:
674 G4Box *outside = new G4Box( "testboolout", 1*m, 1*m, 1*m );
675 G4Tubs *inside = new G4Tubs( "testboolin", 0.0, 0.4*m, 1*m, 0, 360*deg );
676 G4Transform3D tran = G4Translate3D( 0.4*m, 0.0, 0.0 );
677
678 testVolume = new G4SubtractionSolid( "testbool", (G4VSolid *)outside, (G4VSolid *)inside, tran );
679 break;
680
681 }
682
683 G4LogicalVolume *testLog = new G4LogicalVolume( testVolume, Vaccuum, "test_log", 0, 0, 0 );
684 new G4PVPlacement( rot, G4ThreeVector(), testLog,
685 "test", hallLog, false, 0 );
686
687 //
688 // Put some stuff in it, if we want
689 //
690 if (messenger->SelectedVolume() == VOXEL) {
691 G4RotationMatrix *noRot = new G4RotationMatrix();
692
693 G4Box *vxBox = new G4Box( "voxel_x", 0.3*mm, 0.6*m, 0.6*m );
694 G4LogicalVolume *vxLog1 = new G4LogicalVolume( vxBox, Vaccuum, "x1", 0, 0, 0 );
695 new G4PVPlacement( noRot, G4ThreeVector( -0.6*m, 0.0*m, 0.0*m ),
696 vxLog1, "testx1", testLog, false, 0 );
697 G4LogicalVolume *vxLog2 = new G4LogicalVolume( vxBox, Vaccuum, "x2", 0, 0, 0 );
698 new G4PVPlacement( noRot, G4ThreeVector( -0.2*m, 0.0*m, 0.0*m ),
699 vxLog2, "testx2", testLog, false, 0 );
700 G4LogicalVolume *vxLog3 = new G4LogicalVolume( vxBox, Vaccuum, "x3", 0, 0, 0 );
701 new G4PVPlacement( noRot, G4ThreeVector( +0.2*m, 0.0*m, 0.0*m ),
702 vxLog3, "testx3", testLog, false, 0 );
703 G4LogicalVolume *vxLog4 = new G4LogicalVolume( vxBox, Vaccuum, "x4", 0, 0, 0 );
704 new G4PVPlacement( noRot, G4ThreeVector( +0.6*m, 0.0*m, 0.0*m ),
705 vxLog4, "testx4", testLog, false, 0 );
706
707 G4Box *vyBox = new G4Box( "voxel_y", 0.8*m, 0.3*mm, 0.6*m );
708 G4LogicalVolume *vyLog1 = new G4LogicalVolume( vyBox, Vaccuum, "y1", 0, 0, 0 );
709 new G4PVPlacement( noRot, G4ThreeVector( 0.0*m, -0.8*m, 0.0*m ),
710 vyLog1, "testy1", testLog, false, 0 );
711 G4LogicalVolume *vyLog2 = new G4LogicalVolume( vyBox, Vaccuum, "y2", 0, 0, 0 );
712 new G4PVPlacement( noRot, G4ThreeVector( 0.0*m, -0.7*m, 0.0*m ),
713 vyLog2, "testy2", testLog, false, 0 );
714 G4LogicalVolume *vyLog3 = new G4LogicalVolume( vyBox, Vaccuum, "y3", 0, 0, 0 );
715 new G4PVPlacement( noRot, G4ThreeVector( 0.0*m, +0.7*m, 0.0*m ),
716 vyLog3, "testy3", testLog, false, 0 );
717 G4LogicalVolume *vyLog4 = new G4LogicalVolume( vyBox, Vaccuum, "y4", 0, 0, 0 );
718 new G4PVPlacement( noRot, G4ThreeVector( 0.0*m, +0.8*m, 0.0*m ),
719 vyLog4, "testy4", testLog, false, 0 );
720
721 G4Box *vzBox = new G4Box( "voxel_z", 0.8*m, 0.8*m, 0.3*mm );
722 G4LogicalVolume *vzLog1 = new G4LogicalVolume( vzBox, Vaccuum, "z1", 0, 0, 0 );
723 new G4PVPlacement( noRot, G4ThreeVector( 0.0*m, 0.0*m, -0.8*m ),
724 vzLog1, "testz1", testLog, false, 0 );
725 G4LogicalVolume *vzLog2 = new G4LogicalVolume( vzBox, Vaccuum, "z2", 0, 0, 0 );
726 new G4PVPlacement( noRot, G4ThreeVector( 0.0*m, 0.0*m, -0.7*m ),
727 vzLog2, "testz2", testLog, false, 0 );
728 G4LogicalVolume *vzLog3 = new G4LogicalVolume( vzBox, Vaccuum, "z3", 0, 0, 0 );
729 new G4PVPlacement( noRot, G4ThreeVector( 0.0*m, 0.0*m, +0.7*m ),
730 vzLog3, "testz3", testLog, false, 0 );
731 G4LogicalVolume *vzLog4 = new G4LogicalVolume( vzBox, Vaccuum, "z4", 0, 0, 0 );
732 new G4PVPlacement( noRot, G4ThreeVector( 0.0*m, 0.0*m, +0.8*m ),
733 vzLog4, "testz4", testLog, false, 0 );
734 }
735
736 //
737 // Red seems an appropriate color
738 //
739 testLog->SetVisAttributes( redStuff );
740
741 //
742 // Too simple?? Yeah. Let's make our test volume sensitive.
743
744 G4SDManager *sensitiveMan = G4SDManager::GetSDMpointer();
745
746 FredSensitive *sensitive = new FredSensitive( "/fred/test" );
747 sensitiveMan->AddNewDetector( sensitive );
748 testLog->SetSensitiveDetector( sensitive );
749
750 //
751 // And while we're at it, do the same to mother volume
752
753 FredSensMother *sensMother = new FredSensMother( "/fred/mother" );
754 sensitiveMan->AddNewDetector( sensMother );
755 hallLog->SetSensitiveDetector( sensMother );
756
757 //
758 // Tell our "messenger" about this test volume
759 //
760 messenger->SetTestVolume( testVolume );
761
762 return hall;
763 }
Note: See TracBrowser for help on using the repository browser.