Introduction to GEANT4

From UCL HEP PBT Wiki

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 6: Line 5:
* Your experimental setup - geometry, materials and primary particles.
* Your experimental setup - geometry, materials and primary particles.
* Which physics process you are interested in.  
* Which physics process you are interested in.  
-
* You may take actions during the simulation - inspect and store results.  
+
* Take actions during the simulation to inspect and store results.  
The interaction with GEANT4 is done via base classes.     
The interaction with GEANT4 is done via base classes.     
Line 12: Line 11:
; Mandatory classes:   
; Mandatory classes:   
-
* <span style="color:#ff0000"> G4VUserDetectorConstruction </span>: Describe the experimental setup, geometry and materials
+
* <span style="color:#ff0000"> G4VUserDetectorConstruction </span>: Describe the experimental setup, geometry and materials;
-
* <span style="color:#ff0000"> G4VUserPhysicsList </span>: Define particles, physics processes and range cuts
+
* <span style="color:#ff0000"> G4VUserPhysicsList </span>: Define particles, physics processes and range cuts;
-
* <span style="color:#ff0000"> G4VUserPrimaryGeneratorAction </span>: Describe particle source, source dimensions, initial position, energy spectrum, angular distributions
+
* <span style="color:#ff0000"> G4VUserPrimaryGeneratorAction </span>: Describe particle source, source dimensions, initial position, energy spectrum, angular distributions;
; Optional classes:  
; Optional classes:  
-
* <span style="color:#ff0000"> G4UserRunAction </span>: Define and store histograms  
+
* <span style="color:#ff0000"> G4UserRunAction </span>: Define and store histograms;
-
* <span style="color:#ff0000"> G4UserEventAction </span>: Event selection and analysis of simulation data
+
* <span style="color:#ff0000"> G4UserEventAction </span>: Event selection and analysis of simulation data;
-
* <span style="color:#ff0000"> G4UserStackingAction </span>: Customize priority of tracks
+
* <span style="color:#ff0000"> G4UserStackingAction </span>: Customize priority of tracks;
-
* <span style="color:#ff0000"> G4UserTrackingAction </span>: Decide whether a trajectory should be stored or not
+
* <span style="color:#ff0000"> G4UserTrackingAction </span>: Decide whether a trajectory should be stored or not;
-
* <span style="color:#ff0000"> G4UserSteppingAction </span>: Kill, suspend, postpone a track
+
* <span style="color:#ff0000"> G4UserSteppingAction </span>: Kill, suspend, postpone a track;
; Manager class  
; Manager class  
-
* <span style="color:#ff0000"> G4RunManager </span>: Manages the simulation process
+
* <span style="color:#ff0000"> G4RunManager </span>: Manages processing the run;
-
 
+
-
== <span style="color:#000080"> The function main() </span> ==
+
 +
; Useful terminology
-
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 MyDetectorConstruction, MyPhysicsList, MyPrimaryGeneratorAction, MyEventAction and MyRunAction are derived classes from the GEANT4 base classes:
+
* <span style="color:#ff0000"> Step </span>: the smallest unit of Geant4 simulation, a particle is transported from one point to another
 +
* <span style="color:#ff0000"> Trajectory and TrajectoryPoint </span>: collection of steps and step points
 +
* <span style="color:#ff0000"> Process </span>: physics along the step
 +
* <span style="color:#ff0000"> Track </span>: a snapshot of a particle at some point along its path (not the same as trajectory)
 +
* <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:#800000"> { </span>
+
== <span style="color:#000080"> The function main() </span> ==
-
<span style="color:#800000"> ... </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:
-
<span style="color:#800000"> // Run manager construction </span>
+
<pre style="color: #800000; background-color: #dcdcdc">
 +
