Geant4  10.02.p01
G02DetectorConstruction.cc
Go to the documentation of this file.
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //g
28 //
29 //
30 // $Id: G02DetectorConstruction.cc 68025 2013-03-13 13:43:46Z gcosmo $
31 //
32 // Class G02DetectorConstruction implementation
33 //
34 // ----------------------------------------------------------------------------
35 
37 
38 // Geant4 includes
39 //
40 #include "globals.hh"
41 #include "G4GeometryManager.hh"
42 #include "G4VisAttributes.hh"
43 
44 // Materials
45 //
46 #include "G4Material.hh"
47 
48 // Geometry includes
49 //
50 #include "G4LogicalVolume.hh"
51 #include "G4VPhysicalVolume.hh"
52 #include "G4PVParameterised.hh"
53 #include "G4PVPlacement.hh"
54 #include "G4Box.hh"
55 #include "G4Tubs.hh"
56 
57 // Reflected solids
58 //
59 #include "G4ReflectedSolid.hh"
60 #include "G4DisplacedSolid.hh"
61 #include "G4ReflectionFactory.hh"
62 #include "G4RotationMatrix.hh"
63 #include "G4AffineTransform.hh"
64 #include "G4Transform3D.hh"
65 
66 // Assembly volumes
67 //
68 #include "G4AssemblyVolume.hh"
69 
70 // Volume parameterisations
71 //
73 
74 // Messenger
75 //
76 #include "G02DetectorMessenger.hh"
77 
78 // GDML parser include
79 //
80 #include "G4GDMLParser.hh"
81 
82 #include "G4PhysicalConstants.hh"
83 #include "G4SystemOfUnits.hh"
84 
85 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
86 //
87 // Constructor
88 //
91  fAir(0), fAluminum(0), fPb(0), fXenon(0),
92  fDetectorMessenger(0)
93 {
94  fExpHall_x=5.*m;
95 
96  fReadFile ="test.gdml";
97  fWriteFile="wtest.gdml";
98  fStepFile ="mbb";
100 
102 }
103 
104 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
105 //
106 // Destructor
107 //
109 {
111 }
112 
113 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
114 //
115 // Constructs geometries and materials
116 //
118 {
119  // Writing or Reading of Geometry using G4GDML
120 
121  G4VPhysicalVolume* fWorldPhysVol;
122 
123  if(fWritingChoice==0)
124  {
125  // **** LOOK HERE*** FOR READING GDML FILES
126  //
127 
128  // ACTIVATING OVERLAP CHECK when read volumes are placed.
129  // Can take long time in case of complex geometries
130  //
131  // fParser.SetOverlapCheck(true);
132 
134 
135  // READING GDML FILES OPTION: 2nd Boolean argument "Validate".
136  // Flag to "false" disables check with the Schema when reading GDML file.
137  // See the GDML Documentation for more information.
138  //
139  // fParser.Read(fReadFile,false);
140 
141  // Prints the material information
142  //
144 
145  // Giving World Physical Volume from GDML Parser
146  //
147  fWorldPhysVol = fParser.GetWorldVolume();
148  }
149  else if(fWritingChoice==1)
150  {
151  // **** LOOK HERE*** FOR WRITING GDML FILES
152  // Detector Construction and WRITING to GDML
153  //
154  ListOfMaterials();
155  fWorldPhysVol = ConstructDetector();
156 
157  // OPTION: TO ADD MODULE AT DEPTH LEVEL ...
158  //
159  // Can be a integer or a pointer to the top Physical Volume:
160  //
161  // G4int depth=1;
162  // parser.AddModule(depth);
163 
164  // OPTION: SETTING ADDITION OF POINTER TO NAME TO FALSE
165  //
166  // By default, written names in GDML consist of the given name with
167  // appended the pointer reference to it, in order to make it unique.
168  // Naming policy can be changed by using the following method, or
169  // calling Write with additional Boolean argument to "false".
170  // NOTE: you have to be sure not to have duplication of names in your
171  // Geometry Setup.
172  //
173  // parser.SetAddPointerToName(false);
174  //
175  // or
176  //
177  // fParser.Write(fWriteFile, fWorldPhysVol, false);
178 
179  // Writing Geometry to GDML File
180  //
181  fParser.Write(fWriteFile, fWorldPhysVol);
182 
183  // OPTION: SPECIFYING THE SCHEMA LOCATION
184  //
185  // When writing GDML file the default the Schema Location from the
186  // GDML web site will be used:
187  // "http://cern.ch/service-spi/app/releases/GDML/GDML_2_10_0/src/GDMLSchema/gdml.xsd"
188  //
189  // NOTE: GDML Schema is distributed in Geant4 in the directory:
190  // $G4INSTALL/source/persistency/gdml/schema
191  //
192  // You can change the Schema path by adding a parameter to the Write
193  // command, as follows:
194  //
195  // fParser.Write(fWriteFile, fWorldPhysVol, "your-path-to-schema/gdml.xsd");
196  }
197  else // Demonstration how to Read STEP files using GDML
198  {
199  // Some printout...
200  //
201  ListOfMaterials();
202 
203  // Arbitrary values that should enclose any reasonable geometry
204  //
205  const G4double expHall_y = fExpHall_x/50.;
206  const G4double expHall_z = fExpHall_x/50.;
207 
208  // Create the hall
209  //
210  G4Box * experimentalHallBox
211  = new G4Box("ExpHallBox",fExpHall_x/50.,expHall_y,expHall_z);
212  G4LogicalVolume * experimentalHallLV
213  = new G4LogicalVolume(experimentalHallBox, fAir,"ExpHallLV");
214  fWorldPhysVol
215  = new G4PVPlacement(0, G4ThreeVector(0.0,0.0,0.0),
216  experimentalHallLV, "ExpHallPhys", 0, false, 0);
217 
218  // G02DetectorConstruction via reading STEP File
219  //
220  G4LogicalVolume* LogicalVolST
222 
223  // Placement inside of the hall
224  //
225  new G4PVPlacement(0, G4ThreeVector(10.0,0.0,0.0), LogicalVolST,
226  "StepPhys", experimentalHallLV, false, 0);
227  }
228 
229  // Set Visualization attributes to world
230  //
231  G4VisAttributes* BoxVisAtt= new G4VisAttributes(G4Colour(1.0,1.0,1.0));
232  fWorldPhysVol->GetLogicalVolume()->SetVisAttributes(BoxVisAtt);
233 
234  return fWorldPhysVol;
235 }
236 
237 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
238 //
239 // Utility to build and list necessary materials
240 //
242 {
243  G4double a; // atomic mass
244  G4double z; // atomic number
245  G4double density,temperature,pressure;
246  G4double fractionmass;
248  G4int ncomponents;
249 
250  // Elements needed for the materials
251 
252  a = 14.01*g/mole;
253  G4Element* elN = new G4Element(name="Nitrogen", symbol="N", z=7., a);
254 
255  a = 16.00*g/mole;
256  G4Element* elO = new G4Element(name="Oxygen", symbol="O", z=8., a);
257 
258  a = 26.98*g/mole;
259  G4Element* elAl = new G4Element(name="Aluminum", symbol="Al", z=13., a);
260 
261  // Print the Element information
262  //
264 
265  // Air
266  //
267  density = 1.29*mg/cm3;
268  fAir = new G4Material(name="Air", density, ncomponents=2);
269  fAir->AddElement(elN, fractionmass=0.7);
270  fAir->AddElement(elO, fractionmass=0.3);
271 
272  // Aluminum
273  //
274  density = 2.70*g/cm3;
275  fAluminum = new G4Material(name="Aluminum", density, ncomponents=1);
276  fAluminum->AddElement(elAl, fractionmass=1.0);
277 
278  // Lead
279  //
280  fPb = new G4Material("Lead", z=82., a= 207.19*g/mole, density= 11.35*g/cm3);
281 
282  // Xenon gas
283  //
284  fXenon = new G4Material("XenonGas", z=54., a=131.29*g/mole,
285  density= 5.458*mg/cm3, kStateGas,
286  temperature= 293.15*kelvin, pressure= 1*atmosphere);
287 
288  // Prints the material information
289  //
291 }
292 
293 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
294 //
295 // Detector Construction
296 //
297 // Detector consist from DetectorBox, Conrol Room and 4 SubDetectors
298 // SubDetectors1 and 2 show how to use Reflection Factory and Assembly
299 // SubDetectors 3 and 4 show how to use Parameterisation
300 //
302 {
303  // Arbitary values that should enclose any reasonable geometry
304  //
305  const G4double expHall_y = fExpHall_x;
306  const G4double expHall_z = fExpHall_x;
307 
308  // Create the hall
309  //
310  G4Box * experimentalHallBox =
311  new G4Box("ExpHallBox", fExpHall_x, expHall_y, expHall_z);
312  G4LogicalVolume * experimentalHallLV =
313  new G4LogicalVolume(experimentalHallBox, fAir, "ExpHallLV");
314  G4PVPlacement * experimentalHallPhys =
315  new G4PVPlacement(0, G4ThreeVector(0.0,0.0,0.0), experimentalHallLV,
316  "ExpHallPhys", 0, false, 0);
317 
318  // G02DetectorConstruction
319 
320  const G4double det_x = fExpHall_x*0.8;
321  const G4double det_y = fExpHall_x*0.7;
322  const G4double det_z = det_y;
323 
324  // Create the detector box
325  //
326  G4Box * detectorBox =
327  new G4Box("detectorBox", det_x, det_y, det_z);
328  G4LogicalVolume * detectorLV =
329  new G4LogicalVolume(detectorBox, fAir, "detLV");
330  // G4PVPlacement * detectorPhys =
331  new G4PVPlacement(0, G4ThreeVector(0.0,0.0,0.0), detectorLV,
332  "detPhys", experimentalHallLV, false, 0);
333 
334  // Create the Control room box
335  //
336  const G4double room_x = fExpHall_x/20.;
337  const G4double room_y = room_x;
338  const G4double room_z = room_x;
339 
340  G4Box * roomBox =
341  new G4Box("roomBox", room_x, room_y, room_z);
342  G4LogicalVolume * roomLV =
343  new G4LogicalVolume(roomBox, fAir, "roomLV");
344  // G4PVPlacement * roomPhys =
345  new G4PVPlacement(0, G4ThreeVector(fExpHall_x-room_x-10.,0.0,0.0), roomLV,
346  "roomPhys", experimentalHallLV, false, 0);
347 
348  // SubDetector1
349  //
350  const G4double bigL=fExpHall_x/5.+50.;
351  G4LogicalVolume* subDetectorLV1 = ConstructSubDetector1();
352  // G4PVPlacement * detPhys1 =
353  new G4PVPlacement(0, G4ThreeVector(bigL,0.0,0.0), subDetectorLV1,
354  "PhysSubDetector1", detectorLV, false, 0);
355 
356  //
357  // LOOK HERE FOR REFLECTIONS
358  //
359 
360  // SubDetector2
361  //
362  G4Translate3D translation(-bigL, 0., 0.);
363  G4RotationMatrix* rotD3 = new G4RotationMatrix();
364  G4Transform3D rotation = G4Rotate3D(*rotD3);
365  G4ReflectX3D reflection;
366  G4Transform3D transform = translation*rotation*reflection;
367 
368  // Place the reflected part using G4ReflectionFactory
369  //
370  G4ReflectionFactory::Instance()->Place(transform, "reflSubDetector",
371  subDetectorLV1, detectorLV, false, 0);
372 
373  // SubDetector3
374  //
375  G4LogicalVolume* subDetectorLV3 = ConstructSubDetector2();
376  // G4PVPlacement * detPhys3 =
377  new G4PVPlacement(0, G4ThreeVector(0.0,bigL,0.0), subDetectorLV3,
378  "PhysSubDetectorFirst3", detectorLV, false, 0);
379 
380  // SubDetector4, placement of parameterised chambers
381  //
382  G4LogicalVolume* subDetectorLV4 = ConstructSubDetector2();
384  // G4PVPlacement * detChamb =
385  new G4PVPlacement(0, G4ThreeVector(0,0.0,0.0), subChamberLV,
386  "AssemblyPhys", subDetectorLV4, false, 0);
387  // G4PVPlacement * detPhys4 =
388  new G4PVPlacement(0, G4ThreeVector(0.0,-bigL,0.0), subDetectorLV4,
389  "PhysSubDetectorSecond3", detectorLV, false, 0);
390 
391  return experimentalHallPhys;
392 }
393 
394 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
395 //
396 // SubDetector1
397 //
399 {
400  const G4double sub_x = fExpHall_x/5.;
401  const G4double sub_y = sub_x;
402 
403  // Create the hall
404  //
405  G4Tubs * subTub =
406  new G4Tubs("subTub", 0., sub_x, sub_y, -90.*deg, 180*deg);
407  G4LogicalVolume * subTubLV =
408  new G4LogicalVolume(subTub, fPb, "tubLV");
409  G4LogicalVolume *AssemblyLV = ConstructAssembly();
410  // G4PVPlacement * detAss =
411  new G4PVPlacement(0, G4ThreeVector(sub_x/3,0.0,0.0), AssemblyLV,
412  "AssemblyPhys", subTubLV, false, 0);
413  return subTubLV;
414 }
415 
416 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
417 //
418 // SubDetector2
419 //
421 {
422  const G4double sub_x = fExpHall_x/10.;
423  const G4double sub_y = sub_x*2.;
424  const G4double sub_z = sub_x;
425 
426  // Create the hall
427  //
428  G4Box * detHallBox =
429  new G4Box("detHallBox", sub_x, sub_y, sub_z);
430  G4LogicalVolume * detHallLV =
431  new G4LogicalVolume(detHallBox, fAluminum, "detHallLV");
432 
433  return detHallLV;
434 }
435 
436 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
437 //
438 // Assembly
439 //
441 {
442  const G4double big_x = fExpHall_x/17;
443  const G4double big_y = big_x;
444  const G4double big_z = big_x;
445 
446  // Create the Box
447  //
448  G4Box * OuterBox =
449  new G4Box("OuterBox", big_x, big_y, big_z);
450  G4LogicalVolume * OuterBoxLV =
451  new G4LogicalVolume(OuterBox, fAir, "OuterBoxLV");
452  // G4PVPlacement * OuterBoxPhys =
453  new G4PVPlacement(0, G4ThreeVector(0.0,0.0,0.0), OuterBoxLV,
454  "OuterBoxPhys", 0, false, 0);
455 
456  // The aluminum object's logical volume
457  //
458  const G4double bigL=big_x/2.5;
459  const G4double medL=big_x/8;
460  const G4double smalL=big_x/12;
461 
462  G4Box * BigBox =
463  new G4Box("BBox", bigL, bigL, bigL);
464  G4LogicalVolume * BigBoxLV =
465  new G4LogicalVolume(BigBox, fAluminum, "AlBigBoxLV");
466  G4Box * MedBox =
467  new G4Box("MBox", medL, medL, medL);
468  G4LogicalVolume * MedBoxLV1 =
469  new G4LogicalVolume(MedBox, fAluminum, "AlMedBoxLV1");
470  G4Box * SmallBox =
471  new G4Box("SBox", smalL, smalL, smalL);
472  G4LogicalVolume * SmallBoxLV =
473  new G4LogicalVolume(SmallBox, fAluminum, "AlSmaBoxLV");
474 
475  const G4double bigPlace=bigL+10.;
476  const G4double medPlace=medL+10.;
477  // G4PVPlacement * BigBoxPhys =
478  new G4PVPlacement(0, G4ThreeVector(bigPlace,0.0,0.0), BigBoxLV,
479  "AlPhysBig", OuterBoxLV, false, 0);
480 
481  // Construction of Tub
482  //
483  G4Tubs * BigTube =
484  new G4Tubs("BTube",0,smalL,smalL,-pi/2.,pi);
485 
486  // Construction of Reflection of Tub
487  //
488  G4ReflectX3D Xreflection;
489  G4Translate3D translation(-bigPlace, 0., 0.);
490  G4Transform3D transform =Xreflection;
491 
492  G4ReflectedSolid * ReflBig =
493  new G4ReflectedSolid("Refll_Big", BigTube, transform);
494  G4LogicalVolume * ReflBigLV =
495  new G4LogicalVolume(ReflBig, fXenon, "ReflBigAl");
496  new G4PVPlacement(0, G4ThreeVector(0.,0.0,0.0), ReflBigLV,
497  "AlPhysBigTube", SmallBoxLV, false, 0);
498  //
499  // LOOK HERE FOR ASSEMBLY
500  //
501 
502  // create Assembly of Boxes and Tubs
503  //
504  G4AssemblyVolume* assembly = new G4AssemblyVolume();
505  G4RotationMatrix* rot = new G4RotationMatrix();
506  G4ThreeVector posBig(-bigPlace, 0, 0);
507  G4ThreeVector posBig0(bigPlace/4, 0, 0);
508  G4ThreeVector posMed(-medPlace, 0, 0);
509  G4ThreeVector posMed0(medPlace, 0, 0);
510  G4ThreeVector position(0., 0., 0.);
511 
512  // Add to Assembly the MediumBox1
513  //
514  assembly->AddPlacedVolume(MedBoxLV1, posMed0, rot);
515 
516  // Add to Assembly the Small Box
517  //
518  assembly->AddPlacedVolume(SmallBoxLV, posMed, rot);
519 
520  // Place the Assembly
521  //
522  assembly->MakeImprint(BigBoxLV, posBig0, rot, 0);
523 
524  //
525  // LOOK HERE FOR ASSEMBLY with REFLECTION
526  //
527 
528  G4Translate3D translation1(-bigPlace, 0., 0.);
529  G4RotationMatrix* rotD3 = new G4RotationMatrix();
530  G4Transform3D rotation = G4Rotate3D(*rotD3);
531  G4ReflectX3D reflection;
532  G4Transform3D transform1 = translation1*rotation*reflection;
533 
534  assembly->MakeImprint(OuterBoxLV, transform1, 0, 0);
535 
536  return OuterBoxLV;
537 }
538 
539 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
540 //
541 // Parameterised Chamber
542 //
544 {
545  const G4double chamber_x = fExpHall_x/12.;
546  const G4double chamber_y = chamber_x;
547  const G4double chamber_z = chamber_x;
548 
549  // Create the hall
550  //
551  G4Box * paramChamberBox =
552  new G4Box("ChamberBox", chamber_x, chamber_y, chamber_z);
553  G4LogicalVolume * paramChamberLV =
554  new G4LogicalVolume(paramChamberBox, fAir, "ChamberLV");
555 
556  // Parametrisation Chamber (taken from N02 novice example)
557  //
558  G4int NbOfChambers = 5;
559  G4double ChamberWidth = 2*cm;
560  G4double ChamberSpacing = 8*cm;
561  G4double fTrackerLength = (NbOfChambers+1)*ChamberSpacing; // Full length
562  G4double trackerSize = 0.5*fTrackerLength;
563 
564  // An example of parameterised volume
565  // dummy values for G4Box -- modified by parameterised volume
566  //
567  G4Box *solidChamber =
568  new G4Box("chamber", 10*cm, 10*cm, 1*cm);
569  G4LogicalVolume* logicChamber =
570  new G4LogicalVolume(solidChamber, fAluminum, "Chamber", 0, 0, 0);
571 
572  G4double firstPosition = -trackerSize + 0.5*ChamberWidth;
573  G4double firstLength = fTrackerLength/10;
574  G4double lastLength = fTrackerLength;
575 
576  G4VPVParameterisation* chamberParam =
577  new G02ChamberParameterisation( NbOfChambers, // NoChambers
578  firstPosition, // Z of center of first
579  ChamberSpacing, // Z spacing of centers
580  ChamberWidth, // Width Chamber
581  firstLength, // lengthInitial
582  lastLength); // lengthFinal
583  // G4VPhysicalVolume* physiChamber =
584  new G4PVParameterised( "Chamber", // their name
585  logicChamber, // their logical volume
586  paramChamberLV, // mother logical volume
587  kZAxis, // Are placed along this axis
588  NbOfChambers, // Number of chambers
589  chamberParam); // The parametrisation
590  return paramChamberLV;
591 }
592 
593 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
594 //
595 // SetReadFile
596 //
598 {
599  fReadFile=File;
600  fWritingChoice=0;
601 }
602 
603 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
604 //
605 // SetWriteFile
606 //
608 {
609  fWriteFile=File;
610  fWritingChoice=1;
611 }
612 
613 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
614 //
615 // SetStepFile
616 //
618 {
619  fStepFile=File;
620  fWritingChoice=3;
621 }
static const double cm
Definition: G4SIunits.hh:118
Definition of the G02DetectorMessenger class.
G4String symbol
Definition: TRTMaterials.hh:40
void MakeImprint(G4LogicalVolume *pMotherLV, G4ThreeVector &translationInMother, G4RotationMatrix *pRotationInMother, G4int copyNumBase=0, G4bool surfCheck=false)
CLHEP::Hep3Vector G4ThreeVector
CLHEP::HepRotation G4RotationMatrix
Definition of the G02DetectorConstruction class.
void SetWriteFile(const G4String &File)
G4VPhysicalVolume * ConstructDetector()
G4double z
Definition: TRTMaterials.hh:39
Definition: G4Box.hh:64
G4VPhysicalVolume * GetWorldVolume(const G4String &setupName="Default") const
G4String name
Definition: TRTMaterials.hh:40
Definition: G4Tubs.hh:85
static G4MaterialTable * GetMaterialTable()
Definition: G4Material.cc:589
G02DetectorMessenger * fDetectorMessenger
G4LogicalVolume * ConstructParametrisationChamber()
G4double a
Definition: TRTMaterials.hh:39
static const double mg
Definition: G4SIunits.hh:181
int G4int
Definition: G4Types.hh:78
static G4ReflectionFactory * Instance()
G4Element * elN
Definition: TRTMaterials.hh:44
G4LogicalVolume * ConstructSubDetector1()
G4double density
Definition: TRTMaterials.hh:39
G4double expHall_y
void SetReadFile(const G4String &File)
#define position
Definition: xmlparse.cc:622
G4GLOB_DLL std::ostream G4cout
G4Element * elO
Definition: TRTMaterials.hh:46
G4PhysicalVolumesPair Place(const G4Transform3D &transform3D, const G4String &name, G4LogicalVolume *LV, G4LogicalVolume *motherLV, G4bool isMany, G4int copyNo, G4bool surfCheck=false)
virtual G4VPhysicalVolume * Construct()
static const double deg
Definition: G4SIunits.hh:151
static const double cm3
Definition: G4SIunits.hh:120
Detector messenger class used in GDML read/write example.
void Write(const G4String &filename, const G4VPhysicalVolume *pvol=0, G4bool storeReferences=true, const G4String &SchemaLocation=G4GDML_DEFAULT_SCHEMALOCATION)
HepGeom::Transform3D G4Transform3D
void SetStepFile(const G4String &File)
G4LogicalVolume * ParseST(const G4String &name, G4Material *medium, G4Material *solid)
Chamber parametrisation used in the GDML read/write example.
static const double kelvin
Definition: G4SIunits.hh:278
HepGeom::Rotate3D G4Rotate3D
G4LogicalVolume * GetLogicalVolume() const
static const double pi
Definition: G4SIunits.hh:74
void AddPlacedVolume(G4LogicalVolume *pPlacedVolume, G4ThreeVector &translation, G4RotationMatrix *rotation)
G4LogicalVolume * ConstructAssembly()
static const double g
Definition: G4SIunits.hh:180
void Read(const G4String &filename, G4bool Validate=true)
static const double atmosphere
Definition: G4SIunits.hh:234
HepGeom::Translate3D G4Translate3D
static const double mole
Definition: G4SIunits.hh:283
G4LogicalVolume * ConstructSubDetector2()
#define G4endl
Definition: G4ios.hh:61
static const double m
Definition: G4SIunits.hh:128
void AddElement(G4Element *element, G4int nAtoms)
Definition: G4Material.cc:364
double G4double
Definition: G4Types.hh:76
static G4ElementTable * GetElementTable()
Definition: G4Element.cc:395
void SetVisAttributes(const G4VisAttributes *pVA)
HepGeom::ReflectX3D G4ReflectX3D
G4double expHall_z
Definition of the G02ChamberParameterisation class.