G02DetectorConstruction Class Reference

Detector construction used in GDML read/write example. More...

#include <Doxymodules_persistency.h>

Inheritance diagram for G02DetectorConstruction:

Public Member Functions
	G02DetectorConstruction ()
	~G02DetectorConstruction ()
virtual G4VPhysicalVolume *	Construct ()
G4LogicalVolume *	ConstructSubDetector1 ()
G4LogicalVolume *	ConstructSubDetector2 ()
G4VPhysicalVolume *	ConstructDetector ()
G4LogicalVolume *	ConstructAssembly ()
G4LogicalVolume *	ConstructParametrisationChamber ()
void	ListOfMaterials ()
void	SetReadFile (const G4String &File)
void	SetWriteFile (const G4String &File)
void	SetStepFile (const G4String &File)

Private Attributes
G4Material *	fAir
G4Material *	fAluminum
G4Material *	fPb
G4Material *	fXenon
G4GDMLParser	fParser
G4String	fReadFile
G4String	fWriteFile
G4String	fStepFile
G4int	fWritingChoice
G02DetectorMessenger *	fDetectorMessenger
G4double	fExpHall_x

Detailed Description

Detector construction used in GDML read/write example.

Definition at line 35 of file Doxymodules_persistency.h.

Constructor & Destructor Documentation

G02DetectorConstruction()

G02DetectorConstruction::G02DetectorConstruction

(

)

Definition at line 88 of file G02DetectorConstruction.cc.

  : G4VUserDetectorConstruction(), 
    fAir(0), fAluminum(0), fPb(0), fXenon(0),
    fDetectorMessenger(0)
{
  fExpHall_x=5.*m;
  
  fReadFile ="test.gdml";
  fWriteFile="wtest.gdml";
  fStepFile ="mbb";
  fWritingChoice=1;
 
  fDetectorMessenger = new G02DetectorMessenger( this );
}

~G02DetectorConstruction()

G02DetectorConstruction::~G02DetectorConstruction

(

)

Definition at line 107 of file G02DetectorConstruction.cc.

{
  if(fDetectorMessenger) delete fDetectorMessenger;
}

Member Function Documentation

Construct()

G4VPhysicalVolume * G02DetectorConstruction::Construct ( )

virtual

Definition at line 116 of file G02DetectorConstruction.cc.

