introduction to geant4
DESCRIPTION
February 2004, Geant4 v6.0p01. Introduction to Geant4. Makoto Asai (SLAC Computing Services) Geant4 Tutorial Course. Overview. Introduction Basic Structure How to use G4 Detector Modelling Interactions of particles with matter Interactive Capabilities G4-Applications – examples - PowerPoint PPT PresentationTRANSCRIPT
Introductionto
Geant4
Makoto Asai (SLAC Computing Services)
Geant4 Tutorial Course
February 2004, Geant4 v6.0p01
Overview
Introduction Basic Structure How to use G4 Detector Modelling Interactions of particles with matter Interactive Capabilities G4-Applications – examples How to learn more
Introduction to Geant4
Introduction
Example Event with Standard EM Processes Turned On
50 MeV e- entering LAr-Pb calorimeter
Processes used: bremsstrahlung ionization multiple scattering positron-annihilation pair production Compton scattering
Geant4 – Its history and future Dec ’94 - Project start Apr ’97 - First alpha release Jul ’98 - First beta release Dec ’98 - First Geant4 public release … Jun ’03 - Geant4 5.2 release Dec ’03 - Geant4 6.0 release
– Feb 12th, ’04 - Patch01 release Planned near future releases
– Mar 25th, ’04 - Geant4 6.1 release• A few more fixes + minor improvements in verbosity for easily pointing out any
potential problems with mass production
– Jun 25th, ’04 - Geant4 6.2 release– Dec 17th, ’04 - Geant4 7.0 release
We currently provide two to three public releases and bimonthly beta releases in between public releases every year.
What is Geant4?
Geant4 is the successor of GEANT3
Redesigned using an Object-Oriented environment
requirements from heavy ion physics, CP violation
physics, cosmic ray physics, astrophysics, space
science and medical applications.
In order to meet such requirements, a large degree
of functionality and flexibility are provided.
Flexibility of Geant4 Geant4 has many types of geometrical descriptions to
describe most complicated and realistic geometries
– CSG, BREP, Boolean
– STEP compliant
– XML interface
Everything is open to the user
– Choice of physics processes/models
– Choice of GUI/Visualization/persistency/histogramming
technologies
Unit system Internal unit system used in Geant4 is completely hidden not only
from user’s code but also from Geant4 source code implement.
Each hard-coded number must be multiplied by its proper unit.
radius = 10.0 * cm; kineticE = 1.0 * GeV;
To get a number, it must be divided by a proper unit.
G4cout << eDep / MeV << “ [MeV]” << G4endl;
Most of commonly used units are provided and user can add
his/her own units.
By this unit system, source code becomes more readable and
importing / exporting physical quantities becomes straightforward.
– For particular application, user can change the internal unit to
suitable alternative unit without affecting to the result.
Geant4 as a state machine Geant4 has six application states.
– G4State_PreInit• Material, Geometry, Particle and/or Physics
Process need to be initialized/defined
– G4State_Idle• Ready to start a run
– G4State_GeomClosed• Geometry is optimized and ready to process
an event
– G4State_EventProc• An event is processing
– G4State_Quit• (Normal) termination
– G4State_Abort• A fatal exception occurred and program is
aborting
PreInit
Idle
EventProc
GeomClosed
Quit
Abort
initialize
beamOnexit
Introduction to Geant4
Basic Structure
Introduction into Geant4
How to use Geant4
The main program
Geant4 does not provide the main().
In your main(), you have to
– Construct G4RunManager (or your derived class)
– Set user mandatory classes to RunManager
• G4VUserDetectorConstruction
• G4VUserPhysicsList
• G4VUserPrimaryGeneratorAction
You can define VisManager, (G)UI session,
optional user action classes, and/or your persistency
manager in your main().
User classes Initialization classes
– Invoked at the initialization• G4VUserDetectorConstruction• G4VUserPhysicsList
Action classes– Invoked during an event loop
• G4VUserPrimaryGeneratorAction• G4UserRunAction• G4UserEventAction• G4UserStackingAction• G4UserTrackingAction• G4UserSteppingAction
main()– Geant4 does not provide main(). Note : classes written in yellow are mandatory.
Generate primary event Derive your concrete class from
G4VUserPrimaryGeneratorAction abstract base class.
Pass a G4Event object to one or more primary generator concrete
class objects which generate primary vertices and primary
particles.
Geant4 provides several generators in addition to the
G4VPrimaryParticlegenerator base class.
– G4ParticleGun
– G4HEPEvtInterface, G4HepMCInterface
• Interface to /hepevt/ common block or HepMC class
– G4GeneralParticleSource
• Define radioactivity
G4ParticleGun
Concrete implementations of G4VPrimaryGenerator– A good example for experiment-specific primary
generator implementation It shoots one primary particle of a certain energy
from a certain point at a certain time to a certain direction.– Various set methods are available
– Intercoms commands are also available
G4VUserPrimaryGeneratorActionvoid T01PrimaryGeneratorAction:: GeneratePrimaries(G4Event* anEvent){ G4ParticleDefinition* particle; G4int i = (int)(5.*G4UniformRand()); switch(i) { case 0: particle = positron; break; ... } particleGun->SetParticleDefinition(particle); G4double pp = momentum+(G4UniformRand()-0.5)*sigmaMomentum; G4double mass = particle->GetPDGMass(); G4double Ekin = sqrt(pp*pp+mass*mass)-mass; particleGun->SetParticleEnergy(Ekin); G4double angle = (G4UniformRand()-0.5)*sigmaAngle; particleGun->SetParticleMomentumDirection (G4ThreeVector(sin(angle),0.,cos(angle))); particleGun->GeneratePrimaryVertex(anEvent);}
You can repeat this for generating more than one primary particles.
Event in Geant4 At beginning of processing, an event contains primary particles.
These primaries are pushed into a stack.
When the stack becomes empty, processing of an event is over.
G4EventManager class manages processing an event.
G4Event class represents an event. It has following objects at
the end of its processing.
– List of primary vertexes and particles (as input)
– Hits collections
– Trajectory collection (optional)
– Digits collections (optional)
Introduction to Geant4
Detector modelling
Describe your detector Derive your own concrete class from
G4VUserDetectorConstruction abstract base class. In the virtual method Construct(),
– Instantiate all necessary materials
– Instantiate volumes of your detector geometry
– Instantiate your sensitive detector classes and set them to the corresponding logical volumes
Optionally you can define – Regions for any part of your detector
– Visualization attributes (color, visibility, etc.) of your detector elements
Describe your detector Derive your own concrete class from G4VUserDetectorConstruction
abstract base class. Implementing the method Construct()
1) Construct all necessary materials2) Define shapes/solids required to describe the geometry3) Construct and place volumes of your detector geometry4) Instantiate sensitive detectors and set them to corresponding volumes
(optional)5) Associate magnetic field to detector (optional)6) Define visualization attributes for the detector elements (optional)7) Define regions (optional)
Set your construction class to G4RunManager Modularize it w.r.t. each detector component or sub-detector for
easier maintenance of your code
Definition of Materials Different kinds of materials can be described:
– isotopes <-> G4Isotope– elements <-> G4Element– molecules, compounds and mixtures <-> G4Material
Attributes associated to G4Material:– temperature, pressure, state, density
Single element materialdouble density = 1.390*g/cm3;double a = 39.95*g/mole;G4Material* lAr = new G4Material("liquidArgon",z=18.,a,density);
Prefer low-density material to vacuum
Material: molecule A Molecule is made of several elements (composition by number of
atoms)
a = 1.01*g/mole;G4Element* elH = new G4Element("Hydrogen",symbol="H",z=1.,a);a = 16.00*g/mole;G4Element* elO = new G4Element("Oxygen",symbol="O",z=8.,a);density = 1.000*g/cm3;G4Material* H2O = new G4Material("Water",density,ncomp=2);H2O->AddElement(elH, natoms=2);H2O->AddElement(elO, natoms=1);
Volume Three conceptual layers
– G4VSolid -- shape, size (abstract class. all solids in Geant4 derive from it)
– G4LogicalVolume -- daughter physical volumes,
material, sensitivity, user limits, etc.
– G4VPhysicalVolume -- position, rotation
Detector sensitivity should be described by the user in his/her concrete implementation of G4VSensitiveDetector and set to G4LogicalVolume.
Define detector geometry Basic strategy
G4VSolid* pBoxSolid = new G4Box(“aBoxSolid”, 1.*m, 2.*m, 3.*m);G4LogicalVolume* pBoxLog = new G4LogicalVolume( pBoxSolid, pBoxMaterial, “aBoxLog”, 0, 0, 0);
G4VPhysicalVolume* aBoxPhys = new G4PVPlacement( pRotation, G4ThreeVector(posX, posY, posZ), pBoxLog, “aBoxPhys”, pMotherLog, 0, copyNo);
A unique physical volume which represents the experimental area must exist and fully contains all other componentsThe world volume
Sensitive detector and Hit Each Logical Volume can have a pointer to a sensitive detector.
– Then this volume becomes sensitive.
Hit is a snapshot of the physical interaction of a track or an
accumulation of interactions of tracks in the sensitive region of your
detector.
A sensitive detector creates hit(s) using the information given in
G4Step object. The user has to provide his/her own implementation
of the detector response.
– UserSteppingAction class should NOT do this.
Hit objects, which are still the user’s class objects, are collected in a
G4Event object at the end of an event.
Digitizer module and digit Digit represents a detector output (e.g. ADC/TDC count,
trigger signal, etc.).
Digit is created with one or more hits and/or other digits by a
user's concrete implementation derived from
G4VDigitizerModule.
In contradiction to the sensitive detector which is accessed at
tracking time automatically, the digitize() method of each
G4VDigitizerModule must be explicitly invoked by the user’s
code (e.g. at EventAction).
Introduction to Geant4
Physics Processes
Select physics processes Geant4 does not have any default particles or processes.
– Even for the particle transportation, you have to define it explicitly.
Derive your own concrete class from G4VUserPhysicsList abstract base class.– Define all necessary particles
– Define all necessary processes and assign them to proper particles
– Define cut-off ranges applied to the world (and each region)
Geant4 provides lots of utility classes/methods and examples.– "Educated guess" physics lists for defining hadronic processes for
various use-cases.
Physics Lists (1)● This is where the user defines all the physics to be used in his simulation
● First step: derive a class (e.g. MyPhysicsList) from the G4VUserPhysicsList base class
● Next, implement the methods: ConstructParticle() - define all necessary particles ConstructProcess() - assign physics processes to each particle SetCuts() - set the range cuts for secondary production
● Register the physics list with the run manager in the main program runManager -> SetUserInitialization(new MyPhysicsList);
Physics List (ConstructParticle)
void MyPhysicsList::ConstructParticle() { G4Electron::ElectronDefinition(); G4Positron::PositronDefinition(); G4Gamma::GammaDefinition();
G4MuonPlus::MuonPlusDefinition(); G4MuonMinus::MuonMinusDefinition(); G4NeutrinoE::NeutrinoEDefinition(); G4AntiNeutrinoE::AntiNeutrinoEDefinition(); G4NeutrinoMu::NeutrinoMuDefinition(); G4AntiNeutrinoMu::AntiNeutrinoMuDefinition(); }
Physics List (SetCuts and ConstructProcess)
void MyPhysicsList::SetCuts() { defaultCutValue = 1.0*mm; SetCutsWithDefault(); }
void MyPhysicsList::ConstructProcess() { AddTransportation(); // Provided by Geant4 ConstructEM(); // Not provided by Geant4 ConstructDecay(); // “ “ “ “ }
Physics List (ConstructEM)
void MyPhysicsList::ConstructEM()
{
theParticleIterator -> Reset();
while( (*theParticleIterator)() ) {
G4ParticleDefinition* particle = theParticleIterator -> Value();
G4ProcessManager* pm = particle -> GetProcessManager();
G4String particleName = particle -> GetParticleName();
if (particleName == “gamma”) {
pm -> AddDiscreteProcess(new G4ComptonScattering);
pm -> AddDiscreteProcess(new G4GammaConversion);
Particles and Tracks (1)● What is a particle in Geant4?
a collection of all the information needed to propagate it through a material Geant4 arranges this information in layers, starting with:
Particle (ParticleDefinition) simply a definition, no information of energy, direction, … only one instance of each type
Dynamic Particle gives the particle its kinematic properties
Track places the dynamic particle in context snapshot of particle not a collection of steps
Particles and Tracks (2)
G4Track
G4DynamicParticle
G4ParticleDefinition PDG info: mass, charge, spin,
lifetime, decay table
E, p, polarization, time pre-assigned decays
Position, volume, track lengthTOF, ID of itself and mother
many public methods: GetPosition(), GetVolume(), GetMaterial(), many public methods: GetPosition(), GetVolume(), GetMaterial(), GetCreatorProcess(), GetMomentum(), GetParticleDefinition(), …GetCreatorProcess(), GetMomentum(), GetParticleDefinition(), …
Track in Geant4 Track is a snapshot of a particle.
– It has only position and physical quantities of current instance.
Step is a “delta” information to a track.
– Track is not a collection of steps. Track is deleted when
– it goes out of the world volume
– it disappears (e.g. decay)
– it goes down to zero kinetic energy and no “AtRest” additional process is required
– the user decides to kill it
No track object persists at the end of event.– For the record of track, use trajectory class objects.
G4TrackingManager manages processing a track, a track is represented by G4Track class.
Tracking (2)● The basic element of tracking is the Step● It consists of two points and the “delta” information of a particle
step length, energy loss during step, change in elapsed time, etc.● Each point knows which volume it is in
if step limited by boundary, end point is located on boundary, but it logically belongs to next volume
– Because one step knows materials of two volumes, boundary processes such
as transition radiation or refraction could be simulated.
G4SteppingManager class manages processing a step, a step is represented by
G4Step class.
Start of step point End of step point
How Geant4 runs (one step)
Stepping Manager
Physics Process
Particle Change
Step Track Logical Volume
Sensitive Detector
GetPhysicalInteractionLength
SelectShortest
DoIt Fill
Update
Update
IsSensitive
GenerateHits
Threshold for Secondary Production (1)
● A simulation must impose an energy cut below which secondaries are not produced
avoid infrared divergence save CPU time used to track low energy particles
● But, such a cut may cause imprecise stopping location and deposition of energy Particle dependence
range of 10 keV in Si is a 130 microns range of 10 keV e- in Si is about 1.5 microns
~100 times difference range of 100 keV in Si is a 130 microns range of 100 keV e- in Si is about 2.3 cm
~300 times differenece Inhomogeneous materials
Pb-scintillator sandwich: if cut OK for Pb, energy deposited in sensitive scintillator may be wrong
Threshold for Secondary Production (2)
● Solution: impose a cut in range Given a single range cut, Geant4 calculates for all
materials the corresponding energy at which production of secondaries stops
● During tracking: Particle loses energy by generation of secondaries
down to an energy corresponding to the range cut Then the particle is tracked down to zero energy using
continuous energy loss.
Energy cut vs. range cut 500 MeV/c proton in liq.Ar (4mm) / Pb (4mm)
sampling calorimeter
liq.Ar
Pb liq.Ar
Pb
•Geant3 (energy cut)•Ecut = 450 keV
•Geant4 (range cut)•Rcut = 1.5 mm•Corresponds to Ecut in liq.Ar = 450 keV, Ecut in Pb = 2 MeV
Run in Geant4 a run of Geant4 starts with “Beam On”.
Within a run, the user cannot change
– detector geometry
– settings of physics processes
a run is a collection of events sharing the same detector conditions.
beginning of a run: geometry optimized for navigation, cross-
section tables are calculated according to materials in the geometry
and the cut-off values defined.
G4RunManager class manages processing a run, a run is
represented by G4Run class or a user-defined class derived from
G4Run.
Optional user action classes All user action classes, methods of which are invoked during
“Beam On”, must be constructed in the user’s main() and must be set to the RunManager.
G4UserRunAction– G4Run* GenerateRun()
• Instantiate user-customized run object
– void BeginOfRunAction(const G4Run*)• Define histograms
– void EndOfRunAction(const G4Run*)• Store histograms
G4UserEventAction– void BeginOfEventAction(const G4Event*)
• Event selection• Define histograms
– void EndOfEventAction(const G4Event*)• Analyze the event
Optional user action classes G4UserTrackingAction
– void PreUserTrackingAction(const G4Track*)
• Decide trajectory should be stored or not
• Create user-defined trajectory
– void PostUserTrackingAction(const G4Track*)
G4UserSteppingAction
– void UserSteppingAction(const G4Step*)
• Kill / suspend / postpone the track
• Draw the step (for a track not to be stored as a trajectory)
Introduction into Geant4
Interactive Capabilities
Geant4 UI command A command consists of
– Command directory
– Command
– Parameter(s) A parameter can be a type of string, boolean, integer or
double.– Space is a delimiter.
– Use double-quotes (“”) for string-type parameter with space(s).
A parameter may be “omittable”. If it is the case, a default value will be taken if you omit the parameter.– Default value is either predefined default value or current
value according to its definition
/run/verbose 1
/vis/viewer/flush
Command submission Geant4 UI command can be issued by
– (G)UI interactive command submission– Macro file– Hard-coded implementation
• Slow but no need for the targeting class pointer• Should not be used inside an event loop
G4UImanager* UI = G4UImanager::GetUIpointer();UI->ApplyCommand("/run/verbose 1");
The availability of individual command, the ranges of parameters, the available candidates on individual command parameter vary according to the implementation of your application and may even vary dynamically during the execution of your job.
some commands are available only for limited Geant4 application state(s).– E.g. /run/beamOn is available only for Idle states.
Introduction to Geant4 Introduction to Geant4 VisualizationVisualization
Joseph PerlSLAC Computing Services
HepRep/WIRED
DAWN
OpenGL
Steps of Visualization Open a driver (instantiates scene handler and viewer), such as:
– /vis/open HepRepFile Iset camera parameters and drawing style, such as:
– /vis/viewer/reset– /vis/viewer/set/viewpointThetaPhi 70 20– /vis/viewer/set/style wireframe
Create an empty scene:– /vis/scene/create
Declare what 3D data should be added to the created scene:– /vis/scene/add/volume– /vis/scene/add/trajectories– /vis/scene/add/hits
Attach scene to sceneHandler:– /vis/sceneHandler/attach
Run simulation with appropriate options to store trajectory information:– /tracking/storeTrajectory 1– /run/beamOn 1
Execute the visualization (done automatically with each /run/beamOn) /vis/viewer/flush
If using an external viewer, such as for HepRepFile or DAWNFILE:– import the .heprep or .prim file into WIRED or DAWN, set camera parameters,
drawing style, etc., view the visualization
some applications
calorimetrycalorimetry
trackingtracking
Courtesy of D. Wright, BaBar
ATLAS
Courtesy of ATLAS Collaboration
-100 1000 200 300 400 5000
600
100
200
300
400
500
700
800
Calorimeter Signal [nA]
Events
/10 n
A
180 GeV μ180 GeV μ
HEC Testbeam: HEC Testbeam: Muon Response Muon Response ComparisonsComparisons
HEC Testbeam: HEC Testbeam: Muon Response Muon Response ComparisonsComparisons
Extensive comparisons with test beam data(see, for instance, CALOR-2002 conference)
Profile curves at 9.8 cm depth PLATO overestimate the dose at ~ 5% level
CT-simulation with a Rando phantomExperimental data obtained with TLD LiF dosimeter
CT images used to define the geometry:
a thorax slice from a Rando
anthropomorphic phantom
Comparison with commercial treatment planning systemsM. C. Lopes 1, L. Peralta 2, P. Rodrigues 2, A. Trindade 2
1 IPOFG-CROC Coimbra Oncological Regional Center - 2 LIP - Lisbon
Agreement better than 2% between GEANT4 and TLD dosimeters
81.0)(2 TMSndf52.0)4(2 GEANTndf
71.6)(2 PLATOndf
Geant4 users workshop Users workshops were held or are going to be held hosted by
several institutes for various user communities.– KEK - Dec.2000, Jul.2001, Mar.2002, Jul.2002, Mar.2003, Jul.2003
– SLAC - Feb.2002
– Spain (supported by INFN) - Jul.2002
– CERN - Nov.2002
– ESA - Jan.2003
– NASA/ESA/Vanderbilt - May.2004 (planned)
– Helsinki - Oct.2003
– GSI, May 2004 => GSI-Kurier