Introduction to GEANT4

From UCL HEP PBT Wiki

(Difference between revisions)
Jump to: navigation, search
m
m
Line 1: Line 1:
== <span style="color:#000080"> Introduction </span> ==
== <span style="color:#000080"> Introduction </span> ==
-
 
GEANT4 is a software toolkit based on C++. In your code you have to define:  
GEANT4 is a software toolkit based on C++. In your code you have to define:  
Line 36: Line 35:
* <span style="color:#ff0000"> Event </span>: a collection of information from tracks and trajectories
* <span style="color:#ff0000"> Event </span>: a collection of information from tracks and trajectories
* <span style="color:#ff0000"> Run </span>: a collection of events
* <span style="color:#ff0000"> Run </span>: a collection of events
-
 
== <span style="color:#000080"> The function main() </span> ==
== <span style="color:#000080"> The function main() </span> ==
-
 
The function <span style="color:#ff0000"> main() </span> defines the skeleton of your simulation code. Inside the function you instantiate <span style="color:#ff0000"> G4RunManager </span> and notify it of your mandatory and optional classes. This is example <span style="color:#ff0000"> main() </span> function, where <span style="color:#ff0000"> MyDetectorConstruction </span>, <span style="color:#ff0000"> MyPhysicsList </span>, <span style="color:#ff0000"> MyPrimaryGeneratorAction </span>, <span style="color:#ff0000"> MyEventAction </span> and <span style="color:#ff0000"> MyRunAction </span> are derived classes from the GEANT4 base classes:
The function <span style="color:#ff0000"> main() </span> defines the skeleton of your simulation code. Inside the function you instantiate <span style="color:#ff0000"> G4RunManager </span> and notify it of your mandatory and optional classes. This is example <span style="color:#ff0000"> main() </span> function, where <span style="color:#ff0000"> MyDetectorConstruction </span>, <span style="color:#ff0000"> MyPhysicsList </span>, <span style="color:#ff0000"> MyPrimaryGeneratorAction </span>, <span style="color:#ff0000"> MyEventAction </span> and <span style="color:#ff0000"> MyRunAction </span> are derived classes from the GEANT4 base classes:
Line 71: Line 68:
   
   
== <span style="color:#000080"> Experimental setup </span> ==
== <span style="color:#000080"> Experimental setup </span> ==
-
 
You derive your own class from <span style="color:#ff0000"> G4VUserDetectorConstruction </span> base class. In the derived class you will:  
You derive your own class from <span style="color:#ff0000"> G4VUserDetectorConstruction </span> base class. In the derived class you will:  
Line 78: Line 74:
* Construct materials and electromagnetic fields using <span style="color:#ff0000"> G4Logical Volume </span>  
* Construct materials and electromagnetic fields using <span style="color:#ff0000"> G4Logical Volume </span>  
* Place volumes of your detector geometry using <span style="color:#ff0000"> G4VPhysical Volume </span>  
* Place volumes of your detector geometry using <span style="color:#ff0000"> G4VPhysical Volume </span>  
-
 
<u> Simple example of class <span style="color:#ff0000"> MyDetectorConstruction </span> </u>:  
<u> Simple example of class <span style="color:#ff0000"> MyDetectorConstruction </span> </u>:  
Line 100: Line 95:
Now construct the detector. Your detector is always placed in a mother volume called the world volume.   
Now construct the detector. Your detector is always placed in a mother volume called the world volume.   
-
 
<pre style="color: #800000; background-color: #dcdcdc">
<pre style="color: #800000; background-color: #dcdcdc">
Line 114: Line 108:
                                                                            
                                                                            
G4VPhysicalVolume* pWorldPhys = new G4PVPlacement(0,G4ThreeVector(),pWorldLog,"World",0,false,0);   
G4VPhysicalVolume* pWorldPhys = new G4PVPlacement(0,G4ThreeVector(),pWorldLog,"World",0,false,0);   
-
 