{ 
  // Writing or Reading of Geometry using G4GDML
 
  G4VPhysicalVolume* fWorldPhysVol;
 
  if(fWritingChoice==0)
  {
    // **** LOOK HERE*** FOR READING GDML FILES
    //
    
    // ACTIVATING OVERLAP CHECK when read volumes are placed.
    // Can take long time in case of complex geometries
    //
    // fParser.SetOverlapCheck(true);
 
    fParser.Read(fReadFile);
 
    // READING GDML FILES OPTION: 2nd Boolean argument "Validate".
    // Flag to "false" disables check with the Schema when reading GDML file.
    // See the GDML Documentation for more information.
    //
    // fParser.Read(fReadFile,false);
     
    // Prints the material information
    //
    G4cout << *(G4Material::GetMaterialTable() ) << G4endl;
         
    // Giving World Physical Volume from GDML Parser
    //
    fWorldPhysVol = fParser.GetWorldVolume();     
  }
  else if(fWritingChoice==1)
  {
    // **** LOOK HERE*** FOR WRITING GDML FILES
    // Detector Construction and WRITING to GDML
    //
    ListOfMaterials();
    fWorldPhysVol = ConstructDetector();
 
    // OPTION: TO ADD MODULE AT DEPTH LEVEL ...
    //
    // Can be a integer or a pointer to the top Physical Volume:
    //
    // G4int depth=1;
    // fParser.AddModule(depth);
     
    // OPTION: SETTING ADDITION OF POINTER TO NAME TO FALSE
    //
    // By default, written names in GDML consist of the given name with
    // appended the pointer reference to it, in order to make it unique.
    // Naming policy can be changed by using the following method, or
    // calling Write with additional Boolean argument to "false".
    // NOTE: you have to be sure not to have duplication of names in your
    //       Geometry Setup.
    // 
    // fParser.SetAddPointerToName(false);
    //
    // or
    //
    // fParser.Write(fWriteFile, fWorldPhysVol, false);
    
    // OPTION: SET MAXIMUM LEVEL TO EXPORT (REDUCED TREE)...
    //
    // Can be a integer greater than zero:
    //
    // G4int maxlevel=3;
    // fParser.SetMaxExportLevel(maxlevel);
 
    // Writing Geometry to GDML File
    //
    fParser.Write(fWriteFile, fWorldPhysVol);
     
    // OPTION: SPECIFYING THE SCHEMA LOCATION
    //
    // When writing GDML file the default the Schema Location from the
    // GDML web site will be used:
    // "http://cern.ch/service-spi/app/releases/GDML/GDML_2_10_0/src/GDMLSchema/gdml.xsd"
    //
    // NOTE: GDML Schema is distributed in Geant4 in the directory:
    //    $G4INSTALL/source/persistency/gdml/schema
    //
    // You can change the Schema path by adding a parameter to the Write
    // command, as follows:
    //
    // fParser.Write(fWriteFile, fWorldPhysVol, "your-path-to-schema/gdml.xsd");
  }
  else   // Demonstration how to Read STEP files using GDML 
  {
     // Some printout...
     //
     ListOfMaterials();
 
     // Arbitrary values that should enclose any reasonable geometry
     //
     const G4double expHall_y = fExpHall_x/50.;
     const G4double expHall_z = fExpHall_x/50.;
 
     // Create the hall
     //
     G4Box * experimentalHallBox
       = new G4Box("ExpHallBox",fExpHall_x/50.,expHall_y,expHall_z);
     G4LogicalVolume * experimentalHallLV
       = new G4LogicalVolume(experimentalHallBox, fAir,"ExpHallLV");
     fWorldPhysVol
       = new G4PVPlacement(0, G4ThreeVector(0.0,0.0,0.0),
                           experimentalHallLV, "ExpHallPhys", 0, false, 0);
 
     // G02DetectorConstruction via reading STEP File
     //
     G4LogicalVolume* LogicalVolST
       = fParser.ParseST(fStepFile,fAir,fAluminum);
 
     // Placement inside of the hall
     //
     new G4PVPlacement(0, G4ThreeVector(10.0,0.0,0.0), LogicalVolST,
                       "StepPhys", experimentalHallLV, false, 0);
  }
 
  // Set Visualization attributes to world
  //
  G4VisAttributes* BoxVisAtt= new G4VisAttributes(G4Colour(1.0,1.0,1.0));
  fWorldPhysVol->GetLogicalVolume()->SetVisAttributes(BoxVisAtt);  
 
  return fWorldPhysVol;
}

ConstructSubDetector1()

G4LogicalVolume * G02DetectorConstruction::ConstructSubDetector1

(

)

Definition at line 404 of file G02DetectorConstruction.cc.

{    
  const G4double sub_x = fExpHall_x/5.;
  const G4double sub_y = sub_x;
 
  // Create the hall
  //
  G4Tubs * subTub =
    new G4Tubs("subTub", 0., sub_x, sub_y, -90.*deg, 180*deg);
  G4LogicalVolume * subTubLV =
    new G4LogicalVolume(subTub, fPb, "tubLV");
  G4LogicalVolume *AssemblyLV = ConstructAssembly();
  // G4PVPlacement * detAss =
    new G4PVPlacement(0, G4ThreeVector(sub_x/3,0.0,0.0), AssemblyLV,
                      "AssemblyPhys", subTubLV, false, 0);
  return subTubLV;  
}  

ConstructSubDetector2()

G4LogicalVolume * G02DetectorConstruction::ConstructSubDetector2

(

)