int main() {
 +
 
 +
// Run manager construction  
-
<span style="color:#800000"> G4RunManager* runManager = new G4RunManager; </span>
+
G4RunManager* runManager = new G4RunManager;  
-
<span style="color:#800000"> // mandatory user initialization classes </span>
+
// mandatory user initialization classes
-
<span style="color:#800000"> runManager->SetUserInitialization(new MyDetectorConstruction); </span>
+
runManager->SetUserInitialization(new MyDetectorConstruction);  
-
<span style="color:#800000"> runManager->SetUserInitialization(new MyPhysicsList); </span>
+
runManager->SetUserInitialization(new MyPhysicsList);
-
<span style="color:#800000"> // mandatory user action classes  </span>
+
// mandatory user action classes   
-
<span style="color:#800000"> runManager->SetUserAction(new MyPrimaryGeneratorAction); </span>
+
runManager->SetUserAction(new MyPrimaryGeneratorAction);  
-
<span style="color:#800000"> // optional user action classes </span> 
+
// optional user action classes  
-
<span style="color:#800000"> runManager->SetUserAction(new MyEventAction); </span>
+
runManager->SetUserAction(new MyEventAction);
-
<span style="color:#800000"> runManager->SetUserAction(new MyRunAction); </span>
+
runManager->SetUserAction(new MyRunAction); ... }
-
 
+
</pre>
-
<span style="color:#800000"> ... </span>
+
-
 
+
-
<span style="color:#800000"> } </span>
+
   
   
== <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 can define your experiment by using three base classes:
+
* Describe the shape and the size of your detector using <span style="color:#ff0000"> G4VSolid </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>
-
* Describing the shape and the size of your detector: <span style="color:#ff0000"> G4VSolid </span>  
+
<u> Simple example of class <span style="color:#ff0000"> MyDetectorConstruction </span> </u>:  
-
* Adding properties - material and electromagnetic field: <span style="color:#ff0000"> G4Logical Volume </span>  
+
-
* Placing it in another volume - in one or many positions: <span style="color:#ff0000"> G4VPhysical Volume </span>
+
 +
<pre style="color: #800000; background-color: #dcdcdc">
 +
class MyDetectorConstruction:public G4VUserDetectorConstruction {
-
Simple example of <span style="color:#ff0000"> MyDetectorConstruction </span> derived from <span style="color:#ff0000"> G4VUserDetectorConstruction </span>:
+
public:
 +
   
 +
MyDetectorConstruction();
 +
~MyDetectorConstruction();
 +
   
 +
virtual G4VPhysicalVolume* Construct();
-
<span style="color:#800000"> G4VSolid* pBoxSolid = new G4Box(“WaterBox”, 1.*m, 2.*m, 3.*m); </span>  
+
   
 +
private:  
 +
 
 +
void  DefineMaterials(); };   
 +
</pre>
-
<span style="color:#800000"> G4LogicalVolume* pBoxLog = new G4LogicalVolume( pBoxSolid, water, “WaterBox”); </span>
+
Now construct the detector. Your detector is always placed in a mother volume called the world volume. 
-
<span style="color:#800000"> G4VPhysicalVolume* aBoxPhys = new G4PVPlacement( pRotation, G4ThreeVector(posX, posY, posZ), pBoxLog, “WaterBox”, pWorldLog,
+
<pre style="color: #800000; background-color: #dcdcdc">
-
false, copyNo); </span>
+
G4PhysicalVolume* MyDetectorConstruction::Construct() { 
-
 
+
...   
-
Your detector is always placed in a mother volume called the world volume.   
+
-
The world volume is defined in a similar way:
+
 +
// World volume
-
<span style="color:#800000"> G4VSolid* pWorld = new G4Box("World",5*m,5*m,5*m); </span>
+
G4VSolid* pWorld = new G4Box("World",5*m,5*m,5*m);  
                                          
                                          
-
<span style="color:#800000"> G4LogicalVolume* pWorldLog = new G4LogicalVolume(pWorld,vacuum, "World"); </span> 
+
G4LogicalVolume* pWorldLog = new G4LogicalVolume(pWorld,vacuum, "World");  
                                                                            
                                                                            
-
<span style="color:#800000"> G4VPhysicalVolume* pWorldPhys = new G4PVPlacement(0,G4ThreeVector(),pWorldLog,"World",0,false,0); </span>
+
G4VPhysicalVolume* pWorldPhys = new G4PVPlacement(0,G4ThreeVector(),pWorldLog,"World",0,false,0);
 +
// Water box
-
The elements and materials used in the experiment are defined using classes <span style="color:#ff0000"> G4Element </span> and <span style="color:#ff0000"> G4Material </span>. For example material water and elements hydrogen and oxygen are defined as:
+
G4VSolid* pBoxSolid = new G4Box(“WaterBox”, 1.*m, 2.*m, 3.*m); 
 +
G4LogicalVolume* pBoxLog = new G4LogicalVolume( pBoxSolid, water, “WaterBox”);
-
<span style="color:#800000"> G4Element* H = new G4Element("Hydrogen","H",z=1.,a= 1.01*g/mole); </span>
+
G4VPhysicalVolume* aBoxPhys = new G4PVPlacement( pRotation, G4ThreeVector(posX, posY, posZ), pBoxLog,  
-
+
-
<span style="color:#800000"> G4Element* O = new G4Element("Oxygen","O",z=8.,a=16.00*g/mole); </span>
+
 +
“WaterBox”, pWorldLog, false, copyNo); ... }
 +
