#include <IORTDetectorROGeometry.hh>

Inheritance diagram for IORTDetectorROGeometry:

Collaboration diagram for IORTDetectorROGeometry:

Public Member Functions
	IORTDetectorROGeometry (G4String aString, G4ThreeVector detectorPos, G4double detectorDimX, G4double detectorDimY, G4double detectorDimZ, G4int numberOfVoxelsX, G4int numberOfVoxelsY, G4int numberOfVoxelsZ)

	~IORTDetectorROGeometry ()

Public Member Functions inherited from G4VReadOutGeometry
	G4VReadOutGeometry ()

	G4VReadOutGeometry (G4String)

virtual	~G4VReadOutGeometry ()

G4int	operator== (const G4VReadOutGeometry &right) const

G4int	operator!= (const G4VReadOutGeometry &right) const

void	BuildROGeometry ()

virtual G4bool	CheckROVolume (G4Step , G4TouchableHistory &)

const G4SensitiveVolumeList *	GetIncludeList () const

void	SetIncludeList (G4SensitiveVolumeList *value)

const G4SensitiveVolumeList *	GetExcludeList () const

void	SetExcludeList (G4SensitiveVolumeList *value)

G4String	GetName () const

void	SetName (G4String value)

G4VPhysicalVolume *	GetROWorld () const

Private Member Functions
G4VPhysicalVolume *	Build ()

Private Attributes
const G4ThreeVector	detectorToWorldPosition

const G4double	detectorSizeX

const G4double	detectorSizeY

const G4double	detectorSizeZ

const G4int	numberOfVoxelsAlongX

const G4int	numberOfVoxelsAlongY

const G4int	numberOfVoxelsAlongZ

G4VPhysicalVolume *	RODetectorZDivisionPhys

Additional Inherited Members
Protected Member Functions inherited from G4VReadOutGeometry
	G4VReadOutGeometry (const G4VReadOutGeometry &right)

G4VReadOutGeometry &	operator= (const G4VReadOutGeometry &right)

virtual G4bool	FindROTouchable (G4Step *)

Protected Attributes inherited from G4VReadOutGeometry
G4VPhysicalVolume *	ROworld

G4SensitiveVolumeList *	fincludeList

G4SensitiveVolumeList *	fexcludeList

G4String	name

G4Navigator *	ROnavigator

G4TouchableHistory *	touchableHistory

Detailed Description

Definition at line 48 of file IORTDetectorROGeometry.hh.

Constructor & Destructor Documentation

◆ IORTDetectorROGeometry()

IORTDetectorROGeometry::IORTDetectorROGeometry	(	G4String	aString,
		G4ThreeVector	detectorPos,
		G4double	detectorDimX,
		G4double	detectorDimY,
		G4double	detectorDimZ,
		G4int	numberOfVoxelsX,
		G4int	numberOfVoxelsY,
		G4int	numberOfVoxelsZ
	)

Definition at line 53 of file IORTDetectorROGeometry.cc.

                                                        :
    
     G4VReadOutGeometry(aString),
     detectorToWorldPosition(pos),
     detectorSizeX(detectorDimX),
     detectorSizeY(detectorDimY),
     detectorSizeZ(detectorDimZ),
     numberOfVoxelsAlongX(numberOfVoxelsX),
     numberOfVoxelsAlongY(numberOfVoxelsY),
     numberOfVoxelsAlongZ(numberOfVoxelsZ)
 {
 }

◆ ~IORTDetectorROGeometry()

IORTDetectorROGeometry::~IORTDetectorROGeometry ( )

Definition at line 73 of file IORTDetectorROGeometry.cc.

74 {

75 }

Member Function Documentation

◆ Build()

G4VPhysicalVolume * IORTDetectorROGeometry::Build ( void )

privatevirtual

Implements G4VReadOutGeometry.