Definition at line 426 of file G02DetectorConstruction.cc.

{    
  const G4double sub_x = fExpHall_x/10.;
  const G4double sub_y = sub_x*2.;
  const G4double sub_z = sub_x;
 
  // Create the hall
  //
  G4Box * detHallBox =
    new G4Box("detHallBox", sub_x, sub_y, sub_z);
  G4LogicalVolume * detHallLV =
    new G4LogicalVolume(detHallBox, fAluminum, "detHallLV");
 
  return detHallLV;  
} 

ConstructDetector()

G4VPhysicalVolume * G02DetectorConstruction::ConstructDetector

(

)

Definition at line 307 of file G02DetectorConstruction.cc.

{
  // Arbitary values that should enclose any reasonable geometry
  //
  const G4double expHall_y = fExpHall_x;
  const G4double expHall_z = fExpHall_x;
 
  // Create the hall
  //
  G4Box * experimentalHallBox =
      new G4Box("ExpHallBox", fExpHall_x, expHall_y, expHall_z);
  G4LogicalVolume * experimentalHallLV =
      new G4LogicalVolume(experimentalHallBox, fAir, "ExpHallLV");
  G4PVPlacement * experimentalHallPhys =
      new G4PVPlacement(0, G4ThreeVector(0.0,0.0,0.0), experimentalHallLV,
                        "ExpHallPhys", 0, false, 0);
 
  // G02DetectorConstruction
 
  const G4double det_x = fExpHall_x*0.8;
  const G4double det_y = fExpHall_x*0.7;
  const G4double det_z = det_y;
 
  // Create the detector box
  //
  G4Box * detectorBox =
      new G4Box("detectorBox", det_x, det_y, det_z);
  G4LogicalVolume * detectorLV =
      new G4LogicalVolume(detectorBox, fAir, "detLV");
  // G4PVPlacement * detectorPhys = 
      new G4PVPlacement(0, G4ThreeVector(0.0,0.0,0.0), detectorLV,
                        "detPhys", experimentalHallLV, false, 0);
 
  // Create the Control room box
  //
  const G4double room_x = fExpHall_x/20.;
  const G4double room_y = room_x;
  const G4double room_z = room_x;
 
  G4Box * roomBox =
      new G4Box("roomBox", room_x, room_y, room_z);
  G4LogicalVolume * roomLV =
      new G4LogicalVolume(roomBox, fAir, "roomLV");
  // G4PVPlacement * roomPhys =
      new G4PVPlacement(0, G4ThreeVector(fExpHall_x-room_x-10.,0.0,0.0), roomLV,
                        "roomPhys", experimentalHallLV, false, 0);
  
  // SubDetector1
  //
  const G4double bigL=fExpHall_x/5.+50.;
  G4LogicalVolume* subDetectorLV1 = ConstructSubDetector1();
  // G4PVPlacement * detPhys1 =
      new G4PVPlacement(0, G4ThreeVector(bigL,0.0,0.0), subDetectorLV1,
                        "PhysSubDetector1", detectorLV, false, 0); 
        
  //
  // LOOK HERE FOR REFLECTIONS
  //   
 
  // SubDetector2
  //     
  G4Translate3D translation(-bigL, 0., 0.);
  G4RotationMatrix* rotD3 = new G4RotationMatrix();
  G4Transform3D rotation = G4Rotate3D(*rotD3);
  G4ReflectX3D  reflection;
  G4Transform3D transform = translation*rotation*reflection;
 
  // Place the reflected part using G4ReflectionFactory
  //
  G4ReflectionFactory::Instance()->Place(transform, "reflSubDetector",
                                         subDetectorLV1, detectorLV, false, 0);
 
  // SubDetector3
  //
  G4LogicalVolume* subDetectorLV3 = ConstructSubDetector2();
  // G4PVPlacement * detPhys3 =
      new G4PVPlacement(0, G4ThreeVector(0.0,bigL,0.0), subDetectorLV3,
                        "PhysSubDetectorFirst3", detectorLV, false, 0); 
         
  // SubDetector4, placement of parameterised chambers
  //
  G4LogicalVolume* subDetectorLV4 = ConstructSubDetector2();
  G4LogicalVolume* subChamberLV   = ConstructParametrisationChamber();
  // G4PVPlacement * detChamb =
      new G4PVPlacement(0, G4ThreeVector(0,0.0,0.0), subChamberLV,
                        "AssemblyPhys", subDetectorLV4, false, 0);
  // G4PVPlacement * detPhys4 =
      new G4PVPlacement(0, G4ThreeVector(0.0,-bigL,0.0), subDetectorLV4,
                        "PhysSubDetectorSecond3", detectorLV, false, 0);
 
  return experimentalHallPhys;
}