</pre>
-
<span style="color:#800000"> density = 1.000*g/cm3; </span>  
+
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:
-
<span style="color:#800000"> G4Material* H2O = new G4Material("Water",density,ncomp=2); </span>
+
<pre style="color: #800000; background-color: #dcdcdc">
 +
void MyDetectorConstruction::DefineMaterials() {
-
<span style="color:#800000"> H2O->AddElement(H, natoms=2); </span>
+
...
-
<span style="color:#800000"> H2O->AddElement(O, natoms=1); </span>
+
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);
-
== <span style="color:#000080"> Physics processes </span> ==
+
density = 1.000*g/cm3;
 +
G4Material* water = new G4Material("Water",density,ncomp=2); 
-
Two kinds of base physics list classes are available for users to derive from: <span style="color:#ff0000"> G4VUserPhysicsList </span> and <span style="color:#ff0000"> G4ModularPhysicsList </span>. There exists also pre-packaged physics list.
+
water->AddElement(H, natoms=2); 
 +
water->AddElement(O, natoms=1); ...} 
 +
</pre>
-
=== <span style="color:#000080"> Simple physics lists </span> === 
+
[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> ==
-
You can use the class <span style="color:#ff0000"> G4VUserPhysicsList </span> if you want to use simple physics lists. <span style="color:#ff0000"> G4VUserPhysicsList </span> has three methods:
+
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.
-
* ConstructParticles(): define all necessary particles;  
+
=== <span style="color:#000080"> Simple physics lists </span> ===  
-
* ConstructProcesses(): define all necessary processes and assign them to proper particles;
+
-
* SetCuts(): define production thresholds in terms of range;
+
 +
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:
-
Simple example of <span style="color:#ff0000"> MyPhysicsList </span> derived from <span style="color:#ff0000"> G4VUserPhysicsList </span>:
+
* ConstructParticles() : Define all necessary particles; 
 +
* ConstructProcesses() : Define all necessary processes and assign them to corresponding particles;
 +
* SetCuts() : Define production thresholds in terms of range;
 +
<u> Simple example of class <span style="color:#ff0000"> MyPhysicsList </span> </u>:
-
<span style="color:#800000"> class MyPhysicsList : public G4VUserPhysicsList() { </span>
+
<pre style="color: #800000; background-color: #dcdcdc">
 +
class MyPhysicsList:public G4VUserPhysicsList() {  
-
<span style="color:#800000"> public: </span>
+
public:  
-
<span style="color:#800000"> MyPhysicsList(); </span>
+
MyPhysicsList();  
-
<span style="color:#800000"> ~MyPhysicsList(); </span>
+
~MyPhysicsList();  
-
<span style="color:#800000"> void ConstructParticle(); </span>
+
void ConstructParticle();  
-
<span style="color:#800000"> void ConstructProcess(); </span>
+
void ConstructProcess();  
-
<span style="color:#800000"> void SetCuts(); } </span>
+
void SetCuts(); }  
 +
</pre>
   
   
-
 
Now implement the methods ConstructParticle(), ConstructProcess() and SetCuts():
Now implement the methods ConstructParticle(), ConstructProcess() and SetCuts():
-
 
   
   
-
<span style="color:#800000"> void MyPhysicsList :: ConstructParticle() { </span>
+
<pre style="color: #800000; background-color: #dcdcdc">
 +
void MyPhysicsList::ConstructParticle() {  
-
<span style="color:#800000"> //Define the particles </span>
+
// Define the particles  
-
<span style="color:#800000"> G4Electron::ElectronDefinition(); </span>
+
G4Electron::ElectronDefinition();  
-
<span style="color:#800000"> G4Positron::PositronDefinition(); </span>
+
G4Positron::PositronDefinition();  
-
<span style="color:#800000"> G4Proton::ProtonDefinition(); </span>
+
G4Proton::ProtonDefinition();  
-
<span style="color:#800000"> G4Neutron::NeutronDefinition(); </span>
+
G4Neutron::NeutronDefinition();  
-
<span style="color:#800000"> G4Gamma::GammaDefinition(); ... } </span>
+
G4Gamma::GammaDefinition(); ... }  
 +
</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 the user can select those processes which are relevant to his/her simulation. There are seven categories of processes provided by GEANT4:
+
<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 177: 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:
 +
 
 +
<pre style="color: #800000; background-color: #dcdcdc">
 +
void MyPhysicsList::ConstructProcess() {
-
In method ConstructProcess() you define your physics processes:
+
AddTransportation(); // Assign transportation process to all particles
 +
 
 +
ConstructEM(); // Electromagnetic processes
 +
 
 +
ConstructGeneral(); // Other processes }
 +
</pre>
 +
 
 +
In methods ConstructEM() and ConstructGeneral() assign the physics processes to the corresponding particles:  
 +
 
 +
<pre style="color: #800000; background-color: #dcdcdc">
 +
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); ...}
 +
