B3::DetectorConstruction Class Reference

Detector construction class to define materials and geometry. More...

#include <Doxymodules_basic.h>

Inheritance diagram for B3::DetectorConstruction:

Public Member Functions
	DetectorConstruction ()
	~DetectorConstruction () override=default
G4VPhysicalVolume *	Construct () override
void	ConstructSDandField () override

Private Member Functions
void	DefineMaterials ()

Private Attributes
G4bool	fCheckOverlaps = true

Detailed Description

Detector construction class to define materials and geometry.

Crystals are positioned in Ring, with an appropriate rotation matrix. Several copies of Ring are placed in the full detector.

Definition at line 84 of file Doxymodules_basic.h.

Constructor & Destructor Documentation

DetectorConstruction()

B3::DetectorConstruction::DetectorConstruction

(

)

Definition at line 53 of file DetectorConstruction.cc.

{
  DefineMaterials();
}

~DetectorConstruction()

B3::DetectorConstruction::~DetectorConstruction ( )

overridedefault

Member Function Documentation

Construct()

G4VPhysicalVolume * B3::DetectorConstruction::Construct ( )

override

Definition at line 78 of file DetectorConstruction.cc.

{
  // Gamma detector Parameters
  //
  G4double cryst_dX = 6*cm, cryst_dY = 6*cm, cryst_dZ = 3*cm;
  G4int nb_cryst = 32;
  G4int nb_rings = 9;
  //
  G4double dPhi = twopi/nb_cryst, half_dPhi = 0.5*dPhi;
  G4double cosdPhi = std::cos(half_dPhi);
  G4double tandPhi = std::tan(half_dPhi);
  //
  G4double ring_R1 = 0.5*cryst_dY/tandPhi;
  G4double ring_R2 = (ring_R1+cryst_dZ)/cosdPhi;
  //
  G4double detector_dZ = nb_rings*cryst_dX;
  //
  G4NistManager* nist = G4NistManager::Instance();
  G4Material* default_mat = nist->FindOrBuildMaterial("G4_AIR");
  G4Material* cryst_mat   = nist->FindOrBuildMaterial("Lu2SiO5");
 
  //
  // World
  //
  G4double world_sizeXY = 2.4*ring_R2;
  G4double world_sizeZ  = 1.2*detector_dZ;
 
  auto solidWorld = new G4Box("World",                           // its name
    0.5 * world_sizeXY, 0.5 * world_sizeXY, 0.5 * world_sizeZ);  // its size
 
  auto logicWorld = new G4LogicalVolume(solidWorld,  // its solid
    default_mat,                                     // its material
    "World");                                        // its name
 
  auto physWorld = new G4PVPlacement(nullptr,  // no rotation
    G4ThreeVector(),                           // at (0,0,0)
    logicWorld,                                // its logical volume
    "World",                                   // its name
    nullptr,                                   // its mother  volume
    false,                                     // no boolean operation
    0,                                         // copy number
    fCheckOverlaps);                           // checking overlaps
 
  //
  // ring
  //
  auto solidRing = new G4Tubs("Ring", ring_R1, ring_R2, 0.5 * cryst_dX, 0., twopi);
 
  auto logicRing = new G4LogicalVolume(solidRing,  // its solid
    default_mat,                                   // its material
    "Ring");                                       // its name
 
  //
  // define crystal
  //
  G4double gap = 0.5*mm;        //a gap for wrapping
  G4double dX = cryst_dX - gap, dY = cryst_dY - gap;
  auto solidCryst = new G4Box("crystal", dX / 2, dY / 2, cryst_dZ / 2);
 
  auto logicCryst = new G4LogicalVolume(solidCryst,  // its solid
    cryst_mat,                                       // its material
    "CrystalLV");                                    // its name
 
  // place crystals within a ring
  //
  for (G4int icrys = 0; icrys < nb_cryst ; icrys++) {
    G4double phi = icrys*dPhi;
    G4RotationMatrix rotm  = G4RotationMatrix();
    rotm.rotateY(90*deg);
    rotm.rotateZ(phi);
    G4ThreeVector uz = G4ThreeVector(std::cos(phi),  std::sin(phi),0.);
    G4ThreeVector position = (ring_R1+0.5*cryst_dZ)*uz;
    G4Transform3D transform = G4Transform3D(rotm,position);
 
    new G4PVPlacement(transform,             //rotation,position
                      logicCryst,            //its logical volume
                      "crystal",             //its name
                      logicRing,             //its mother  volume
                      false,                 //no boolean operation
                      icrys,                 //copy number
                      fCheckOverlaps);       // checking overlaps
  }
 
  //
  // full detector
  //
  auto solidDetector = new G4Tubs("Detector", ring_R1, ring_R2, 0.5 * detector_dZ, 0., twopi);
 
  auto logicDetector = new G4LogicalVolume(solidDetector,  // its solid
    default_mat,                                           // its material
    "Detector");                                           // its name
 
  //
  // place rings within detector
  //
  G4double OG = -0.5*(detector_dZ + cryst_dX);
  for (G4int iring = 0; iring < nb_rings ; iring++) {
    OG += cryst_dX;
    new G4PVPlacement(nullptr,  // no rotation
      G4ThreeVector(0, 0, OG),  // position
      logicRing,                // its logical volume
      "ring",                   // its name
      logicDetector,            // its mother  volume
      false,                    // no boolean operation
      iring,                    // copy number
      fCheckOverlaps);          // checking overlaps
  }
 
  //
  // place detector in world
  //
  new G4PVPlacement(nullptr,  // no rotation
    G4ThreeVector(),          // at (0,0,0)
    logicDetector,            // its logical volume
    "Detector",               // its name
    logicWorld,               // its mother  volume
    false,                    // no boolean operation
    0,                        // copy number
    fCheckOverlaps);          // checking overlaps
 
  //
  // patient
  //
  G4double patient_radius = 8*cm;
  G4double patient_dZ = 10*cm;
  G4Material* patient_mat = nist->FindOrBuildMaterial("G4_BRAIN_ICRP");
 
  auto solidPatient = new G4Tubs("Patient", 0., patient_radius, 0.5 * patient_dZ, 0., twopi);
 
  auto logicPatient = new G4LogicalVolume(solidPatient,  // its solid
    patient_mat,                                         // its material
    "PatientLV");                                        // its name
 
  //
  // place patient in world
  //
  new G4PVPlacement(nullptr,  // no rotation
    G4ThreeVector(),          // at (0,0,0)
    logicPatient,             // its logical volume
    "Patient",                // its name
    logicWorld,               // its mother  volume
    false,                    // no boolean operation
    0,                        // copy number
    fCheckOverlaps);          // checking overlaps
 
  // Visualization attributes
  //
  logicRing->SetVisAttributes (G4VisAttributes::GetInvisible());
  logicDetector->SetVisAttributes (G4VisAttributes::GetInvisible());
 
  // Print materials
  G4cout << *(G4Material::GetMaterialTable()) << G4endl;
 
  //always return the physical World
  //
  return physWorld;
}