ConstructAssembly()

G4LogicalVolume * G02DetectorConstruction::ConstructAssembly

(

)

Definition at line 446 of file G02DetectorConstruction.cc.

{    
  const G4double big_x = fExpHall_x/17;
  const G4double big_y = big_x;
  const G4double big_z = big_x;
 
  // Create the Box
  //
  G4Box * OuterBox =
    new G4Box("OuterBox", big_x, big_y, big_z);
  G4LogicalVolume * OuterBoxLV =
    new G4LogicalVolume(OuterBox, fAir, "OuterBoxLV");
  // G4PVPlacement * OuterBoxPhys = 
    new G4PVPlacement(0, G4ThreeVector(0.0,0.0,0.0), OuterBoxLV,
                      "OuterBoxPhys", 0, false, 0);
 
  // The aluminum object's logical volume
  //
  const G4double bigL=big_x/2.5;
  const G4double medL=big_x/8;
  const G4double smalL=big_x/12;
 
  G4Box * BigBox =
    new G4Box("BBox", bigL, bigL, bigL);
  G4LogicalVolume * BigBoxLV =
    new G4LogicalVolume(BigBox, fAluminum, "AlBigBoxLV");
  G4Box * MedBox =
    new G4Box("MBox", medL, medL, medL);
  G4LogicalVolume * MedBoxLV1 =
    new G4LogicalVolume(MedBox, fAluminum, "AlMedBoxLV1");
  G4Box * SmallBox =
    new G4Box("SBox", smalL, smalL, smalL);
  G4LogicalVolume * SmallBoxLV =
    new G4LogicalVolume(SmallBox, fAluminum, "AlSmaBoxLV");
 
  const G4double bigPlace=bigL+10.;
  const G4double medPlace=medL+10.;
  // G4PVPlacement * BigBoxPhys = 
    new G4PVPlacement(0, G4ThreeVector(bigPlace,0.0,0.0), BigBoxLV,
                      "AlPhysBig", OuterBoxLV, false, 0); 
 
  // Construction of Tub 
  //
  G4Tubs * BigTube =
    new G4Tubs("BTube",0,smalL,smalL,-pi/2.,pi);
 
  // Construction of Reflection of Tub
  //
  G4ReflectX3D  Xreflection;
  G4Translate3D translation(-bigPlace, 0., 0.);
  G4Transform3D transform =Xreflection;
 
  G4ReflectedSolid * ReflBig =
    new G4ReflectedSolid("Refll_Big", BigTube, transform);
  G4LogicalVolume * ReflBigLV =
    new G4LogicalVolume(ReflBig, fXenon, "ReflBigAl");
   new G4PVPlacement(0, G4ThreeVector(0.,0.0,0.0), ReflBigLV,
                      "AlPhysBigTube", SmallBoxLV, false, 0); 
  //
  // LOOK HERE FOR ASSEMBLY 
  //
 
  // create Assembly of Boxes and Tubs
  //
  G4AssemblyVolume* assembly = new G4AssemblyVolume();
  G4RotationMatrix* rot = new G4RotationMatrix();
  G4ThreeVector posBig(-bigPlace, 0, 0);
  G4ThreeVector posBig0(bigPlace/4, 0, 0);
  G4ThreeVector posMed(-medPlace, 0, 0);
  G4ThreeVector posMed0(medPlace, 0, 0);
  G4ThreeVector position(0., 0., 0.);
 
  // Add to Assembly the MediumBox1
  //
  assembly->AddPlacedVolume(MedBoxLV1, posMed0, rot);
 
  // Add to Assembly the Small Box
  //
  assembly->AddPlacedVolume(SmallBoxLV, posMed, rot);
  
  // Place the Assembly
  //
  assembly->MakeImprint(BigBoxLV, posBig0, rot, 0);
 
  //
  // LOOK HERE FOR ASSEMBLY with REFLECTION 
  //   
 
  G4Translate3D translation1(-bigPlace, 0., 0.);
  G4RotationMatrix* rotD3 = new G4RotationMatrix();
  G4Transform3D rotation = G4Rotate3D(*rotD3);
  G4ReflectX3D  reflection;
  G4Transform3D transform1 = translation1*rotation*reflection;
 
  assembly->MakeImprint(OuterBoxLV, transform1, 0, 0);
 
  return OuterBoxLV;  
}