// Water box  
// Water box  
Line 126: Line 119:
“WaterBox”, pWorldLog, false, copyNo); ... }  
“WaterBox”, pWorldLog, false, copyNo); ... }  
</pre>
</pre>
-
 
The elements and materials are defined using classes <span style="color:#ff0000"> G4Element </span> and <span style="color:#ff0000"> G4Material </span>. For example water, hydrogen and oxygen are defined as:
The elements and materials are defined using classes <span style="color:#ff0000"> G4Element </span> and <span style="color:#ff0000"> G4Material </span>. For example water, hydrogen and oxygen are defined as:
-
 
<pre style="color: #800000; background-color: #dcdcdc">
<pre style="color: #800000; background-color: #dcdcdc">
Line 149: Line 140:
water->AddElement(O, natoms=1); ...}   
water->AddElement(O, natoms=1); ...}   
</pre>
</pre>
-
 
[http://geant4.web.cern.ch/geant4/UserDocumentation/Doxygen/examples_doc/html/group__extended__common__detectorConstruction.html Here] you can find more examples of DetectorConstruction classes.
[http://geant4.web.cern.ch/geant4/UserDocumentation/Doxygen/examples_doc/html/group__extended__common__detectorConstruction.html Here] you can find more examples of DetectorConstruction classes.
-
 
== <span style="color:#000080"> Physics processes </span> ==  
== <span style="color:#000080"> Physics processes </span> ==  
-
 
You can build your own physics list or chose from already built physics lists. To build your own physics lists, you can use two base physics list classes: <span style="color:#ff0000"> G4VUserPhysicsList </span> and <span style="color:#ff0000"> G4ModularPhysicsList </span>. The class <span style="color:#ff0000"> G4VUserPhysicsList </span> is used for simple physics lists while <span style="color:#ff0000"> G4ModularPhysicsList </span> is used to build more complex physics lists. There exist also already built pre-packaged physics lists.
You can build your own physics list or chose from already built physics lists. To build your own physics lists, you can use two base physics list classes: <span style="color:#ff0000"> G4VUserPhysicsList </span> and <span style="color:#ff0000"> G4ModularPhysicsList </span>. The class <span style="color:#ff0000"> G4VUserPhysicsList </span> is used for simple physics lists while <span style="color:#ff0000"> G4ModularPhysicsList </span> is used to build more complex physics lists. There exist also already built pre-packaged physics lists.
-
 
=== <span style="color:#000080"> Simple physics lists </span> ===   
=== <span style="color:#000080"> Simple physics lists </span> ===   
-
 
If the particles in your simulation undergo a descrete number of physics processes you can use the class <span style="color:#ff0000"> G4VUserPhysicsList </span> to define them. This class has three methods:
If the particles in your simulation undergo a descrete number of physics processes you can use the class <span style="color:#ff0000"> G4VUserPhysicsList </span> to define them. This class has three methods:
Line 168: Line 154:
* ConstructProcesses() : Define all necessary processes and assign them to proper particles;
* ConstructProcesses() : Define all necessary processes and assign them to proper particles;
* SetCuts() : Define production thresholds in terms of range;  
* SetCuts() : Define production thresholds in terms of range;  
-
 
<u> Simple example of class <span style="color:#ff0000"> MyPhysicsList </span> </u>:  
<u> Simple example of class <span style="color:#ff0000"> MyPhysicsList </span> </u>:  
-
 
<pre style="color: #800000; background-color: #dcdcdc">
<pre style="color: #800000; background-color: #dcdcdc">
Line 189: Line 173:
</pre>
</pre>
   
   
-
 
Now implement the methods ConstructParticle(), ConstructProcess() and SetCuts():
Now implement the methods ConstructParticle(), ConstructProcess() and SetCuts():
-
 
   
   
<pre style="color: #800000; background-color: #dcdcdc">
<pre style="color: #800000; background-color: #dcdcdc">
Line 209: Line 191:
</pre>
</pre>
-
 
+
GEANT4 provides a variety of physics processes. These processes are decoupled from one another and you can select those which are relevant to your simulation. The processes are grouped in seven categories  
-
GEANT4 provides a variety of physics processes. These processes are decoupled from one another and you can select those which are relevant to your simulation. The processes are grouped in seven categories and their list is available [http://geant4.cern.ch/support/proc_mod_catalog/processes/ here]:
+
<div style="column-count:2;-moz-column-count:2;-webkit-column-count:2">
<div style="column-count:2;-moz-column-count:2;-webkit-column-count:2">
Line 222: Line 203:
</div>
</div>
-
 
+
and their list is available [http://geant4.cern.ch/support/proc_mod_catalog/processes/ here]. For each particle in ConstructParticle() assign all the physics processes you want to consider in your simulation:  
-
For each particle defined in ConstructParticle() assign all the physics processes that you want to
+
-
consider in your simulation:  
+
    
    
-
 
<pre style="color: #800000; background-color: #dcdcdc">
<pre style="color: #800000; background-color: #dcdcdc">
void MyPhysicsList::ConstructProcess() {  
void MyPhysicsList::ConstructProcess() {  
Line 236: Line 214:
ConstructGeneral(); // Other processes }
ConstructGeneral(); // Other processes }
</pre>
</pre>
-
 
In methods ConstructEM() and ConstructGeneral() assign the physics processes to the corresponding particles:  
In methods ConstructEM() and ConstructGeneral() assign the physics processes to the corresponding particles:  
-
 
<pre style="color: #800000; background-color: #dcdcdc">
<pre style="color: #800000; background-color: #dcdcdc">
Line 282: Line 258:
</pre>
</pre>
-
 
+
This is the full [http://geant4.cern.ch/support/proc_mod_catalog/particles/ list] of physics processes available for every  particle. Finally, in method SetCuts() you can define cuts on the particles:
-
This is the full [http://geant4.cern.ch/support/proc_mod_catalog/particles/ list] of physics processes available for every  particle. Finally, method SetCuts() is defined as:
+
Line 297: Line 272:
SetCutValue(defaultCutValue, "e-");  
SetCutValue(defaultCutValue, "e-");  
</pre>
</pre>
-
 
=== <span style="color:#000080"> Detailed physics lists </span> ===  
=== <span style="color:#000080"> Detailed physics lists </span> ===  
-
 
If you want to build more realistic physics list you have to use the class <span style="color:#ff0000"> G4VModularPhysicsList </span>. For example, the photon from the example above can undergo compton scattering apart from conversion. In <span style="color:#ff0000"> G4VModularPhysicsList </span> you can group the physics processes into separate modules: EM physics, hadronic physics, decay physics etc.  
If you want to build more realistic physics list you have to use the class <span style="color:#ff0000"> G4VModularPhysicsList </span>. For example, the photon from the example above can undergo compton scattering apart from conversion. In <span style="color:#ff0000"> G4VModularPhysicsList </span> you can group the physics processes into separate modules: EM physics, hadronic physics, decay physics etc.  
-
 
<u> Simple example of class <span style="color:#ff0000"> MyPhysicsList </span> </u>:
<u> Simple example of class <span style="color:#ff0000"> MyPhysicsList </span> </u>:
-
 
<pre style="color: #800000; background-color: #dcdcdc">
<pre style="color: #800000; background-color: #dcdcdc">
Line 337: Line 308:
</pre>
</pre>
-
 
+
Now, build the physics lists:
-
Now we can build the physics lists:
+
-
 
+
<pre style="color: #800000; background-color: #dcdcdc">
<pre style="color: #800000; background-color: #dcdcdc">
Line 384: Line 353:
} ... }  
} ... }  
</pre>
</pre>
-
 
and  
and  
-
 
<pre style="color: #800000; background-color: #dcdcdc">
<pre style="color: #800000; background-color: #dcdcdc">
Line 403: Line 370:
</pre>
</pre>
    
    
-
 
=== <span style="color:#000080"> Pre-packaged physics lists </span> ===
=== <span style="color:#000080"> Pre-packaged physics lists </span> ===
-
 
Some built-in pre-packaged physics lists are available [http://geant4.web.cern.ch/geant4/support/proc_mod_catalog/physics_lists/referencePL.shtml here]. You can use them as a starting point of your simulation.     
Some built-in pre-packaged physics lists are available [http://geant4.web.cern.ch/geant4/support/proc_mod_catalog/physics_lists/referencePL.shtml here]. You can use them as a starting point of your simulation.     
-
 
<u> Simple example of <span style="color:#ff0000"> pre-packaged physics list </span> </u>:
<u> Simple example of <span style="color:#ff0000"> pre-packaged physics list </span> </u>:
-
 
In function <span style="color:#ff0000"> main() </span>:  
In function <span style="color:#ff0000"> main() </span>:  
-
 
<pre style="color: #800000; background-color: #dcdcdc">
<pre style="color: #800000; background-color: #dcdcdc">
Line 425: Line 387:
For example, if you want to simulate clinical proton beam of energy 150 MeV you can use pre-packaged physics list e.g. QGSP_BIC, QGSP_BERT and FTFP_BERT. If you are interested in Bragg curve physics, use a physics list ending in "EMV" or "EMX" e.g. QGSP_BERT_EMV.  
For example, if you want to simulate clinical proton beam of energy 150 MeV you can use pre-packaged physics list e.g. QGSP_BIC, QGSP_BERT and FTFP_BERT. If you are interested in Bragg curve physics, use a physics list ending in "EMV" or "EMX" e.g. QGSP_BERT_EMV.  
 +
 +
=== <span style="color:#000080"> Building your own physics list </span> ===
 +
 +
See Computed tomography tutorial.
   
   
-
 
== <span style="color:#000080"> Generate primary particles </span> ==  
== <span style="color:#000080"> Generate primary particles </span> ==  
-
 
You derive your own class from <span style="color:#ff0000"> G4VUserPrimaryGeneratorAction </span> base class.
You derive your own class from <span style="color:#ff0000"> G4VUserPrimaryGeneratorAction </span> base class.
Line 435: Line 399:
* <span style="color:#ff0000"> G4ParticleGun </span> is used to simulate a beam of particles. It shoots a primary particle of a certain energy and direction from a given point at a given time.
* <span style="color:#ff0000"> G4ParticleGun </span> is used to simulate a beam of particles. It shoots a primary particle of a certain energy and direction from a given point at a given time.
* <span style="color:#ff0000"> G4GeneralParticleSource </span> simulates a beam of particles and the primary vertex is randomly chosen on surface of a given volume with pre-defined energy spectra, spatial and angular distribution.  
* <span style="color:#ff0000"> G4GeneralParticleSource </span> simulates a beam of particles and the primary vertex is randomly chosen on surface of a given volume with pre-defined energy spectra, spatial and angular distribution.  
-
 
<u> Simple example of class <span style="color:#ff0000"> MyPrimaryGeneratorAction </span> using particle gun </u>:
<u> Simple example of class <span style="color:#ff0000"> MyPrimaryGeneratorAction </span> using particle gun </u>:
-
 
<pre style="color: #800000; background-color: #dcdcdc">
<pre style="color: #800000; background-color: #dcdcdc">
Line 464: Line 426:
G4ParticleGun*  fParticleGun; };  
G4ParticleGun*  fParticleGun; };  
</pre>
</pre>
-
 
<u> Simple example of class <span style="color:#ff0000"> MyPrimaryGeneratorAction </span> using general particle source </u>:
<u> Simple example of class <span style="color:#ff0000"> MyPrimaryGeneratorAction </span> using general particle source </u>:
-
 
<pre style="color: #800000; background-color: #dcdcdc">
<pre style="color: #800000; background-color: #dcdcdc">
Line 490: Line 450:
</pre>
</pre>
-
 
+
[http://geant4.web.cern.ch/geant4/UserDocumentation/Doxygen/examples_doc/html/group__extended__common__primaryGenerator.html Here] you can find how to implement MyPrimaryGeneratorAction class in your code.
-
[http://geant4.web.cern.ch/geant4/UserDocumentation/Doxygen/examples_doc/html/group__extended__common__primaryGenerator.html Here] you can find how to implement MyPrimaryGeneratorAction class defined above in your code.
+
    
    
-
 
== <span style="color:#000080"> Optional user classes </span> ==
== <span style="color:#000080"> Optional user classes </span> ==
Line 521: Line 479:
Status is attached to each <span style="color:#ff0000"> G4StepPoint </span> to show how step was determined. You can use ''PostStepPoint'' to get status of current step and ''PreStepPoint'' to get status of previous step. For example to get the x coordinate of a step you do the following:
Status is attached to each <span style="color:#ff0000"> G4StepPoint </span> to show how step was determined. You can use ''PostStepPoint'' to get status of current step and ''PreStepPoint'' to get status of previous step. For example to get the x coordinate of a step you do the following:
-
 
<pre style="color: #800000; background-color: #dcdcdc">
<pre style="color: #800000; background-color: #dcdcdc">

Revision as of 12:20, 2 September 2014

Contents

Introduction

GEANT4 is a software toolkit based on C++. In your code you have to define:

  • Your experimental setup - geometry, materials and primary particles.
  • Which physics process you are interested in.
  • Take actions during the simulation to inspect and store results.

The interaction with GEANT4 is done via base classes.

Mandatory classes
  • G4VUserDetectorConstruction : Describe the experimental setup, geometry and materials;
  • G4VUserPhysicsList : Define particles, physics processes and range cuts;
  • G4VUserPrimaryGeneratorAction : Describe particle source, source dimensions, initial position, energy spectrum, angular distributions;
Optional classes
  • G4UserRunAction : Define and store histograms;
  • G4UserEventAction : Event selection and analysis of simulation data;
  • G4UserStackingAction : Customize priority of tracks;
  • G4UserTrackingAction : Decide whether a trajectory should be stored or not;
  • G4UserSteppingAction : Kill, suspend, postpone a track;
Manager class
  • G4RunManager : Manages processing the run;
Useful terminology
  • Step : the smallest unit of Geant4 simulation, a particle is transported from one point to another
  • Trajectory and TrajectoryPoint : collection of steps and step points
  • Process : physics along the step
  • Track : a snapshot of a particle at some point along its path (not the same as trajectory)
  • Event : a collection of information from tracks and trajectories
  • Run : a collection of events

The function main()

The function main() defines the skeleton of your simulation code. Inside the function you instantiate G4RunManager and notify it of your mandatory and optional classes. This is example main() function, where MyDetectorConstruction , MyPhysicsList , MyPrimaryGeneratorAction , MyEventAction and MyRunAction are derived classes from the GEANT4 base classes:

int main() { 
  
// Run manager construction 

G4RunManager* runManager = new G4RunManager; 


// mandatory user initialization classes

runManager->SetUserInitialization(new MyDetectorConstruction); 

runManager->SetUserInitialization(new MyPhysicsList);


// mandatory user action classes  

runManager->SetUserAction(new MyPrimaryGeneratorAction); 


// optional user action classes 

runManager->SetUserAction(new MyEventAction);  

runManager->SetUserAction(new MyRunAction); ... } 

Experimental setup

You derive your own class from G4VUserDetectorConstruction base class. In the derived class you will:

  • Describe the shape and the size of your detector using G4VSolid
  • Construct materials and electromagnetic fields using G4Logical Volume
  • Place volumes of your detector geometry using G4VPhysical Volume

Simple example of class MyDetectorConstruction :

class MyDetectorConstruction:public G4VUserDetectorConstruction { 

public:  
    
MyDetectorConstruction();

~MyDetectorConstruction(); 
    
virtual G4VPhysicalVolume* Construct(); 

     
private: 
   
void  DefineMaterials(); };    

Now construct the detector. Your detector is always placed in a mother volume called the world volume.

G4PhysicalVolume* MyDetectorConstruction::Construct() {  

...  

// World volume 

G4VSolid* pWorld = new G4Box("World",5*m,5*m,5*m); 
                                         
G4LogicalVolume* pWorldLog = new G4LogicalVolume(pWorld,vacuum, "World");    
                                                                           
G4VPhysicalVolume* pWorldPhys = new G4PVPlacement(0,G4ThreeVector(),pWorldLog,"World",0,false,0);  

// Water box 

G4VSolid* pBoxSolid = new G4Box(“WaterBox”, 1.*m, 2.*m, 3.*m);  

G4LogicalVolume* pBoxLog = new G4LogicalVolume( pBoxSolid, water, “WaterBox”); 

G4VPhysicalVolume* aBoxPhys = new G4PVPlacement( pRotation, G4ThreeVector(posX, posY, posZ), pBoxLog, 

“WaterBox”, pWorldLog, false, copyNo); ... } 

The elements and materials are defined using classes G4Element and G4Material . For example water, hydrogen and oxygen are defined as:

void MyDetectorConstruction::DefineMaterials() { 

... 

G4Element* H = new G4Element("Hydrogen","H",z=1.,a= 1.01*g/mole); 
 
G4Element* O = new G4Element("Oxygen","O",z=8.,a=16.00*g/mole); 


density = 1.000*g/cm3; 

G4Material* water = new G4Material("Water",density,ncomp=2);  

water->AddElement(H, natoms=2);  

water->AddElement(O, natoms=1); ...}  

Here you can find more examples of DetectorConstruction classes.

Physics processes

You can build your own physics list or chose from already built physics lists. To build your own physics lists, you can use two base physics list classes: G4VUserPhysicsList and G4ModularPhysicsList . The class G4VUserPhysicsList is used for simple physics lists while G4ModularPhysicsList is used to build more complex physics lists. There exist also already built pre-packaged physics lists.

Simple physics lists

If the particles in your simulation undergo a descrete number of physics processes you can use the class G4VUserPhysicsList to define them. This class has three methods:

  • ConstructParticles() : Define all necessary particles;
  • ConstructProcesses() : Define all necessary processes and assign them to proper particles;
  • SetCuts() : Define production thresholds in terms of range;

Simple example of class MyPhysicsList :

class MyPhysicsList:public G4VUserPhysicsList() { 

public: 

MyPhysicsList(); 

~MyPhysicsList(); 

void ConstructParticle(); 

void ConstructProcess(); 

void SetCuts(); } 

Now implement the methods ConstructParticle(), ConstructProcess() and SetCuts():

void MyPhysicsList::ConstructParticle() { 

// Define the particles 

G4Electron::ElectronDefinition(); 

G4Positron::PositronDefinition(); 

G4Proton::ProtonDefinition(); 

G4Neutron::NeutronDefinition(); 

G4Gamma::GammaDefinition(); ... } 

GEANT4 provides a variety of physics processes. These processes are decoupled from one another and you can select those which are relevant to your simulation. The processes are grouped in seven categories

  • electromagnetic
  • hadronic
  • decay
  • photolepton-hadron
  • optical
  • parameterization
  • transportation

and their list is available here. For each particle in ConstructParticle() assign all the physics processes you want to consider in your simulation:

void MyPhysicsList::ConstructProcess() { 

AddTransportation(); // Assign transportation process to all particles 

ConstructEM(); // Electromagnetic processes 

ConstructGeneral(); // Other processes }

In methods ConstructEM() and ConstructGeneral() assign the physics processes to the corresponding particles:

void MyPhysicsList::ConstructEM() { 

aParticleIterator->reset(); 

while((*aParticleIterator)()){ 

G4ParticleDefinition* particle = aParticleIterator->value(); 
 
G4ProcessManager* pmanager = particle->GetProcessManager(); 

G4String particleName = particle->GetParticleName(); 
     
if (particleName == "gamma") { 
     
pmanager->AddDiscreteProcess(new G4GammaConversion); ...} 


void MyPhysicsList::ConstructGeneral() { 

G4Decay* theDecayProcess = new G4Decay() 

aParticleIterator->reset(); 

while((*aParticleIterator)()) { 

G4ParticleDefinition* particle = aParticleIterator->value(); 
 
G4ProcessManager* pmanager = particle->GetProcessManager(); 

if theDecayProcess->IsApplicable(*particle)) { 
     
pmanager->AddProcess(theDecayProcess); 
     
pmanager->SetProcessOrdering(theDecayProcess,idxPostStep);  
    
pmanager->SetProcessOrdering(theDecayProcess,idxAtRest); }}} 

This is the full list of physics processes available for every particle. Finally, in method SetCuts() you can define cuts on the particles:


void MyPhysicsList::SetCuts() { </span>

defaultCutValue = 1.0*mm; 

SetCutValue(defaultCutValue, "gamma"); 

SetCutValue(defaultCutValue, "e+"); 

SetCutValue(defaultCutValue, "e-"); 

Detailed physics lists

If you want to build more realistic physics list you have to use the class G4VModularPhysicsList . For example, the photon from the example above can undergo compton scattering apart from conversion. In G4VModularPhysicsList you can group the physics processes into separate modules: EM physics, hadronic physics, decay physics etc.

Simple example of class MyPhysicsList :

class MyPhysicsList:public G4VModularPhysicsList { 

public: 

MyPhysicsList(); 

~MyPhysicsList(); 

virtual void ConstructParticle(); 
    
virtual void SetCuts(); 
        
void AddPhysicsList(const G4String& name); 

virtual void ConstructProcess(); 

      
private: 
    
G4String                             fEmName; 

G4VPhysicsConstructor*               fEmPhysicsList; 

G4VPhysicsConstructor*               fDecPhysicsList; 

std::vector<G4VPhysicsConstructor*>  fHadronPhysicsList; };

Now, build the physics lists:

void MyPhysicsList::AddPhysicsList(const G4String& name) { 

... 

if (name == "emstandard_opt3") { 
    
fEmName = name;   
    
delete fEmPhysicsList; 
    
fEmPhysicsList = new G4EmStandardPhysics_option3(); 


} else if (name == "emlivermore") { 
   
fEmName = name; 
    
delete fEmPhysicsList; 
    
fEmPhysicsList = new G4EmLivermorePhysics(); 


} else if (name == "empenelope") { 
    
fEmName = name; 
    
delete fEmPhysicsList; 
    
fEmPhysicsList = new G4EmPenelopePhysics(); 


} else if (name == "HElastic") { 
    
fHadronPhysicsList.push_back( new G4HadronHElasticPhysics()); 


} else if (name == "HInelastic") { 
   
fHadronPhysicsList.push_back(new G4HadronInelasticQBBC()); 
    
} ... } 

and

void MyPhysicsList::ConstructProcess() { 
 
AddTransportation(); // transportation 
  
fEmPhysicsList->ConstructProcess(); // electromagnetic physics list 

fDecPhysicsList->ConstructProcess(); // decay physics list 
  
for(size_t i=0; i<fHadronPhys.size(); i++) { // hadronic physics lists 
  
fHadronPhys[i]->ConstructProcess(); } } 

Pre-packaged physics lists

Some built-in pre-packaged physics lists are available here. You can use them as a starting point of your simulation.

Simple example of pre-packaged physics list :

In function main() :

G4PhysListFactory factory* physListFactory = new G4PhysListFactory(); 

G4VUserPhysicsList* physicsList = physListFactory->GetReferencePhysList(“FTFP_BERT”); 

runManager->SetUserInitialization(physicsList); 

For example, if you want to simulate clinical proton beam of energy 150 MeV you can use pre-packaged physics list e.g. QGSP_BIC, QGSP_BERT and FTFP_BERT. If you are interested in Bragg curve physics, use a physics list ending in "EMV" or "EMX" e.g. QGSP_BERT_EMV.

Building your own physics list

See Computed tomography tutorial.

Generate primary particles

You derive your own class from G4VUserPrimaryGeneratorAction base class. Actual generation of primary particles is done via classes G4ParticleGun and G4GeneralParticleSource .

  • G4ParticleGun is used to simulate a beam of particles. It shoots a primary particle of a certain energy and direction from a given point at a given time.
  • G4GeneralParticleSource simulates a beam of particles and the primary vertex is randomly chosen on surface of a given volume with pre-defined energy spectra, spatial and angular distribution.

Simple example of class MyPrimaryGeneratorAction using particle gun :

class MyPrimaryGeneratorAction:public G4VUserPrimaryGeneratorAction { 

public: 

MyPrimaryGeneratorAction( 

const G4String& particleName = "proton", 
      
G4double energy = 1.*CLHEP::MeV, 
      
G4ThreeVector position= G4ThreeVector(0,0,0), 
      
G4ThreeVector momentumDirection = G4ThreeVector(0,0,1));     
    
~MyPrimaryGeneratorAction(); 

virtual void GeneratePrimaries(G4Event*); 


private: 
    
G4ParticleGun*  fParticleGun; }; 

Simple example of class MyPrimaryGeneratorAction using general particle source :

class MyPrimaryGeneratorAction:public G4VUserPrimaryGeneratorAction { 

public: 

MyPrimaryGeneratorAction();     

~MyPrimaryGeneratorAction(); 

virtual void GeneratePrimaries(G4Event*); 


private: 

static const G4String ParticleName; 

static const G4double ParticleEnergy; 

G4GeneralParticleSource*  fGeneralParticleSource; }; 

Here you can find how to implement MyPrimaryGeneratorAction class in your code.

Optional user classes

Run

You can derive your own class from G4UserRunAction base class where you may book results of the run. The run starts with "Beam On" and within a run you can not change the detector geometry and physics processes. The run is represented by class G4Run .

Here you can find examples of user defined RunAction classes.

Event

Event is the basic GEANT4 unit. At the beginning of an event are generated primary tracks which are pushed into a stack. The tracks from the stack are analyzed one by one. The primary tracks might lead to secondary tracks which are also pushed into the stack. When the stack becomes empty the processing of the event is over. The event is represented by class G4Event which gives hits and trajectory collections as output.

You can derive your own class from G4UserEventAction base class where you can select and analize data.

Here you can find examples of user defined EventAction classes.

Track

Track is a snapshot of a particle and it is represented by G4Track class. At the end of the event the track objects do not exist. Tracks are pushed step by step. Moving by one step is called "stepping" and this can be controlled by the G4UserSteppingAction class (see below). At the end of each step the state of a track can be changed (killed, suspended, postponed).

Step

Step has two points and information about the particle e.g. energy loss on the step. A step is represented by G4Step and G4StepPoint classes. G4UserSteppingAction is optional class where you can kill, suspend, postpone a track.

Status is attached to each G4StepPoint to show how step was determined. You can use PostStepPoint to get status of current step and PreStepPoint to get status of previous step. For example to get the x coordinate of a step you do the following:

G4StepPoint* prePoint  = step->GetPreStepPoint();

G4double x1 = prePoint->GetPosition().x(); 

Trajectory

Trajectories are represented by classes G4Trajectory and G4TrajectoryPoint . G4Trajectory class copies some of the G4Track class information. G4TrajectoryPoint is the class which copies some of G4Step information.

Personal tools