ConstructSDandField()

void B3::DetectorConstruction::ConstructSDandField ( )

override

Definition at line 238 of file DetectorConstruction.cc.

{
  G4SDManager::GetSDMpointer()->SetVerboseLevel(1);
 
  // declare crystal as a MultiFunctionalDetector scorer
  //
  auto cryst = new G4MultiFunctionalDetector("crystal");
  G4SDManager::GetSDMpointer()->AddNewDetector(cryst);
  G4VPrimitiveScorer* primitiv1 = new G4PSEnergyDeposit("edep");
  cryst->RegisterPrimitive(primitiv1);
  SetSensitiveDetector("CrystalLV",cryst);
 
  // declare patient as a MultiFunctionalDetector scorer
  //
  auto patient = new G4MultiFunctionalDetector("patient");
  G4SDManager::GetSDMpointer()->AddNewDetector(patient);
  G4VPrimitiveScorer* primitiv2 = new G4PSDoseDeposit("dose");
  patient->RegisterPrimitive(primitiv2);
  SetSensitiveDetector("PatientLV",patient);
}

DefineMaterials()

void B3::DetectorConstruction::DefineMaterials ( )

private

Definition at line 60 of file DetectorConstruction.cc.

{
  G4NistManager* man = G4NistManager::Instance();
 
  G4bool isotopes = false;
 
  G4Element*  O = man->FindOrBuildElement("O" , isotopes);
  G4Element* Si = man->FindOrBuildElement("Si", isotopes);
  G4Element* Lu = man->FindOrBuildElement("Lu", isotopes);
 
  auto LSO = new G4Material("Lu2SiO5", 7.4 * g / cm3, 3);
  LSO->AddElement(Lu, 2);
  LSO->AddElement(Si, 1);
  LSO->AddElement(O , 5);
}

Member Data Documentation

fCheckOverlaps

G4bool B3::DetectorConstruction::fCheckOverlaps = true

private

Definition at line 60 of file DetectorConstruction.hh.

---

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

• .doxygen/Doxymodules_basic.h
• basic/B3/B3a/include/DetectorConstruction.hh
• basic/B3/B3a/src/DetectorConstruction.cc