SimonJolly at 15:23, 30 March 2016

2016-03-30T15:23:07Z

← Older revision		Revision as of 15:23, 30 March 2016
Line 9:		Line 9:
	The interaction with GEANT4 is done via base classes.		The interaction with GEANT4 is done via base classes.

	=== Mandatory ~~classes:~~ ===		=== Mandatory Classes ===

	; G4VUserDetectorConstruction : Describe the experimental setup, geometry and materials.		; G4VUserDetectorConstruction : Describe the experimental setup, geometry and materials.
Line 15:		Line 15:
	; G4VUserPrimaryGeneratorAction : Describe particle source, source dimensions, initial position, energy spectrum, angular distributions.		; G4VUserPrimaryGeneratorAction : Describe particle source, source dimensions, initial position, energy spectrum, angular distributions.

	=== Optional ~~classes:~~ ===		=== Optional Classes ===

	; G4UserRunAction : Define and store histograms.		; G4UserRunAction : Define and store histograms.
Line 23:		Line 23:
	; G4UserSteppingAction : Kill, suspend, postpone a track.		; G4UserSteppingAction : Kill, suspend, postpone a track.

	=== Manager ~~class~~ ===		=== Manager Class ===

	; G4RunManager : Manages processing the run.		; G4RunManager : Manages processing the run.
Line 167:		Line 167:
	; SetCuts() : Define production thresholds in terms of range.		; SetCuts() : Define production thresholds in terms of range.

	==== Simple example of class <code>MyPhysicsList</code>: ====		==== Simple example of class <code>MyPhysicsList</code> ====

	<pre>		<pre>
Line 185:		Line 185:
	</pre>		</pre>

	==== Implement <code>ConstructParticle()</code>, <code>ConstructProcess()</code> and <code>SetCuts()</code> methods: ====		==== Implement <code>ConstructParticle()</code>, <code>ConstructProcess()</code> and <code>SetCuts()</code> methods ====

	<pre>		<pre>
Line 294:		Line 294:
	In <code>G4VModularPhysicsList</code> you can group the physics processes into separate modules which are already pre-build physics list and later chose one of those modules.		In <code>G4VModularPhysicsList</code> you can group the physics processes into separate modules which are already pre-build physics list and later chose one of those modules.

	==== Simple example of class <code>MyPhysicsList</code>: ====		==== Simple example of class <code>MyPhysicsList</code> ====

	<pre>		<pre>
Line 325:		Line 325:
	</pre>		</pre>

	==== Now build the physics lists: ====		==== Now build the physics lists ====

	<pre>		<pre>

SimonJolly at 15:21, 30 March 2016

2016-03-30T15:21:21Z

← Older revision		Revision as of 15:21, 30 March 2016
Line 11:		Line 11:
	=== Mandatory classes: ===		=== Mandatory classes: ===

	* '''G4VUserDetectorConstruction~~'''~~: Describe the experimental setup, geometry and materials;		; G4VUserDetectorConstruction : Describe the experimental setup, geometry and materials.
	* '''G4VUserPhysicsList~~'''~~: Define particles, physics processes and range cuts;		; G4VUserPhysicsList : Define particles, physics processes and range cuts.
	* '''G4VUserPrimaryGeneratorAction~~'''~~: Describe particle source, source dimensions, initial position, energy spectrum, angular distributions.		; G4VUserPrimaryGeneratorAction : Describe particle source, source dimensions, initial position, energy spectrum, angular distributions.

	=== Optional classes: ===		=== Optional classes: ===

	* '''G4UserRunAction~~'''~~: Define and store histograms;		; G4UserRunAction : Define and store histograms.
	* '''G4UserEventAction~~'''~~: Event selection and analysis of simulation data;		; G4UserEventAction : Event selection and analysis of simulation data.
	* '''G4UserStackingAction~~'''~~: Customize priority of tracks;		; G4UserStackingAction : Customize priority of tracks.
	* '''G4UserTrackingAction~~'''~~: Decide whether a trajectory should be stored or not;		; G4UserTrackingAction : Decide whether a trajectory should be stored or not.
	* '''G4UserSteppingAction~~'''~~: Kill, suspend, postpone a track.		; G4UserSteppingAction : Kill, suspend, postpone a track.

	=== Manager class ===		=== Manager class ===

	* '''G4RunManager~~'''~~: Manages processing the run.		; G4RunManager : Manages processing the run.

	=== Useful terminology ===		=== Useful terminology ===