Definition at line 78 of file IORTDetectorROGeometry.cc.

 {
   // A dummy material is used to fill the volumes of the readout geometry.
   // (It will be allowed to set a NULL pointer in volumes of such virtual
   // division in future, since this material is irrelevant for tracking.)
 
   G4Material* dummyMat = new G4Material(name="dummyMat", 1., 1.*g/mole, 1.*g/cm3);
 
   G4double worldSizeX = 400.0 *cm;   // 200.0 *cm;
   G4double worldSizeY = 400.0 *cm;   // 200.0 *cm;
   G4double worldSizeZ = 400.0 *cm;   // 200.0 *cm;
 
   G4double halfDetectorSizeX = detectorSizeX;
   G4double halfDetectorSizeY = detectorSizeY;
   G4double halfDetectorSizeZ = detectorSizeZ;
 
   // World volume of ROGeometry ...
   G4Box* ROWorld = new G4Box("ROWorld",
                  worldSizeX,
                  worldSizeY,
                  worldSizeZ);
   
   G4LogicalVolume* ROWorldLog = new G4LogicalVolume(ROWorld, dummyMat, 
                             "ROWorldLog", 0,0,0);
   
   G4VPhysicalVolume* ROWorldPhys = new G4PVPlacement(0,G4ThreeVector(), 
                              "ROWorldPhys", 
                              ROWorldLog, 
                              0,false,0);
 
   // Detector ROGeometry 
   G4Box *RODetector = new G4Box("RODetector", 
                    halfDetectorSizeX, 
                    halfDetectorSizeY, 
                    halfDetectorSizeZ);
 
   G4LogicalVolume *RODetectorLog = new G4LogicalVolume(RODetector,
                                dummyMat,
                               "RODetectorLog",
                               0,0,0);
   
   G4VPhysicalVolume *RODetectorPhys = new G4PVPlacement(0,
                             detectorToWorldPosition,
                             "DetectorPhys",
                             RODetectorLog,
                             ROWorldPhys,
                             false,0);
   
   
   // Division along X axis: the detector is divided in slices along the X axis
   
   G4double halfXVoxelSizeX = halfDetectorSizeX/numberOfVoxelsAlongX;
   G4double halfXVoxelSizeY = halfDetectorSizeY;
   G4double halfXVoxelSizeZ = halfDetectorSizeZ;
   G4double voxelXThickness = 2*halfXVoxelSizeX;
 
   G4Box *RODetectorXDivision = new G4Box("RODetectorXDivision",
                      halfXVoxelSizeX,
                      halfXVoxelSizeY,
                      halfXVoxelSizeZ);
   
   G4LogicalVolume *RODetectorXDivisionLog = new G4LogicalVolume(RODetectorXDivision,
                                    dummyMat,
                                    "RODetectorXDivisionLog",
                                    0,0,0);
 
   G4VPhysicalVolume *RODetectorXDivisionPhys = new G4PVReplica("RODetectorXDivisionPhys",
                                                               RODetectorXDivisionLog,
                                                               RODetectorPhys,
                                                               kXAxis,
                                                               numberOfVoxelsAlongX,
                                                               voxelXThickness);
 
   // Division along Y axis: the slices along the X axis are divided along the Y axis
 
   G4double halfYVoxelSizeX = halfXVoxelSizeX;
   G4double halfYVoxelSizeY = halfDetectorSizeY/numberOfVoxelsAlongY;
   G4double halfYVoxelSizeZ = halfDetectorSizeZ;
   G4double voxelYThickness = 2*halfYVoxelSizeY;
 
   G4Box *RODetectorYDivision = new G4Box("RODetectorYDivision",
                     halfYVoxelSizeX, 
                     halfYVoxelSizeY,
                     halfYVoxelSizeZ);
 
   G4LogicalVolume *RODetectorYDivisionLog = new G4LogicalVolume(RODetectorYDivision,
                                    dummyMat,
                                    "RODetectorYDivisionLog",
                                    0,0,0);
  
   G4VPhysicalVolume *RODetectorYDivisionPhys = new G4PVReplica("RODetectorYDivisionPhys",
                                   RODetectorYDivisionLog,
                                   RODetectorXDivisionPhys,
                                   kYAxis,
                                   numberOfVoxelsAlongY,
                                   voxelYThickness);
   
   // Division along Z axis: the slices along the Y axis are divided along the Z axis
 
   G4double halfZVoxelSizeX = halfXVoxelSizeX;
   G4double halfZVoxelSizeY = halfYVoxelSizeY;
   G4double halfZVoxelSizeZ = halfDetectorSizeZ/numberOfVoxelsAlongZ;
   G4double voxelZThickness = 2*halfZVoxelSizeZ;
  
   G4Box *RODetectorZDivision = new G4Box("RODetectorZDivision",
                     halfZVoxelSizeX,
                     halfZVoxelSizeY, 
                     halfZVoxelSizeZ);
  
   G4LogicalVolume *RODetectorZDivisionLog = new G4LogicalVolume(RODetectorZDivision,
                                    dummyMat,
                                    "RODetectorZDivisionLog",
                                    0,0,0);
  
   RODetectorZDivisionPhys = new G4PVReplica("RODetectorZDivisionPhys",
                        RODetectorZDivisionLog,
                        RODetectorYDivisionPhys,
                        kZAxis,
                        numberOfVoxelsAlongZ,
                        voxelZThickness);
 
   IORTDummySD *dummySD = new IORTDummySD;
   RODetectorZDivisionLog -> SetSensitiveDetector(dummySD);
 
   return ROWorldPhys;
 }

Here is the call graph for this function:

Member Data Documentation

◆ detectorSizeX

const G4double IORTDetectorROGeometry::detectorSizeX

private

Definition at line 67 of file IORTDetectorROGeometry.hh.

◆ detectorSizeY

const G4double IORTDetectorROGeometry::detectorSizeY

private

Definition at line 68 of file IORTDetectorROGeometry.hh.

◆ detectorSizeZ

const G4double IORTDetectorROGeometry::detectorSizeZ

private

Definition at line 69 of file IORTDetectorROGeometry.hh.

◆ detectorToWorldPosition

const G4ThreeVector IORTDetectorROGeometry::detectorToWorldPosition

private

Definition at line 66 of file IORTDetectorROGeometry.hh.

◆ numberOfVoxelsAlongX

const G4int IORTDetectorROGeometry::numberOfVoxelsAlongX

private

Definition at line 71 of file IORTDetectorROGeometry.hh.

◆ numberOfVoxelsAlongY

const G4int IORTDetectorROGeometry::numberOfVoxelsAlongY

private

Definition at line 72 of file IORTDetectorROGeometry.hh.

◆ numberOfVoxelsAlongZ

const G4int IORTDetectorROGeometry::numberOfVoxelsAlongZ

private

Definition at line 73 of file IORTDetectorROGeometry.hh.

◆ RODetectorZDivisionPhys

G4VPhysicalVolume* IORTDetectorROGeometry::RODetectorZDivisionPhys

private

Definition at line 75 of file IORTDetectorROGeometry.hh.

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

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ IORTDetectorROGeometry()

◆ ~IORTDetectorROGeometry()

Member Function Documentation

◆ Build()

Member Data Documentation

◆ detectorSizeX

◆ detectorSizeY

◆ detectorSizeZ

◆ detectorToWorldPosition

◆ numberOfVoxelsAlongX

◆ numberOfVoxelsAlongY

◆ numberOfVoxelsAlongZ

◆ RODetectorZDivisionPhys