CML2ReadOutGeometry Class Reference

#include <ML2ReadOutGeometry.hh>

Inheritance diagram for CML2ReadOutGeometry:

Public Member Functions
	CML2ReadOutGeometry ()
	~CML2ReadOutGeometry (void)
void	setBuildData (G4ThreeVector centre, G4ThreeVector halfSize, G4int NumberOfVoxelsAlongX, G4int NumberOfVoxelsAlongY, G4int NumberOfVoxelsAlongZ)
G4VPhysicalVolume *	Build ()
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

Additional Inherited Members
Protected Member Functions inherited from G4VReadOutGeometry
	G4VReadOutGeometry (const G4VReadOutGeometry &right)
const 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 52 of file ML2ReadOutGeometry.hh.

Constructor & Destructor Documentation

CML2ReadOutGeometry::CML2ReadOutGeometry

(

)

Definition at line 54 of file ML2ReadOutGeometry.cc.

References G4NistManager::FindOrBuildMaterial(), CLHEP::Hep3Vector::getX(), CLHEP::Hep3Vector::getY(), CLHEP::Hep3Vector::getZ(), G4NistManager::Instance(), python.hepunit::mm, and CLHEP::Hep3Vector::set().

                                         : ROPhyVol(0)
{
    // Build the world volume
    G4Material *Vacuum=G4NistManager::Instance()->FindOrBuildMaterial("G4_Galactic");
    G4ThreeVector halfSizeWorld, ctr;
    ctr.set(0.*mm, 0.*mm, 0.*mm);
    halfSizeWorld.set(3000.*mm, 3000*mm, 3000*mm);
    G4Box *ROphmWorldB = new G4Box("ROphmWorldG", halfSizeWorld.getX(), halfSizeWorld.getY(), halfSizeWorld.getZ());
    G4LogicalVolume *ROphmWorldLV = new G4LogicalVolume(ROphmWorldB, Vacuum, "ROphmWorldL", 0, 0, 0);
    ROPhyVol= new G4PVPlacement(0, ctr, "ROphmWorldPV", ROphmWorldLV, 0, false, 0);
}

CML2ReadOutGeometry::~CML2ReadOutGeometry

(

void

)

Definition at line 66 of file ML2ReadOutGeometry.cc.

{
    delete ROPhyVol;
}

Member Function Documentation

G4VPhysicalVolume * CML2ReadOutGeometry::Build ( )

virtual

Implements G4VReadOutGeometry.

Definition at line 80 of file ML2ReadOutGeometry.cc.

References G4NistManager::FindOrBuildMaterial(), CLHEP::Hep3Vector::getX(), CLHEP::Hep3Vector::getY(), CLHEP::Hep3Vector::getZ(), G4NistManager::Instance(), kXAxis, kYAxis, kZAxis, and G4LogicalVolume::SetSensitiveDetector().

{
    // Build RO Zone
    G4Material *Vacuum=G4NistManager::Instance()->FindOrBuildMaterial("G4_Galactic");
    G4Box *ROBox = new G4Box("ROBox", halfSize.getX(), halfSize.getY(), halfSize.getZ());
    G4LogicalVolume *ROLV = new G4LogicalVolume(ROBox, Vacuum, "ROLV", 0, 0, 0);
    G4VPhysicalVolume *ROPV;
    ROPV = new G4PVPlacement(0, centre, "ROPV", ROLV, ROPhyVol, false, 0);

    // ROGeomtry: Voxel division

    G4double halfXVoxelDimensionX, halfXVoxelDimensionY, halfXVoxelDimensionZ;

    halfXVoxelDimensionX=halfSize.getX()/NumberOfVoxelsAlongX;
    halfXVoxelDimensionY=halfSize.getY()/NumberOfVoxelsAlongY;
    halfXVoxelDimensionZ=halfSize.getZ()/NumberOfVoxelsAlongZ;

    G4double voxelXThicknessX = 2*halfXVoxelDimensionX;
    G4double voxelXThicknessY = 2*halfXVoxelDimensionY;
    G4double voxelXThicknessZ = 2*halfXVoxelDimensionZ;


    // X division first... slice along X axis
    G4Box *ROPhantomXDivision = new G4Box("ROPhantomXDivision",
                                          halfXVoxelDimensionX,
                                          halfSize.getY(),
                                          halfSize.getZ());

    G4LogicalVolume *ROPhantomXDivisionLog = new G4LogicalVolume(ROPhantomXDivision,
                                                                 Vacuum,
                                                                 "ROPhantomXDivisionLog",
                                                                 0,0,0);
    G4VPhysicalVolume *ROPhantomXDivisionPhys;
    ROPhantomXDivisionPhys = new G4PVReplica("ROPhantomXDivisionPhys",
                                             ROPhantomXDivisionLog,
                                             ROPV,
                                             kXAxis,
                                             NumberOfVoxelsAlongX,
                                             voxelXThicknessX,
                                             -halfSize.getX());
    // ...then Z division

    G4Box *ROPhantomZDivision = new G4Box("ROPhantomZDivision",
                                          halfXVoxelDimensionX,
                                          halfSize.getY(),
                                          halfXVoxelDimensionZ);

    G4LogicalVolume *ROPhantomZDivisionLog = new G4LogicalVolume(ROPhantomZDivision,
                                                                 Vacuum,
                                                                 "ROPhantomZDivisionLog",
                                                                 0,0,0);
    G4VPhysicalVolume *ROPhantomZDivisionPhys;
    ROPhantomZDivisionPhys = new G4PVReplica("ROPhantomZDivisionPhys",
                                             ROPhantomZDivisionLog,
                                             ROPhantomXDivisionPhys,
                                             kZAxis,
                                             NumberOfVoxelsAlongZ,
                                             voxelXThicknessZ,
                                             -halfSize.getZ());
    // ...then Y  division

    G4Box *ROPhantomYDivision = new G4Box("ROPhantomYDivision",
                                          halfXVoxelDimensionX,
                                          halfXVoxelDimensionY,
                                          halfXVoxelDimensionZ);

    G4LogicalVolume *ROPhantomYDivisionLog = new G4LogicalVolume(ROPhantomYDivision,
                                                                 Vacuum,
                                                                 "ROPhantomYDivisionLog",
                                                                 0,0,0);
    ROPhantomYDivisionPhys = new G4PVReplica("ROPhantomYDivisionPhys",
                                             ROPhantomYDivisionLog,
                                             ROPhantomZDivisionPhys,
                                             kYAxis,
                                             NumberOfVoxelsAlongY,
                                             voxelXThicknessY,
                                             -halfSize.getY());

    // Sensitive detector doesn't matter which logical volume is used
    G4VSensitiveDetector *sensDet=new CML2DummySD("Dummy ROG phantom");
    ROPhantomYDivisionLog->SetSensitiveDetector(sensDet);

    return ROPhyVol;
}

void CML2ReadOutGeometry::setBuildData	(	G4ThreeVector	centre,
		G4ThreeVector	halfSize,
		G4int	NumberOfVoxelsAlongX,
		G4int	NumberOfVoxelsAlongY,
		G4int	NumberOfVoxelsAlongZ
	)

Definition at line 71 of file ML2ReadOutGeometry.cc.

Referenced by CML2Ph_FullWater::Construct(), and CML2Ph_BoxInBox::Construct().

{
    centre=ctr;
    halfSize=hSiz;
    NumberOfVoxelsAlongX=NVX;
    NumberOfVoxelsAlongY=NVY;
    NumberOfVoxelsAlongZ=NVZ;
}

---

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

• ML2ReadOutGeometry.hh
• ML2ReadOutGeometry.cc