SimonJolly: Created page with "== 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 ph..."

2016-03-30T15:19:29Z

Created page with "== 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 ph..."

New page

== 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 <code>main()</code> ==

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

<pre>
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); ... }
</pre>

== Experimental setup ==

You derive your own class from the <code>G4VUserDetectorConstruction</code> base class.
In the derived class you will:

* Describe the shape and the size of your detector using <code>G4VSolid</code>;
* Construct materials and electromagnetic fields using <code>G4Logical Volume</code>;
* Place volumes of your detector geometry using <code>G4VPhysical Volume</code>;

=== Simple example of class <code>MyDetectorConstruction</code> ===

<pre>
class MyDetectorConstruction:public G4VUserDetectorConstruction {

public:

MyDetectorConstruction();

~MyDetectorConstruction();

virtual G4VPhysicalVolume* Construct();

private:

void DefineMaterials(); };
</pre>

=== Detector Construction ===

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

<pre>
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); ... }
</pre>

=== Define Elements and Materials ===

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

<pre>
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); ...}
</pre>

You can find more examples of DetectorConstruction classes [http://geant4.web.cern.ch/geant4/UserDocumentation/Doxygen/examples_doc/html/group__extended__common__detectorConstruction.html on the Geant4 website].

== 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: <code>G4VUserPhysicsList</code> and <code>G4ModularPhysicsList</code>.
The class <code>G4VUserPhysicsList</code> is used for simple physics lists while <code>G4ModularPhysicsList</code> is used to build more complex physics lists.
There also exist already built pre-packaged physics lists.

=== Simple physics lists ===

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

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

==== Simple example of class <code>MyPhysicsList</code>: ====

<pre>
class MyPhysicsList:public G4VUserPhysicsList() {

public:

MyPhysicsList();

~MyPhysicsList();

void ConstructParticle();

void ConstructProcess();

void SetCuts(); }
</pre>

==== Implement <code>ConstructParticle()</code>, <code>ConstructProcess()</code> and <code>SetCuts()</code> methods: ====

<pre>
void MyPhysicsList::ConstructParticle() {

// Define the particles

G4Electron::ElectronDefinition();

G4Positron::PositronDefinition();

G4Proton::ProtonDefinition();

G4Neutron::NeutronDefinition();

G4Gamma::GammaDefinition(); ... }
</pre>

==== Relevant physics processes ====

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 [http://geant4.cern.ch/support/proc_mod_catalog/processes/ on the Geant4 website].
For each particle in <code>ConstructParticle()</code> assign all the physics processes you want to consider in your simulation:

<pre>
void MyPhysicsList::ConstructProcess() {

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

ConstructEM(); // Electromagnetic processes

ConstructGeneral(); // Other processes }
</pre>

In methods <code>ConstructEM()</code> and <code>ConstructGeneral()</code> assign the physics processes to the corresponding particles:

<pre>
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>
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); }}}
</pre>

[http://geant4.cern.ch/support/proc_mod_catalog/particles/ This is the full list] of physics processes available for every particle.
Finally, in method <code>SetCuts()</code> you can define cuts on the particles:

<pre>
void MyPhysicsList::SetCuts() {

defaultCutValue = 1.0*mm;

SetCutValue(defaultCutValue, "gamma");

SetCutValue(defaultCutValue, "e+");

SetCutValue(defaultCutValue, "e-");
</pre>

See the [[Geant4/Tutorials/Advanced/Computed Tomography|Computed Tomography]] tutorial to learn more about simple physics lists.

=== Detailed Physics Lists ===

If you want to build more realistic physics list you have to use the class <code>G4VModularPhysicsList</code>.
In <code>G4VModularPhysicsList</code> you can group the physics processes into separate modules which are already pre-build physics list and later chose one of those modules.

==== Simple example of class <code>MyPhysicsList</code>: ====

<pre>
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; };
</pre>

==== Now build the physics lists: ====

<pre>
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());

} ... }
</pre>

