lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 9.2.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-09 15:58:43 +02:00
parent 96c8bcd0af
commit b79225fb37
7544 changed files with 245407 additions and 91099 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/advanced/hadrontherapy/src/EMElectronEEDL.cc
+1 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyElectronEEDL.cc; May 2005
// $Id: HadrontherapyElectronEEDL.cc; Last by G.A.P.Cirrone September 2008
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
examples/advanced/hadrontherapy/src/EMElectronStandard.cc
+8 -8
View File
@@ -23,6 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: EMElectronStandard.cc; Last by G.A.P.Cirrone September 2008
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
@@ -35,6 +37,9 @@
// (b) National Institute for Nuclear Physics Section of Genova, genova, Italy
//
// * cirrone@lns.infn.it
//
// This class manages the electromagnetic processes for electrons
// using the Standard Models of Geant4
// --------------------------------------------------------------
#include "EMElectronStandard.hh"
@@ -44,7 +49,6 @@
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
#include "G4StepLimiter.hh"
#include "G4EmProcessOptions.hh"
EMElectronStandard::EMElectronStandard(const G4String& name):
@@ -70,20 +74,16 @@ void EMElectronStandard::ConstructProcess()
// *** Electron ***
// ****************
G4EmProcessOptions* electronEmProcessOptions = new G4EmProcessOptions();
electronEmProcessOptions -> SetDEDXBinning(480);
G4MultipleScattering* electronMultipScatProcess = new G4MultipleScattering();
G4eIonisation* electronIonisationProcess = new G4eIonisation();
G4eBremsstrahlung* electronBremsstrProcess = new G4eBremsstrahlung();
G4StepLimiter* electronStepLimiter = new G4StepLimiter();
G4ParticleDefinition* particle = G4Electron::Electron();
G4ProcessManager* processManager = particle -> GetProcessManager();
processManager -> AddProcess(electronMultipScatProcess, -1, 1, 1);
processManager -> AddProcess(electronIonisationProcess, -1, 2, 2);
processManager -> AddProcess(electronBremsstrProcess, -1, -1, 3);
processManager -> AddProcess(electronStepLimiter, -1, -1, 3);
processManager -> AddProcess(electronBremsstrProcess, -1, 3, 3);
}
examples/advanced/hadrontherapy/src/EMHadronIonLowEICRU49.cc
+18 -11
View File
@@ -23,21 +23,27 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyIonLowE.cc; May 2005
// $Id: EMHadronIonLowEICRU49.cc;
// Last modified: A.Lechner (anton.lechner@cern.ch), August 2008;
//
// See more at: http://geant4infn.wikispaces.com
//
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
// Code developed by:
//
// G.A.P. Cirrone(a)*, G. Candiano, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
//
// (a) Laboratori Nazionali del Sud
// of the National Institute for Nuclear Physics, Catania, Italy
// (b) National Institute for Nuclear Physics Section of Genova, genova, Italy
// of the INFN, Catania, Italy
// (b) INFN Section of Genova, Genova, Italy
//
// * cirrone@lns.infn.it
// --------------------------------------------------------------
// ----------------------------------------------------------------------------
#include "G4SDManager.hh"
#include "EMHadronIonLowEICRU49.hh"
#include "G4ProcessManager.hh"
#include "G4ParticleDefinition.hh"
@@ -72,12 +78,6 @@ void EMHadronIonLowEICRU49::ConstructProcess()
// *** Charged Hadrons and Ions ***
// ********************************
G4VProcess* hadronIonMultipleScatProcess = new G4MultipleScattering();
G4hLowEnergyIonisation* hadronIonIonisationProcess = new G4hLowEnergyIonisation();
hadronIonIonisationProcess -> SetNuclearStoppingOn();
G4StepLimiter* hadronIonStepLimiter = new G4StepLimiter();
theParticleIterator -> reset();
while( (*theParticleIterator)() )
@@ -96,6 +96,13 @@ void EMHadronIonLowEICRU49::ConstructProcess()
if((!particle -> IsShortLived()) &&
(particle -> GetParticleName() != "chargedgeantino"))
{
G4MultipleScattering* hadronIonMultipleScatProcess = new G4MultipleScattering();
G4hLowEnergyIonisation* hadronIonIonisationProcess = new G4hLowEnergyIonisation();
hadronIonIonisationProcess -> SetNuclearStoppingOn();
G4StepLimiter* hadronIonStepLimiter = new G4StepLimiter();
processManager -> AddProcess(hadronIonMultipleScatProcess, -1, 1, 1);
processManager -> AddProcess(hadronIonIonisationProcess, -1, 2, 2);
processManager -> AddProcess(hadronIonStepLimiter, -1, -1, 3);
examples/advanced/hadrontherapy/src/EMHadronIonLowEZiegler1977.cc
+14 -10
View File
@@ -23,20 +23,24 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyIonLowE.cc; May 2005
// $Id: EMHadronIonLowEZiegler1977.cc
// Last modified: A.Lechner (anton.lechner@cern.ch), August 2008;
//
// See more at: http://geant4infn.wikispaces.com
//
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
// Code developed by:
//
// G.A.P. Cirrone(a)*, G. Candiano, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
//
// (a) Laboratori Nazionali del Sud
// of the National Institute for Nuclear Physics, Catania, Italy
// (b) National Institute for Nuclear Physics Section of Genova, genova, Italy
// of the INFN, Catania, Italy
// (b) INFN Section of Genova, Genova, Italy
//
// * cirrone@lns.infn.it
// --------------------------------------------------------------
// ---------------------------------------------------
#include "EMHadronIonLowEZiegler1977.hh"
#include "G4ProcessManager.hh"
@@ -73,10 +77,6 @@ void EMHadronIonLowEZiegler1977::ConstructProcess()
// *** Charged Hadrons and Ions ***
// ********************************
G4VProcess* hadronIonMultipleScatProcess = new G4MultipleScattering();
G4StepLimiter* hadronIonStepLimiter = new G4StepLimiter();
theParticleIterator -> reset();
while( (*theParticleIterator)() )
@@ -94,12 +94,16 @@ void EMHadronIonLowEZiegler1977::ConstructProcess()
{
if((!particle -> IsShortLived()) &&
(particle -> GetParticleName() != "chargedgeantino"))
{
{
G4MultipleScattering* hadronIonMultipleScatProcess = new G4MultipleScattering();
G4hLowEnergyIonisation* hadronIonIonisationProcess = new G4hLowEnergyIonisation();
hadronIonIonisationProcess -> SetElectronicStoppingPowerModel(particle, "Ziegler1977p");
hadronIonIonisationProcess -> SetNuclearStoppingPowerModel("Ziegler1977");
hadronIonIonisationProcess -> SetNuclearStoppingOn();
G4StepLimiter* hadronIonStepLimiter = new G4StepLimiter();
processManager -> AddProcess(hadronIonMultipleScatProcess, -1, 1, 1);
processManager -> AddProcess(hadronIonIonisationProcess, -1, 2, 2);
processManager -> AddProcess(hadronIonStepLimiter, -1, -1, 3);
examples/advanced/hadrontherapy/src/EMHadronIonLowEZiegler1985.cc
+13 -9
View File
@@ -23,20 +23,25 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyIonLowEZiegler1985.cc; May 2005
//
// $Id: EMHadronIonLowEZiegler1985.cc;
// Last modified: A.Lechner (anton.lechner@cern.ch), August 2008;
//
// See more at: http://geant4infn.wikispaces.com
//
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
// Code developed by:
//
// G.A.P. Cirrone(a)*, G. Candiano, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
//
// (a) Laboratori Nazionali del Sud
// of the National Institute for Nuclear Physics, Catania, Italy
// (b) National Institute for Nuclear Physics Section of Genova, genova, Italy
// of the INFN, Catania, Italy
// (b) INFN Section of Genova, Genova, Italy
//
// * cirrone@lns.infn.it
// --------------------------------------------------------------
// ----------------------------------------------------------------------------
#include "EMHadronIonLowEZiegler1985.hh"
#include "G4ProcessManager.hh"
@@ -74,10 +79,6 @@ void EMHadronIonLowEZiegler1985::ConstructProcess()
// *** Charged Hadrons and Ions ***
// ********************************
G4VProcess* hadronIonMultipleScatProcess = new G4MultipleScattering();
G4StepLimiter* hadronIonStepLimiter = new G4StepLimiter();
theParticleIterator -> reset();
while( (*theParticleIterator)() )
@@ -96,11 +97,14 @@ void EMHadronIonLowEZiegler1985::ConstructProcess()
if((!particle -> IsShortLived()) &&
(particle -> GetParticleName() != "chargedgeantino"))
{
G4MultipleScattering* hadronIonMultipleScatProcess = new G4MultipleScattering();
G4hLowEnergyIonisation* hadronIonIonisationProcess = new G4hLowEnergyIonisation();
hadronIonIonisationProcess -> SetElectronicStoppingPowerModel(particle, "Ziegler1985p");
hadronIonIonisationProcess -> SetNuclearStoppingPowerModel("Ziegler1985");
hadronIonIonisationProcess -> SetNuclearStoppingOn();
G4StepLimiter* hadronIonStepLimiter = new G4StepLimiter();
processManager -> AddProcess(hadronIonMultipleScatProcess, -1, 1, 1);
processManager -> AddProcess(hadronIonIonisationProcess, -1, 2, 2);
processManager -> AddProcess(hadronIonStepLimiter, -1, -1, 3);
examples/advanced/hadrontherapy/src/EMHadronIonStandard.cc
+13 -22
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyIonStandard.cc; May 2005
// $Id: EMIonStandard.cc; November 2008
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
@@ -36,18 +36,21 @@
// (b) National Institute for Nuclear Physics Section of Genova, genova, Italy
//
// * cirrone@lns.infn.it
//
// This class manages the electromagnetic processes for charged hadrons and ions
// using the Standard Models of Geant4
// ----------------------------------------------------------------------------
#include "EMHadronIonStandard.hh"
#include "G4ProcessManager.hh"
#include "G4ParticleDefinition.hh"
#include "G4MultipleScattering.hh"
#include "G4hMultipleScattering.hh"
#include "G4hIonisation.hh"
#include "G4ionIonisation.hh"
#include "G4MultipleScattering.hh"
#include "G4StepLimiter.hh"
#include "G4EmProcessOptions.hh"
#include "G4MuIonisation.hh"
EMHadronIonStandard::EMHadronIonStandard(const G4String& name):
G4VPhysicsConstructor(name)
@@ -61,23 +64,12 @@ void EMHadronIonStandard::ConstructProcess()
G4ParticleDefinition* particle = 0;
G4ProcessManager* processManager = 0;
// ********************************
// *** Charged Hadrons and Ions ***
// ********************************
G4EmProcessOptions* hadronIonEmProcessOptions = new G4EmProcessOptions();
hadronIonEmProcessOptions -> SetDEDXBinning(480);
G4VProcess* hadronIonMultipleScatProcess = new G4MultipleScattering();
G4ionIonisation* ionIonisationProcess = new G4ionIonisation();
G4hIonisation* hadronIonisationProcess = new G4hIonisation();
G4StepLimiter* hadronIonStepLimiter = new G4StepLimiter();
theParticleIterator -> reset();
while( (*theParticleIterator)() )
{
particle = theParticleIterator -> value();
@@ -89,9 +81,8 @@ void EMHadronIonStandard::ConstructProcess()
particleName == "alpha" ||
particleName == "He3")
{
processManager -> AddProcess(hadronIonMultipleScatProcess, -1, 1, 1);
processManager -> AddProcess(ionIonisationProcess, -1, 2, 2);
processManager -> AddProcess(hadronIonStepLimiter, -1, -1, 3);
processManager -> AddProcess(new G4hMultipleScattering, -1, 1, 1);
processManager -> AddProcess(new G4hIonisation ,-1, 2, 2);
}
else
{
@@ -104,13 +95,13 @@ void EMHadronIonStandard::ConstructProcess()
if((!particle -> IsShortLived()) &&
(particle -> GetParticleName() != "chargedgeantino"))
{
processManager -> AddProcess(hadronIonMultipleScatProcess, -1, 1, 1);
processManager -> AddProcess(hadronIonisationProcess, -1, 2, 2);
processManager -> AddProcess(hadronIonStepLimiter, -1, -1, 3);
processManager -> AddProcess(new G4hMultipleScattering, -1, 1, 1);
processManager -> AddProcess(new G4hIonisation, -1, 2, 2);
}
}
}
}
}
}
examples/advanced/hadrontherapy/src/EMMuonStandard.cc
+43 -47
View File
@@ -23,7 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyMuonStandard.cc; May 2005
// $Id: EMMuonStandard.cc;
// Last modified: A.Lechner (anton.lechner@cern.ch), August 2008;
//
// See more at: http://geant4infn.wikispaces.com
//
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
@@ -32,8 +36,8 @@
// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
//
// (a) Laboratori Nazionali del Sud
// of the National Institute for Nuclear Physics, Catania, Italy
// (b) National Institute for Nuclear Physics Section of Genova, genova, Italy
// of the INFN, Catania, Italy
// (b) INFN Section of Genova, Genova, Italy
//
// * cirrone@lns.infn.it
// ----------------------------------------------------------------------------
@@ -73,66 +77,58 @@ void EMMuonStandard::ConstructProcess()
{
G4ParticleDefinition* particle = 0;
G4ProcessManager* processManager = 0;
// ***********************************
// *** Muon+/-: Common Definitions ***
// ***********************************
G4EmProcessOptions* muonEmProcessOptions = new G4EmProcessOptions;
muonEmProcessOptions -> SetDEDXBinning(480);
G4MultipleScattering* muonMultipleScatteringProcess = new G4MultipleScattering();
G4MuIonisation* muonIonisationProcess = new G4MuIonisation();
G4MuBremsstrahlung* muonBremsstrahlungProcess = new G4MuBremsstrahlung();
G4MuPairProduction* muonPairProductionProcess = new G4MuPairProduction();
G4StepLimiter* muonStepLimiter = new G4StepLimiter();
// *************
// *** Muon+ ***
// *************
G4MultipleScattering* muonPlusMultipleScatteringProcess = new G4MultipleScattering();
G4MuIonisation* muonPlusIonisationProcess = new G4MuIonisation();
G4MuBremsstrahlung* muonPlusBremsstrahlungProcess = new G4MuBremsstrahlung();
G4MuPairProduction* muonPlusPairProductionProcess = new G4MuPairProduction();
particle = G4MuonPlus::MuonPlus();
processManager = particle -> GetProcessManager();
processManager -> AddProcess(muonMultipleScatteringProcess);
processManager -> AddProcess(muonIonisationProcess);
processManager -> AddProcess(muonBremsstrahlungProcess);
processManager -> AddProcess(muonPairProductionProcess);
processManager -> AddProcess(muonStepLimiter, -1, -1, 3);
processManager -> AddProcess(muonPlusMultipleScatteringProcess);
processManager -> AddProcess(muonPlusIonisationProcess);
processManager -> AddProcess(muonPlusBremsstrahlungProcess);
processManager -> AddProcess(muonPlusPairProductionProcess);
processManager -> SetProcessOrdering(muonMultipleScatteringProcess, idxAlongStep,1);
processManager -> SetProcessOrdering(muonIonisationProcess, idxAlongStep,2);
processManager -> SetProcessOrdering(muonBremsstrahlungProcess, idxAlongStep,3);
processManager -> SetProcessOrdering(muonPairProductionProcess, idxAlongStep,4);
processManager -> SetProcessOrdering(muonPlusMultipleScatteringProcess, idxAlongStep,1);
processManager -> SetProcessOrdering(muonPlusIonisationProcess, idxAlongStep,2);
processManager -> SetProcessOrdering(muonPlusBremsstrahlungProcess, idxAlongStep,3);
processManager -> SetProcessOrdering(muonPlusPairProductionProcess, idxAlongStep,4);
processManager -> SetProcessOrdering(muonMultipleScatteringProcess, idxPostStep,1);
processManager -> SetProcessOrdering(muonIonisationProcess, idxPostStep,2);
processManager -> SetProcessOrdering(muonBremsstrahlungProcess, idxPostStep,3);
processManager -> SetProcessOrdering(muonPairProductionProcess, idxPostStep,4);
processManager -> SetProcessOrdering(muonPlusMultipleScatteringProcess, idxPostStep,1);
processManager -> SetProcessOrdering(muonPlusIonisationProcess, idxPostStep,2);
processManager -> SetProcessOrdering(muonPlusBremsstrahlungProcess, idxPostStep,3);
processManager -> SetProcessOrdering(muonPlusPairProductionProcess, idxPostStep,4);
// *************
// *** Muon- ***
// *************
G4MultipleScattering* muonMinusMultipleScatteringProcess = new G4MultipleScattering();
G4MuIonisation* muonMinusIonisationProcess = new G4MuIonisation();
G4MuBremsstrahlung* muonMinusBremsstrahlungProcess = new G4MuBremsstrahlung();
G4MuPairProduction* muonMinusPairProductionProcess = new G4MuPairProduction();
particle = G4MuonMinus::MuonMinus();
processManager = particle -> GetProcessManager();
processManager -> AddProcess(muonMultipleScatteringProcess);
processManager -> AddProcess(muonIonisationProcess);
processManager -> AddProcess(muonBremsstrahlungProcess);
processManager -> AddProcess(muonPairProductionProcess);
processManager -> AddProcess(muonStepLimiter, -1, -1, 3);
processManager -> AddProcess(muonMinusMultipleScatteringProcess);
processManager -> AddProcess(muonMinusIonisationProcess);
processManager -> AddProcess(muonMinusBremsstrahlungProcess);
processManager -> AddProcess(muonMinusPairProductionProcess);
processManager -> SetProcessOrdering(muonMultipleScatteringProcess, idxAlongStep,1);
processManager -> SetProcessOrdering(muonIonisationProcess, idxAlongStep,2);
processManager -> SetProcessOrdering(muonBremsstrahlungProcess, idxAlongStep,3);
processManager -> SetProcessOrdering(muonPairProductionProcess, idxAlongStep,4);
processManager -> SetProcessOrdering(muonMinusMultipleScatteringProcess, idxAlongStep,1);
processManager -> SetProcessOrdering(muonMinusIonisationProcess, idxAlongStep,2);
processManager -> SetProcessOrdering(muonMinusBremsstrahlungProcess, idxAlongStep,3);
processManager -> SetProcessOrdering(muonMinusPairProductionProcess, idxAlongStep,4);
processManager -> SetProcessOrdering(muonMultipleScatteringProcess, idxPostStep,1);
processManager -> SetProcessOrdering(muonIonisationProcess, idxPostStep,2);
processManager -> SetProcessOrdering(muonBremsstrahlungProcess, idxPostStep,3);
processManager -> SetProcessOrdering(muonPairProductionProcess, idxPostStep,4);
processManager -> SetProcessOrdering(muonMinusMultipleScatteringProcess, idxPostStep,1);
processManager -> SetProcessOrdering(muonMinusIonisationProcess, idxPostStep,2);
processManager -> SetProcessOrdering(muonMinusBremsstrahlungProcess, idxPostStep,3);
processManager -> SetProcessOrdering(muonMinusPairProductionProcess, idxPostStep,4);
}
examples/advanced/hadrontherapy/src/EMPhotonStandard.cc
+5 -9
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyPhotonStandard.cc; May 2005
// $Id: EMPhotonStandard.cc; September 2008
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
@@ -36,6 +36,9 @@
// (b) National Institute for Nuclear Physics Section of Genova, genova, Italy
//
// * cirrone@lns.infn.it
//
// This class manages the electromagnetic processes for photons
// using the Standard Electromagnetic Models of Geant4
// ----------------------------------------------------------------------------
#include "EMPhotonStandard.hh"
@@ -46,7 +49,7 @@
#include "G4GammaConversion.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4StepLimiter.hh"
#include "G4EmProcessOptions.hh"
EMPhotonStandard::EMPhotonStandard(const G4String& name):
@@ -72,20 +75,13 @@ void EMPhotonStandard::ConstructProcess()
// *** Photon ***
// **************
G4EmProcessOptions* photonEmProcessOptions = new G4EmProcessOptions();
photonEmProcessOptions -> SetDEDXBinning(480);
G4PhotoElectricEffect* photonPhotoElectricProcess = new G4PhotoElectricEffect();
G4ComptonScattering* photonComptonProcess = new G4ComptonScattering;
G4GammaConversion* photonGammaConvProcess = new G4GammaConversion;
G4StepLimiter* photonStepLimiter = new G4StepLimiter();
G4ParticleDefinition* particle = G4Gamma::Gamma();
G4ProcessManager* processManager = particle -> GetProcessManager();
processManager -> AddDiscreteProcess(photonPhotoElectricProcess);
processManager -> AddDiscreteProcess(photonComptonProcess);
processManager -> AddDiscreteProcess(photonGammaConvProcess);
processManager -> AddProcess(photonStepLimiter, -1, -1, 3);
}
examples/advanced/hadrontherapy/src/EMPositronStandard.cc
+13 -6
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// HadrontherapyPositronStandard.cc May 2005
// EMPositronStandard.cc February 2008
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
@@ -36,6 +36,9 @@
// (b) National Institute for Nuclear Physics Section of Genova, genova, Italy
//
// * cirrone@lns.infn.it
//
// This class manages the electromagnetic processes for positrons
// using the Standard Electromagnetic Models of Geant4
// ----------------------------------------------------------------------------
#include "EMPositronStandard.hh"
@@ -74,15 +77,11 @@ void EMPositronStandard::ConstructProcess()
// *** Positron ***
// ****************
G4EmProcessOptions* positronEmProcessOptions = new G4EmProcessOptions();
positronEmProcessOptions -> SetDEDXBinning(480);
G4MultipleScattering* positronMultipScatProcess = new G4MultipleScattering();
G4eIonisation* positronIonisationProcess = new G4eIonisation();
G4eBremsstrahlung* positronBremsstrProcess = new G4eBremsstrahlung();
G4eplusAnnihilation* positronAnnihilationProcess = new G4eplusAnnihilation();
G4StepLimiter* positronStepLimiter = new G4StepLimiter();
G4ParticleDefinition* particle = G4Positron::Positron();
G4ProcessManager* processManager = particle -> GetProcessManager();
@@ -90,6 +89,14 @@ void EMPositronStandard::ConstructProcess()
processManager -> AddProcess(positronIonisationProcess, -1, 2, 2);
processManager -> AddProcess(positronBremsstrProcess, -1, -1, 3);
processManager -> AddProcess(positronAnnihilationProcess, 0, -1, 4);
processManager -> AddProcess(positronStepLimiter, -1, -1, 3);
// Options activated to improve accuracy;
// Usefull for a medical application
G4EmProcessOptions opt;
opt.SetStepFunction(0.2, 10*um);
opt.SetMinEnergy(0.1*keV);
opt.SetMaxEnergy(100.*GeV);
opt.SetDEDXBinning(360);
opt.SetLambdaBinning(360);
opt.SetLinearLossLimit(1.e-6);
}
examples/advanced/hadrontherapy/src/HEHadronIonBertiniElastic.cc
+1 -4
View File
@@ -45,7 +45,6 @@
#include "G4HadronElasticProcess.hh"
#include "G4CascadeElasticInterface.hh"
HEHadronIonBertiniElastic::HEHadronIonBertiniElastic(const G4String& name):
G4VPhysicsConstructor(name)
{
@@ -59,13 +58,12 @@ HEHadronIonBertiniElastic::HEHadronIonBertiniElastic(const G4String& name):
HEHadronIonBertiniElastic::~HEHadronIonBertiniElastic()
{}
/////////////////////////////////////////////////////////////////////////////
void HEHadronIonBertiniElastic::ConstructProcess()
{
G4ParticleDefinition* particle = 0;
G4ProcessManager* processManager = 0;
// **********************************************
// *** Proton, Neutron, Pion plus, Pion minus ***
// **********************************************
@@ -90,7 +88,6 @@ void HEHadronIonBertiniElastic::ConstructProcess()
processManager = particle -> GetProcessManager();
processManager -> AddDiscreteProcess(hadronElasticProcess);
// *******************************
// *** Deuteron, Triton, Alpha ***
// *******************************
examples/advanced/hadrontherapy/src/HIIonLEP.cc
+1 -4
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyProtonPrecompound.cc; May 2005
// $Id: HadrontherapyProtonPrecompound.cc; November 2008
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
@@ -89,7 +89,6 @@ void HIIonLEP::ConstructProcess()
deuteronLEPModel -> SetMaxEnergy(ionLEPMaxEnergy);
deuteronInelasticProcess -> AddDataSet(ionTripathiCrossSection);
deuteronInelasticProcess -> AddDataSet(ionShenCrossSection);
deuteronInelasticProcess -> RegisterMe(deuteronLEPModel);
particle = G4Deuteron::Deuteron();
@@ -107,7 +106,6 @@ void HIIonLEP::ConstructProcess()
tritonLEPModel -> SetMaxEnergy(ionLEPMaxEnergy);
tritonInelasticProcess -> AddDataSet(ionTripathiCrossSection);
tritonInelasticProcess -> AddDataSet(ionShenCrossSection);
tritonInelasticProcess -> RegisterMe(tritonLEPModel);
particle = G4Triton::Triton();
@@ -125,7 +123,6 @@ void HIIonLEP::ConstructProcess()
alphaLEPModel -> SetMaxEnergy(ionLEPMaxEnergy);
alphaInelasticProcess -> AddDataSet(ionTripathiCrossSection);
alphaInelasticProcess -> AddDataSet(ionShenCrossSection);
alphaInelasticProcess -> RegisterMe(alphaLEPModel);
particle = G4Alpha::Alpha();
examples/advanced/hadrontherapy/src/HIProtonNeutronBertini.cc
+1 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyProtonBertini.cc; May 2005
// $Id: HadrontherapyProtonBertini.cc; November 2008
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
examples/advanced/hadrontherapy/src/HadrontherapyAnalysisManager.cc
+20 -12
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyAnalisysManager.cc; May 2005
// $Id: HadrontherapyAnalisysManager.cc; Last modified: G.A.P.Cirrone, February 2008;
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
@@ -125,9 +125,17 @@ void HadrontherapyAnalysisManager::book()
aFact = AIDA_createAnalysisFactory();
AIDA::ITreeFactory* treeFact = aFact -> createTreeFactory();
// Create the .hbk file
G4String fileName = "hadrontherapy.hbk";
// Create the .hbk or the .root file
G4String fileName = "hadrontherapyOutput.hbk";
G4String rootFileName = "hadrontherapyOutput.root";
std::string opts = "export=root";
theTree = treeFact -> create(fileName,"hbook",false,true);
theTree = treeFact -> create(rootFileName,"ROOT",false,true,opts);
// Factories are not "managed" by an AIDA analysis system.
// They must be deleted by the AIDA user code.
delete treeFact;
// Create the histogram and the ntuple factory
@@ -135,23 +143,23 @@ void HadrontherapyAnalysisManager::book()
tupFact = aFact -> createTupleFactory(*theTree);
// Create the histograms with the enrgy deposit along the X axis
h1 = histFact -> createHistogram1D("10","slice, energy", 200, 0., 200. );
h1 = histFact -> createHistogram1D("10","slice, energy", 400, 0., 400. );
h2 = histFact -> createHistogram1D("20","Secondary protons - slice, energy", 200, 0., 200. );
h2 = histFact -> createHistogram1D("20","Secondary protons - slice, energy", 400, 0., 400. );
h3 = histFact -> createHistogram1D("30","Secondary neutrons - slice, energy", 200, 0., 200. );
h3 = histFact -> createHistogram1D("30","Secondary neutrons - slice, energy", 400, 0., 400. );
h4 = histFact -> createHistogram1D("40","Secondary alpha - slice, energy", 200, 0., 200. );
h4 = histFact -> createHistogram1D("40","Secondary alpha - slice, energy", 400, 0., 400. );
h5 = histFact -> createHistogram1D("50","Secondary gamma - slice, energy", 200, 0., 200. );
h5 = histFact -> createHistogram1D("50","Secondary gamma - slice, energy", 400, 0., 400. );
h6 = histFact -> createHistogram1D("60","Secondary electron - slice, energy", 200, 0., 200. );
h6 = histFact -> createHistogram1D("60","Secondary electron - slice, energy", 400, 0., 400. );
h7 = histFact -> createHistogram1D("70","Secondary triton - slice, energy", 200, 0., 200. );
h7 = histFact -> createHistogram1D("70","Secondary triton - slice, energy", 400, 0., 400. );
h8 = histFact -> createHistogram1D("80","Secondary deuteron - slice, energy", 200, 0., 200. );
h8 = histFact -> createHistogram1D("80","Secondary deuteron - slice, energy", 400, 0., 400. );
h9 = histFact -> createHistogram1D("90","Secondary pion - slice, energy", 200, 0., 200. );
h9 = histFact -> createHistogram1D("90","Secondary pion - slice, energy", 400, 0., 400. );
h10 = histFact -> createHistogram1D("100","Energy distribution of secondary electrons", 70, 0., 70. );
examples/advanced/hadrontherapy/src/HadrontherapyBeamLine.cc
+769 -384
View File
File diff suppressed because it is too large Load Diff
examples/advanced/hadrontherapy/src/HadrontherapyDetectorConstruction.cc
+80 -70
View File
@@ -23,7 +23,12 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyDetectorConstruction.cc; Version 4.0 May 2005
//
// $Id: HadrontherapyDetectorConstruction.cc;
// Last modified: G.A.P.Cirrone, April 2008;
//
// See more at: http://geant4infn.wikispaces.com
//
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
@@ -50,41 +55,43 @@
#include "G4Colour.hh"
#include "G4UserLimits.hh"
#include "G4VisAttributes.hh"
#include "HadrontherapyPhantomROGeometry.hh"
#include "HadrontherapyDetectorROGeometry.hh"
#include "HadrontherapyDetectorMessenger.hh"
#include "HadrontherapyPhantomSD.hh"
#include "HadrontherapyDetectorSD.hh"
#include "HadrontherapyDetectorConstruction.hh"
#include "HadrontherapyMaterial.hh"
#include "HadrontherapyBeamLine.hh"
#include "HadrontherapyModulator.hh"
/////////////////////////////////////////////////////////////////////////////
HadrontherapyDetectorConstruction::HadrontherapyDetectorConstruction()
: phantomSD(0), phantomROGeometry(0), beamLine(0), modulator(0),
: detectorSD(0), detectorROGeometry(0), beamLine(0), modulator(0),
physicalTreatmentRoom(0),
patientPhysicalVolume(0),
phantomLogicalVolume(0),
phantomPhysicalVolume(0)
detectorLogicalVolume(0),
detectorPhysicalVolume(0)
{
// Messenger to change parameters of the geometry
detectorMessenger = new HadrontherapyDetectorMessenger(this);
material = new HadrontherapyMaterial();
// Phantom sizes
phantomSizeX = 20.*mm;
phantomSizeY = 20.*mm;
phantomSizeZ = 20.*mm;
// Detector sizes
detectorSizeX = 20.*mm;
detectorSizeY = 20.*mm;
detectorSizeZ = 20.*mm;
// Number of the phantom voxels
numberOfVoxelsAlongX = 200;
numberOfVoxelsAlongY = 200;
numberOfVoxelsAlongZ = 200;
// Number of the detector voxels
numberOfVoxelsAlongX = 400;
numberOfVoxelsAlongY = 1;
numberOfVoxelsAlongZ = 1;
}
/////////////////////////////////////////////////////////////////////////////
HadrontherapyDetectorConstruction::~HadrontherapyDetectorConstruction()
{
delete material;
if (phantomROGeometry) delete phantomROGeometry;
if (detectorROGeometry) delete detectorROGeometry;
delete detectorMessenger;
}
@@ -95,7 +102,7 @@ G4VPhysicalVolume* HadrontherapyDetectorConstruction::Construct()
// Define the geometry components
ConstructBeamLine();
ConstructPhantom();
ConstructDetector();
// Set the sensitive detector where the energy deposit is collected
ConstructSensitiveDetector();
@@ -103,14 +110,15 @@ G4VPhysicalVolume* HadrontherapyDetectorConstruction::Construct()
return physicalTreatmentRoom;
}
/////////////////////////////////////////////////////////////////////////////
void HadrontherapyDetectorConstruction::ConstructBeamLine()
{
G4Material* air = material -> GetMat("Air") ;
G4Material* water = material -> GetMat("Water");
G4Material* water = material -> GetMat("G4_WATER");
// ---------------------
// -----------------------------
// Treatment room - World volume
//---------------------
//------------------------------
// Treatment room sizes
const G4double worldX = 400.0 *cm;
@@ -123,9 +131,6 @@ void HadrontherapyDetectorConstruction::ConstructBeamLine()
air,
"logicTreatmentRoom",
0,0,0);
physicalTreatmentRoom = new G4PVPlacement(0,
G4ThreeVector(),
"physicalTreatmentRoom",
@@ -141,22 +146,28 @@ void HadrontherapyDetectorConstruction::ConstructBeamLine()
beamLine = new HadrontherapyBeamLine(physicalTreatmentRoom);
beamLine -> HadrontherapyBeamLineSupport();
beamLine -> HadrontherapyBeamScatteringFoils();
beamLine -> HadrontherapyRangeShifter();
beamLine -> HadrontherapyBeamCollimators();
beamLine -> HadrontherapyBeamMonitoring();
beamLine -> HadrontherapyMOPIDetector();
beamLine -> HadrontherapyBeamNozzle();
beamLine -> HadrontherapyBeamFinalCollimator();
modulator = new HadrontherapyModulator();
modulator -> BuildModulator(physicalTreatmentRoom);
// Patient - Mother volume of the phantom
//----------------------------------------
// Patient:
// a water box used to approximate tissues
//----------------------------------------
G4Box* patient = new G4Box("patient",20 *cm, 20 *cm, 20 *cm);
G4LogicalVolume* patientLogicalVolume = new G4LogicalVolume(patient,
water,
"patientLog", 0, 0, 0);
patientPhysicalVolume = new G4PVPlacement(0,G4ThreeVector(0., 0., 0.),
patientPhysicalVolume = new G4PVPlacement(0,G4ThreeVector(200.*mm, 0.*mm, 0.*mm),
"patientPhys",
patientLogicalVolume,
physicalTreatmentRoom,
@@ -169,51 +180,50 @@ void HadrontherapyDetectorConstruction::ConstructBeamLine()
patientLogicalVolume -> SetVisAttributes(redWire);
}
void HadrontherapyDetectorConstruction::ConstructPhantom()
/////////////////////////////////////////////////////////////////////////////
void HadrontherapyDetectorConstruction::ConstructDetector()
{
G4Colour lightBlue (0.0, 0.0, .75);
G4Material* water = material -> GetMat("Water");
//ComputeVoxelSize();
//----------------------
// Water phantom
//----------------------
G4Box* phantom = new G4Box("Phantom",phantomSizeX,phantomSizeY,phantomSizeZ);
phantomLogicalVolume = new G4LogicalVolume(phantom,
water,
"PhantomLog",
0,0,0);
// Fixing the max step allowed in the phantom
G4Material* water = material -> GetMat("G4_WATER");
//-----------
// Detector
//-----------
G4Box* detector = new G4Box("Detector",detectorSizeX,detectorSizeY,detectorSizeZ);
detectorLogicalVolume = new G4LogicalVolume(detector,
water,
"DetectorLog",
0,0,0);
// Fixing the max step allowed in the detector
G4double maxStep = 0.01 *mm;
phantomLogicalVolume -> SetUserLimits(new G4UserLimits(maxStep));
G4double phantomXtranslation = -180.*mm;
phantomPhysicalVolume = new G4PVPlacement(0,
G4ThreeVector(phantomXtranslation, 0.0 *mm, 0.0 *mm),
"PhantomPhys",
phantomLogicalVolume,
patientPhysicalVolume,
false,0);
detectorLogicalVolume -> SetUserLimits(new G4UserLimits(maxStep));
G4double detectorXtranslation = -180.*mm;
detectorPhysicalVolume = new G4PVPlacement(0,
G4ThreeVector(detectorXtranslation, 0.0 *mm, 0.0 *mm),
"DetectorPhys",
detectorLogicalVolume,
patientPhysicalVolume,
false,0);
// Visualisation attributes of the phantom
G4VisAttributes* simpleBoxVisAttributes = new G4VisAttributes(lightBlue);
simpleBoxVisAttributes -> SetVisibility(true);
simpleBoxVisAttributes -> SetForceSolid(true);
phantomLogicalVolume -> SetVisAttributes(simpleBoxVisAttributes);
detectorLogicalVolume -> SetVisAttributes(simpleBoxVisAttributes);
// **************
// Cut per Region
// **************
// A smaller cut is fixed in the phantom to calculate the energy deposit with the
// required accuracy
G4Region* aRegion = new G4Region("PhantomLog");
phantomLogicalVolume -> SetRegion(aRegion);
aRegion -> AddRootLogicalVolume(phantomLogicalVolume);
G4Region* aRegion = new G4Region("DetectorLog");
detectorLogicalVolume -> SetRegion(aRegion);
aRegion -> AddRootLogicalVolume(detectorLogicalVolume);
}
void HadrontherapyDetectorConstruction::ConstructSensitiveDetector()
@@ -221,26 +231,26 @@ void HadrontherapyDetectorConstruction::ConstructSensitiveDetector()
// Sensitive Detector and ReadOut geometry definition
G4SDManager* sensitiveDetectorManager = G4SDManager::GetSDMpointer();
G4String sensitiveDetectorName = "Phantom";
G4String sensitiveDetectorName = "Detector";
if(!phantomSD)
if(!detectorSD)
{
// The sensitive detector is instantiated
phantomSD = new HadrontherapyPhantomSD(sensitiveDetectorName);
detectorSD = new HadrontherapyDetectorSD(sensitiveDetectorName);
// The Read Out Geometry is instantiated
G4String ROGeometryName = "PhantomROGeometry";
phantomROGeometry = new HadrontherapyPhantomROGeometry(ROGeometryName,
phantomSizeX,
phantomSizeY,
phantomSizeZ,
G4String ROGeometryName = "DetectorROGeometry";
detectorROGeometry = new HadrontherapyDetectorROGeometry(ROGeometryName,
detectorSizeX,
detectorSizeY,
detectorSizeZ,
numberOfVoxelsAlongX,
numberOfVoxelsAlongY,
numberOfVoxelsAlongZ);
phantomROGeometry -> BuildROGeometry();
phantomSD -> SetROgeometry(phantomROGeometry);
sensitiveDetectorManager -> AddNewDetector(phantomSD);
phantomLogicalVolume -> SetSensitiveDetector(phantomSD);
detectorROGeometry -> BuildROGeometry();
detectorSD -> SetROgeometry(detectorROGeometry);
sensitiveDetectorManager -> AddNewDetector(detectorSD);
detectorLogicalVolume -> SetSensitiveDetector(detectorSD);
}
}
examples/advanced/hadrontherapy/src/HadrontherapyPhantomHit.cc → examples/advanced/hadrontherapy/src/HadrontherapyDetectorHit.cc
+13 -8
View File
@@ -23,7 +23,12 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyPhantomHit.cc; May 2005
// $Id: HadrontherapyDetectorHit.cc;
// Last modified: G.A.P.Cirrone March 2008;
//
// See more at: http://geant4infn.wikispaces.com/HadrontherapyExample
//
//
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
@@ -38,20 +43,20 @@
// * cirrone@lns.infn.it
// ----------------------------------------------------------------------------
#include "HadrontherapyPhantomHit.hh"
#include "HadrontherapyDetectorHit.hh"
G4Allocator<HadrontherapyPhantomHit> HadrontherapyPhantomHitAllocator;
G4Allocator<HadrontherapyDetectorHit> HadrontherapyDetectorHitAllocator;
HadrontherapyPhantomHit::HadrontherapyPhantomHit()
HadrontherapyDetectorHit::HadrontherapyDetectorHit()
{
energyDeposit = 0;
}
HadrontherapyPhantomHit::~HadrontherapyPhantomHit()
HadrontherapyDetectorHit::~HadrontherapyDetectorHit()
{
}
HadrontherapyPhantomHit::HadrontherapyPhantomHit(const HadrontherapyPhantomHit &right)
HadrontherapyDetectorHit::HadrontherapyDetectorHit(const HadrontherapyDetectorHit &right)
: G4VHit()
{
xHitID = right.xHitID;
@@ -60,7 +65,7 @@ HadrontherapyPhantomHit::HadrontherapyPhantomHit(const HadrontherapyPhantomHit &
energyDeposit = right.energyDeposit;
}
const HadrontherapyPhantomHit& HadrontherapyPhantomHit::operator=(const HadrontherapyPhantomHit &right)
const HadrontherapyDetectorHit& HadrontherapyDetectorHit::operator=(const HadrontherapyDetectorHit &right)
{
xHitID = right.xHitID;
zHitID = right.zHitID;
@@ -69,7 +74,7 @@ const HadrontherapyPhantomHit& HadrontherapyPhantomHit::operator=(const Hadronth
return *this;
}
int HadrontherapyPhantomHit::operator==(const HadrontherapyPhantomHit &right) const
int HadrontherapyDetectorHit::operator==(const HadrontherapyDetectorHit &right) const
{
return((xHitID==right.xHitID)&&(zHitID==right.zHitID)&&(yHitID==right.yHitID));
}
examples/advanced/hadrontherapy/src/HadrontherapyPhantomROGeometry.cc → examples/advanced/hadrontherapy/src/HadrontherapyDetectorROGeometry.cc
+72 -67
View File
@@ -23,7 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyPhantomROGeometry.cc; May 2005
// $Id: HadrontherapyDetectorROGeometry.cc;
// Last modified: G.A.P.Cirrone April 2008;
//
// See more at: http://geant4infn.wikispaces.com/HadrontherapyExample
//
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
@@ -38,7 +42,7 @@
// * cirrone@lns.infn.it
// ----------------------------------------------------------------------------
#include "HadrontherapyPhantomROGeometry.hh"
#include "HadrontherapyDetectorROGeometry.hh"
#include "HadrontherapyDummySD.hh"
#include "G4LogicalVolume.hh"
#include "G4VPhysicalVolume.hh"
@@ -48,28 +52,31 @@
#include "G4ThreeVector.hh"
#include "G4Material.hh"
HadrontherapyPhantomROGeometry::HadrontherapyPhantomROGeometry(G4String aString,
G4double phantomDimX,
G4double phantomDimY,
G4double phantomDimZ,
/////////////////////////////////////////////////////////////////////////////
HadrontherapyDetectorROGeometry::HadrontherapyDetectorROGeometry(G4String aString,
G4double detectorDimX,
G4double detectorDimY,
G4double detectorDimZ,
G4int numberOfVoxelsX,
G4int numberOfVoxelsY,
G4int numberOfVoxelsZ):
G4VReadOutGeometry(aString),
phantomSizeX(phantomDimX),
phantomSizeY(phantomDimY),
phantomSizeZ(phantomDimZ),
detectorSizeX(detectorDimX),
detectorSizeY(detectorDimY),
detectorSizeZ(detectorDimZ),
numberOfVoxelsAlongX(numberOfVoxelsX),
numberOfVoxelsAlongY(numberOfVoxelsY),
numberOfVoxelsAlongZ(numberOfVoxelsZ)
{
}
HadrontherapyPhantomROGeometry::~HadrontherapyPhantomROGeometry()
/////////////////////////////////////////////////////////////////////////////
HadrontherapyDetectorROGeometry::~HadrontherapyDetectorROGeometry()
{
}
G4VPhysicalVolume* HadrontherapyPhantomROGeometry::Build()
/////////////////////////////////////////////////////////////////////////////
G4VPhysicalVolume* HadrontherapyDetectorROGeometry::Build()
{
// A dummy material is used to fill the volumes of the readout geometry.
// (It will be allowed to set a NULL pointer in volumes of such virtual
@@ -81,67 +88,65 @@ G4VPhysicalVolume* HadrontherapyPhantomROGeometry::Build()
G4double worldSizeY = 200.0 *cm;
G4double worldSizeZ = 200.0 *cm;
G4double halfPhantomSizeX = phantomSizeX;
G4double halfPhantomSizeY = phantomSizeY;
G4double halfPhantomSizeZ = phantomSizeZ;
G4double halfDetectorSizeX = detectorSizeX;
G4double halfDetectorSizeY = detectorSizeY;
G4double halfDetectorSizeZ = detectorSizeZ;
// World volume of ROGeometry ...
G4Box* ROWorld = new G4Box("ROWorld",
worldSizeX,
worldSizeY,
worldSizeZ);
G4LogicalVolume* ROWorldLog = new G4LogicalVolume(ROWorld, dummyMat,
"ROWorldLog", 0,0,0);
G4VPhysicalVolume* ROWorldPhys = new G4PVPlacement(0,G4ThreeVector(),
"ROWorldPhys",
ROWorldLog,
0,false,0);
// Phantom ROGeometry
G4Box *ROPhantom = new G4Box("ROPhantom",
halfPhantomSizeX,
halfPhantomSizeY,
halfPhantomSizeZ);
// Detector ROGeometry
G4Box *RODetector = new G4Box("RODetector",
halfDetectorSizeX,
halfDetectorSizeY,
halfDetectorSizeZ);
G4LogicalVolume *ROPhantomLog = new G4LogicalVolume(ROPhantom,
dummyMat,
"ROPhantomLog",
G4LogicalVolume *RODetectorLog = new G4LogicalVolume(RODetector,
dummyMat,
"RODetectorLog",
0,0,0);
G4VPhysicalVolume *ROPhantomPhys = new G4PVPlacement(0,
G4ThreeVector(-180.0 *mm,
0.0 *mm,
0.0 *mm),
"PhantomPhys",
ROPhantomLog,
ROWorldPhys,
false,0);
// ROGeomtry: the phantom is divided in voxels along the axis X, Y, Z
// Division along X axis: the phantom is devided in slices along the X axis
G4double halfXVoxelSizeX = halfPhantomSizeX/numberOfVoxelsAlongX;
G4double halfXVoxelSizeY = halfPhantomSizeY;
G4double halfXVoxelSizeZ = halfPhantomSizeZ;
G4VPhysicalVolume *RODetectorPhys = new G4PVPlacement(0,
G4ThreeVector(20.0 *mm,
0.0 *mm,
0.0 *mm),
"DetectorPhys",
RODetectorLog,
ROWorldPhys,
false,0);
// Division along X axis: the detector is devided in slices along the X axis
G4double halfXVoxelSizeX = halfDetectorSizeX/numberOfVoxelsAlongX;
G4double halfXVoxelSizeY = halfDetectorSizeY;
G4double halfXVoxelSizeZ = halfDetectorSizeZ;
G4double voxelXThickness = 2*halfXVoxelSizeX;
G4Box *ROPhantomXDivision = new G4Box("ROPhantomXDivision",
halfXVoxelSizeX,
halfXVoxelSizeY,
halfXVoxelSizeZ);
G4LogicalVolume *ROPhantomXDivisionLog = new G4LogicalVolume(ROPhantomXDivision,
G4Box *RODetectorXDivision = new G4Box("RODetectorXDivision",
halfXVoxelSizeX,
halfXVoxelSizeY,
halfXVoxelSizeZ);
G4LogicalVolume *RODetectorXDivisionLog = new G4LogicalVolume(RODetectorXDivision,
dummyMat,
"ROPhantomXDivisionLog",
"RODetectorXDivisionLog",
0,0,0);
G4VPhysicalVolume *ROPhantomXDivisionPhys = new G4PVReplica("ROPhantomXDivisionPhys",
ROPhantomXDivisionLog,
ROPhantomPhys,
G4VPhysicalVolume *RODetectorXDivisionPhys = new G4PVReplica("RODetectorXDivisionPhys",
RODetectorXDivisionLog,
RODetectorPhys,
kXAxis,
numberOfVoxelsAlongX,
voxelXThickness);
@@ -149,23 +154,23 @@ G4VPhysicalVolume* HadrontherapyPhantomROGeometry::Build()
// Division along Y axis: the slices along the X axis are devided along the Y axis
G4double halfYVoxelSizeX = halfXVoxelSizeX;
G4double halfYVoxelSizeY = halfPhantomSizeY/numberOfVoxelsAlongY;
G4double halfYVoxelSizeZ = halfPhantomSizeZ;
G4double halfYVoxelSizeY = halfDetectorSizeY/numberOfVoxelsAlongY;
G4double halfYVoxelSizeZ = halfDetectorSizeZ;
G4double voxelYThickness = 2*halfYVoxelSizeY;
G4Box *ROPhantomYDivision = new G4Box("ROPhantomYDivision",
G4Box *RODetectorYDivision = new G4Box("RODetectorYDivision",
halfYVoxelSizeX,
halfYVoxelSizeY,
halfYVoxelSizeZ);
G4LogicalVolume *ROPhantomYDivisionLog = new G4LogicalVolume(ROPhantomYDivision,
G4LogicalVolume *RODetectorYDivisionLog = new G4LogicalVolume(RODetectorYDivision,
dummyMat,
"ROPhantomYDivisionLog",
"RODetectorYDivisionLog",
0,0,0);
G4VPhysicalVolume *ROPhantomYDivisionPhys = new G4PVReplica("ROPhantomYDivisionPhys",
ROPhantomYDivisionLog,
ROPhantomXDivisionPhys,
G4VPhysicalVolume *RODetectorYDivisionPhys = new G4PVReplica("RODetectorYDivisionPhys",
RODetectorYDivisionLog,
RODetectorXDivisionPhys,
kYAxis,
numberOfVoxelsAlongY,
voxelYThickness);
@@ -174,28 +179,28 @@ G4VPhysicalVolume* HadrontherapyPhantomROGeometry::Build()
G4double halfZVoxelSizeX = halfXVoxelSizeX;
G4double halfZVoxelSizeY = halfYVoxelSizeY;
G4double halfZVoxelSizeZ = halfPhantomSizeZ/numberOfVoxelsAlongZ;
G4double halfZVoxelSizeZ = halfDetectorSizeZ/numberOfVoxelsAlongZ;
G4double voxelZThickness = 2*halfZVoxelSizeZ;
G4Box *ROPhantomZDivision = new G4Box("ROPhantomZDivision",
G4Box *RODetectorZDivision = new G4Box("RODetectorZDivision",
halfZVoxelSizeX,
halfZVoxelSizeY,
halfZVoxelSizeZ);
G4LogicalVolume *ROPhantomZDivisionLog = new G4LogicalVolume(ROPhantomZDivision,
G4LogicalVolume *RODetectorZDivisionLog = new G4LogicalVolume(RODetectorZDivision,
dummyMat,
"ROPhantomZDivisionLog",
"RODetectorZDivisionLog",
0,0,0);
ROPhantomZDivisionPhys = new G4PVReplica("ROPhantomZDivisionPhys",
ROPhantomZDivisionLog,
ROPhantomYDivisionPhys,
RODetectorZDivisionPhys = new G4PVReplica("RODetectorZDivisionPhys",
RODetectorZDivisionLog,
RODetectorYDivisionPhys,
kZAxis,
numberOfVoxelsAlongZ,
voxelZThickness);
HadrontherapyDummySD *dummySD = new HadrontherapyDummySD;
ROPhantomZDivisionLog -> SetSensitiveDetector(dummySD);
RODetectorZDivisionLog -> SetSensitiveDetector(dummySD);
return ROWorldPhys;
}
examples/advanced/hadrontherapy/src/HadrontherapyPhantomSD.cc → examples/advanced/hadrontherapy/src/HadrontherapyDetectorSD.cc
+19 -15
View File
@@ -23,7 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyPhantomSD.cc; May 2005
// $Id: HadrontherapyDetectorSD.cc;
// Last modified: G.A.P.Cirrone March 2008;
//
// See more at: http://geant4infn.wikispaces.com/HadrontherapyExample
//
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
@@ -38,40 +42,40 @@
// * cirrone@lns.infn.it
// ----------------------------------------------------------------------------
#include "HadrontherapyPhantomSD.hh"
#include "HadrontherapyDetectorSD.hh"
#include "HadrontherapyAnalysisManager.hh"
#include "HadrontherapyPhantomHit.hh"
#include "HadrontherapyDetectorHit.hh"
#include "G4Step.hh"
#include "G4VTouchable.hh"
#include "G4TouchableHistory.hh"
#include "G4SDManager.hh"
HadrontherapyPhantomSD::HadrontherapyPhantomSD(G4String name):G4VSensitiveDetector(name)
HadrontherapyDetectorSD::HadrontherapyDetectorSD(G4String name):G4VSensitiveDetector(name)
{
G4String HCname;
collectionName.insert(HCname="HadrontherapyPhantomHitsCollection");
collectionName.insert(HCname="HadrontherapyDetectorHitsCollection");
HitsCollection = NULL;
G4String sensitiveDetectorName = name;
}
HadrontherapyPhantomSD::~HadrontherapyPhantomSD()
HadrontherapyDetectorSD::~HadrontherapyDetectorSD()
{
}
void HadrontherapyPhantomSD::Initialize(G4HCofThisEvent*)
void HadrontherapyDetectorSD::Initialize(G4HCofThisEvent*)
{
HitsCollection = new HadrontherapyPhantomHitsCollection(sensitiveDetectorName,
HitsCollection = new HadrontherapyDetectorHitsCollection(sensitiveDetectorName,
collectionName[0]);
}
G4bool HadrontherapyPhantomSD::ProcessHits(G4Step* aStep, G4TouchableHistory* ROhist)
G4bool HadrontherapyDetectorSD::ProcessHits(G4Step* aStep, G4TouchableHistory* ROhist)
{
if(!ROhist)
return false;
if(aStep -> GetPreStepPoint() -> GetPhysicalVolume() -> GetName() != "PhantomPhys")
if(aStep -> GetPreStepPoint() -> GetPhysicalVolume() -> GetName() != "DetectorPhys")
return false;
G4double energyDeposit = aStep -> GetTotalEnergyDeposit();
@@ -89,10 +93,10 @@ G4bool HadrontherapyPhantomSD::ProcessHits(G4Step* aStep, G4TouchableHistory* RO
if(energyDeposit != 0)
{
// Create a hit with the information of position in the phantom and energy deposit
HadrontherapyPhantomHit* phantomHit = new HadrontherapyPhantomHit();
phantomHit -> SetEdepAndPosition(i, j, k, energyDeposit);
HitsCollection -> insert(phantomHit);
// Create a hit with the information of position is in the detector
HadrontherapyDetectorHit* detectorHit = new HadrontherapyDetectorHit();
detectorHit -> SetEdepAndPosition(i, j, k, energyDeposit);
HitsCollection -> insert(detectorHit);
}
// Energy deposit of secondary particles along X (integrated on Y and Z)
@@ -136,7 +140,7 @@ G4bool HadrontherapyPhantomSD::ProcessHits(G4Step* aStep, G4TouchableHistory* RO
return true;
}
void HadrontherapyPhantomSD::EndOfEvent(G4HCofThisEvent* HCE)
void HadrontherapyDetectorSD::EndOfEvent(G4HCofThisEvent* HCE)
{
static G4int HCID = -1;
if(HCID < 0)
examples/advanced/hadrontherapy/src/HadrontherapyEventAction.cc
+22 -11
View File
@@ -23,7 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyEventAction.cc; May 2005
// $Id: HadrontherapyEventAction.cc;
// Last modified: G.A.P.Cirrone March 2008;
//
// See more at: http://geant4infn.wikispaces.com/HadrontherapyExample
//
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
@@ -47,13 +51,13 @@
#include "G4SDManager.hh"
#include "G4VVisManager.hh"
#include "HadrontherapyEventAction.hh"
#include "HadrontherapyPhantomHit.hh"
#include "HadrontherapyPhantomSD.hh"
#include "HadrontherapyDetectorHit.hh"
#include "HadrontherapyDetectorSD.hh"
#include "HadrontherapyDetectorConstruction.hh"
#include "HadrontherapyMatrix.hh"
HadrontherapyEventAction::HadrontherapyEventAction(HadrontherapyMatrix* matrixPointer) :
drawFlag("all" )
drawFlag("all" ),printModulo(10000)
{
hitsCollectionID = -1;
matrix = matrixPointer;
@@ -63,11 +67,18 @@ HadrontherapyEventAction::~HadrontherapyEventAction()
{
}
void HadrontherapyEventAction::BeginOfEventAction(const G4Event* )
void HadrontherapyEventAction::BeginOfEventAction(const G4Event* evt)
{
G4SDManager* pSDManager = G4SDManager::GetSDMpointer();
if(hitsCollectionID == -1)
hitsCollectionID = pSDManager -> GetCollectionID("HadrontherapyPhantomHitsCollection");
G4int evtNb = evt->GetEventID();
//printing survey
if (evtNb%printModulo == 0)
G4cout << "\n---> Begin of Event: " << evtNb << G4endl;
G4SDManager* pSDManager = G4SDManager::GetSDMpointer();
if(hitsCollectionID == -1)
hitsCollectionID = pSDManager -> GetCollectionID("HadrontherapyDetectorHitsCollection");
}
void HadrontherapyEventAction::EndOfEventAction(const G4Event* evt)
@@ -76,17 +87,17 @@ void HadrontherapyEventAction::EndOfEventAction(const G4Event* evt)
return;
G4HCofThisEvent* HCE = evt -> GetHCofThisEvent();
HadrontherapyPhantomHitsCollection* CHC = NULL;
HadrontherapyDetectorHitsCollection* CHC = NULL;
if(HCE)
CHC = (HadrontherapyPhantomHitsCollection*)(HCE -> GetHC(hitsCollectionID));
CHC = (HadrontherapyDetectorHitsCollection*)(HCE -> GetHC(hitsCollectionID));
if(CHC)
{
if(matrix)
{
// Fill the matrix with the information: voxel and associated energy deposit
// in the phantom at the end of the event
// in the detector at the end of the event
G4int HitCount = CHC -> entries();
for (G4int h=0; h<HitCount; h++)
examples/advanced/hadrontherapy/src/HadrontherapyMaterial.cc
+27 -6
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyMaterial.cc; May 2005
// $Id: HadrontherapyMaterial.cc; Last modified: G.A.P.Cirrone, March 2008;
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
@@ -43,6 +43,7 @@
#include "G4Element.hh"
#include "G4ElementTable.hh"
#include "HadrontherapyMaterial.hh"
#include "G4NistManager.hh"
HadrontherapyMaterial::HadrontherapyMaterial():
matW(0), matAl(0), matSi(0), matTa(0), matCu(0),
@@ -83,8 +84,27 @@ void HadrontherapyMaterial::DefineMaterials()
G4double fractionmass; // Fraction in mass of an element in a material
G4int nAtoms; // Number of atoms in a molecuule
/////////////////////////////////////////////////////////////////////////////
// MATERIA DEFINITION FOLLOWING THE NIST DATABASE
// Pointer to the G4Nist manager
// for the material definition following
// the NIST database.
// It recommended to use this when
// the Standard models for electromagnetic physic
// are called
G4NistManager* nistMaterialManager = G4NistManager::Instance();
G4bool isotopes = false;
// Material NIST definition
nistMaterialManager -> FindOrBuildMaterial("G4_AIR" , isotopes);
nistMaterialManager -> FindOrBuildMaterial("G4_WATER", isotopes);
nistMaterialManager -> FindOrBuildMaterial("G4_PMMA", isotopes);
nistMaterialManager -> FindOrBuildMaterial("G4_MYLAR", isotopes);
/////////////////////////////////////////////////////////////////////////////
// Elements
a = 1.01*g/mole;
G4Element* elH = new G4Element ("Hydrogen","H",z = 1.,a);
@@ -211,7 +231,7 @@ void HadrontherapyMaterial::DefineMaterials()
matAir -> AddElement(elN,0.7);
matAir -> AddElement(elO,0.3);
// Water
// Water by "hand"
d = 1.000*g/cm3;
nComponents = 2;
matH2O = new G4Material("Water", d, nComponents);
@@ -220,7 +240,8 @@ void HadrontherapyMaterial::DefineMaterials()
matH2O -> GetIonisation()->SetMeanExcitationEnergy(75.0*eV);
matH2O -> SetChemicalFormula("H_2O");
G4cout << "-----------> CHEMICAL FORMULA FOR WATER FIXED <----------"<< G4endl;
//soft tissue(http://www.nist.gov)
d = 1.0*g/cm3;
nComponents = 13;
@@ -245,7 +266,7 @@ void HadrontherapyMaterial::DefineMaterials()
d = 19.32*g/cm3;
gold = new G4Material("gold", z, a, d);
// Compact bone (http://www.NIST.gov)
// Compact bone
d = 1.85*g/cm3;
nComponents = 8;
bone = new G4Material("bone", d, nComponents);
@@ -258,7 +279,7 @@ void HadrontherapyMaterial::DefineMaterials()
bone -> AddElement(elS,0.002);
bone -> AddElement(elCa,0.147);
//muscle(http://www.NIST.gov)
//muscle
nComponents = 9;
muscle = new G4Material("muscle", d, nComponents);
muscle -> AddElement(elH,0.101997);
examples/advanced/hadrontherapy/src/HadrontherapyMatrix.cc
+17 -12
View File
@@ -23,7 +23,12 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyPhantomSD.cc; May 2005
//
// $Id: HadrontherapyMatrix.cc;
// Last modified: G.A.P.Cirrone, May 2008;
//
// See more at: http://geant4infn.wikispaces.com/HadrontherapyExample
//
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
@@ -46,9 +51,9 @@
HadrontherapyMatrix::HadrontherapyMatrix()
{
// Number of the voxels of the phantom
numberVoxelX = 200;
numberVoxelY = 200;
numberVoxelZ = 200;
numberVoxelX = 400;
numberVoxelY = 1;
numberVoxelZ = 1;
// Create the matrix
matrix = new G4double[numberVoxelX*numberVoxelY*numberVoxelZ];
@@ -94,20 +99,20 @@ void HadrontherapyMatrix::TotalEnergyDeposit()
if (matrix)
{
for(G4int l = 0; l < numberVoxelZ; l++)
{
k = l;
for(G4int m = 0; m < numberVoxelY; m++)
{
j = m * numberVoxelZ + k;
for(G4int l = 0; l < numberVoxelZ; l++)
{
k = l;
for(G4int m = 0; m < numberVoxelY; m++)
{
j = m * numberVoxelZ + k;
for(G4int n = 0; n < numberVoxelX; n++)
{
i = n* numberVoxelZ * numberVoxelY + j;
if(matrix[i] != 0)
{
#ifdef G4ANALYSIS_USE
HadrontherapyAnalysisManager* analysis =
HadrontherapyAnalysisManager::getInstance();
examples/advanced/hadrontherapy/src/HadrontherapyModulator.cc
+1 -1
View File
@@ -163,7 +163,7 @@ void HadrontherapyModulator::BuildModulator(G4VPhysicalVolume* motherVolume)
// Mother of the modulator wheel
G4ThreeVector positionMotherMod = G4ThreeVector(-2260.50 *mm, 30 *mm, 50 *mm);
G4ThreeVector positionMotherMod = G4ThreeVector(-1960.50 *mm, 30 *mm, 50 *mm);
G4Box* solidMotherMod = new G4Box("MotherMod", 12 *cm, 12 *cm, 12 *cm);
examples/advanced/hadrontherapy/src/HadrontherapyPhysicsList.cc
+44 -10
View File
@@ -23,13 +23,17 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyPhysicsList.cc,v 1.0
// $Id: HadrontherapyPhysicsList.cc
// Last modified: M.P. Russo Nov 2008;
//
// See more at: http://geant4infn.wikispaces.com/
//
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
// Code developed by:
//
// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a), M.P. Russo
//
// (a) Laboratori Nazionali del Sud
// of the National Institute for Nuclear Physics, Catania, Italy
@@ -45,6 +49,11 @@
#include "G4ParticleDefinition.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4PhysListFactory.hh"
#include "G4VModularPhysicsList.hh"
#include "G4VPhysicsConstructor.hh"
#include "HadrontherapyPhysicsList.hh"
#include "HadrontherapyPhysicsListMessenger.hh"
#include "HadrontherapyParticles.hh"
@@ -77,6 +86,7 @@
#include "HEHadronIonQElastic.hh"
#include "HEHadronIonUElastic.hh"
#include "HRMuonMinusCapture.hh"
#include "G4EmProcessOptions.hh"
HadrontherapyPhysicsList::HadrontherapyPhysicsList(): G4VModularPhysicsList(),
@@ -92,9 +102,9 @@ HadrontherapyPhysicsList::HadrontherapyPhysicsList(): G4VModularPhysicsList(),
hadrInelasticProtonNeutronIsRegistered(false),
hadrAtRestMuonIsRegistered(false)
{
// The secondary production threshold is set to 10. mm
// for all the particles in all the experimental set-up
// The phantom is defined as a Geant4 Region. Here the cut is fixed to 0.001 mm
// A default cut is applied to all volumes
// Moreover, in the HadrontherapyDetectorConstruction.cc a
// spevific cut can be applied to the region where energy is collected
defaultCutValue = 0.01 * mm;
// Messenger: it is possible to activate physics processes and models interactively
@@ -111,17 +121,43 @@ HadrontherapyPhysicsList::~HadrontherapyPhysicsList()
delete messenger;
}
void HadrontherapyPhysicsList::AddPackage(const G4String& name)
{
G4PhysListFactory factory;
G4VModularPhysicsList* phys =factory.GetReferencePhysList(name);
G4int i=0;
const G4VPhysicsConstructor* elem= phys->GetPhysics(i);
G4VPhysicsConstructor* tmp = const_cast<G4VPhysicsConstructor*> (elem);
while (elem !=0)
{
RegisterPhysics(tmp);
elem= phys->GetPhysics(++i) ;
tmp = const_cast<G4VPhysicsConstructor*> (elem);
}
}
void HadrontherapyPhysicsList::AddPhysicsList(const G4String& name)
{
G4cout << "Adding PhysicsList component " << name << G4endl;
// Options activated to improve accuracy and activated for the Standard EM models
// Usefull for a medical application
G4EmProcessOptions opt;
opt.SetStepFunction(0.2, 10*um);
opt.SetMinEnergy(0.1*keV);
opt.SetMaxEnergy(100.*GeV);
opt.SetDEDXBinning(360);
opt.SetLambdaBinning(360);
opt.SetLinearLossLimit(1.e-6);
G4cout << "Adding PhysicsList component " << name << G4endl;
// ****************
// *** A. DECAY ***
// ****************
if (name == "Decay")
{
if (decayIsRegistered)
{
@@ -777,15 +813,13 @@ void HadrontherapyPhysicsList::SetCuts()
// Definition of a smaller threshold of production in the phantom region
// where high accuracy is required in the energy deposit calculation
G4String regionName = "PhantomLog";
G4String regionName = "DetectorLog";
G4Region* region = G4RegionStore::GetInstance()->GetRegion(regionName);
G4ProductionCuts* cuts = new G4ProductionCuts ;
G4double regionCut = 0.01*mm;
cuts -> SetProductionCut(regionCut,G4ProductionCuts::GetIndex("gamma"));
cuts -> SetProductionCut(regionCut,G4ProductionCuts::GetIndex("e-"));
cuts -> SetProductionCut(regionCut,G4ProductionCuts::GetIndex("e+"));
cuts -> SetProductionCut(regionCut,G4ProductionCuts::GetIndex("proton"));
cuts -> SetProductionCut(regionCut,G4ProductionCuts::GetIndex("genericIons"));
region -> SetProductionCuts(cuts);
if (verboseLevel>0) DumpCutValuesTable();
examples/advanced/hadrontherapy/src/HadrontherapyPhysicsListMessenger.cc
+11 -3
View File
@@ -23,13 +23,13 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyPhisicsListMessenger.cc; May 2005
// $Id: HadrontherapyPhisicsListMessenger.cc; Nov 2008
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
// Code developed by:
//
// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a), M.P. Russo
//
// (a) Laboratori Nazionali del Sud
// of the National Institute for Nuclear Physics, Catania, Italy
@@ -56,18 +56,26 @@ HadrontherapyPhysicsListMessenger::HadrontherapyPhysicsListMessenger(Hadronthera
physicsListCmd->SetGuidance("Add chunks of PhysicsList.");
physicsListCmd->SetParameterName("physList",false);
physicsListCmd->AvailableForStates(G4State_PreInit);
packageListCmd = new G4UIcmdWithAString("/physics/addPackage",this);
packageListCmd->SetGuidance("Add physics package.");
packageListCmd->SetParameterName("package",false);
packageListCmd->AvailableForStates(G4State_PreInit);
}
HadrontherapyPhysicsListMessenger::~HadrontherapyPhysicsListMessenger()
{
delete physicsListCmd;
delete listDir;
delete packageListCmd;
}
void HadrontherapyPhysicsListMessenger::SetNewValue(G4UIcommand* command,G4String newValue)
{
if (command == physicsListCmd)
{ physicsList->AddPhysicsList(newValue);}
{ physicsList->AddPhysicsList(newValue);}
else if (command == packageListCmd)
{ physicsList->AddPackage(newValue);}
}
examples/advanced/hadrontherapy/src/HadrontherapyPrimaryGeneratorAction.cc
+9 -4
View File
@@ -23,7 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyPositronPrimaryGeneratorAction.cc; May 2005
//
// $Id: HadrontherapyPrimarygeneratorAction.cc;
// Last modified: G.A.P.Cirrone, May 2008;
//
// See more at: http://geant4infn.wikispaces.com/HadrontherapyExample
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
@@ -74,9 +78,9 @@ void HadrontherapyPrimaryGeneratorAction::SetDefaultPrimaryParticle()
particleGun -> SetParticleDefinition(particle);
// Define the energy of primary particles:
// gaussian distribution with mean energy = 64.55 *MeV
// gaussian distribution with mean energy = 64.00 *MeV
// and sigma = 300.0 *keV
G4double defaultMeanKineticEnergy = 63.50 *MeV;
G4double defaultMeanKineticEnergy = 64.00 *MeV;
meanKineticEnergy = defaultMeanKineticEnergy;
G4double defaultsigmaEnergy = 300.0 *keV;
@@ -84,7 +88,8 @@ void HadrontherapyPrimaryGeneratorAction::SetDefaultPrimaryParticle()
// Define the parameters of the initial position:
// the y, z coordinates have a gaussian distribution
G4double defaultX0 = -3248.59 *mm;
G4double defaultX0 = -2700.0 *mm;
X0 = defaultX0;
G4double defaultY0 = 0.0 *mm;
examples/advanced/hadrontherapy/src/HadrontherapySteppingAction.cc
+16 -9
View File
@@ -23,7 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyProtonSteppingAction.cc; May 2005
// $Id: HadrontherapyProtonSteppingAction.cc;
// Last modified: G.A.P.Cirrone March 2008;
//
// See more at: http://geant4infn.wikispaces.com/HadrontherapyExample
//
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
@@ -57,20 +61,23 @@
#include "HadrontherapyRunAction.hh"
/////////////////////////////////////////////////////////////////////////////
HadrontherapySteppingAction::HadrontherapySteppingAction( HadrontherapyRunAction* run)
{
runAction = run;
}
/////////////////////////////////////////////////////////////////////////////
HadrontherapySteppingAction::~HadrontherapySteppingAction()
{
}
/////////////////////////////////////////////////////////////////////////////
void HadrontherapySteppingAction::UserSteppingAction(const G4Step* aStep)
{
// Electromagnetic and hadronic processes of primary particles in the phantom
if ((aStep -> GetTrack() -> GetTrackID() == 1) &&
// Electromagnetic and hadronic processes of primary particles in the phantom
if ((aStep -> GetTrack() -> GetTrackID() == 1) &&
(aStep -> GetTrack() -> GetVolume() -> GetName() == "PhantomPhys") &&
(aStep -> GetPostStepPoint() -> GetProcessDefinedStep() != NULL))
{
@@ -96,11 +103,10 @@ void HadrontherapySteppingAction::UserSteppingAction(const G4Step* aStep)
// Retrieve information about the secondaries originated in the phantom
#ifdef G4ANALYSIS_USE
G4SteppingManager* steppingManager = fpSteppingManager;
G4Track* theTrack = aStep -> GetTrack();
G4SteppingManager* steppingManager = fpSteppingManager;
// check if it is alive
if(theTrack-> GetTrackStatus() == fAlive) { return; }
//if(theTrack-> GetTrackStatus() == fAlive) { return; }
// Retrieve the secondary particles
G4TrackVector* fSecondary = steppingManager -> GetfSecondary();
@@ -136,9 +142,10 @@ void HadrontherapySteppingAction::UserSteppingAction(const G4Step* aStep)
{
G4int a = (*fSecondary)[lp1]-> GetDynamicParticle() -> GetDefinition() -> GetBaryonNumber();
G4int electronOccupancy = (*fSecondary)[lp1] -> GetDynamicParticle() -> GetTotalOccupancy();
// If a generic ion is originated in the phantom, its baryonic number, PDG charge,
// If a generic ion is originated in the detector, its baryonic number, PDG charge,
// total number of electrons in the orbitals are stored in a ntuple
analysis -> genericIonInformation(a, z, electronOccupancy, secondaryParticleKineticEnergy/MeV);
analysis -> genericIonInformation(a, z, electronOccupancy, secondaryParticleKineticEnergy/MeV);
}
}
}