ConstructParametrisationChamber()

G4LogicalVolume * G02DetectorConstruction::ConstructParametrisationChamber

(

)

Definition at line 549 of file G02DetectorConstruction.cc.

{    
  const G4double chamber_x = fExpHall_x/12.;
  const G4double chamber_y = chamber_x;
  const G4double chamber_z = chamber_x;
 
  // Create the hall
  //
  G4Box * paramChamberBox =
    new G4Box("ChamberBox", chamber_x, chamber_y, chamber_z);
  G4LogicalVolume * paramChamberLV =
    new G4LogicalVolume(paramChamberBox, fAir, "ChamberLV");
 
  // Parametrisation Chamber (taken from N02 novice example)
  //
  G4int NbOfChambers = 5;
  G4double ChamberWidth = 2*cm;
  G4double ChamberSpacing = 8*cm;
  G4double fTrackerLength = (NbOfChambers+1)*ChamberSpacing; // Full length
  G4double trackerSize = 0.5*fTrackerLength;
 
  // An example of parameterised volume
  // dummy values for G4Box -- modified by parameterised volume
  //
  G4Box *solidChamber =
    new G4Box("chamber", 10*cm, 10*cm, 1*cm); 
  G4LogicalVolume* logicChamber =
    new G4LogicalVolume(solidChamber, fAluminum, "Chamber", 0, 0, 0);
    
  G4double firstPosition = -trackerSize + 0.5*ChamberWidth;
  G4double firstLength = fTrackerLength/10;
  G4double lastLength  = fTrackerLength;
 
  G4VPVParameterisation* chamberParam =
    new G02ChamberParameterisation( NbOfChambers,          // NoChambers 
                                 firstPosition,         // Z of center of first 
                                 ChamberSpacing,        // Z spacing of centers
                                 ChamberWidth,          // Width Chamber 
                                 firstLength,           // lengthInitial 
                                 lastLength);           // lengthFinal
  // G4VPhysicalVolume* physiChamber = 
    new G4PVParameterised( "Chamber",          // their name
                           logicChamber,       // their logical volume
                           paramChamberLV,     // mother logical volume      
                           kZAxis,             // Are placed along this axis 
                           NbOfChambers,       // Number of chambers
                           chamberParam);      // The parametrisation
  return paramChamberLV;
} 

ListOfMaterials()

void G02DetectorConstruction::ListOfMaterials

(

)

Definition at line 247 of file G02DetectorConstruction.cc.

