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

Last change on this file since 1358 was 1316, checked in by garnier, 14 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.