HadrontherapyDetectorROGeometry Class Reference

#include <HadrontherapyDetectorROGeometry.hh>

Inheritance diagram for HadrontherapyDetectorROGeometry:

Collaboration diagram for HadrontherapyDetectorROGeometry:

Public Member Functions
	HadrontherapyDetectorROGeometry (G4String)
	~HadrontherapyDetectorROGeometry ()
void	Initialize (G4ThreeVector detectorPos, G4double detectorDimX, G4double detectorDimY, G4double detectorDimZ, G4int numberOfVoxelsX, G4int numberOfVoxelsY, G4int numberOfVoxelsZ)
void	UpdateROGeometry ()
virtual void	Construct ()
virtual void	ConstructSD ()
Public Member Functions inherited from G4VUserParallelWorld
	G4VUserParallelWorld (G4String worldName)
virtual	~G4VUserParallelWorld ()
G4String	GetName ()

Additional Inherited Members
Protected Member Functions inherited from G4VUserParallelWorld
G4VPhysicalVolume *	GetWorld ()
void	SetSensitiveDetector (const G4String &logVolName, G4VSensitiveDetector *aSD, G4bool multi=false)
void	SetSensitiveDetector (G4LogicalVolume *logVol, G4VSensitiveDetector *aSD)
Protected Attributes inherited from G4VUserParallelWorld
G4String	fWorldName

Detailed Description

Definition at line 40 of file HadrontherapyDetectorROGeometry.hh.

Constructor & Destructor Documentation

HadrontherapyDetectorROGeometry::HadrontherapyDetectorROGeometry

(

G4String

aString

)

Definition at line 65 of file HadrontherapyDetectorROGeometry.cc.

  : G4VUserParallelWorld(aString),RODetector(0),RODetectorXDivision(0),
    RODetectorYDivision(0),RODetectorZDivision(0),worldLogical(0),RODetectorLog(0),
    RODetectorXDivisionLog(0),RODetectorYDivisionLog(0),RODetectorZDivisionLog(0),
    sensitiveLogicalVolume(0)
{
  isBuilt = false;
  isInitialized = false;
}

HadrontherapyDetectorROGeometry::~HadrontherapyDetectorROGeometry

(

)

Definition at line 191 of file HadrontherapyDetectorROGeometry.cc.

{;}

Member Function Documentation

void HadrontherapyDetectorROGeometry::Construct ( void  )

virtual

Implements G4VUserParallelWorld.