</pre> 
    
    
 +
<pre style="color: #800000; background-color: #dcdcdc">
 +
void MyPhysicsList::ConstructGeneral() {
-
<span style="color:#800000"> void MyPhysicsList :: ConstructProcess() </span>
+
G4Decay* theDecayProcess = new G4Decay()  
-
<span style="color:#800000"> { // Assign transportation process to all particles </span>
+
aParticleIterator->reset();
-
<span style="color:#800000"> AddTransportation(); </span>
+
while((*aParticleIterator)()) {
 +
G4ParticleDefinition* particle = aParticleIterator->value();
 +
 +
G4ProcessManager* pmanager = particle->GetProcessManager();
-
<span style="color:#800000"> // Electromagnetic processes </span>
+
if theDecayProcess->IsApplicable(*particle)) {
 +
   
 +
pmanager->AddProcess(theDecayProcess);
 +
   
 +
pmanager->SetProcessOrdering(theDecayProcess,idxPostStep); 
 +
   
 +
pmanager->SetProcessOrdering(theDecayProcess,idxAtRest); }}}
 +
</pre>
-
<span style="color:#800000"> ConstructEM(); </span>
+
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:
 +
<pre style="color: #800000; background-color: #dcdcdc">
 +
void MyPhysicsList::SetCuts() { </span>
-
<span style="color:#800000"> // Other processes </span>
+
defaultCutValue = 1.0*mm;
-
<span style="color:#800000"> ConstructGeneral(); ... } </span>
+
SetCutValue(defaultCutValue, "gamma");  
 +
SetCutValue(defaultCutValue, "e+");
-
where the method ConstructEM() is defined as:
+
SetCutValue(defaultCutValue, "e-");
 +
</pre>
 +