{
  G4double a;  // atomic mass
  G4double z;  // atomic number
  G4double density,temperature,pressure;
  G4double fractionmass;
  G4String name, symbol;
  G4int ncomponents;
 
  // Elements needed for the materials
 
  a = 14.01*g/mole;
  G4Element* elN = new G4Element(name="Nitrogen", symbol="N", z=7., a);
 
  a = 16.00*g/mole;
  G4Element* elO = new G4Element(name="Oxygen", symbol="O", z=8., a);
          
  a = 26.98*g/mole;
  G4Element* elAl = new G4Element(name="Aluminum", symbol="Al", z=13., a);
        
  // Print the Element information
  //
  G4cout << *(G4Element::GetElementTable()) << G4endl;
 
  // Air
  //
  density = 1.29*mg/cm3;
  fAir = new G4Material(name="Air", density, ncomponents=2);
  fAir->AddElement(elN, fractionmass=0.7);
  fAir->AddElement(elO, fractionmass=0.3);
 
  // Aluminum
  //
  density = 2.70*g/cm3;
  fAluminum = new G4Material(name="Aluminum", density, ncomponents=1);
  fAluminum->AddElement(elAl, fractionmass=1.0);
 
  // Lead
  //
  fPb = new G4Material("Lead", z=82., a= 207.19*g/mole, density= 11.35*g/cm3);
 
  // Xenon gas
  //
  fXenon = new G4Material("XenonGas", z=54., a=131.29*g/mole,
                         density= 5.458*mg/cm3, kStateGas,
                         temperature= 293.15*kelvin, pressure= 1*atmosphere);
 
  // Prints the material information
  //
  G4cout << *(G4Material::GetMaterialTable() ) << G4endl;
}

SetReadFile()

void G02DetectorConstruction::SetReadFile

(

const G4String &

File

)

Definition at line 603 of file G02DetectorConstruction.cc.

{
  fReadFile=File;
  fWritingChoice=0;
}

SetWriteFile()

void G02DetectorConstruction::SetWriteFile

(

const G4String &

File

)

Definition at line 613 of file G02DetectorConstruction.cc.

{
  fWriteFile=File;
  fWritingChoice=1;
}

SetStepFile()

void G02DetectorConstruction::SetStepFile

(

const G4String &

File

)

Definition at line 623 of file G02DetectorConstruction.cc.

{
  fStepFile=File;
  fWritingChoice=3;
}

Member Data Documentation

fAir

G4Material* G02DetectorConstruction::fAir

private

Definition at line 87 of file G02DetectorConstruction.hh.

fAluminum

G4Material* G02DetectorConstruction::fAluminum

private

Definition at line 88 of file G02DetectorConstruction.hh.

fPb

G4Material* G02DetectorConstruction::fPb

private

Definition at line 89 of file G02DetectorConstruction.hh.

fXenon

G4Material* G02DetectorConstruction::fXenon

private

Definition at line 90 of file G02DetectorConstruction.hh.

fParser

G4GDMLParser G02DetectorConstruction::fParser

private

Definition at line 94 of file G02DetectorConstruction.hh.

fReadFile

G4String G02DetectorConstruction::fReadFile

private

Definition at line 98 of file G02DetectorConstruction.hh.

fWriteFile

G4String G02DetectorConstruction::fWriteFile

private

Definition at line 99 of file G02DetectorConstruction.hh.

fStepFile

G4String G02DetectorConstruction::fStepFile

private

Definition at line 100 of file G02DetectorConstruction.hh.

fWritingChoice

G4int G02DetectorConstruction::fWritingChoice

private

Definition at line 101 of file G02DetectorConstruction.hh.

fDetectorMessenger

G02DetectorMessenger* G02DetectorConstruction::fDetectorMessenger

private

Definition at line 105 of file G02DetectorConstruction.hh.

fExpHall_x

G4double G02DetectorConstruction::fExpHall_x

private

Definition at line 109 of file G02DetectorConstruction.hh.

---

The documentation for this class was generated from the following files:

• .doxygen/Doxymodules_persistency.h
• extended/persistency/gdml/G02/include/G02DetectorConstruction.hh
• extended/persistency/gdml/G02/src/G02DetectorConstruction.cc