Definition at line 195 of file HadrontherapyDetectorROGeometry.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.)
  

  //
  // World
  //
  G4VPhysicalVolume* ghostWorld = GetWorld();
  worldLogical = ghostWorld->GetLogicalVolume();
  
  if (!isInitialized)
    {
      G4Exception("HadrontherapyDetectorROGeometry::Construct","had001",
          FatalException,"Parameters of the RO geometry are not initialized");
      return;
    }

  
  G4double halfDetectorSizeX = detectorSizeX;
  G4double halfDetectorSizeY = detectorSizeY;
  G4double halfDetectorSizeZ = detectorSizeZ;
    
    // World volume of ROGeometry ... SERVE SOLO PER LA ROG

  // Detector ROGeometry 
  RODetector = new G4Box("RODetector", 
             halfDetectorSizeX, 
             halfDetectorSizeY, 
             halfDetectorSizeZ);
  
  RODetectorLog = new G4LogicalVolume(RODetector,
                      0,
                      "RODetectorLog",
                      0,0,0);
  
  
  
  G4VPhysicalVolume *RODetectorPhys = new G4PVPlacement(0,
                            detectorToWorldPosition,RODetectorLog,
                            "RODetectorPhys",
                            worldLogical,                           
                            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;
  

  RODetectorXDivision = new G4Box("RODetectorXDivision",
                  halfXVoxelSizeX,
                  halfXVoxelSizeY,
                  halfXVoxelSizeZ);
  
  RODetectorXDivisionLog = new G4LogicalVolume(RODetectorXDivision,
                           0,
                           "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;

  RODetectorYDivision = new G4Box("RODetectorYDivision",
                  halfYVoxelSizeX, 
                  halfYVoxelSizeY,
                  halfYVoxelSizeZ);

  RODetectorYDivisionLog = new G4LogicalVolume(RODetectorYDivision,
                           0,
                           "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;
 
  RODetectorZDivision = new G4Box("RODetectorZDivision",
                  halfZVoxelSizeX,
                  halfZVoxelSizeY, 
                  halfZVoxelSizeZ);
 
  RODetectorZDivisionLog = new G4LogicalVolume(RODetectorZDivision,
                           0,
                           "RODetectorZDivisionLog",
                           0,0,0);
 
  new G4PVReplica("RODetectorZDivisionPhys",
          RODetectorZDivisionLog,
          RODetectorYDivisionPhys,
          kZAxis,
          numberOfVoxelsAlongZ,
          voxelZThickness);

  sensitiveLogicalVolume = RODetectorZDivisionLog;
  isBuilt = true;
}

Here is the call graph for this function:

void HadrontherapyDetectorROGeometry::ConstructSD ( )

virtual

Reimplemented from G4VUserParallelWorld.

Definition at line 321 of file HadrontherapyDetectorROGeometry.cc.

{
 
 G4String sensitiveDetectorName = "RODetector";
 
 HadrontherapyDetectorSD* detectorSD = new HadrontherapyDetectorSD(sensitiveDetectorName);
 G4SDManager::GetSDMpointer()->AddNewDetector(detectorSD);
 SetSensitiveDetector(sensitiveLogicalVolume,detectorSD);


}

Here is the call graph for this function:

void HadrontherapyDetectorROGeometry::Initialize	(	G4ThreeVector	detectorPos,
		G4double	detectorDimX,
		G4double	detectorDimY,
		G4double	detectorDimZ,
		G4int	numberOfVoxelsX,
		G4int	numberOfVoxelsY,
		G4int	numberOfVoxelsZ
	)

Definition at line 77 of file HadrontherapyDetectorROGeometry.cc.

{  
  detectorToWorldPosition = pos;
  detectorSizeX = detectorDimX;
  detectorSizeY= detectorDimY;
  detectorSizeZ=detectorDimZ;
  numberOfVoxelsAlongX=numberOfVoxelsX;
  numberOfVoxelsAlongY=numberOfVoxelsY;
  numberOfVoxelsAlongZ=numberOfVoxelsZ;

  isInitialized = true;


  
}

Here is the caller graph for this function:

void HadrontherapyDetectorROGeometry::UpdateROGeometry

(

)

Definition at line 99 of file HadrontherapyDetectorROGeometry.cc.

{
  //Nothing happens if the RO geometry is not built. But parameters are properly set.
  if (!isBuilt)
    {
      //G4Exception("HadrontherapyDetectorROGeometry::UpdateROGeometry","had001",
      //          JustWarning,"Cannot update geometry before it is built");
      return;
    }
 
  //1) Update the dimensions of the G4Boxes
  G4double halfDetectorSizeX = detectorSizeX;
  G4double halfDetectorSizeY = detectorSizeY;
  G4double halfDetectorSizeZ = detectorSizeZ;

  RODetector->SetXHalfLength(halfDetectorSizeX);
  RODetector->SetYHalfLength(halfDetectorSizeY);
  RODetector->SetZHalfLength(halfDetectorSizeZ);

  G4double halfXVoxelSizeX = halfDetectorSizeX/numberOfVoxelsAlongX;
  G4double halfXVoxelSizeY = halfDetectorSizeY;
  G4double halfXVoxelSizeZ = halfDetectorSizeZ;
  G4double voxelXThickness = 2*halfXVoxelSizeX;
  
  RODetectorXDivision->SetXHalfLength(halfXVoxelSizeX);
  RODetectorXDivision->SetYHalfLength(halfXVoxelSizeY);
  RODetectorXDivision->SetZHalfLength(halfXVoxelSizeZ);

  G4double halfYVoxelSizeX = halfXVoxelSizeX;
  G4double halfYVoxelSizeY = halfDetectorSizeY/numberOfVoxelsAlongY;
  G4double halfYVoxelSizeZ = halfDetectorSizeZ;
  G4double voxelYThickness = 2*halfYVoxelSizeY;

  RODetectorYDivision->SetXHalfLength(halfYVoxelSizeX);
  RODetectorYDivision->SetYHalfLength(halfYVoxelSizeY);
  RODetectorYDivision->SetZHalfLength(halfYVoxelSizeZ);

  G4double halfZVoxelSizeX = halfXVoxelSizeX;
  G4double halfZVoxelSizeY = halfYVoxelSizeY;
  G4double halfZVoxelSizeZ = halfDetectorSizeZ/numberOfVoxelsAlongZ;
  G4double voxelZThickness = 2*halfZVoxelSizeZ;

  RODetectorZDivision->SetXHalfLength(halfZVoxelSizeX);
  RODetectorZDivision->SetYHalfLength(halfZVoxelSizeY);
  RODetectorZDivision->SetZHalfLength(halfZVoxelSizeZ);

  //Delete and re-build the relevant physical volumes
  G4PhysicalVolumeStore* store =
    G4PhysicalVolumeStore::GetInstance();

  //Delete...
  G4VPhysicalVolume* myVol = store->GetVolume("RODetectorPhys");
  store->DeRegister(myVol);
  //..and rebuild
  G4VPhysicalVolume *RODetectorPhys = new G4PVPlacement(0,
                            detectorToWorldPosition,
                            RODetectorLog,
                            "RODetectorPhys",
                            worldLogical,                           
                            false,0);

  myVol = store->GetVolume("RODetectorXDivisionPhys");
  store->DeRegister(myVol);
  G4VPhysicalVolume *RODetectorXDivisionPhys = new G4PVReplica("RODetectorXDivisionPhys",
                                   RODetectorXDivisionLog,
                                   RODetectorPhys,
                                   kXAxis,
                                   numberOfVoxelsAlongX,
                                   voxelXThickness);
  myVol = store->GetVolume("RODetectorYDivisionPhys");
  store->DeRegister(myVol);
  G4VPhysicalVolume *RODetectorYDivisionPhys = new G4PVReplica("RODetectorYDivisionPhys",
                                   RODetectorYDivisionLog,
                                   RODetectorXDivisionPhys,
                                   kYAxis,
                                   numberOfVoxelsAlongY,
                                   voxelYThickness);
  
  myVol = store->GetVolume("RODetectorZDivisionPhys");
  store->DeRegister(myVol);
  new G4PVReplica("RODetectorZDivisionPhys",
          RODetectorZDivisionLog,
          RODetectorYDivisionPhys,
          kZAxis,
          numberOfVoxelsAlongZ,
          voxelZThickness);

  return;

}

Here is the call graph for this function:

Here is the caller graph for this function:

---

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

• source/geant4.10.03.p03/examples/advanced/hadrontherapy/include/HadrontherapyDetectorROGeometry.hh
• source/geant4.10.03.p03/examples/advanced/hadrontherapy/src/HadrontherapyDetectorROGeometry.cc