UFRO Master Fisica Medica 5 3 Geant4

5.
Tcnicas de Simulacin
3. Geant4
Dr. Willy H. Gerber
Instituto de Fisica
Universidad Austral
Valdivia, Chile
Objetiv
os:
Comprender como se estructuran

programas que simulan procesos
basados en Geant4.
1
www.gphysics.net UFRO-Master-Fisica-Medica-5-3-Geant4-05.09
Estructura de archivos
Demo
Include
ExDetectorConstruction.hh
ExPhysicsList.hh
ExPrimaryGeneratorActi
src on.hh
ExDetectorConstruction.cc
ExPhysicsList.cc
ExPrimaryGeneratorActi
on.cc
MainDemo.cc
2
Programas Geant4
Includes
necesarios
int main(int argc,char** argv)
{
Setear
runManager
Definir
Output
Ejecutar
Proceso
delete visManager;
delete runManager;
return 0;
}
Estructuras a incluir
#include
#include
#include
#include
"G4RunManager.hh"
"G4UImanager.hh"
"G4UIterminal.hh"
"G4VisExecutive.hh"
#include "ExDetectorConstruction.hh"
#include "ExPhysicsList.hh"
#include "ExPrimaryGeneratorAction.hh
#include ExRunAction.hh"
#include ExEventAction.hh"
#include ExSteppingAction.hh"
#include G4templates.hh"
4
Inicializacin runManager - Clases
Construction del runManager

G4RunManager* runManager = new G4RunManager;
Clases obligatorias de inicializacin

runManager->SetUserInitialization(new ExDetectorConstruction);
runManager->SetUserInitialization(new ExPhysicsList);
Clases obligatorias respecto de acciones