and

<pre>
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 [[Software/Geant4/Tutorials/Basic/Monoenergetic Proton Pencil Beam|Monoenergetic Proton Pencil Beam]] tutorial to learn more about detailed physics lists.

=== Pre-Packaged Physics Lists ===

Some built-in pre-packaged physics lists [http://geant4.web.cern.ch/geant4/support/proc_mod_catalog/physics_lists/referencePL.shtml are available here].
You can use them as a starting point of your simulation.
Here is a simple example of a ''pre-packaged physics list''.
In function <code>main()</code>:

<pre>
G4PhysListFactory factory* physListFactory = new G4PhysListFactory();

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

runManager->SetUserInitialization(physicsList);
</pre>

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

== Generate Primary Particles ==

You derive your own class from the <code>G4VUserPrimaryGeneratorAction</code> base class.
The actual generation of primary particles is done via the classes <code>G4ParticleGun</code> and <code>G4GeneralParticleSource</code>.

; G4ParticleGun : 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 the surface of a given volume with pre-defined energy spectra, spatial and angular distribution.

'''Simple example of class <code>MyPrimaryGeneratorAction</code> using particle gun''':

<pre>
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; };
</pre>

'''Simple example of class <code>MyPrimaryGeneratorAction</code> using general particle source''':

<pre>
class MyPrimaryGeneratorAction:public G4VUserPrimaryGeneratorAction {

public:

MyPrimaryGeneratorAction();

~MyPrimaryGeneratorAction();

virtual void GeneratePrimaries(G4Event*);

private:

static const G4String ParticleName;

static const G4double ParticleEnergy;

G4GeneralParticleSource* fGeneralParticleSource; };
</pre>

Instructions on how to implement the <code>MyPrimaryGeneratorAction</code> class in your code can be found [http://geant4.web.cern.ch/geant4/UserDocumentation/Doxygen/examples_doc/html/group__extended__common__primaryGenerator.html on the Geant4 website].

The [[Software/Geant4/Tutorials/Basic/Monoenergetic Photon Pencil Beam|Monoenergetic Photon Pencil Beam]] example uses the <code>G4ParticleGun</code> class.
The [[Software/Geant4/Tutorials/Basic/Proton Beam With Realistic Geometry|Proton Beam With Realistic Geometry]] tutorial uses <code>G4GeneralParticleSource</code>.

== Optional User Classes ==

=== Run ===

You can derive your own class from the <code>G4UserRunAction</code> 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 the class <code>G4Run</code>.

You can find examples of user defined RunAction classes [http://geant4.web.cern.ch/geant4/UserDocumentation/Doxygen/examples_doc/html/group__extended__common__userActions.html on the Geant4 website].

=== 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 the <code>G4Event</code> class which gives hits and trajectory collections as output.

You can derive your own class from the <code>G4UserEventAction</code> base class where you can select and analyse data.
Examples of user defined <code>EventAction</code> classes [http://geant4.web.cern.ch/geant4/UserDocumentation/Doxygen/examples_doc/html/group__extended__common__userActions.html can be found on the Geant4 website].

=== Track ===

'''Track''' is a snapshot of a particle and it is represented by the <code>G4Track</code> 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 <code>G4UserSteppingAction</code> class (see below).
At the end of each step the state of a track can be changed (killed, suspended, postponed).

=== Step ===

'''Step''' is defined by two points: it also contains information about the particle e.g. energy loss on the step.
A step is represented by the <code>G4Step</code> and <code>G4StepPoint</code> classes.
<code>G4UserSteppingAction</code> is an optional class where you can kill, suspend, postpone a track.

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

<pre>
G4StepPoint* prePoint = step->GetPreStepPoint();

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

=== Trajectory ===

Trajectories are represented by the classes <code>G4Trajectory</code> and <code>G4TrajectoryPoint</code>.
The <code>G4Trajectory</code> class copies some of the <code>G4Track</code> class information.
<code>G4TrajectoryPoint</code> is the class which copies some of the <code>G4Step</code> information.

Software/Geant4/Introduction - Revision history

SimonJolly at 15:23, 30 March 2016

SimonJolly at 15:21, 30 March 2016

SimonJolly: Created page with "== 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 ph..."