See the [[Computed tomography]] tutorial to learn more about simple physics lists .
-
<span style="color:#800000"> void MyPhysicsList::ConstructEM() </span>
+
=== <span style="color:#000080"> Detailed physics lists </span> ===
-
<span style="color:#800000"> { aParticleIterator->reset(); </span>
+
If you want to build more realistic physics list you have to use the class <span style="color:#ff0000"> G4VModularPhysicsList </span>. In <span style="color:#ff0000"> G4VModularPhysicsList </span> you can group the physics processes into separate modules which are already pre-build physics list and later chose one of those modules. 
-
<span style="color:#800000"> while( (*aParticleIterator)() ){ </span>
+
<u> Simple example of class <span style="color:#ff0000"> MyPhysicsList </span> </u>:
-
<span style="color:#800000"> G4ParticleDefinition* particle = aParticleIterator->value(); </span>
+
<pre style="color: #800000; background-color: #dcdcdc">
-
+
class MyPhysicsList:public G4VModularPhysicsList {
-
<span style="color:#800000"> G4ProcessManager* pmanager = particle->GetProcessManager(); </span>
+
-
<span style="color:#800000"> G4String particleName = particle->GetParticleName(); </span>
+
public:  
-
   
+
 
-
<span style="color:#800000"> if (particleName == "gamma") { </span>
+
MyPhysicsList();  
-
   
+
 
-
<span style="color:#800000"> pmanager->AddDiscreteProcess(new G4GammaConversion); ...} </span>
+
~MyPhysicsList();
 +
 
 +
virtual void ConstructParticle();  
      
      
 +
virtual void SetCuts();
 +
       
 +
void AddPhysicsList(const G4String& name);
-
and the method ConstructGeneral() is defined as:
+
virtual void ConstructProcess();
 +
     
 +
private:
 +
   
 +
G4String                            fEmName;
-
<span style="color:#800000"> void MyPhysicsList::ConstructGeneral() </span>
+
G4VPhysicsConstructor*              fEmPhysicsList;
-
<span style="color:#800000"> G4Decay* theDecayProcess = new G4Decay() </span>
+
G4VPhysicsConstructor*               fDecPhysicsList;
-
<span style="color:#800000"> { aParticleIterator->reset(); </span>
+
std::vector<G4VPhysicsConstructor*> fHadronPhysicsList; };
 +
</pre>
-
<span style="color:#800000"> while( (*aParticleIterator)() ){ </span>
+
Now, build the physics lists:
-
<span style="color:#800000"> G4ParticleDefinition* particle = aParticleIterator->value(); </span>
+
<pre style="color: #800000; background-color: #dcdcdc">
-
+
void MyPhysicsList::AddPhysicsList(const G4String& name) {
-
<span style="color:#800000"> G4ProcessManager* pmanager = particle->GetProcessManager(); </span>
+
-
<span style="color:#800000"> if theDecayProcess->IsApplicable(*particle)) { </span>
+
...
-
   
+
 
-
<span style="color:#800000"> pmanager->AddProcess(theDecayProcess); </span>
+
if (name == "emstandard_opt3") {
-
   
+
-
<span style="color:#800000"> pmanager->SetProcessOrdering(theDecayProcess,idxPostStep); </span>
+
      
      
-
<span style="color:#800000"> pmanager->SetProcessOrdering(theDecayProcess,idxAtRest); }}} </span>
+
fEmName = name; 
 +
   
 +
delete fEmPhysicsList;
 +
   
 +
fEmPhysicsList = new G4EmStandardPhysics_option3();  
-
In methods ConstructEM() and ConstructGeneral() to each particle you have to assign the corresponding physics processes they are involved in. This is a link to the physics processes available for each particles [http://geant4.cern.ch/support/proc_mod_catalog/particles/ Physics Process for Particles].   
+
} else if (name == "emlivermore") {
 +
 
 +
fEmName = name;
 +
   
 +
delete fEmPhysicsList;
 +
   
 +
fEmPhysicsList = new G4EmLivermorePhysics();
-
Finally, method SetCuts() is defined as:
+
} else if (name == "empenelope") {
 +
   
 +
fEmName = name;
 +
   
 +
delete fEmPhysicsList;
 +
   
 +
fEmPhysicsList = new G4EmPenelopePhysics();
-
<span style="color:#800000"> void MyPhysicsList :: SetCuts() </span>
+
} else if (name == "HElastic") {
 +
   
 +
fHadronPhysicsList.push_back( new G4HadronHElasticPhysics());
-
<span style="color:#800000"> { defaultCutValue = 1.0*mm; </span>
 
-
<span style="color:#800000"> SetCutValue(defaultCutValue, "gamma"); </span>
+
} else if (name == "HInelastic") {
 +
 
 +
fHadronPhysicsList.push_back(new G4HadronInelasticQBBC());  
 +
   
 +
} ... }
 +
</pre>
-
<span style="color:#800000"> SetCutValue(defaultCutValue, "e+"); </span>
+
and
-
<span style="color:#800000"> SetCutValue(defaultCutValue, "e-"); </span>
+
<pre style="color: #800000; background-color: #dcdcdc">
 +
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>
 +
 
 +
See the [[Monoenergetic proton pencil beam]] tutorial to learn more about detailed physics lists.
-
=== <span style="color:#000080"> Detailed physics lists </span> ===  
+
=== <span style="color:#000080"> Pre-packaged physics lists </span> ===
-
A realistic physics list has a lot of different physics processes. Therefore it is better to define a new class <span style="color:#ff0000"> G4VModularPhysicsList </span> derived from <span style="color:#ff0000"> G4VUserPhysicsList </span> where you can group the physics processes into EM physics, hadronic physics, optical physics etc. The method AddTransportation() is called automatically for all particles. Simple example of <span style="color:#ff0000"> G4VModularPhysicsList </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.   
 +
<u> Simple example of <span style="color:#ff0000"> pre-packaged physics list </span> </u>:
-
<span style="color:#800000"> MyModPhysList::MyModPhysList(): G4ModularPhysicsList() </span>
+
In function <span style="color:#ff0000"> main() </span>:
-
<span style="color:#800000"> { defaultCutValue = 1.0*mm; </span>
+
<pre style="color: #800000; background-color: #dcdcdc">
 +
G4PhysListFactory factory* physListFactory = new G4PhysListFactory();  
-
<span style="color:#800000"> RegisterPhysics(new ProtonPhysics()); </span>
+
G4VUserPhysicsList* physicsList = physListFactory->GetReferencePhysList(“FTFP_BERT”);  
-
<span style="color:#800000"> //all physics processes having to do with protons </span>
+
runManager->SetUserInitialization(physicsList);
 +
</pre>
 +
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"> Generate primary particles </span> ==
-
<span style="color:#800000"> RegisterPhysics(new ElectronPhysics()); </span>
+
You derive your own class from <span style="color:#ff0000"> G4VUserPrimaryGeneratorAction </span> base class.
 +
Actual generation of primary particles is done via classes <span style="color:#ff0000"> G4ParticleGun </span> and <span style="color:#ff0000"> G4GeneralParticleSource </span>.
-
<span style="color:#800000"> //all physics processes having to do with electrons </span>
+
* <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.
 +
<u> Simple example of class <span style="color:#ff0000"> MyPrimaryGeneratorAction </span> using particle gun </u>:
-
<span style="color:#800000"> RegisterPhysics(new DecayPhysics()); </span>
+
<pre style="color: #800000; background-color: #dcdcdc">
 +
class MyPrimaryGeneratorAction:public G4VUserPrimaryGeneratorAction {
-
<span style="color:#800000"> // physics of unstable particles ...} </span>
+
public:  
 +
MyPrimaryGeneratorAction(
-
<span style="color:#800000"> void MyModPhysList::SetCuts() </span>
+
const G4String& particleName = "proton",
 +
     
 +
G4double energy = 1.*CLHEP::MeV,
 +
     
 +
G4ThreeVector position= G4ThreeVector(0,0,0),
 +
     
 +
G4ThreeVector momentumDirection = G4ThreeVector(0,0,1));   
 +
   
 +
~MyPrimaryGeneratorAction();
-
<span style="color:#800000"> {SetCutsWithDefault();} </span>
+
virtual void GeneratePrimaries(G4Event*);  
-
where for example the class ProtonPhysics() is defined as
+
private:
 +
   
 +
G4ParticleGun*  fParticleGun; };
 +
</pre>
 +
<u> Simple example of class <span style="color:#ff0000"> MyPrimaryGeneratorAction </span> using general particle source </u>:
-
<span style="color:#800000"> class ProtonPhysics() : public G4VPhysicsConstructor </span>
+
<pre style="color: #800000; background-color: #dcdcdc">
 +
class MyPrimaryGeneratorAction:public G4VUserPrimaryGeneratorAction {
-
<span style="color:#800000"> { public: </span>
+
public:  
-
<span style="color:#800000"> ProtonPhysics(const G4String& name="proton"); </span>
+
MyPrimaryGeneratorAction();    
-
<span style="color:#800000"> virtual ~ProtonPhysics(); </span>
+
~MyPrimaryGeneratorAction();  
-
<span style="color:#800000"> virtual void ConstructParticle(); </span>
+
virtual void GeneratePrimaries(G4Event*);  
-
<span style="color:#800000"> virtual void ConstructProcess(); </span>
 
-
<span style="color:#800000"> //all processes a proton can have } </span>
+
private:  
 +
static const G4String ParticleName;
-
== <span style="color:#000080"> Generate primary particles </span> ==
+
static const G4double ParticleEnergy;
-
<span style="color:#ff0000"> G4VUserPrimaryGeneratorAction </span> is a mandatory user action class to control the generation of primary particles.
+
G4GeneralParticleSource*  fGeneralParticleSource; };
-
The particle generation is done via classes <span style="color:#ff0000"> G4ParticleGun </span> and <span style="color:#ff0000"> G4GeneralParticleSource </span>.
+
</pre>
-
* <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.
+
[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.
-
* <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.  
+
 +
The [[Monoenergetic photon pencil beam]] example uses the '''G4ParticleGun''' class. The [[Proton beam with realistic geometry]] tutorial uses '''G4GeneralParticleSource'''. 
 +
 
== <span style="color:#000080"> Optional user classes </span> ==
== <span style="color:#000080"> Optional user classes </span> ==
 +
 +
=== <span style="color:#000080"> Run </span> ===
 +
 +
You can derive your own class from <span style="color:#ff0000"> G4UserRunAction </span> 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 <span style="color:#ff0000"> G4Run </span>. 
 +
 
 +
[http://geant4.web.cern.ch/geant4/UserDocumentation/Doxygen/examples_doc/html/group__extended__common__userActions.html Here] you can find examples of user defined RunAction classes.
 +
 +
=== <span style="color:#000080"> Event </span> ===
 +
 +
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 <span style="color:#ff0000"> G4Event </span> which gives hits and trajectory collections as output.   
 +
 +
You can derive your own class from <span style="color:#ff0000"> G4UserEventAction </span> base class where
 +
you can select and analize data.
 +
 +
[http://geant4.web.cern.ch/geant4/UserDocumentation/Doxygen/examples_doc/html/group__extended__common__userActions.html Here] you can find examples of user defined EventAction classes.
 +
 +
=== <span style="color:#000080"> Track </span> ===
 +
 +
Track is a snapshot of a particle and it is represented by <span style="color:#ff0000"> G4Track </span> 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 <span style="color:#ff0000"> G4UserSteppingAction </span> class (see below). At the end of each step the state of a track can be changed (killed, suspended, postponed).   
 +
 +
=== <span style="color:#000080"> Step </span> ===
 +
 +
Step is defined by two points, it contains also information about the particle e.g. energy loss on the step. A step is represented by <span style="color:#ff0000"> G4Step </span> and <span style="color:#ff0000"> G4StepPoint </span> classes. <span style="color:#ff0000"> G4UserSteppingAction </span> is optional class where you can kill, suspend, postpone a track.
 +
 +
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">
 +
G4StepPoint* prePoint  = step->GetPreStepPoint();
 +
 +
G4double x1 = prePoint->GetPosition().x();
 +
</pre>
 +
 +
=== <span style="color:#000080"> Trajectory </span> ===
 +
 +
Trajectories are represented by classes <span style="color:#ff0000"> G4Trajectory </span> and <span style="color:#ff0000"> G4TrajectoryPoint </span>. <span style="color:#ff0000"> G4Trajectory </span> class copies some of the <span style="color:#ff0000"> G4Track </span> class information. <span style="color:#ff0000"> G4TrajectoryPoint </span> is the class which copies some of the <span style="color:#ff0000"> G4Step </span> information.

Latest revision as of 17:00, 4 September 2014

Retrieved from "https://www.hep.ucl.ac.uk/pbt/RadiotherapyWorkbook/index.php/Introduction_to_GEANT4"
Personal tools