runManager->SetUserAction(new
ExPrimaryGeneratorAction);
ExRunAction);
ExEventAction);
ExSteppingAction);
5
Inicializacion runManager
Inicializacion del
Display
G4UImanager* UI = G4UImanager::GetUIpointer();
UI->ApplyCommand("/run/verbose 1");
UI->ApplyCommand("/event/verbose 1");
UI->ApplyCommand("/tracking/verbose 1");
Inicializacion
G4VisManager* visManager = new G4VisExecutive;
visManager->Initialize();
Inicializacion el
sistema
runManager->Initialize();
6
Ejecutar
Ejecucin
int numberOfEvent = 3;
runManager->BeamOn(numberOfEvent);
if(argc==1)
// Define (G)UI terminal for interactive mode
{
G4UIsession * session = new G4UIterminal;
UI->ApplyCommand("/control/execute prerun.g4mac");
session->sessionStart();
delete session;
} else
// Batch mode
{
G4String command = "/control/execute ";
G4String fileName = argv[1];
UI->ApplyCommand(command+fileName);
}
7
Includes y Subrutinas
Includes y
Subrutinas
ExDetectorConstruction - demo
ExDetectorConstruc
tion
ExDetectorConstruction
Lgica de la rutina con solo 2 elementos
Crear caja (volumen World)
Crear cilindro
Crear volumen lgico para caja
Crear volumen lgico para cilindro
Posicionar cilindro
Posicionar caja
Crear caja clase G4Box (volumen World)
G4double expHall_x = 3.0*m;
G4double expHall_y = 1.0*m;
G4double expHall_z = 1.0*m;
G4Box* experimentalHall_box = new G4Box("expHall_box",expHall_x,expHall_y,exp
Crear cilindro clase G4Tubs

G4double
G4double
G4double
G4double
G4double
innerRadiusOfTheTube = 0.*cm;
outerRadiusOfTheTube = 60.*cm;
hightOfTheTube = 25.*cm;
startAngleOfTheTube = 0.*deg;
spanningAngleOfTheTube = 360.*deg;
G4Tubs* tracker_tube = new G4Tubs("tracker_tube", innerRadiusOfTheTube,

outerRadiusOfTheTube, hightOfTheTube,
startAngleOfTheTube, spanningAngleOfTh
Crear volumen lgico para caja clase G4LogicalVolume
G4LogicalVolume* experimentalHall_log =
new G4LogicalVolume(experimentalHall_box,Ar,"expHall_log");
Crear volumen lgico para cilindro clase G4LogicalVolume

G4LogicalVolume* tracker_log =
new G4LogicalVolume(tracker_tube,Al,"tracker_log");
Posicionar cilindroc
G4double trackerPos_x = -1.0*meter;
G4double trackerPos_y = 0.0*meter;
G4double trackerPos_z = 0.0*meter;
G4VPhysicalVolume* tracker_phys = new G4PVPlacement(0, // no rotation

G4ThreeVector(trackerPos_x,trackerPos_y,trackerPos_z), // tran
tracker_log, // its logical volume
"tracker", // its name experimentalHall_log, // its mother (logic
volume false, // no boolean
operations 0); // its copy number
Posicionar caja clase
G4LogicalVolume
G4VPhysicalVolume* experimentalHall_phys = new G4PVPlacement(0, // no rotati

G4ThreeVector(0.,0.,0.), // translation position
experimentalHall_log, // its logical volume
"expHall", // its name
0, // its mother volume
false, // no boolean
operations 0); // its copy number
Material (directo)
G4double density = 1.390*g/cm3;
G4double a = 39.95*g/mole;
G4Material* lAr = new G4Material(name="liquidArgon", z=18., a, density);
G4LogicalVolume* myLbox = new G4LogicalVolume(aBox,lAr,"Lbox",0,0,0);
Elementos
a = 1.01*g/mole;
G4Element* elH = new G4Element(name="Hydrogen",symbol="H" , z= 1., a);
a = 16.00*g/mole;
G4Element* elO = new G4Element(name="Oxygen" ,symbol="O" , z= 8., a);
density = 1.000*g/cm3;
Material (compuesto desde elementos, por numero de elementos)

G4Material* H2O = new
G4Material(name="Water",density,ncomponents=2);
H2O->AddElement(elH, natoms=2);
H2O->AddElement(elO, natoms=1);
Elementos
a = 14.01*g/mole;
G4Element* elN = new G4Element(name="Nitrogen",symbol="N" , z= 7., a);
a = 16.00*g/mole;
G4Element* elO = new G4Element(name="Oxygen" ,symbol="O" , z= 8., a);
Material (compuesto desde elementos, por fraccin de tomos)

density = 1.290*mg/cm3;
G4Material* Air = new G4Material(name="Air
",density,ncomponents=2);
Air->AddElement(elN, fractionmass=70*perCent);
Air->AddElement(elO, fractionmass=30*perCent);
ExDetectorConstruction.hh primer parte
class G4LogicalVolume;
class G4VPhysicalVolume;
#include
"G4VUserDetectorConstruction.hh"
class ExDetectorConstruction : public
G4VUserDetectorConstruction
{
public:
ExDetectorConstruction();
~ExDetectorConstruction();
G4VPhysicalVolume* Construct();
ExDetectorConstruction.hh segunda parte
private:
// Logical volumes
//
G4LogicalVolume*
G4LogicalVolume*
G4LogicalVolume*
G4LogicalVolume*
experimentalHall_log;
tracker_log;
calorimeterBlock_log;
calorimeterLayer_log;
// Physical volumes
//
G4VPhysicalVolume*
experimentalHall_phys;
G4VPhysicalVolume*
calorimeterLayer_phys;
G4VPhysicalVolume*
calorimeterBlock_phys;
G4VPhysicalVolume* tracker_phys;
};
ExDetectorConstruction.cc primera parte

#include "ExDetectorConstruction.hh"
#include
#include
#include
#include
#include
#include
#include
"G4Material.hh"
"G4Box.hh"
"G4Tubs.hh"
"G4LogicalVolume.hh"
"G4ThreeVector.hh"
"G4PVPlacement.hh"
"globals.hh"
ExDetectorConstruction::ExDetectorConstruction
()
: experimentalHall_log(0), tracker_log(0),
calorimeterBlock_log(0),
calorimeterLayer_log(0),
experimentalHall_phys(0),
calorimeterLayer_phys(0),
calorimeterBlock_phys(0), tracker_phys(0)
{;}
ExDetectorConstruction::~ExDetectorConstructi
on()
{
ExDetectorConstruction.cc segunda parte
G4VPhysicalVolume* ExN01DetectorConstruction::Construct()
{
//------------------------------------------------------ materials
G4double a; // atomic mass
G4double z; // atomic number
G4double density;
G4Material* Ar = new G4Material("ArgonGas", z= 18., a= 39.95*g/mole, density=
1.782*mg/cm3);
G4Material* Al = new G4Material("Aluminum", z= 13., a= 26.98*g/mole, density=
2.7*g/cm3);
G4Material* Pb = new G4Material("Lead", z= 82., a= 207.19*g/mole, density=
11.35*g/cm3);
ExDetectorConstruction.cc tercera parte
//------------------------------------------------------ volumes
//------------------------------ experimental hall (world volume)
//------------------------------ beam line along x axis
G4double expHall_x = 3.0*m;
G4double expHall_y = 1.0*m;
G4double expHall_z = 1.0*m;
G4Box* experimentalHall_box = new
G4Box("expHall_box",expHall_x,expHall_y,expHall_z);
experimentalHall_log = new G4LogicalVolume(experimentalHall_box,
Ar,"expHall_log",0,0,0);
experimentalHall_phys = new G4PVPlacement(0,G4ThreeVector(),
experimentalHall_log,"expHall",0,false,0);
ExDetectorConstruction.cc cuarta parte

//------------------------------ a tracker tube
G4double
G4double
G4double
G4double
G4double
innerRadiusOfTheTube = 0.*cm;
outerRadiusOfTheTube = 60.*cm;
hightOfTheTube = 50.*cm;
startAngleOfTheTube = 0.*deg;
spanningAngleOfTheTube = 360.*deg;
G4Tubs* tracker_tube = new G4Tubs("tracker_tube",innerRadiusOfTheTube,

outerRadiusOfTheTube,hightOfTheTube,
startAngleOfTheTube,spanningAngleOfTheTube);
tracker_log = new G4LogicalVolume(tracker_tube,Al,"tracker_log",0,0,0);
G4double trackerPos_x = -1.0*m;
G4double trackerPos_y = 0.*m;
G4double trackerPos_z = 0.*m;
tracker_phys = new G4PVPlacement(0,
G4ThreeVector(trackerPos_x,trackerPos_y,trackerPos_z),
ExDetectorConstruction.cc quinta parte
//------------------------------ a calorimeter block

G4double block_x = 1.0*m;
G4double block_y = 50.0*cm;
G4double block_z = 50.0*cm;
G4Box* calorimeterBlock_box = new G4Box("calBlock_box",block_x,
block_y,block_z);
calorimeterBlock_log = new G4LogicalVolume(calorimeterBlock_box,
Pb,"caloBlock_log",0,0,0);
G4double blockPos_x = 1.0*m;
G4double blockPos_y = 0.0*m;
G4double blockPos_z = 0.0*m;
calorimeterBlock_phys = new G4PVPlacement(0,
G4ThreeVector(blockPos_x,blockPos_y,blockPos_z),
calorimeterBlock_log,"caloBlock",
ExDetectorConstruction.cc sesta parte

//------------------------------ calorimeter layers (20 elements)
G4double calo_x = 1.*cm;
G4double calo_y = 40.*cm;
G4double calo_z = 40.*cm;
G4Box* calorimeterLayer_box = new G4Box("caloLayer_box,
calo_x,calo_y,calo_z);
calorimeterLayer_log = new G4LogicalVolume(calorimeterLayer_box,
Al,"caloLayer_log",0,0,0);
for(G4int i=0;i<19;i++) // loop for 19 layers
{
G4double caloPos_x = (i-9)*10.*cm;
G4double caloPos_y = 0.0*m;
G4double caloPos_z = 0.0*m;
calorimeterLayer_phys = new G4PVPlacement(0,
G4ThreeVector(caloPos_x,caloPos_y,caloPos_z),
calorimeterLayer_log,"caloLayer",calorimeterBlock_log,false,i);
}
//-----------------------------------------------------------------return experimentalHall_phys;
ExPhysicsList
ExPhysicsLi
st
Definicin de partculas
G4String
G4double
G4double
G4double
G4double
G4double
G4int
G4int
G4double
G4double
G4int
G4String
G4String
G4int
G4int
G4int
G4int
GetParticleName()
particle name
GetPDGMass()
mass
GetPDGWidth()
decay width
GetPDGCharge()
electric charge
GetPDGSpin()
spin
GetPDGMagneticMoment()
magnetic moment (a)
GetPDGiParity()
parity (b)
GetPDGiConjugation() charge conjugation (b)
GetPDGIsospin()
iso-spin
GetPDGIsospin3()
3rd-component of iso-spin
GetPDGiGParity()
G-parity (0:not defined)
GetParticleType()
particle type
GetParticleSubType()
particle sub-type
GetLeptonNumber()
lepton number
GetBaryonNumber()
baryon number
GetPDGEncoding()
particle encoding number by PDG
GetAntiPDGEncoding() encoding for anti-particle of this particle
a: 0: not defined or no mag. Moment

b: 0:not defined
Definicin de partculas
G4bool
G4double
G4DecayTa
ble
GetPDGStable(
)
GetPDGLifeTim
e()
*GetDecayTabl
e()
stable
flag
life time
decay
table
Variables dinmicas
G4double
theDynamicalMass
dynamical mass
G4ThreeVector
theMomentumDirection
normalized momentum vector
G4ParticleDefinition
*theParticleDefinition definition of particle
G4double
theDynamicalSpin
dynamical spin (1)
G4ThreeVector
thePolarization
polarization vector
G4double
theMagneticMoment dynamical magnetic moment (2)
G4double
theKineticEnergy
kinetic energy
G4double
theProperTime
proper time
G4double
theDynamicalCharge dynamical electric charge (3)
G4ElectronOccupancy
*theElectronOccupancy
electron orbits for ions
1. i.e. total angular momentum as a ion/atom

2. i.e. total magnetic moment as a ion/atom
3. i.e. total electric charge as a ion/atom
ExPhysicsList - demo
ExPhysicsList.hh
protected:
// Construct particle and physics
void ConstructParticle();
void ConstructProcess();
void SetCuts();
// these methods Construct particles
void ConstructBosons();
void ConstructLeptons();
void ConstructMesons();
void ConstructBaryons();
protected:
// these methods Construct physics processes and
register them
void ConstructGeneral();
void ConstructEM();
void AddStepMax();
ExPhysicsList.cc
#include "G4ProcessManager.hh"
#include "G4ParticleTypes.hh"
void ExPhysicsList::ConstructParticle()
{
G4Proton::ProtonDefinition();
ConstructBosons();
ConstructLeptons();
ConstructMesons();
ConstructBaryons();
G4Geantino::GeantinoDefinition();
}
void ExPhysicsList::ConstructBosons()
{
G4Geantino::GeantinoDefinition(); // pseudoparticles
G4ChargedGeantino::ChargedGeantinoDefinition();
G4Gamma::GammaDefinition();
// gamma
void ExPhysicsList::ConstructLeptons()
{
G4Electron::ElectronDefinition(); // eG4Positron::PositronDefinition(); // e+
Construir todos de una vez:
G4MuonPlus::MuonPlusDefinition(); // mu+
G4LeptonConstructor pConstructo
G4MuonMinus::MuonMinusDefinition(); // mupConstructor.ConstructParticle();
G4NeutrinoE::NeutrinoEDefinition(); // nu_e
G4AntiNeutrinoE::AntiNeutrinoEDefinition(); // nu_e
G4NeutrinoMu::NeutrinoMuDefinition(); // nu_mu
G4AntiNeutrinoMu::AntiNeutrinoMuDefinition(); // nu_mu
}
void ExPhysicsList::ConstructBaryons()
{
G4Proton::ProtonDefinition();
G4AntiProton::AntiProtonDefinition();
G4Neutron::NeutronDefinition();
G4AntiNeutron::AntiNeutronDefinition();
}
void ExPhysicsList::ConstructMesons()
{
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4PionZero::PionZeroDefinition();
G4Eta::EtaDefinition();
G4EtaPrime::EtaPrimeDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
G4KaonZero::KaonZeroDefinition();
G4AntiKaonZero::AntiKaonZeroDefinition();
G4KaonZeroLong::KaonZeroLongDefinition();
G4KaonZeroShort::KaonZeroShortDefinition();
}
void ExPhysicsList::ConstructProcess()
{
AddTransportation();
ConstructEM();
ConstructGeneral();
AddStepMax();
}
#include "G4ComptonScattering.hh"
#include "G4GammaConversion.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4eMultipleScattering.hh"
#include "G4hMultipleScattering.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
#include "G4eplusAnnihilation.hh"
#include "G4MuIonisation.hh"
#include "G4MuBremsstrahlung.hh"
#include "G4MuPairProduction.hh"
#include "G4hIonisation.hh"
#include "G4hBremsstrahlung.hh"
#include "G4hPairProduction.hh"
#include "G4ionIonisation.hh"
void ExN02PhysicsList::ConstructEM()
{
theParticleIterator->reset();
while( (*theParticleIterator)() ){
G4ParticleDefinition* particle = theParticleIterator->value();
G4ProcessManager* pmanager = particle->GetProcessManager();
G4String particleName = particle->GetParticleName();
if (particleName == "gamma") {
// gamma
pmanager->AddDiscreteProcess(new G4PhotoElectricEffect);
pmanager->AddDiscreteProcess(new G4ComptonScattering);
pmanager->AddDiscreteProcess(new G4GammaConversion);
} else if (particleName == "e-") {
//electron
pmanager->AddProcess(new G4eMultipleScattering, -1, 1, 1);
pmanager->AddProcess(new G4eIonisation,
-1, 2, 2);
pmanager->AddProcess(new G4eBremsstrahlung,
-1, 3, 3);
} else if (particleName == "e+") {
//positron
pmanager->AddProcess(new G4eMultipleScattering, -1, 1, 1);
pmanager->AddProcess(new G4eIonisation,
-1, 2, 2);
pmanager->AddProcess(new G4eBremsstrahlung,
-1, 3, 3);
pmanager->AddProcess(new G4eplusAnnihilation, 0,-1, 4);
} else if( particleName == "mu+" || particleName == "mu-" ) {
pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
pmanager->AddProcess(new G4MuIonisation,
-1, 2, 2);
pmanager->AddProcess(new G4MuBremsstrahlung, -1, 3, 3);
pmanager->AddProcess(new G4MuPairProduction, -1, 4, 4);
//muon
} else if( particleName == "proton" || particleName == "pi-" || particleName ==

"pi+" ) { //proton
pmanager->AddProcess(new G4hIonisation,
-1, 2, 2);
pmanager->AddProcess(new G4hBremsstrahlung,
-1, 3, 3);
pmanager->AddProcess(new G4hPairProduction,
-1, 4, 4);
} else if( particleName == "alpha" || particleName == "He3" || particleName ==
"GenericIon" ) {//Ions
pmanager->AddProcess(new G4ionIonisation,
-1, 2, 2);
} else if ((!particle->IsShortLived()) && (particle->GetPDGCharge() != 0.0) &&
(particle->GetParticleName() != "chargedgeantino")) { //all others charged
particles except geantino
pmanager->AddProcess(new G4hIonisation,
-1, 2, 2);
}
#include "G4Decay.hh"
void ExN02PhysicsList::ConstructGeneral()
{
// Add Decay Process
G4Decay* theDecayProcess = new G4Decay();
while( (*theParticleIterator)() ){
G4ParticleDefinition* particle = theParticleIterator>value();
G4ProcessManager* pmanager = particle>GetProcessManager();
if (theDecayProcess->IsApplicable(*particle)) {
pmanager ->AddProcess(theDecayProcess);
// set ordering for PostStepDoIt and AtRestDoIt
pmanager ->SetProcessOrdering(theDecayProcess,
idxPostStep);
pmanager ->SetProcessOrdering(theDecayProcess,
idxAtRest);
}
}
}
#include "G4StepLimiter.hh"
#include "G4UserSpecialCuts.hh"
void ExPhysicsList::AddStepMax()
{
// Step limitation seen as a process
G4StepLimiter* stepLimiter = new G4StepLimiter();
////G4UserSpecialCuts* userCuts = new G4UserSpecialCuts();
while ((*theParticleIterator)())
{
G4ParticleDefinition* particle = theParticleIterator>value();
G4ProcessManager* pmanager = particle>GetProcessManager();
if (particle->GetPDGCharge() != 0.0)
{
pmanager ->AddDiscreteProcess(stepLimiter);
////pmanager ->AddDiscreteProcess(userCuts);
}
}
ExPhysicsList::ExPhysicsList(): G4VUserPhysicsList()
{ // default cut
value (1.0mm) defaultCutValue = 1.0*mm;
}
void ExPhysicsList::SetCuts()
{
// the default cut value for all particle types
SetCutsWithDefault();
// specific cut values
SetCutValue(cutForGamma, "gamma");
SetCutValue(cutForElectron, "e-");
SetCutValue(cutForElectron, "e+");
if (verboseLevel>0) DumpCutValuesTable();
}
ExPhysicsList.hh
#include "G4VUserPhysicsList.hh"
#include "globals.hh"
class ExPhysicsList: public
G4VUserPhysicsList
{
public:
ExPhysicsList();
~ExPhysicsList();
protected:
// Construct particle and physics process
void ConstructParticle();
void ConstructProcess();
void SetCuts();
};
ExPhysicsList.cc primera parte

#include "G4ParticleTypes.hh"
ExPhysicsList::ExPhysicsList()
{;}
ExPhysicsList::~ExPhysicsList()
{;}
void ExPhysicsList::ConstructParticle()
{
// In this method, static member functions should be called
// for all particles which you want to use.
// This ensures that objects of these particle types will be
// created in the program.
G4Geantino::GeantinoDefinition();
}
ExPhysicsList.cc segunda parte

void ExPhysicsList::ConstructProcess()
{
// Define transportation process
AddTransportation();
}
void ExPhysicsList::SetCuts()
{
// uppress error messages even in case e/gamma/proton do
not exist
G4int temp = GetVerboseLevel();
SetVerboseLevel(0);
// " G4VUserPhysicsList::SetCutsWithDefault" method sets
// the default cut value for all particle types
SetCutsWithDefault();
// Retrieve verbose level
SetVerboseLevel(temp);
}
ExPrimaryGeneratorAction
ExPrimaryGeneratorActio
n
ExPrimaryGeneratorAction - demo
Definicin de partcula disparadas
G4int n_particle = 1;
particleGun = new G4ParticleGun(n_particle);
particleGun>SetParticleDefinition(G4Geantino::GeantinoDefinition());
particleGun->SetParticleEnergy(1.0*GeV);
particleGun->SetParticlePosition(G4ThreeVector(2.0*m,0.0*m,0.0*m));
Seteos posibles
void
SetParticleDefinition(G4ParticleDefinition*)
void
SetParticleMomentum(G4ParticleMomentum)
void
SetParticleMomentumDirection(G4ThreeVect
or)
void SetParticleEnergy(G4double)
void SetParticleTime(G4double)
void SetParticlePosition(G4ThreeVector)
ExPrimaryGeneratorAction.hh
#include "G4VUserPrimaryGeneratorAction.hh"
class G4ParticleGun;
class G4Event;
class ExPrimaryGeneratorAction : public
G4VUserPrimaryGeneratorAction
{
public:
ExPrimaryGeneratorAction();
~ExPrimaryGeneratorAction();
public:
void GeneratePrimaries(G4Event* anEvent);
private:
G4ParticleGun* particleGun;
};
ExPrimaryGeneratorAction.cc primera parte

#include "ExPrimaryGeneratorAction.hh"
#include
#include
#include
#include
#include
"G4Event.hh"
"G4ParticleGun.hh"
"G4ParticleTable.hh"
"G4ParticleDefinition.hh"
"globals.hh"
ExPrimaryGeneratorAction::ExPrimaryGeneratorAction()
{
G4int n_particle = 1;
particleGun = new G4ParticleGun(n_particle);
G4ParticleTable* particleTable = G4ParticleTable::GetParticleTable();
G4ParticleDefinition* particle = particleTable->FindParticle("proton");
G4String particleName;
// find in particle table
particleGun->SetParticleDefinition(particleTable>FindParticle(particleName="geantino"));
// use defined particle
particleGun->SetParticleDefinition(particle);
particleGun->SetParticleEnergy(1.0*GeV);
particleGun->SetParticlePosition(G4ThreeVector(-2.0*m,
0.0, 0.0));
ExPrimaryGeneratorAction.cc segunda parte

ExPrimaryGeneratorAction::~ExN01PrimaryGeneratorAction()
{
delete particleGun;
}
void ExPrimaryGeneratorAction::GeneratePrimaries(G4Event* anEvent)
{
G4int i = anEvent->get_eventID() % 3;
switch(i)
{
case 0: particleGun>SetParticleMomentumDirection(G4ThreeVector(1.0,0.0,0.0));
break;
break;
break;
}
particleGun->generatePrimaryVertex(anEvent);
}

UFRO Master Fisica Medica 5 3 Geant4

Diunggah oleh

Informasi Dokumen

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

UFRO Master Fisica Medica 5 3 Geant4

Diunggah oleh

Hak Cipta:

Format Tersedia

5.

Comprender como se estructuran

Inicializacin runManager - Clases

Construction del runManager

Clases obligatorias de inicializacin

Clases obligatorias respecto de acciones

G4Box* experimentalHall_box = new G4Box("expHall_box",expHall_x,expHall_y,exp

Crear cilindro clase G4Tubs

G4Tubs* tracker_tube = new G4Tubs("tracker_tube", innerRadiusOfTheTube,

Crear volumen lgico para cilindro clase G4LogicalVolume

G4VPhysicalVolume* tracker_phys = new G4PVPlacement(0, // no rotation

G4VPhysicalVolume* experimentalHall_phys = new G4PVPlacement(0, // no rotati

Material (compuesto desde elementos, por numero de elementos)

Material (compuesto desde elementos, por fraccin de tomos)

ExDetectorConstruction.hh primer parte

ExDetectorConstruction.hh segunda parte

ExDetectorConstruction.cc primera parte

ExDetectorConstruction.cc segunda parte

ExDetectorConstruction.cc tercera parte

ExDetectorConstruction.cc cuarta parte

G4Tubs* tracker_tube = new G4Tubs("tracker_tube",innerRadiusOfTheTube,

ExDetectorConstruction.cc quinta parte

//------------------------------ a calorimeter block

ExDetectorConstruction.cc sesta parte

a: 0: not defined or no mag. Moment

1. i.e. total angular momentum as a ion/atom

} else if( particleName == "proton" || particleName == "pi-" || particleName ==

ExPhysicsList.cc primera parte

ExPhysicsList.cc segunda parte

ExPrimaryGeneratorAction.cc primera parte

ExPrimaryGeneratorAction.cc segunda parte

Anda mungkin juga menyukai