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

Import Geant4 8.2.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-09 14:55:03 +02:00
parent 216a75eeb1
commit fe73f43734
6714 changed files with 118229 additions and 68144 deletions
Download Patch File Download Diff File Expand all files Collapse all files
examples/advanced/hadrontherapy/History
+19 -1
View File
@@ -3,11 +3,29 @@ $Id: History, v 1.6 2004/02/27 G.A.P. Cirrone
-----------------------------------------------------------
====================================================
Geant4 - Hadrontherapy
Geant4 - Hadrontherapy
====================================================
Category History file
---------------------
16.11.2006 S. Guatelli (hadrontherapy-V08-01-05)
- Physics lists cleaned
15.11.2006 G.A.P. Cirrone (hadrontherapy-V08-01-04)
- Changed cut and cut per region default values. Improved Max Step function
along the beam line.
14.11.2006 J. Allison
- Removed /vis/scene/transientsAction none (no longer available).
02.10.2006 G.A.P. Cirrone and S. Guatelli(hadrontherapy-V08-01-03)
- Bug fix in the geometry (hadrontherapy beam line)
problem: wrong volume hierarchy
24.07.2006 S. Guatelli (hadrontherapy-V08-01-00)
- Bug fix in the HadrontherapyProtonPrecompound.cc concerning
neutron fission and capture
30.05.2006 S. Guatelli (hadrontherapy-V08-00-04)
- Bug deleted in all the hadronic phsyics lists; the hadronic
examples/advanced/hadrontherapy/bertini.mac
+8 -5
View File
@@ -6,7 +6,7 @@
# - INELASTIC SCATTERING --->
# PRECOMPOUND PHYSICS LIST with THE DEFAULT EVAPORATION MODEL AND WITHOUT THE FERMI BREAK-UP
#
# * BERTINI MODEL FOR PROTONS,
# * PRECOMPOUND + EVAPORATION (DEFAULT MODEL) NO FERMI BREAK-UP FOR PROTONS,
# NEUTRONS AND PIONS
#
# * LEP MODEL UP TO 100 MEV AND BINARY ION MODEL BETWEEN 80 MEV AND 40. GEV
@@ -32,7 +32,7 @@
/physics/addPhysics decay
# SETTING FOR THE PARTICULAR HADRONIC MODEL
/physics/addPhysics bertini
/physics/addPhysics proton-bertini
/run/initialize
@@ -42,9 +42,12 @@
#/beamLine/RangeShifter/thickness 4 cm
#/beamLine/RangeShifter/RSMat Water
/vis/viewer/flush
/run/beamOn 1000
/run/beamOn 500
examples/advanced/hadrontherapy/binaryDefault.mac
-45
View File
@@ -1,45 +0,0 @@
#----------------------------------------------------------------------------
# PHYSICS LIST:
#
# - LOW ENERGY ELECTROMAGNETIC PHYSICS
# - ELASTIC SCATTERING FOR ALL THE HADRONS AND IONS
# - INELASTIC SCATTERING --->
#
# * BINARY CASCADE MODEL WITH THE DEFAULT PRECOMPOUND
#
# * LEP MODEL UP TO 100 MEV AND BINARY ION MODEL BETWEEN 80 MEV AND 40. GEV
# FOR DEUTERON, TRITON, HE3, ALPHA
#
# * FISSION AND HADRON CAPTURE FOR NEUTRONS BETWEEN 0. MEV AND 100. TEV
#
#
#-------------------------------------------------------------------------------
/control/verbose 1
/tracking/verbose 0
/run/verbose 0
/event/verbose 0
# SETTING FOR THE PHYSICS MODELS
/physics/addPhysics photon-epdl
/physics/addPhysics electron-eedl
/physics/addPhysics positron-standard
/physics/addPhysics ion-LowE
/physics/addPhysics proton-precompound-binary
/physics/addPhysics muon-standard
/physics/addPhysics decay
/run/initialize
# IF YOU WANT A RANGE SHIFTER PLEASE CHANGE
# THE FOLLOWIG PARAMETERS
# SETTING FOR THE RANGE SHIFTER
#/beamLine/RangeShifter/thickness 0 cm
#/beamLine/RangeShifter/RSMat Water
#/tracking/verbose 1
/beam/energy/meanEnergy 25 MeV
/run/beamOn 100
examples/advanced/hadrontherapy/currentEvent.rndm
+174 -174
View File
@@ -1,203 +1,203 @@
Uvec
2226355706
1071703215
2147483648
1071384726
2147483648
1072034353
2684354560
1070570947
0
1071698880
1072117611
1610612736
1068998050
0
1070013228
2147483648
1072614208
0
1072635681
536870912
1071851394
0
1072685874
536870912
1072377448
1610612736
1070853780
1073741824
1069647016
2147483648
1070874471
3221225472
1067083504
0
1068625460
0
1072116142
0
1072495278
536870912
1071668168
2147483648
1068452266
0
1070896795
2147483648
1070768794
0
1071388582
1073741824
1071749431
1072474390
3758096384
1070298467
0
1071367454
3221225472
1071959766
1073741824
1070638935
0
1071867903
1073741824
1071611865
0
1071839277
536870912
1072662627
0
1071930492
0
1071555665
1073741824
1069013722
0
1072054667
3221225472
1070641352
3221225472
1069857933
0
1066470476
0
1071352944
1073741824
1071695989
536870912
1070793269
0
1071822457
536870912
1071967002
1072056252
1610612736
1068549642
1071879239
0
1071578742
3221225472
1069716552
2147483648
1071668383
2684354560
1070946140
2147483648
1072145389
0
1071658598
1072292310
3758096384
1072679907
1071892397
3758096384
1072083606
2147483648
1072137233
1070833779
1073741824
1072568340
2684354560
1066143112
0
1070850314
1070627542
2147483648
1068065164
0
1069720738
1070211792
2147483648
1072295888
2684354560
1072131427
3758096384
1071899044
1072345802
1610612736
1072079169
1068850291
0
1071588201
3221225472
1071051474
1073741824
1071762151
3221225472
1071081728
3221225472
1072587532
1073741824
1070206898
2147483648
1071999392
1610612736
1068762358
0
1071327201
2147483648
1071534434
3221225472
1071063361
3221225472
1072269914
2684354560
1071864209
1071957532
536870912
1068778056
1069655588
0
1070175791
1069415718
0
1072232850
1073741824
1070952822
0
1067725964
0
1071381321
0
1072229963
1610612736
1070475310
0
1072478700
1610612736
1068733037
0
1072341873
1071408867
2147483648
1071071539
2147483648
1071985410
3758096384
1072658241
3221225472
1071929349
1073741824
1071405470
1069141981
0
1071691832
2684354560
1071187435
0
1070891902
2147483648
1072080829
1071899078
536870912
1072413488
3758096384
1072232517
1073741824
1071157787
1071753217
0
1069928263
2147483648
1072465233
1072448270
2684354560
1071363092
1071673783
2147483648
1071953458
2684354560
1071939849
1071212335
0
1070403033
0
1067911822
0
1069506703
0
1071894475
1071194310
3221225472
1071879158
1610612736
1072225459
1067850418
0
1072668722
2684354560
1071418550
1073741824
1071374082
3221225472
1070629504
3221225472
1070456746
0
1071830657
2684354560
1072073430
1073741824
1072186161
2684354560
1071417969
1073741824
1072486452
2684354560
1071429109
0
1070391955
2147483648
1071801088
2684354560
1072506823
3758096384
1071967156
1610612736
1071876772
2147483648
1072265406
0
1071325579
2147483648
1071851021
536870912
1071981605
2684354560
1072265211
1073741824
1072293446
2684354560
1068355136
0
1070697330
1073741824
1072637171
1073741824
1071719676
0
1072343457
1073741824
1067937546
0
1071770664
2147483648
1068451014
0
1072084223
1610612736
1072402541
1610612736
1072393275
0
1071950375
3221225472
1071465126
0
1071604482
1073741824
1072248661
0
1072182419
3221225472
1070214037
0
1072294972
3758096384
1071581359
1073741824
1071596144
0
1072293255
3758096384
1069637560
0
1071098882
2147483648
1069172691
0
1071855760
0
1070550116
0
1071296702
1073741824
1072232776
2147483648
1070626446
2147483648
1070174602
2147483648
1071571772
1073741824
1071765798
2684354560
1072310981
3758096384
1068567187
0
1070283848
2147483648
1071233108
0
1072552408
2684354560
1071308624
1073741824
1072003335
3758096384
1070825712
0
1071461100
1073741824
1072693247
2684354560
39
70
examples/advanced/hadrontherapy/defaultMacro.mac
-1
View File
@@ -50,7 +50,6 @@
/tracking/storeTrajectory 1
/vis/scene/endOfEventAction accumulate
/vis/viewer/update
/vis/scene/transientsAction none
/run/beamOn 100
examples/advanced/hadrontherapy/include/HadrontherapyBeamLine.hh
+2
View File
@@ -137,6 +137,8 @@ private:
G4VPhysicalVolume* physiThirdMonitorLayer3;
G4VPhysicalVolume* physiThirdMonitorLayer4;
G4VPhysicalVolume* physiNozzleSupport;
G4VPhysicalVolume* physiHoleNozzle;
G4VPhysicalVolume* physiHoleNozzleSupport;
G4VPhysicalVolume* physiSecondHoleNozzleSupport;
G4Tubs* solidFinalCollimator;
examples/advanced/hadrontherapy/include/HadrontherapyDetectorConstruction.hh
+1 -1
View File
@@ -109,7 +109,7 @@ public:
// This method allows to change the material
// of the range shifter through UI command.
void ComputeVoxelSize() {phantomSizeX/numberOfVoxelsAlongX;}
G4double ComputeVoxelSize() {return phantomSizeX/numberOfVoxelsAlongX;};
// Returns the size of the voxel along the X axis
private:
examples/advanced/hadrontherapy/include/HadrontherapyProtonBertini.hh
+7 -73
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyProtonBertini.hh; May 2005
// $Id: HadrontherapyProtonBertiniElastic.hh; May 2005
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
@@ -42,48 +42,11 @@
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4ProcessManager.hh"
#include "G4ExcitationHandler.hh"
#include "G4PreCompoundModel.hh"
#include "G4ProtonInelasticCrossSection.hh"
#include "G4TheoFSGenerator.hh"
#include "G4ExcitationHandler.hh"
#include "G4PreCompoundModel.hh"
#include "G4ExcitedStringDecay.hh"
// For neutron
#include "G4HENeutronInelastic.hh"
#include "G4LENeutronInelastic.hh"
#include "G4LFission.hh"
#include "G4LCapture.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4NeutronInelasticCrossSection.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronHPElastic.hh"
#include "G4NeutronHPElasticData.hh"
#include "G4NeutronHPInelastic.hh"
#include "G4NeutronHPInelasticData.hh"
// For ions
#include "G4TripathiCrossSection.hh"
#include "G4IonsShenCrossSection.hh"
#include "G4HadronInelasticProcess.hh"
#include "G4BinaryLightIonReaction.hh"
//#include "G4BinaryCascade.hh"
#include "G4IonInelasticProcess.hh"
#include "G4LEDeuteronInelastic.hh"
#include "G4DeuteronInelasticProcess.hh"
#include "G4TritonInelasticProcess.hh"
#include "G4LETritonInelastic.hh"
#include "G4AlphaInelasticProcess.hh"
#include "G4LEAlphaInelastic.hh"
class HadrontherapyProtonBertini: public G4VPhysicsConstructor
{
@@ -96,41 +59,12 @@ class HadrontherapyProtonBertini: public G4VPhysicsConstructor
void ConstructParticle(){};
void ConstructProcess();
private:
G4double binaryLightIonLowLimit;
G4double binaryLightIonHighLimit;
G4double LEPHighLimit;
G4double bertiniLowLimit;
G4double bertiniHighLimit;
G4double neutronLowLimit;
G4double neutronHighLimit;
G4ExcitationHandler theHandler;
// Proton inelastic proces
G4ProtonInelasticProcess theIPProton;
// Cross Section for proton inelastic process
G4ProtonInelasticCrossSection thePXSec;
// Neutron inelastic process
G4NeutronInelasticProcess theIPNeutron;
// Cross Section for neutron inelastic process
G4NeutronInelasticCrossSection theNXSec;
// Deuteron inelastic process
G4DeuteronInelasticProcess theIPdeuteron;
// Tritium inelastic process
G4TritonInelasticProcess theIPtriton;
// Alpha inelastic process
G4AlphaInelasticProcess theIPalpha;
// He3 inelastic process
G4HadronInelasticProcess* theIPHe3;
private:
G4ProtonInelasticCrossSection theProtonCrossSection;
G4NeutronInelasticCrossSection theNeutronCrossSection;
G4DeuteronInelasticProcess theDeuteronInelasticProcess;
G4TritonInelasticProcess theTritonInelasticProcess;
G4AlphaInelasticProcess theAlphaInelasticProcess;
};
#endif
examples/advanced/hadrontherapy/include/HadrontherapyProtonBinary.hh
-132
View File
@@ -1,132 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyProtonBinary.hh; May 2005
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
// Code developed by:
//
// 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
//
// * cirrone@lns.infn.it
// ----------------------------------------------------------------------------
#ifndef HadrontherapyProtonBinary_h
#define HadrontherapyProtonBinary_h 1
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4ProcessManager.hh"
#include "G4ExcitationHandler.hh"
#include "G4PreCompoundModel.hh"
#include "G4ProtonInelasticCrossSection.hh"
#include "G4TheoFSGenerator.hh"
#include "G4ExcitationHandler.hh"
#include "G4PreCompoundModel.hh"
#include "G4ExcitedStringDecay.hh"
// For neutron
#include "G4HENeutronInelastic.hh"
#include "G4LENeutronInelastic.hh"
#include "G4LFission.hh"
#include "G4LCapture.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4NeutronInelasticCrossSection.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronHPElastic.hh"
#include "G4NeutronHPElasticData.hh"
#include "G4NeutronHPInelastic.hh"
#include "G4NeutronHPInelasticData.hh"
// For ions
#include "G4TripathiCrossSection.hh"
#include "G4IonsShenCrossSection.hh"
#include "G4HadronInelasticProcess.hh"
#include "G4BinaryLightIonReaction.hh"
#include "G4BinaryCascade.hh"
#include "G4IonInelasticProcess.hh"
#include "G4LEDeuteronInelastic.hh"
#include "G4DeuteronInelasticProcess.hh"
#include "G4TritonInelasticProcess.hh"
#include "G4LETritonInelastic.hh"
#include "G4AlphaInelasticProcess.hh"
#include "G4LEAlphaInelastic.hh"
class HadrontherapyProtonBinary: public G4VPhysicsConstructor
{
public:
HadrontherapyProtonBinary(const G4String& name = "proton-precompound-binary");
virtual ~HadrontherapyProtonBinary();
protected:
// Construct particle and physics
void ConstructParticle(){};
void ConstructProcess();
private:
G4double binaryLightIonLowLimit;
G4double binaryLightIonHighLimit;
G4double LEPHighLimit;
G4double precompoundLowLimit;
G4double precompoundHighLimit;
G4double binaryLowLimit;
G4double binaryHighLimit;
G4double neutronLowLimit;
G4double neutronHighLimit;
G4ProtonInelasticCrossSection theXSec;
G4ExcitationHandler theHandler;
G4DeuteronInelasticProcess theIPdeuteron;
G4TritonInelasticProcess theIPtriton;
G4AlphaInelasticProcess theIPalpha;
G4HadronInelasticProcess* theIPHe3;
G4HadronInelasticProcess* theIPIonC12;
G4HadronInelasticProcess* theIPGenericIon;
G4ProtonInelasticCrossSection thePXSec;
G4ProtonInelasticProcess theIPProton;
G4NeutronInelasticProcess theIPNeutron;
G4NeutronInelasticCrossSection theNXSec;
};
#endif
examples/advanced/hadrontherapy/include/HadrontherapyProtonPrecompound.hh
+19 -81
View File
@@ -32,107 +32,45 @@
// G.A.P. Cirrone(a)*, F. Di Rosa(a), S. Guatelli(b), G. Russo(a)
//
// (a) Laboratori Nazionali del Sud
// of the INFN, Catania, Italy
// (b) INFN Section of Genova, Genova, Italy
// of the National Institute for Nuclear Physics, Catania, Italy
// (b) National Institute for Nuclear Physics Section of Genova, genova, Italy
//
// * cirrone@lns.infn.it
// ----------------------------------------------------------------------------
#ifndef HadrontherapyProtonPrecompound_h
#define HadrontherapyProtonPrecompound_h 1
#include "G4VPhysicsConstructor.hh"
#include "G4ExcitationHandler.hh"
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4ProcessManager.hh"
#include "G4PreCompoundModel.hh"
#include "G4ProtonInelasticCrossSection.hh"
#include "G4TheoFSGenerator.hh"
#include "G4ExcitationHandler.hh"
#include "G4PreCompoundModel.hh"
#include "G4GeneratorPrecompoundInterface.hh"
#include "G4ExcitedStringDecay.hh"
// For neutron
#include "G4HENeutronInelastic.hh"
#include "G4LENeutronInelastic.hh"
#include "G4LFission.hh"
#include "G4LCapture.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4NeutronInelasticCrossSection.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronHPElastic.hh"
#include "G4NeutronHPElasticData.hh"
#include "G4NeutronHPInelastic.hh"
#include "G4NeutronHPInelasticData.hh"
// For ions
#include "G4TripathiCrossSection.hh"
#include "G4IonsShenCrossSection.hh"
#include "G4HadronInelasticProcess.hh"
#include "G4BinaryLightIonReaction.hh"
#include "G4BinaryCascade.hh"
#include "G4IonInelasticProcess.hh"
#include "G4LEDeuteronInelastic.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4DeuteronInelasticProcess.hh"
#include "G4TritonInelasticProcess.hh"
#include "G4LETritonInelastic.hh"
#include "G4AlphaInelasticProcess.hh"
#include "G4LEAlphaInelastic.hh"
#include "G4PionPlusInelasticProcess.hh"
#include "G4PionMinusInelasticProcess.hh"
#include "G4PiNuclearCrossSection.hh"
class G4HadronInelasticProcess;
#include "G4ExcitationHandler.hh"
class HadrontherapyProtonPrecompound: public G4VPhysicsConstructor
{
public:
HadrontherapyProtonPrecompound(const G4String& name = "proton-precompound");
virtual ~HadrontherapyProtonPrecompound();
public:
HadrontherapyProtonPrecompound(const G4String& name = "proton-precompound");
virtual ~HadrontherapyProtonPrecompound();
protected:
// Construct particle and physics
void ConstructParticle(){};
void ConstructProcess();
protected:
// Construct particle and physics
void ConstructParticle(){};
void ConstructProcess();
private:
G4double binaryLightIonLowLimit;
G4double binaryLightIonHighLimit;
G4double LEPHighLimit;
G4double precompoundLowLimit;
G4double precompoundHighLimit;
G4double neutronLowLimit;
G4double neutronHighLimit;
G4ExcitationHandler theHandler;
// Proton inelastic proces
G4ProtonInelasticProcess protonInelasticProcess;
// Cross Section for proton inelastic process
G4ProtonInelasticCrossSection protonInelasticCrossSection;
// Neutron inelastic process
G4NeutronInelasticProcess neutronInelasticProcess;
// Cross Section for neutron inelastic process
G4ExcitationHandler theHandler;
G4ProtonInelasticProcess protonInelasticProcess;
G4ProtonInelasticCrossSection protonInelasticCrossSection;
G4NeutronInelasticProcess neutronInelasticProcess;
G4NeutronInelasticCrossSection neutronInelasticCrossSection;
// Deuteron inelastic process
G4DeuteronInelasticProcess deuteronInelasticProcess;
// Tritium inelastic process
G4TritonInelasticProcess tritonInelasticProcess;
// Alpha inelastic process
G4AlphaInelasticProcess alphaInelasticProcess;
G4DeuteronInelasticProcess deuteronInelasticProcess;
G4TritonInelasticProcess tritonInelasticProcess;
G4AlphaInelasticProcess alphaInelasticProcess;
};
#endif
examples/advanced/hadrontherapy/include/HadrontherapyProtonPrecompoundFermi.hh
-146
View File
@@ -1,146 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyProtonPrecompoundFermi.hh; May 2005
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
// Code developed by:
//
// 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
//
// * cirrone@lns.infn.it
// ----------------------------------------------------------------------------
#ifndef HadrontherapyProtonPrecompoundFermi_h
#define HadrontherapyProtonPrecompoundFermi_h 1
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4ProcessManager.hh"
#include "G4ExcitationHandler.hh"
#include "G4PreCompoundModel.hh"
#include "G4ProtonInelasticCrossSection.hh"
#include "G4TheoFSGenerator.hh"
#include "G4ExcitationHandler.hh"
#include "G4PreCompoundModel.hh"
#include "G4GeneratorPrecompoundInterface.hh"
#include "G4ExcitedStringDecay.hh"
// For neutron
#include "G4HENeutronInelastic.hh"
#include "G4LENeutronInelastic.hh"
#include "G4LFission.hh"
#include "G4LCapture.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4NeutronInelasticCrossSection.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronHPElastic.hh"
#include "G4NeutronHPElasticData.hh"
#include "G4NeutronHPInelastic.hh"
#include "G4NeutronHPInelasticData.hh"
// For ions
#include "G4TripathiCrossSection.hh"
#include "G4IonsShenCrossSection.hh"
#include "G4HadronInelasticProcess.hh"
#include "G4BinaryLightIonReaction.hh"
#include "G4BinaryCascade.hh"
#include "G4IonInelasticProcess.hh"
#include "G4LEDeuteronInelastic.hh"
#include "G4DeuteronInelasticProcess.hh"
#include "G4TritonInelasticProcess.hh"
#include "G4LETritonInelastic.hh"
#include "G4AlphaInelasticProcess.hh"
#include "G4LEAlphaInelastic.hh"
#include "G4PiNuclearCrossSection.hh"
class HadrontherapyProtonPrecompoundFermi: public G4VPhysicsConstructor
{
public:
HadrontherapyProtonPrecompoundFermi(const G4String& name = "proton-precompoundFermi");
virtual ~HadrontherapyProtonPrecompoundFermi();
protected:
// Construct particle and physics
void ConstructParticle(){};
void ConstructProcess();
private:
G4double binaryLightIonLowLimit;
G4double binaryLightIonHighLimit;
G4double LEPHighLimit;
G4double precompoundLowLimit;
G4double precompoundHighLimit;
G4double neutronLowLimit;
G4double neutronHighLimit;
G4int targetA;
G4int targetZ;
G4ExcitationHandler theHandler;
// Proton inelastic proces
G4ProtonInelasticProcess theIPProton;
// Cross Section for proton inelastic process
G4ProtonInelasticCrossSection thePXSec;
// Neutron inelastic process
G4NeutronInelasticProcess theIPNeutron;
// Cross Section for neutron inelastic process
G4NeutronInelasticCrossSection theNXSec;
// Deuteron inelastic process
G4DeuteronInelasticProcess theIPdeuteron;
// Tritium inelastic process
G4TritonInelasticProcess theIPtriton;
// Alpha inelastic process
G4AlphaInelasticProcess theIPalpha;
// He3 inelastic process
G4HadronInelasticProcess* theIPHe3;
};
#endif
examples/advanced/hadrontherapy/include/HadrontherapyProtonPrecompoundGEM.hh
-143
View File
@@ -1,143 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyProtonPrecompoundGEM.hh; May 2005
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
// Code developed by:
//
// 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
//
// * cirrone@lns.infn.it
// ----------------------------------------------------------------------------
#ifndef HadrontherapyProtonPrecompoundGEM_h
#define HadrontherapyProtonPrecompoundGEM_h 1
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4ProcessManager.hh"
#include "G4ExcitationHandler.hh"
#include "G4PreCompoundModel.hh"
#include "G4ProtonInelasticCrossSection.hh"
#include "G4TheoFSGenerator.hh"
#include "G4ExcitationHandler.hh"
#include "G4PreCompoundModel.hh"
#include "G4GeneratorPrecompoundInterface.hh"
#include "G4ExcitedStringDecay.hh"
// For neutron
#include "G4HENeutronInelastic.hh"
#include "G4LENeutronInelastic.hh"
#include "G4LFission.hh"
#include "G4LCapture.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4NeutronInelasticCrossSection.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronHPElastic.hh"
#include "G4NeutronHPElasticData.hh"
#include "G4NeutronHPInelastic.hh"
#include "G4NeutronHPInelasticData.hh"
// For ions
#include "G4TripathiCrossSection.hh"
#include "G4IonsShenCrossSection.hh"
#include "G4HadronInelasticProcess.hh"
#include "G4BinaryLightIonReaction.hh"
#include "G4BinaryCascade.hh"
#include "G4IonInelasticProcess.hh"
#include "G4LEDeuteronInelastic.hh"
#include "G4DeuteronInelasticProcess.hh"
#include "G4TritonInelasticProcess.hh"
#include "G4LETritonInelastic.hh"
#include "G4AlphaInelasticProcess.hh"
#include "G4LEAlphaInelastic.hh"
class HadrontherapyProtonPrecompoundGEM: public G4VPhysicsConstructor
{
public:
HadrontherapyProtonPrecompoundGEM(const G4String& name = "proton-precompoundGEM");
virtual ~HadrontherapyProtonPrecompoundGEM();
protected:
// Construct particle and physics
void ConstructParticle(){};
void ConstructProcess();
private:
G4double binaryLightIonLowLimit;
G4double binaryLightIonHighLimit;
G4double LEPHighLimit;
G4double precompoundLowLimit;
G4double precompoundHighLimit;
G4double neutronLowLimit;
G4double neutronHighLimit;
G4ExcitationHandler theHandler;
// Proton inelastic proces
G4ProtonInelasticProcess theIPProton;
// Cross Section for proton inelastic process
G4ProtonInelasticCrossSection thePXSec;
// Neutron inelastic process
G4NeutronInelasticProcess theIPNeutron;
// Cross Section for neutron inelastic process
G4NeutronInelasticCrossSection theNXSec;
// Deuteron inelastic process
G4DeuteronInelasticProcess theIPdeuteron;
// Tritium inelastic process
G4TritonInelasticProcess theIPtriton;
// Alpha inelastic process
G4AlphaInelasticProcess theIPalpha;
// He3 inelastic process
G4HadronInelasticProcess* theIPHe3;
};
#endif
examples/advanced/hadrontherapy/include/HadrontherapyProtonPrecompoundGEMFermi.hh
-145
View File
@@ -1,145 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyProtonPrecompoundGEMFermi.hh; May 2005
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
// Code developed by:
//
// 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
//
// * cirrone@lns.infn.it
// ----------------------------------------------------------------------------
#ifndef HadrontherapyProtonPrecompoundGEMFermi_h
#define HadrontherapyProtonPrecompoundGEMFermi_h 1
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
#include "G4HadronElasticProcess.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4ProcessManager.hh"
#include "G4ExcitationHandler.hh"
#include "G4PreCompoundModel.hh"
#include "G4ProtonInelasticCrossSection.hh"
#include "G4TheoFSGenerator.hh"
#include "G4ExcitationHandler.hh"
#include "G4PreCompoundModel.hh"
#include "G4GeneratorPrecompoundInterface.hh"
#include "G4ExcitedStringDecay.hh"
// For neutron
#include "G4HENeutronInelastic.hh"
#include "G4LENeutronInelastic.hh"
#include "G4LFission.hh"
#include "G4LCapture.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4NeutronInelasticCrossSection.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4NeutronHPElastic.hh"
#include "G4NeutronHPElasticData.hh"
#include "G4NeutronHPInelastic.hh"
#include "G4NeutronHPInelasticData.hh"
// For ions
#include "G4TripathiCrossSection.hh"
#include "G4IonsShenCrossSection.hh"
#include "G4HadronInelasticProcess.hh"
#include "G4BinaryLightIonReaction.hh"
#include "G4BinaryCascade.hh"
#include "G4IonInelasticProcess.hh"
#include "G4LEDeuteronInelastic.hh"
#include "G4DeuteronInelasticProcess.hh"
#include "G4TritonInelasticProcess.hh"
#include "G4LETritonInelastic.hh"
#include "G4AlphaInelasticProcess.hh"
#include "G4LEAlphaInelastic.hh"
class HadrontherapyProtonPrecompoundGEMFermi: public G4VPhysicsConstructor
{
public:
HadrontherapyProtonPrecompoundGEMFermi(const G4String& name = "proton-precompoundGEMFermi");
virtual ~HadrontherapyProtonPrecompoundGEMFermi();
protected:
// Construct particle and physics
void ConstructParticle(){};
void ConstructProcess();
private:
G4double binaryLightIonLowLimit;
G4double binaryLightIonHighLimit;
G4double LEPHighLimit;
G4double precompoundLowLimit;
G4double precompoundHighLimit;
G4double neutronLowLimit;
G4double neutronHighLimit;
G4int targetZ;
G4int targetA;
G4ExcitationHandler theHandler;
// Proton inelastic proces
G4ProtonInelasticProcess theIPProton;
// Cross Section for proton inelastic process
G4ProtonInelasticCrossSection thePXSec;
// Neutron inelastic process
G4NeutronInelasticProcess theIPNeutron;
// Cross Section for neutron inelastic process
G4NeutronInelasticCrossSection theNXSec;
// Deuteron inelastic process
G4DeuteronInelasticProcess theIPdeuteron;
// Tritium inelastic process
G4TritonInelasticProcess theIPtriton;
// Alpha inelastic process
G4AlphaInelasticProcess theIPalpha;
// He3 inelastic process
G4HadronInelasticProcess* theIPHe3;
};
#endif
examples/advanced/hadrontherapy/precompoundDefaultEvaporation.mac
+3 -1
View File
@@ -42,7 +42,9 @@
#/beamLine/RangeShifter/thickness 4 cm
#/beamLine/RangeShifter/RSMat Water
/run/beamOn 200
/run/beamOn 500
examples/advanced/hadrontherapy/precompoundDefaultEvaporationFermi.mac
-49
View File
@@ -1,49 +0,0 @@
#----------------------------------------------------------------------------
# PHYSICS LIST:
#
# - LOW ENERGY ELECTROMAGNETIC PHYSICS
# - ELASTIC SCATTERING FOR ALL THE HADRONS AND IONS
# - INELASTIC SCATTERING --->
# PRECOMPOUND PHYSICS LIST with DEFAULT EVAPORATION MODEL + FERMI
# BREAK-UP
#
# * PRECOMPOUND + DEFAULT EVAPORATION + FERMI BREAK-UP FOR PROTONS,
# NEUTRONS AND PIONS
#
# * LEP MODEL UP TO 100 MEV AND BINARY ION MODEL BETWEEN 80 MEV AND 40. GEV
# FOR DEUTERON, TRITON, HE3, ALPHA
#
# * FISSION AND HADRON CAPTURE FOR NEUTRONS BETWEEN 0. MEV AND 100. TEV
#
#
#-------------------------------------------------------------------------------
/control/verbose 1
/tracking/verbose 0
/run/verbose 0
/event/verbose 0
# SETTING FOR THE PHYSICS MODELS
/physics/addPhysics photon-epdl
/physics/addPhysics electron-eedl
/physics/addPhysics positron-standard
/physics/addPhysics ion-LowE
/physics/addPhysics muon-standard
/physics/addPhysics decay
# SETTING FOR THE PARTICULAR HADRONIC MODEL
/physics/addPhysics proton-precompoundFermi
/run/initialize
# IF YOU WANT A RANGE SHIFTER PLEASE CHANGE
# THE FOLLOWIG PARAMETERS
# SETTING FOR THE RANGE SHIFTER
#/beamLine/RangeShifter/thickness 4 cm
#/beamLine/RangeShifter/RSMat Water
/run/beamOn 200
examples/advanced/hadrontherapy/precompoundGEMEvaporation.mac
-48
View File
@@ -1,48 +0,0 @@
#----------------------------------------------------------------------------
# PHYSICS LIST:
#
# - LOW ENERGY ELECTROMAGNETIC PHYSICS
# - ELASTIC SCATTERING FOR ALL THE HADRONS AND IONS
# - INELASTIC SCATTERING --->
# * PRECOMPOUND PHYSICS LIST with GEM EVAPORATION MODEL
#
# * PRECOMPOUND + EVAPORATION (GEM MODEL) NO FERMI BREAK-UP FOR PROTONS,
# NEUTRONS AND PIONS
#
# * LEP MODEL UP TO 100 MEV AND BINARY ION MODEL BETWEEN 80 MEV AND 40. GEV
# FOR DEUTERON, TRITON, HE3, ALPHA
#
# * FISSION AND HADRON CAPTURE FOR NEUTRONS BETWEEN 0. MEV AND 100. TEV
#
#
#-------------------------------------------------------------------------------
/control/verbose 1
/tracking/verbose 0
/run/verbose 0
/event/verbose 0
# SETTING FOR THE PHYSICS MODELS
/physics/addPhysics photon-epdl
/physics/addPhysics electron-eedl
/physics/addPhysics positron-standard
/physics/addPhysics ion-LowE
/physics/addPhysics muon-standard
/physics/addPhysics decay
# SETTING FOR THE HADRONIC PHYSICS MODELS
/physics/addPhysics proton-precompoundGEM
/run/initialize
# IF YOU WANT A RANGE SHIFTER PLEASE CHANGE
# THE FOLLOWIG PARAMETERS
# SETTING FOR THE RANGE SHIFTER
#/beamLine/RangeShifter/thickness 4 cm
#/beamLine/RangeShifter/RSMat Water
/run/beamOn 10
examples/advanced/hadrontherapy/precompoundGEMFermi.mac
-47
View File
@@ -1,47 +0,0 @@
#----------------------------------------------------------------------------
# PHYSICS LIST:
#
# - LOW ENERGY ELECTROMAGNETIC PHYSICS
# - ELASTIC SCATTERING FOR ALL THE HADRONS AND IONS
# - INELASTIC SCATTERING --->
# PRECOMPOUND PHYSICS LIST with GEM EVAPORATION MODEL and FERMI BREAK-UP MODEL
#
# * PRECOMPOUND + EVAPORATION(GEM MODEL) + FERMI BREAK-UP FOR PROTONS,
# NEUTRONS AND PIONS
#
# * LEP MODEL UP TO 100 MEV AND BINARY ION MODEL BETWEEN 80 MEV AND 40. GEV
# FOR DEUTERON, TRITON, HE3, ALPHA
#
# * FISSION AND HADRON CAPTURE FOR NEUTRONS BETWEEN 0. MEV AND 100. TEV
#
#
#-------------------------------------------------------------------------------
/control/verbose 1
/tracking/verbose 0
/run/verbose 0
/event/verbose 0
# SETTING FOR THE PHYSICS MODELS
/physics/addPhysics photon-epdl
/physics/addPhysics electron-eedl
/physics/addPhysics positron-standard
/physics/addPhysics ion-LowE
/physics/addPhysics muon-standard
/physics/addPhysics decay
# SETTING FOR THE PARTICULAR HADRONIC MODEL
/physics/addPhysics proton-precompoundGEMFermi
/run/initialize
# IF YOU WANT A RANGE SHIFTER PLEASE CHANGE
# THE FOLLOWIG PARAMETERS
# SETTING FOR THE RANGE SHIFTER
#/beamLine/RangeShifter/thickness 4 cm
#/beamLine/RangeShifter/RSMat Water
/run/beamOn 10
examples/advanced/hadrontherapy/src/HadrontherapyAnalysisManager.cc
+19 -22
View File
@@ -179,18 +179,16 @@ void HadrontherapyAnalysisManager::FillEnergyDeposit(G4int i,
G4int k,
G4double energy)
{
if (ntuple)
{
G4int iSlice = ntuple -> findColumn("i");
G4int jSlice = ntuple -> findColumn("j");
G4int kSlice = ntuple -> findColumn("k");
G4int iEnergy = ntuple -> findColumn("energy");
if (ntuple) {
G4int iSlice = ntuple -> findColumn("i");
G4int jSlice = ntuple -> findColumn("j");
G4int kSlice = ntuple -> findColumn("k");
G4int iEnergy = ntuple -> findColumn("energy");
ntuple -> fill(iSlice,i);
ntuple -> fill(jSlice,j);
ntuple -> fill(kSlice,k);
ntuple -> fill(iEnergy, energy);
}
ntuple -> fill(iSlice,i);
ntuple -> fill(jSlice,j);
ntuple -> fill(kSlice,k);
ntuple -> fill(iEnergy, energy); }
ntuple -> addRow();
}
@@ -270,19 +268,18 @@ void HadrontherapyAnalysisManager::genericIonInformation(G4int a,
G4int electronOccupancy,
G4double energy)
{
if (ionTuple)
{
G4int aIndex = ionTuple -> findColumn("a");
G4int zIndex = ionTuple -> findColumn("z");
G4int electronIndex = ionTuple -> findColumn("occupancy");
G4int energyIndex = ionTuple -> findColumn("energy");
if (ionTuple) {
G4int aIndex = ionTuple -> findColumn("a");
G4int zIndex = ionTuple -> findColumn("z");
G4int electronIndex = ionTuple -> findColumn("occupancy");
G4int energyIndex = ionTuple -> findColumn("energy");
ionTuple -> fill(aIndex,a);
ionTuple -> fill(zIndex,z);
ionTuple -> fill(aIndex,a);
ionTuple -> fill(zIndex,z);
ionTuple -> fill(electronIndex, electronOccupancy);
ionTuple -> fill(energyIndex, energy);
}
ionTuple -> addRow();
ionTuple -> fill(energyIndex, energy);
}
ionTuple -> addRow();
}
void HadrontherapyAnalysisManager::finish()
examples/advanced/hadrontherapy/src/HadrontherapyBeamLine.cc
+228 -133
View File
@@ -49,9 +49,10 @@
#include "G4RotationMatrix.hh"
#include "HadrontherapyBeamLine.hh"
#include "G4Material.hh"
#include "G4SubtractionSolid.hh"
HadrontherapyBeamLine::HadrontherapyBeamLine(G4VPhysicalVolume* motherVolume):
physiBeamLineSupport(0), physiBeamLineCover(0), physiBeamLineCover2(0),
physiBeamLineSupport(0),/* physiBeamLineCover(0), physiBeamLineCover2(0)*/
firstScatteringFoil(0), physiFirstScatteringFoil(0), physiKaptonWindow(0),
solidStopper(0), physiStopper(0),
secondScatteringFoil(0), physiSecondScatteringFoil(0),
@@ -67,11 +68,10 @@ HadrontherapyBeamLine::HadrontherapyBeamLine(G4VPhysicalVolume* motherVolume):
physiSecondMonitorLayer3(0), physiSecondMonitorLayer4(0),
physiThirdMonitorLayer1(0), physiThirdMonitorLayer2(0),
physiThirdMonitorLayer3(0), physiThirdMonitorLayer4(0),
physiNozzleSupport(0), physiHoleNozzleSupport(0),
physiSecondHoleNozzleSupport(0),
physiNozzleSupport(0), physiHoleNozzle(0),
/*physiSecondHoleNozzleSupport(0),*/
solidFinalCollimator(0),
physiFinalCollimator(0)
{
mother = motherVolume;
material = new HadrontherapyMaterial();
@@ -140,55 +140,7 @@ void HadrontherapyBeamLine::HadrontherapyBeamLineSupport()
gray-> SetForceSolid(true);
logicBeamLineSupport -> SetVisAttributes(gray);
//---------------------------------//
// Beam line cover 1 (left panel) //
//---------------------------------//
const G4double beamLineCoverXSize = 1.5*m;
const G4double beamLineCoverYSize = 750.*mm;
const G4double beamLineCoverZSize = 10.*mm;
const G4double beamLineCoverXPosition = -1948.59 *mm;
const G4double beamLineCoverYPosition = -980.*mm;
const G4double beamLineCoverZPosition = 600.*mm;
G4Box* beamLineCover = new G4Box("BeamLineCover",
beamLineCoverXSize,
beamLineCoverYSize,
beamLineCoverZSize);
G4LogicalVolume* logicBeamLineCover = new G4LogicalVolume(beamLineCover,
Al,
"BeamLineCover");
physiBeamLineCover = new G4PVPlacement(0, G4ThreeVector(beamLineCoverXPosition,
beamLineCoverYPosition,
beamLineCoverZPosition),
"BeamLineCover",
logicBeamLineCover,
mother,
false,
0);
// ---------------------------------//
// Beam line cover 2 (rigth panel) //
// ---------------------------------//
// It has the same characteristic of beam line cover 1 but set in a different position
physiBeamLineCover2 = new G4PVPlacement(0, G4ThreeVector(beamLineCoverXPosition,
beamLineCoverYPosition,
- beamLineCoverZPosition),
"BeamLineCover2",
logicBeamLineCover,
mother,
false,
0);
// Visualisation attributes of the beam line covers
G4VisAttributes* blue = new G4VisAttributes(G4Colour(0. ,0. ,1.));
blue -> SetVisibility(true);
blue -> SetForceSolid(true);
logicBeamLineCover -> SetVisAttributes(blue);
}
void HadrontherapyBeamLine::HadrontherapyBeamScatteringFoils()
@@ -291,7 +243,7 @@ void HadrontherapyBeamLine::HadrontherapyBeamScatteringFoils()
const G4double startAngleStopper = 0.*deg;
const G4double spanningAngleStopper = 360.*deg;
const G4double stopperXPosition = -2956.02 *mm;
const G4double stopperXPosition = -2956.04 *mm;
const G4double stopperYPosition = 0.*m;
const G4double stopperZPosition = 0.*m;
@@ -327,7 +279,7 @@ void HadrontherapyBeamLine::HadrontherapyBeamScatteringFoils()
const G4double secondScatteringFoilYSize = 52.5 *mm;
const G4double secondScatteringFoilZSize = 52.5 *mm;
const G4double secondScatteringFoilXPosition = -2952.51 *mm;
const G4double secondScatteringFoilXPosition = -2952.52 *mm;
const G4double secondScatteringFoilYPosition = 0 *mm;
const G4double secondScatteringFoilZPosition = 0 *mm;
@@ -459,28 +411,70 @@ void HadrontherapyBeamLine::HadrontherapyBeamCollimators()
const G4double secondCollimatorYPosition = 0*mm;
const G4double secondCollimatorZPosition = 0*mm;
const G4double secondCollimatorXSize = 20.*mm;
const G4double secondCollimatorYSize = 100.*mm;
const G4double secondCollimatorZSize = 100.*mm;
G4Box* solidSecondCollimator = new G4Box("SecondCollimator",
secondCollimatorXSize,
secondCollimatorYSize,
secondCollimatorZSize);
G4LogicalVolume* logicSecondCollimator = new G4LogicalVolume(solidSecondCollimator,
PMMA,
"SecondCollimator");
physiSecondCollimator = new G4PVPlacement(0, G4ThreeVector(secondCollimatorXPosition,
secondCollimatorYPosition,
secondCollimatorZPosition),
"SecondCollimator",
logicFirstCollimator,
mother,
false,
0);
secondCollimatorYPosition,
secondCollimatorZPosition),
"SecondCollimator",
logicSecondCollimator,
mother,
false,
0);
// ------------------------------//
// Hole of the second collimator //
// ------------------------------//
physiHoleSecondCollimator = new G4PVPlacement(G4Transform3D(rm, G4ThreeVector()),
"HoleSecondCollimator",
logicHoleFirstCollimator,
physiSecondCollimator,
false,
0);
G4double innerRadiusHoleSecondCollimator = 0.*mm;
G4double outerRadiusHoleSecondCollimator = 15.*mm;
G4double hightHoleSecondCollimator = 20.*mm;
G4double startAngleHoleSecondCollimator = 0.*deg;
G4double spanningAngleHoleSecondCollimator = 360.*deg;
G4Tubs* solidHoleSecondCollimator = new G4Tubs("HoleSecondCollimator",
innerRadiusHoleSecondCollimator,
outerRadiusHoleSecondCollimator,
hightHoleSecondCollimator,
startAngleHoleSecondCollimator,
spanningAngleHoleSecondCollimator);
G4LogicalVolume* logicHoleSecondCollimator = new G4LogicalVolume(solidHoleSecondCollimator,
Air,
"HoleSecondCollimator",
0, 0, 0);
G4double phi2 = 90. *deg;
// Matrix definition for a 90 deg rotation. Also used for other volumes
G4RotationMatrix rm2;
rm2.rotateY(phi2);
physiHoleSecondCollimator = new G4PVPlacement(G4Transform3D(rm2, G4ThreeVector()),
"HoleSecondCollimator",
logicHoleSecondCollimator,
physiSecondCollimator,
false,
0);
// ---------------------------------//
// First Collimator modulator box //
// First Collimator modulator box //
// ---------------------------------//
const G4double firstCollimatorModulatorXSize = 10.*mm;
@@ -534,21 +528,58 @@ void HadrontherapyBeamLine::HadrontherapyBeamCollimators()
// -------------------------------------------//
// Second collimator modulator box //
// -------------------------------------------//
const G4double secondCollimatorModulatorXSize = 10.*mm;
const G4double secondCollimatorModulatorYSize = 200.*mm;
const G4double secondCollimatorModulatorZSize = 200.*mm;
const G4double secondCollimatorModulatorXPosition = -2090.5 *mm;
const G4double secondCollimatorModulatorYPosition = 0.*mm;
const G4double secondCollimatorModulatorZPosition = 0.*mm;
G4Box* solidSecondCollimatorModulatorBox = new G4Box("SecondCollimatorModulatorBox",
secondCollimatorModulatorXSize,
secondCollimatorModulatorYSize,
secondCollimatorModulatorZSize);
G4LogicalVolume* logicSecondCollimatorModulatorBox = new G4LogicalVolume(solidSecondCollimatorModulatorBox,
Al, "SecondCollimatorModulatorBox");
physiSecondCollimatorModulatorBox = new G4PVPlacement(0, G4ThreeVector(secondCollimatorModulatorXPosition,
secondCollimatorModulatorYPosition,
secondCollimatorModulatorZPosition),
"SecondCollimatorModulatorBox",
logicSecondCollimatorModulatorBox,
mother, false, 0);
physiSecondCollimatorModulatorBox = new G4PVPlacement(0, G4ThreeVector(secondCollimatorModulatorXPosition,0., 0.),
"SecondCollimatorModulatorBox", logicFirstCollimatorModulatorBox,
mother, false, 0);
// -------------------------------//
// Hole of the second collimator //
// -------------------------------//
// Hole of the second collimator modulator box //
// -------------------------------//
const G4double innerRadiusHoleSecondCollimatorModulatorBox = 0.*mm;
const G4double outerRadiusHoleSecondCollimatorModulatorBox = 31.*mm;
const G4double hightHoleSecondCollimatorModulatorBox = 10.*mm;
const G4double startAngleHoleSecondCollimatorModulatorBox = 0.*deg;
const G4double spanningAngleHoleSecondCollimatorModulatorBox = 360.*deg;
G4Tubs* solidHoleSecondCollimatorModulatorBox = new G4Tubs("HoleSecondCollimatorModulatorBox",
innerRadiusHoleSecondCollimatorModulatorBox,
outerRadiusHoleSecondCollimatorModulatorBox,
hightHoleSecondCollimatorModulatorBox ,
startAngleHoleSecondCollimatorModulatorBox,
spanningAngleHoleSecondCollimatorModulatorBox);
G4LogicalVolume* logicHoleSecondCollimatorModulatorBox = new G4LogicalVolume(solidHoleSecondCollimatorModulatorBox,
Air, "HoleSecondCollimatorModulatorBox", 0, 0, 0);
physiHoleSecondCollimatorModulatorBox = new G4PVPlacement(G4Transform3D(rm, G4ThreeVector()),
"HoleSecondCollimatorModulatorBox",
logicHoleFirstCollimatorModulatorBox,
physiSecondCollimatorModulatorBox, false, 0);
"HoleSecondCollimatorModulatorBox",
logicHoleSecondCollimatorModulatorBox,
physiSecondCollimatorModulatorBox, false, 0);
G4VisAttributes * blue = new G4VisAttributes( G4Colour(0. ,0. ,1.));
blue -> SetVisibility(true);
@@ -556,6 +587,8 @@ void HadrontherapyBeamLine::HadrontherapyBeamCollimators()
logicFirstCollimator -> SetVisAttributes(yellow);
logicFirstCollimatorModulatorBox -> SetVisAttributes(blue);
logicSecondCollimatorModulatorBox -> SetVisAttributes(blue);
}
void HadrontherapyBeamLine::HadrontherapyBeamMonitoring()
@@ -589,6 +622,8 @@ void HadrontherapyBeamLine::HadrontherapyBeamMonitoring()
physiFirstMonitorLayer1 = new G4PVPlacement(0,G4ThreeVector(monitor1XPosition,0.*cm,0.*cm),
"FirstMonitorLayer1", logicFirstMonitorLayer1, mother, false, 0);
G4Box* solidFirstMonitorLayer2 = new G4Box("FirstMonitorLayer2", monitor2XSize, monitorYSize, monitorZSize);
G4LogicalVolume* logicFirstMonitorLayer2 = new G4LogicalVolume(solidFirstMonitorLayer2, Cu, "FirstMonitorLayer2");
@@ -597,63 +632,120 @@ void HadrontherapyBeamLine::HadrontherapyBeamMonitoring()
"FirstMonitorLayer2", logicFirstMonitorLayer2, physiFirstMonitorLayer1,
false, 0);
G4Box* solidFirstMonitorLayer3 = new G4Box("FirstMonitorLayer3", monitor3XSize, monitorYSize, monitorZSize);
G4LogicalVolume* logicFirstMonitorLayer3 = new G4LogicalVolume(solidFirstMonitorLayer3, Air, "FirstMonitorLayer3");
physiFirstMonitorLayer3 = new G4PVPlacement(0, G4ThreeVector(0.*mm,0.*cm,0.*cm), "MonitorLayer3",
logicFirstMonitorLayer3, physiFirstMonitorLayer1, false, 0);
G4Box* solidFirstMonitorLayer4 = new G4Box("FirstMonitorLayer4", monitor2XSize, monitorYSize, monitorZSize);
G4LogicalVolume* logicFirstMonitorLayer4 = new G4LogicalVolume(solidFirstMonitorLayer4, Cu, "FirstMonitorLayer4");
physiFirstMonitorLayer4 = new G4PVPlacement(0, G4ThreeVector(monitor4XPosition,0.*cm,0.*cm),
"FirstMonitorLayer4",
logicFirstMonitorLayer4,
physiFirstMonitorLayer1, false, 0);
"FirstMonitorLayer4", logicFirstMonitorLayer4, physiFirstMonitorLayer1, false, 0);
// ------------------------//
// Second monitor chamber //
// ------------------------//
physiSecondMonitorLayer1 = new G4PVPlacement(0, G4ThreeVector(-1634.92493 *mm,0.*cm,0.*cm),
"SecondMonitorLayer1", logicFirstMonitorLayer1,mother, false, 0);
physiSecondMonitorLayer2 = new G4PVPlacement(0, G4ThreeVector( monitor2XPosition,0.*cm,0.*cm), "SecondMonitorLayer2",
logicFirstMonitorLayer2, physiSecondMonitorLayer1, false, 0);
G4Box* solidSecondMonitorLayer1 = new G4Box("SecondMonitorLayer1", monitor1XSize, monitorYSize, monitorZSize);
G4LogicalVolume* logicSecondMonitorLayer1 = new G4LogicalVolume(solidSecondMonitorLayer1, Kapton, "SecondMonitorLayer1");
physiSecondMonitorLayer1 = new G4PVPlacement(0, G4ThreeVector(-1634.92493 *mm,0.*cm,0.*cm),
"SecondMonitorLayer1", logicSecondMonitorLayer1,mother, false, 0);
G4Box* solidSecondMonitorLayer2 = new G4Box("SecondMonitorLayer2", monitor2XSize, monitorYSize, monitorZSize);
G4LogicalVolume* logicSecondMonitorLayer2 = new G4LogicalVolume(solidSecondMonitorLayer2, Cu, "SecondMonitorLayer2");
physiSecondMonitorLayer2 = new G4PVPlacement(0, G4ThreeVector( monitor2XPosition,0.*cm,0.*cm), "SecondMonitorLayer2",
logicSecondMonitorLayer2, physiSecondMonitorLayer1, false, 0);
physiSecondMonitorLayer3 = new G4PVPlacement(0, G4ThreeVector(0.*mm,0.*cm,0.*cm), "MonitorLayer3",
logicFirstMonitorLayer3, physiSecondMonitorLayer1, false, 0);
physiSecondMonitorLayer4 = new G4PVPlacement(0, G4ThreeVector(monitor4XPosition,0.*cm,0.*cm), "SecondMonitorLayer4",
logicFirstMonitorLayer4, physiSecondMonitorLayer1, false, 0);
G4Box* solidSecondMonitorLayer3 = new G4Box("SecondMonitorLayer3", monitor3XSize, monitorYSize, monitorZSize);
G4LogicalVolume* logicSecondMonitorLayer3 = new G4LogicalVolume(solidSecondMonitorLayer3, Air, "SecondMonitorLayer3");
physiSecondMonitorLayer3 = new G4PVPlacement(0, G4ThreeVector(0.*mm,0.*cm,0.*cm), "MonitorLayer3",
logicSecondMonitorLayer3, physiSecondMonitorLayer1, false, 0);
G4Box* solidSecondMonitorLayer4 = new G4Box("SecondMonitorLayer4", monitor2XSize, monitorYSize, monitorZSize);
G4LogicalVolume* logicSecondMonitorLayer4 = new G4LogicalVolume(solidSecondMonitorLayer4, Cu, "SecondMonitorLayer4");
physiSecondMonitorLayer4 = new G4PVPlacement(0, G4ThreeVector(monitor4XPosition,0.*cm,0.*cm), "SecondMonitorLayer4",
logicSecondMonitorLayer4, physiSecondMonitorLayer1, false, 0);
// -----------------------//
// Third monitor chamber //
// -----------------------//
physiThirdMonitorLayer1 = new G4PVPlacement(0, G4ThreeVector(-1505.87489 *mm,0.*cm,0.*cm),
"ThirdMonitorLayer1", logicFirstMonitorLayer1, mother, false, 0);
physiThirdMonitorLayer2 = new G4PVPlacement(0, G4ThreeVector(monitor2XPosition, 0.*cm,0.*cm),
G4Box* solidThirdMonitorLayer1 = new G4Box("ThirdMonitorLayer1", monitor1XSize, monitorYSize, monitorZSize);
G4LogicalVolume* logicThirdMonitorLayer1 = new G4LogicalVolume(solidThirdMonitorLayer1, Kapton, "ThirdMonitorLayer1");
physiThirdMonitorLayer1 = new G4PVPlacement(0, G4ThreeVector(-1505.87489 *mm,0.*cm,0.*cm),
"ThirdMonitorLayer1", logicThirdMonitorLayer1, mother, false, 0);
G4Box* solidThirdMonitorLayer2 = new G4Box("ThirdMonitorLayer2", monitor2XSize, monitorYSize, monitorZSize);
G4LogicalVolume* logicThirdMonitorLayer2 = new G4LogicalVolume(solidThirdMonitorLayer2, Cu, "ThirdMonitorLayer2");
physiThirdMonitorLayer2 = new G4PVPlacement(0, G4ThreeVector(monitor2XPosition, 0.*cm,0.*cm),
"ThirdMonitorLayer2",
logicFirstMonitorLayer2,
logicThirdMonitorLayer2,
physiThirdMonitorLayer1,
false, 0);
physiThirdMonitorLayer3 = new G4PVPlacement(0, G4ThreeVector(0.*mm,0.*cm,0.*cm), "MonitorLayer3",
logicFirstMonitorLayer3, physiThirdMonitorLayer1, false, 0);
G4Box* solidThirdMonitorLayer3 = new G4Box("ThirdMonitorLayer3", monitor3XSize, monitorYSize, monitorZSize);
G4LogicalVolume* logicThirdMonitorLayer3 = new G4LogicalVolume(solidThirdMonitorLayer3, Air, "ThirdMonitorLayer3");
physiThirdMonitorLayer3 = new G4PVPlacement(0, G4ThreeVector(0.*mm,0.*cm,0.*cm), "MonitorLayer3",
logicThirdMonitorLayer3, physiThirdMonitorLayer1, false, 0);
physiThirdMonitorLayer4 = new G4PVPlacement(0, G4ThreeVector(monitor4XPosition,0.*cm,0.*cm), "ThirdMonitorLayer4",
logicFirstMonitorLayer4, physiThirdMonitorLayer1, false, 0);
G4Box* solidThirdMonitorLayer4 = new G4Box("ThirdMonitorLayer4", monitor2XSize, monitorYSize, monitorZSize);
G4LogicalVolume* logicThirdMonitorLayer4 = new G4LogicalVolume(solidThirdMonitorLayer4, Cu, "ThirdMonitorLayer4");
physiThirdMonitorLayer4 = new G4PVPlacement(0, G4ThreeVector(monitor4XPosition,0.*cm,0.*cm), "ThirdMonitorLayer4",
logicThirdMonitorLayer4, physiThirdMonitorLayer1, false, 0);
}
void HadrontherapyBeamLine::HadrontherapyBeamNozzle()
{
// ---------------//
// Nozzle support //
//----------------//
const G4double nozzleSupportXSize = 29.5 *mm;
const G4double nozzleSupportXSize = 29.50 *mm;
const G4double nozzleSupportYSize = 180. *mm;
const G4double nozzleSupportZSize = 180. *mm;
@@ -661,24 +753,52 @@ void HadrontherapyBeamLine::HadrontherapyBeamNozzle()
G4Material* PMMA = material -> GetMat("PMMA");
G4Material* Brass = material -> GetMat("Brass") ;
G4Material* Air = material -> GetMat("Air") ;
// G4Material* Air = material -> GetMat("Air") ;
G4double phi = 90. *deg;
// Matrix definition for a 90 deg rotation. Also used for other volumes
G4RotationMatrix rm;
rm.rotateY(phi);
G4Box* solidNozzleSupport = new G4Box("NozzlSupport", nozzleSupportXSize, nozzleSupportYSize, nozzleSupportZSize);
// G4Subtraction
G4Box* solidNozzleBox = new G4Box("NozzleBox", nozzleSupportXSize, nozzleSupportYSize, nozzleSupportZSize);
const G4double innerRadiusHoleNozzle = 0.*mm;
const G4double outerRadiusHoleNozzle = 21.5 *mm;
const G4double hightHoleNozzle = 29.5 *mm;
const G4double startAngleHoleNozzle = 0.*deg;
const G4double spanningAngleHoleNozzle = 360.*deg;
G4Tubs* solidHoleNozzle = new G4Tubs("HoleNozzle",
innerRadiusHoleNozzle,
outerRadiusHoleNozzle,
hightHoleNozzle,
startAngleHoleNozzle,
spanningAngleHoleNozzle);
G4SubtractionSolid* solidNozzleSupport = new G4SubtractionSolid("NozzleSupport",solidNozzleBox, solidHoleNozzle,
&rm, G4ThreeVector(0 ,0,0 ));
G4LogicalVolume* logicNozzleSupport = new G4LogicalVolume(solidNozzleSupport, PMMA, "NozzleSupport");
physiNozzleSupport = new G4PVPlacement(0, G4ThreeVector(nozzleSupportXPosition,0., 0.),
"NozzleSupport", logicNozzleSupport, mother, false, 0);
G4VisAttributes * blue = new G4VisAttributes( G4Colour(0. ,0. ,1.));
blue -> SetVisibility(true);
blue -> SetForceSolid(false);
logicNozzleSupport -> SetVisAttributes(blue);
//logicHoleNozzle -> SetVisAttributes(blue);
// ---------------------------------//
// First hole of the noozle support //
// ---------------------------------//
const G4double innerRadiusHoleNozzleSupport = 18.*mm;
const G4double outerRadiusHoleNozzleSupport = 21.5 *mm;
const G4double hightHoleNozzleSupport = 185.*mm;
@@ -703,38 +823,11 @@ void HadrontherapyBeamLine::HadrontherapyBeamNozzle()
0., 0.)),
"HoleNozzleSupport", logicHoleNozzleSupport, mother, false, 0);
//------------------------------------//
// Second Hole of the noozle support //
//------------------------------------//
const G4double innerRadiusSecondHoleNozzleSupport = 0.*mm;
const G4double outerRadiusSecondHoleNozzleSupport = 18.*mm;
const G4double hightSecondHoleNozzleSupport = 29.5 *mm;
const G4double startAngleSecondHoleNozzleSupport = 0.*deg;
const G4double spanningAngleSecondHoleNozzleSupport = 360.*deg;
G4Tubs* solidSecondHoleNozzleSupport = new G4Tubs("SecondHoleNozzleSupport",
innerRadiusSecondHoleNozzleSupport,
outerRadiusSecondHoleNozzleSupport,
hightSecondHoleNozzleSupport,
startAngleSecondHoleNozzleSupport,
spanningAngleSecondHoleNozzleSupport);
G4LogicalVolume* logicSecondHoleNozzleSupport = new G4LogicalVolume(solidSecondHoleNozzleSupport,
Air,
"SecondHoleNozzleSupport",
0, 0, 0);
physiSecondHoleNozzleSupport = new G4PVPlacement(G4Transform3D(rm, G4ThreeVector()),
"SecondHoleNozzleSupport",
logicSecondHoleNozzleSupport,
physiNozzleSupport,
false, 0);
G4VisAttributes * yellow = new G4VisAttributes( G4Colour(1., 1., 0. ));
G4VisAttributes * yellow = new G4VisAttributes( G4Colour(1., 1., 0. ));
yellow-> SetVisibility(true);
yellow-> SetForceSolid(true);
logicHoleNozzleSupport -> SetVisAttributes(yellow);
logicHoleNozzleSupport -> SetVisAttributes(yellow);
}
void HadrontherapyBeamLine::HadrontherapyBeamFinalCollimator()
@@ -743,7 +836,7 @@ void HadrontherapyBeamLine::HadrontherapyBeamFinalCollimator()
// -----------------------//
// Final collimator //
//------------------------//
const G4double outerRadiusFinalCollimator = 21.5*mm;
const G4double hightFinalCollimator = 3.5*mm;
const G4double startAngleFinalCollimator = 0.*deg;
@@ -774,6 +867,8 @@ void HadrontherapyBeamLine::HadrontherapyBeamFinalCollimator()
yellow-> SetVisibility(true);
yellow-> SetForceSolid(true);
logicFinalCollimator -> SetVisAttributes(yellow);
}
void HadrontherapyBeamLine::SetRangeShifterXPosition(G4double value)
examples/advanced/hadrontherapy/src/HadrontherapyDetectorConstruction.cc
+12 -8
View File
@@ -56,10 +56,10 @@
#include "HadrontherapyDetectorConstruction.hh"
#include "HadrontherapyMaterial.hh"
#include "HadrontherapyBeamLine.hh"
#include "HadrontherapyModulator.hh"
//#include "HadrontherapyModulator.hh"
HadrontherapyDetectorConstruction::HadrontherapyDetectorConstruction()
: phantomSD(0), phantomROGeometry(0), beamLine(0), modulator(0),
: phantomSD(0), phantomROGeometry(0), beamLine(0), /*modulator(0),*/
physicalTreatmentRoom(0),
patientPhysicalVolume(0),
phantomLogicalVolume(0),
@@ -124,12 +124,16 @@ void HadrontherapyDetectorConstruction::ConstructBeamLine()
"logicTreatmentRoom",
0,0,0);
physicalTreatmentRoom = new G4PVPlacement(0,
G4ThreeVector(),
"physicalTreatmentRoom",
logicTreatmentRoom,
0,false,0);
G4double maxStepTreatmentRoom = 0.1 *mm;
logicTreatmentRoom -> SetUserLimits(new G4UserLimits(maxStepTreatmentRoom));
// The treatment room is invisible in the Visualisation
logicTreatmentRoom -> SetVisAttributes (G4VisAttributes::Invisible);
@@ -142,8 +146,8 @@ void HadrontherapyDetectorConstruction::ConstructBeamLine()
beamLine -> HadrontherapyBeamNozzle();
beamLine -> HadrontherapyBeamFinalCollimator();
modulator = new HadrontherapyModulator();
modulator -> BuildModulator(physicalTreatmentRoom);
//modulator = new HadrontherapyModulator();
//modulator -> BuildModulator(physicalTreatmentRoom);
// Patient - Mother volume of the phantom
G4Box* patient = new G4Box("patient",20 *cm, 20 *cm, 20 *cm);
@@ -171,7 +175,7 @@ void HadrontherapyDetectorConstruction::ConstructPhantom()
G4Material* water = material -> GetMat("Water");
ComputeVoxelSize();
//ComputeVoxelSize();
//----------------------
// Water phantom
@@ -184,7 +188,7 @@ void HadrontherapyDetectorConstruction::ConstructPhantom()
0,0,0);
// Fixing the max step allowed in the phantom
G4double maxStep = 0.02*cm;
G4double maxStep = 0.01 *mm;
phantomLogicalVolume -> SetUserLimits(new G4UserLimits(maxStep));
G4double phantomXtranslation = -180.*mm;
@@ -239,13 +243,13 @@ void HadrontherapyDetectorConstruction::ConstructSensitiveDetector()
phantomLogicalVolume -> SetSensitiveDetector(phantomSD);
}
}
/*
void HadrontherapyDetectorConstruction::SetModulatorAngle(G4double value)
{
modulator -> SetModulatorAngle(value);
G4RunManager::GetRunManager() -> GeometryHasBeenModified();
}
*/
void HadrontherapyDetectorConstruction::SetRangeShifterXPosition(G4double value)
{
beamLine -> SetRangeShifterXPosition(value);
examples/advanced/hadrontherapy/src/HadrontherapyDetectorMessenger.cc
+13 -13
View File
@@ -47,8 +47,8 @@ HadrontherapyDetectorMessenger::HadrontherapyDetectorMessenger(
HadrontherapyDetectorConstruction* detector)
:hadrontherapyDetector(detector)
{
modulatorDir = new G4UIdirectory("/modulator/");
modulatorDir -> SetGuidance("Command to rotate the modulator wheel");
//modulatorDir = new G4UIdirectory("/modulator/");
//modulatorDir -> SetGuidance("Command to rotate the modulator wheel");
beamLineDir = new G4UIdirectory("/beamLine/");
beamLineDir -> SetGuidance("set specification of range shifter");
@@ -68,12 +68,12 @@ HadrontherapyDetectorMessenger::HadrontherapyDetectorMessenger(
finalCollimatorDir = new G4UIdirectory("/beamLine/FinalCollimator/");
finalCollimatorDir -> SetGuidance("set specification of final collimator");
modulatorAngleCmd = new G4UIcmdWithADoubleAndUnit("/modulator/angle",this);
modulatorAngleCmd -> SetGuidance("Set Modulator Angle");
modulatorAngleCmd -> SetParameterName("Size",false);
modulatorAngleCmd -> SetRange("Size>=0.");
modulatorAngleCmd -> SetUnitCategory("Angle");
modulatorAngleCmd -> AvailableForStates(G4State_Idle);
// modulatorAngleCmd = new G4UIcmdWithADoubleAndUnit("/modulator/angle",this);
//modulatorAngleCmd -> SetGuidance("Set Modulator Angle");
//modulatorAngleCmd -> SetParameterName("Size",false);
//modulatorAngleCmd -> SetRange("Size>=0.");
//modulatorAngleCmd -> SetUnitCategory("Angle");
//modulatorAngleCmd -> AvailableForStates(G4State_Idle);
rangeShifterMatCmd = new G4UIcmdWithAString("/beamLine/RangeShifter/RSMat",this);
rangeShifterMatCmd -> SetGuidance("Set material of range shifter");
@@ -132,21 +132,21 @@ HadrontherapyDetectorMessenger::~HadrontherapyDetectorMessenger()
delete rangeShifterXPositionCmd;
delete rangeShifterXSizeCmd;
delete rangeShifterMatCmd;
delete modulatorAngleCmd;
//delete modulatorAngleCmd;
delete finalCollimatorDir;
delete rangeStopperDir;
delete secondScatteringFoilDir;
delete firstScatteringFoilDir;
delete rangeShifterDir;
delete beamLineDir;
delete modulatorDir;
//delete modulatorDir;
}
void HadrontherapyDetectorMessenger::SetNewValue(G4UIcommand* command,G4String newValue)
{
if( command == modulatorAngleCmd )
{ hadrontherapyDetector -> SetModulatorAngle
(modulatorAngleCmd -> GetNewDoubleValue(newValue));}
//if( command == modulatorAngleCmd )
// { hadrontherapyDetector -> SetModulatorAngle
// (modulatorAngleCmd -> GetNewDoubleValue(newValue));}
if( command == rangeShifterMatCmd )
{ hadrontherapyDetector -> SetRSMaterial(newValue);}
examples/advanced/hadrontherapy/src/HadrontherapyPhysicsList.cc
+13 -101
View File
@@ -59,17 +59,14 @@
#include "HadrontherapyIonLowEZiegler2000.hh"
#include "HadrontherapyIonStandard.hh"
#include "HadrontherapyProtonPrecompound.hh"
#include "HadrontherapyProtonPrecompoundFermi.hh"
#include "HadrontherapyProtonPrecompoundGEM.hh"
#include "HadrontherapyProtonPrecompoundGEMFermi.hh"
#include "HadrontherapyProtonBertini.hh"
#include "HadrontherapyProtonBinary.hh"
#include "HadrontherapyMuonStandard.hh"
#include "HadrontherapyDecay.hh"
#include "HadrontherapyParticles.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
HadrontherapyPhysicsList::HadrontherapyPhysicsList(): G4VModularPhysicsList(),
electronIsRegistered(false),
positronIsRegistered(false),
@@ -79,15 +76,12 @@ HadrontherapyPhysicsList::HadrontherapyPhysicsList(): G4VModularPhysicsList(),
muonIsRegistered(false),
decayIsRegistered(false)
{
//
// The threshold of production of secondaries is fixed 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.
//
defaultCutValue = 10. * mm;
// 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
defaultCutValue = 0.01 * mm;
// Messenger: it is possible to activate interactively physics processes and models
// Messenger: it is possible to activate physics processes and models interactively
messenger = new HadrontherapyPhysicsListMessenger(this);
SetVerboseLevel(1);
@@ -109,13 +103,14 @@ void HadrontherapyPhysicsList::AddPhysicsList(const G4String& name)
// Electromagnetic physics //
//*************************//
//
// The user can choose three alternative approaches:
// The user can choose three alternative approaches for electrons and photons:
// Standard, Low Energy based on the Livermore libraries and Low Energy Penelope
//
// ******** PHOTONS ********//
// Register standard processes for photons
if (name == "photon-standard")
{
if (photonIsRegistered)
@@ -421,96 +416,11 @@ void HadrontherapyPhysicsList::AddPhysicsList(const G4String& name)
protonHadronicIsRegistered = true;
}
}
//Precompond Default Evaporation + Fermi Breck-up Model
if (name == "proton-precompoundFermi")
{
if (protonHadronicIsRegistered)
{
G4cout << "HadrontherapyPhysicsList::AddPhysicsList: " << name
<< " cannot be registered ---- decay List already existing"
<< G4endl;
}
else
{
G4cout << "HadrontherapyPhysicsList::AddPhysicsList: " << name
<< " is registered" << G4endl;
RegisterPhysics( new HadrontherapyProtonPrecompoundFermi(name) );
protonHadronicIsRegistered = true;
}
}
//Precompound GEM Evaporation
if (name == "proton-precompoundGEM")
{
if (protonHadronicIsRegistered)
{
G4cout << "HadrontherapyPhysicsList::AddPhysicsList: " << name
<< " cannot be registered ---- decay List already existing"
<< G4endl;
}
else
{
G4cout << "HadrontherapyPhysicsList::AddPhysicsList: " << name
<< " is registered" << G4endl;
RegisterPhysics( new HadrontherapyProtonPrecompoundGEM(name) );
protonHadronicIsRegistered = true;
}
}
//Precompound GEM Evaporation + Fermi Breck-up Model
if (name == "proton-precompoundGEMFermi")
{
if (protonHadronicIsRegistered)
{
G4cout << "HadrontherapyPhysicsList::AddPhysicsList: " << name
<< " cannot be registered ---- decay List already existing"
<< G4endl;
}
else
{
G4cout << "HadrontherapyPhysicsList::AddPhysicsList: " << name
<< " is registered" << G4endl;
RegisterPhysics( new HadrontherapyProtonPrecompoundGEMFermi(name) );
protonHadronicIsRegistered = true;
}
}
//-------------------------------------------------------------------------------------------------
// End Hadronic Precompound models
//-------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------
//Begin Hadronic Binary models
//--------------------------------------------------------------------------------------------
// Binary cascade model with the default precompound
if (name == "proton-precompound-binary")
{
if (protonHadronicIsRegistered)
{
G4cout << "HadrontherapyPhysicsList::AddPhysicsList: " << name
<< " cannot be registered ---- decay List already existing"
<< G4endl;
}
else
{
G4cout << "HadrontherapyPhysicsList::AddPhysicsList: " << name
<< " is registered" << G4endl;
RegisterPhysics( new HadrontherapyProtonBinary(name) );
protonHadronicIsRegistered = true;
}
}
//--------------------------------------------------------------------------------------------
// Begin Hadronic Bertini model
//--------------------------------------------------------------------------------------------
@@ -558,14 +468,16 @@ void HadrontherapyPhysicsList::SetCuts()
// Set the threshold of production equal to the defaultCutValue
// in the experimental set-up
G4VUserPhysicsList::SetCutsWithDefault();
G4double lowlimit=250*eV;
G4ProductionCutsTable::GetProductionCutsTable() ->SetEnergyRange(lowlimit, 100.*GeV);
// Definition of a smaller threshold of production in the phantom region
// where high accuracy is required in the energy deposit calculation
G4String regionName = "PhantomLog";
G4Region* region = G4RegionStore::GetInstance()->GetRegion(regionName);
G4ProductionCuts* cuts = new G4ProductionCuts ;
G4double regionCut = 0.001*mm;
G4double regionCut = 0.01*mm;
cuts -> SetProductionCut(regionCut,G4ProductionCuts::GetIndex("gamma"));
cuts -> SetProductionCut(regionCut,G4ProductionCuts::GetIndex("e-"));
cuts -> SetProductionCut(regionCut,G4ProductionCuts::GetIndex("e+"));
examples/advanced/hadrontherapy/src/HadrontherapyPrimaryGeneratorAction.cc
+7 -7
View File
@@ -74,12 +74,12 @@ void HadrontherapyPrimaryGeneratorAction::SetDefaultPrimaryParticle()
particleGun -> SetParticleDefinition(particle);
// Define the energy of primary particles:
// gaussian distribution with mean energy = 63.450 *MeV
// and sigma = 400.0 *keV
// gaussian distribution with mean energy = 64.55 *MeV
// and sigma = 300.0 *keV
G4double defaultMeanKineticEnergy = 63.50 *MeV;
meanKineticEnergy = defaultMeanKineticEnergy;
G4double defaultsigmaEnergy = 400.0 *keV;
G4double defaultsigmaEnergy = 300.0 *keV;
sigmaEnergy = defaultsigmaEnergy;
// Define the parameters of the initial position:
@@ -93,18 +93,18 @@ void HadrontherapyPrimaryGeneratorAction::SetDefaultPrimaryParticle()
G4double defaultZ0 = 0.0 *mm;
Z0 = defaultZ0;
G4double defaultsigmaY = 1 *mm;
G4double defaultsigmaY = 1. *mm;
sigmaY = defaultsigmaY;
G4double defaultsigmaZ = 1 *mm;
G4double defaultsigmaZ = 1. *mm;
sigmaZ = defaultsigmaZ;
// Define the parameters of the momentum of primary particles:
// The momentum along the y and z axis has a gaussian distribution
G4double defaultsigmaMomentumY = 0.0001;
G4double defaultsigmaMomentumY = 0.0;
sigmaMomentumY = defaultsigmaMomentumY;
G4double defaultsigmaMomentumZ = 0.0001;
G4double defaultsigmaMomentumZ = 0.0;
sigmaMomentumZ = defaultsigmaMomentumZ;
}
examples/advanced/hadrontherapy/src/HadrontherapyProtonBertini.cc
+206 -185
View File
@@ -36,65 +36,61 @@
// (b) National Institute for Nuclear Physics Section of Genova, genova, Italy
//
// * cirrone@lns.infn.it
// Code review by M.G. Pia, 2 November 2006
// Further code review is needed
// ----------------------------------------------------------------------------
#include "HadrontherapyProtonBertini.hh"
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
#include "G4ProcessVector.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4Material.hh"
#include "G4HadronElasticProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4ExcitationHandler.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4HadronInelasticProcess.hh"
#include "G4DeuteronInelasticProcess.hh"
#include "G4TritonInelasticProcess.hh"
#include "G4AlphaInelasticProcess.hh"
#include "G4LElastic.hh"
#include "G4CascadeInterface.hh"
#include "G4PionPlusInelasticProcess.hh"
#include "G4LEPionPlusInelastic.hh"
#include "G4LEPionMinusInelastic.hh"
#include "G4HEPionPlusInelastic.hh"
#include "G4HEPionMinusInelastic.hh"
#include "G4PionMinusInelasticProcess.hh"
#include "G4LEPionMinusInelastic.hh"
#include "G4HEPionMinusInelastic.hh"
#include "G4PiMinusAbsorptionAtRest.hh"
#include "G4AntiProtonInelasticProcess.hh"
#include "G4LEAntiProtonInelastic.hh"
#include "G4HEAntiProtonInelastic.hh"
#include "G4AntiProtonAnnihilationAtRest.hh"
//
#include "G4CascadeElasticInterface.hh"
#include "G4HadronFissionProcess.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4LFission.hh"
#include "G4LCapture.hh"
#include "G4TripathiCrossSection.hh"
#include "G4IonsShenCrossSection.hh"
#include "G4BinaryLightIonReaction.hh"
#include "G4LEDeuteronInelastic.hh"
#include "G4LETritonInelastic.hh"
#include "G4LEAlphaInelastic.hh"
// BERTINI PHYSICS LIST
//
// BERTINI FOR PROTONS, NEUTRONS AND PIONS
//
// LEP MODEL UP TO 100 MEV AND BINARY ION MODEL BETWEEN 80 MEV AND 40. GEV
// FOR DEUTERON, TRITON, HE3, ALPHA
// FOR DEUTERON, TRITON, ALPHA
//
// FISSION AND HADRON CAPTURE FOR NEUTRONS BETWEEN 0. MEV AND 100. TEV
//
HadrontherapyProtonBertini::HadrontherapyProtonBertini(const G4String& name):
G4VPhysicsConstructor(name)
{
G4cout << "The Bertini model is set for protons, neutrons and pions !!!!" << G4endl;
// Inelastic process, energy limits
G4cout << "The Bertini model (for inelastic scattering) is set for protons, neutrons and pions" << G4endl;
//
// The Bertini model is set for protons, neutrons and pions
// This model contains a pre-equilibrium model and a de-excitation model
// Energy limit of the Bertini model
bertiniLowLimit = 0.*MeV;
bertiniHighLimit = 300.*MeV;
// Energy limit of the neutron fission and capture
neutronLowLimit = 0.*TeV;
neutronHighLimit = 100.*TeV;
// Ions:
// The inelastic scattering is modelled with LEP model up to 100 MeV,
// then Binary Ion Model
// Energy limit of the LEP model for ions
LEPHighLimit = 100.*MeV;
// Energy limit of the binary ion model
binaryLightIonLowLimit = 80.*MeV;
binaryLightIonHighLimit = 40.*GeV;
}
HadrontherapyProtonBertini::~HadrontherapyProtonBertini()
@@ -103,31 +99,131 @@ HadrontherapyProtonBertini::~HadrontherapyProtonBertini()
void HadrontherapyProtonBertini::ConstructProcess()
{
G4ParticleDefinition* particle = 0;
G4ProcessManager* pmanager = 0;
G4ProcessManager* processManager = 0;
// LOW ENERGY ELASTIC SCATTERING
// FOR PROTON, NEUTRON, IONS
G4LElastic* elastic_model = new G4LElastic();
G4HadronElasticProcess* elastic_scattering = new G4HadronElasticProcess();
elastic_scattering -> RegisterMe(elastic_model);
// Physics for proton, neutron, pion+ and pion-
// Elastic scattering: Low Energy Parameterised model
G4LElastic* elasticModel = new G4LElastic();
G4HadronElasticProcess* elasticScattering = new G4HadronElasticProcess();
elasticScattering->RegisterMe(elasticModel);
// Inelastic scattering: Bertini Inelastic model
G4CascadeInterface* theBertiniModel = new G4CascadeInterface;
// INELASTIC SCATTERING
// Bertini Model for protons, pions and neutrons
G4CascadeInterface * theBertiniModel = new G4CascadeInterface;
// Set the min and max energy for the Bertini Model
theBertiniModel -> SetMinEnergy(bertiniLowLimit);
theBertiniModel -> SetMaxEnergy(bertiniHighLimit);
// Energy limit of the Bertini model
G4double bertiniLowEnergyLimit = 0.* MeV;
G4double bertiniHighEnergyLimit = 300.*MeV;
theBertiniModel->SetMinEnergy(bertiniLowEnergyLimit);
theBertiniModel->SetMaxEnergy(bertiniHighEnergyLimit);
// Binary Cascade for deuteron, triton, alpha particle, He3
G4BinaryLightIonReaction* theBinaryCascade = new G4BinaryLightIonReaction();
// Set the min and max energy for the Binary Cascade
theBinaryCascade -> SetMinEnergy(binaryLightIonLowLimit);
theBinaryCascade -> SetMaxEnergy(binaryLightIonHighLimit);
//--------------------------------------------------------------------------------------
// Proton processes
particle = G4Proton::Proton();
processManager = particle->GetProcessManager();
// Model Registration
G4ProtonInelasticProcess* theProtonInelasticProcess = new G4ProtonInelasticProcess();
theProtonInelasticProcess->RegisterMe(theBertiniModel);
// Activate the cross-sections for proton nuclear scattering up to 20 GeV
theProtonInelasticProcess->AddDataSet(&theProtonCrossSection);
// Activate the proton inelastic scattering
processManager->AddDiscreteProcess(theProtonInelasticProcess);
// Activate the elastic scattering
processManager->AddDiscreteProcess(elasticScattering);
//--------------------------------------------------------------------------------------
// Pions plus processes
particle = G4PionPlus::PionPlus();
processManager = particle->GetProcessManager();
// Define the inelastic process for pions plus
G4PionPlusInelasticProcess* thePionPlusInelasticProcess = new G4PionPlusInelasticProcess("inelastic");
// Register the Low Energy Inelastic Model for pions plus
thePionPlusInelasticProcess->RegisterMe(theBertiniModel);
// Activate the inelastic process for pions plus
processManager->AddDiscreteProcess(thePionPlusInelasticProcess);
// Activate the elastic process for pions plus
processManager->AddDiscreteProcess(elasticScattering);
//--------------------------------------------------------------------------------------
// Pion Minus processes
particle = G4PionMinus::PionMinus();
processManager = particle->GetProcessManager();
// Define the inelastic process for pions minus
G4PionMinusInelasticProcess* thePionMinusInelasticProcess = new G4PionMinusInelasticProcess("inelastic");
// Register the inelastic model for pion minus
thePionMinusInelasticProcess->RegisterMe(theBertiniModel);
// Activate the inelastic process for pion minus
processManager->AddDiscreteProcess(thePionMinusInelasticProcess);
// Activate the elastic process for pion minus
processManager->AddDiscreteProcess(elasticScattering);
//--------------------------------------------------------------------------------------
// Neutron processes
particle = G4Neutron::Neutron();
processManager = particle->GetProcessManager();
// Register the Bertini model
G4NeutronInelasticProcess* theNeutronInelasticProcess = new G4NeutronInelasticProcess();
theNeutronInelasticProcess->RegisterMe(theBertiniModel);
// Activate the Cross-sections for neutron nuclear scattering from 14 MeV up to 20 GeV
theNeutronInelasticProcess->AddDataSet(&theNeutronCrossSection);
// Activate the neutron inelastic process
processManager->AddDiscreteProcess(theNeutronInelasticProcess);
// Activate the Hadron Elastic Process
processManager->AddDiscreteProcess(elasticScattering);
// Neutron capture process
// Energy limits
G4double neutronLowEnergyLimit = 0. * MeV;
G4double neutronHighEnergyLimit = 100. * TeV;
G4HadronCaptureProcess* neutronCapture = new G4HadronCaptureProcess();
// Final state production model for capture of neutral hadrons in nuclei
G4LCapture* captureModel = new G4LCapture();
// Set the energy range for the capture model
captureModel->SetMinEnergy(neutronLowEnergyLimit);
captureModel->SetMaxEnergy(neutronHighEnergyLimit);
// Register the neutron capture model
neutronCapture->RegisterMe(captureModel);
// Activate the neutron capture process
processManager->AddDiscreteProcess(neutronCapture);
// Process for induced fission
G4HadronFissionProcess* fission = new G4HadronFissionProcess();
//Final state production model for induced fission
G4LFission* fissionModel = new G4LFission();
// Set the energy range for the fission model
fissionModel->SetMinEnergy(neutronLowEnergyLimit);
fissionModel->SetMaxEnergy(neutronHighEnergyLimit);
// Register the fission model
fission->RegisterMe(fissionModel);
// Activate the fission process
processManager->AddDiscreteProcess(fission);
//--------------------------------------------------------------------------------------
// Physics for ions
// Energy limit of the LEP model for ions
G4double LEPHighEnergyLimit = 100.* MeV;
// Energy limit of the binary ion model
G4double binaryLightIonLowEnergyLimit = 80.* MeV;
G4double binaryLightIonHighEnergyLimit = 40.* GeV;
// Cross section data sets
// TRIPATHI CROSS SECTION
// Implementation of formulas in analogy to NASA technical paper 3621 by
// Implementation of formulas taken from NASA technical paper 3621 by
// Tripathi, et al. Cross-sections for ion ion scattering
G4TripathiCrossSection* TripathiCrossSection = new G4TripathiCrossSection;
G4TripathiCrossSection* tripathiCrossSection = new G4TripathiCrossSection;
// IONS SHEN CROSS SECTION
// Implementation of formulas
@@ -135,158 +231,83 @@ void HadrontherapyProtonBertini::ConstructProcess()
// Total Reaction Cross Section for Heavy-Ion Collisions
G4IonsShenCrossSection* aShen = new G4IonsShenCrossSection;
//--------------------------------------------------------------------------------------
// Proton BERTINI MODEL
particle = G4Proton::Proton();
pmanager = particle -> GetProcessManager();
// Model Registration
theIPProton.RegisterMe(theBertiniModel);
// Active the Cross-sections for proton nuclear scattering up to 20 GeV
theIPProton.AddDataSet(&thePXSec);
// Intra-nuclear transport: Binary Cascade Model
// Binary Cascade for deuteron, triton, alpha particle
G4BinaryLightIonReaction* theBinaryCascade = new G4BinaryLightIonReaction();
// Set the min and max energy for the Binary Cascade
theBinaryCascade->SetMinEnergy(binaryLightIonLowEnergyLimit);
theBinaryCascade->SetMaxEnergy(binaryLightIonHighEnergyLimit);
// Active the proton inelastic scattering
pmanager -> AddDiscreteProcess(&theIPProton);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic_scattering);
// deuteron
//--------------------------------------------------------------------------------------
// Deuteron
particle = G4Deuteron::Deuteron();
pmanager = particle -> GetProcessManager();
processManager = particle->GetProcessManager();
// Final state production model for deuteron inelastic scattering below 100 MeV
G4LEDeuteronInelastic* theDIModel = new G4LEDeuteronInelastic;
// Final state production model for deuteron inelastic scattering below 100 MeV: Low Energy Parameterised model
G4LEDeuteronInelastic* theDeuteronLEInelasticModel = new G4LEDeuteronInelastic;
// Set the maximum energy for LEP model
theDIModel -> SetMaxEnergy(LEPHighLimit);
// Active the Tripathi and aShen Cross Section
theIPdeuteron.AddDataSet(TripathiCrossSection);
theIPdeuteron.AddDataSet(aShen);
theDeuteronLEInelasticModel->SetMaxEnergy(LEPHighEnergyLimit);
// G4DeuteronInelasticProcess theDeuteronInelasticProcess;
// Activate the Tripathi and Shen Cross Section
theDeuteronInelasticProcess.AddDataSet(tripathiCrossSection);
theDeuteronInelasticProcess.AddDataSet(aShen);
// Register the Parameterised Deuteron Inelastic Model and the Ion Binary Cascade Model
theIPdeuteron.RegisterMe(theDIModel);
theIPdeuteron.RegisterMe(theBinaryCascade);
// Active the deuteron elastic and inelastic scattering
pmanager -> AddDiscreteProcess(&theIPdeuteron);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic_scattering);
theDeuteronInelasticProcess.RegisterMe(theDeuteronLEInelasticModel);
theDeuteronInelasticProcess.RegisterMe(theBinaryCascade);
// triton
// Activate the deuteron elastic and inelastic scattering
processManager->AddDiscreteProcess(&theDeuteronInelasticProcess);
// Activate the Hadron Elastic Process
processManager->AddDiscreteProcess(elasticScattering);
//--------------------------------------------------------------------------------------
// Triton
particle = G4Triton::Triton();
pmanager = particle -> GetProcessManager();
processManager = particle->GetProcessManager();
// Final state production model for Triton inelastic scattering below 100 MeV
G4LETritonInelastic* theTIModel = new G4LETritonInelastic;
// Final state production model for Triton inelastic scattering below 100 MeV: Low Energy Parameterised model
G4LETritonInelastic* theTritonLEInelasticModel = new G4LETritonInelastic;
// Set the maximum energy for LEP model
theTIModel -> SetMaxEnergy(LEPHighLimit);
// Active the Tripathi and aShen Cross Section
theIPtriton.AddDataSet(TripathiCrossSection);
theIPtriton.AddDataSet(aShen);
// Register the Triton Inelastic and Binary Cascade Model
theIPtriton.RegisterMe(theTIModel);
theIPtriton.RegisterMe(theBinaryCascade);
// Active the triton inelastic scattering using the triton inelastic and binary cascade model
pmanager -> AddDiscreteProcess(&theIPtriton);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic_scattering);
theTritonLEInelasticModel->SetMaxEnergy(LEPHighEnergyLimit);
// alpha
// Activate the Tripathi and Shen Cross Section
//G4TritonInelasticProcess theTritonInelasticProcess;
theTritonInelasticProcess.AddDataSet(tripathiCrossSection);
theTritonInelasticProcess.AddDataSet(aShen);
// Register the Triton Inelastic and Binary Cascade Models
theTritonInelasticProcess.RegisterMe(theTritonLEInelasticModel);
theTritonInelasticProcess.RegisterMe(theBinaryCascade);
// Activate the triton inelastic scattering using the parameterised Triton Inelastic and Binary Cascade models
processManager->AddDiscreteProcess(&theTritonInelasticProcess);
// Activate the Hadron Elastic Process
processManager->AddDiscreteProcess(elasticScattering);
//--------------------------------------------------------------------------------------
// Alpha
particle = G4Alpha::Alpha();
pmanager = particle->GetProcessManager();
// Final state production model for Alpha inelastic scattering below 20 GeV
G4LEAlphaInelastic* theAIModel = new G4LEAlphaInelastic;
processManager = particle->GetProcessManager();
// Final state production model for Alpha inelastic scattering below 20 GeV: Low Energy Parameterised model
G4LEAlphaInelastic* theAlphaLEInelasticModel = new G4LEAlphaInelastic;
// Set the maximum energy for LEP model
theAIModel -> SetMaxEnergy(LEPHighLimit);
// Register the Triton Inelastic and Binary Cascade Model
theIPalpha.AddDataSet(TripathiCrossSection);
theIPalpha.AddDataSet(aShen);
// Register the Alpha Inelastic and Binary Cascade Model
theIPalpha.RegisterMe(theAIModel);
theIPalpha.RegisterMe(theBinaryCascade);
// Active the alpha inelastic scattering using the alpha inelastic and binary cascade model
pmanager -> AddDiscreteProcess(&theIPalpha);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic_scattering);
theAlphaLEInelasticModel->SetMaxEnergy(LEPHighEnergyLimit);
// He3
// particle = G4He3::He3();
// pmanager = particle->GetProcessManager();
// // Binary Cascade inelastic scattering for ions
// G4BinaryLightIonReaction * theGenIonBC= new G4BinaryLightIonReaction;
// // Inelastic Scattering for ions
// G4HadronInelasticProcess* theIPHe3 = new G4HadronInelasticProcess("He3Inelastic",particle);
// // Active the Tripathi and aShen Cross Section
// theIPHe3 -> AddDataSet(TripathiCrossSection);
// theIPHe3 -> AddDataSet(aShen);
// // Register the Alpha Binary Cascade Model
// theIPHe3 -> RegisterMe(theGenIonBC);
// // Active the Inelastic Process for He3
// pmanager -> AddDiscreteProcess(theIPHe3);
// // Active the Hadron Elastic Process
// pmanager -> AddDiscreteProcess(elastic_scattering);
//G4AlphaInelasticProcess theAlphaInelasticProcess;
// Neutron processes
particle = G4Neutron::Neutron();
pmanager = particle->GetProcessManager();
// Register the Precompound model
theIPNeutron.RegisterMe(theBertiniModel);
// Active the Cross-sections for neutron nuclear scattering from 14 MeV up to 20 GeV
theIPNeutron.AddDataSet(&theNXSec);
// Active the neutron inelastic process
pmanager -> AddDiscreteProcess(&theIPNeutron);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic_scattering);
// Activate the Tripathi and Shen Cross Section
theAlphaInelasticProcess.AddDataSet(tripathiCrossSection);
theAlphaInelasticProcess.AddDataSet(aShen);
// Pions plus processes
particle = G4PionPlus::PionPlus();
pmanager = particle -> GetProcessManager();
// Define the inelastic process for pions plus
G4PionPlusInelasticProcess* thePionPlusInelasticProcess = new G4PionPlusInelasticProcess("inelastic");
// Register the Low Energy Inelastic Model for pions plus
thePionPlusInelasticProcess -> RegisterMe(theBertiniModel);
// Active the inelastic process for pions plus
pmanager->AddDiscreteProcess(thePionPlusInelasticProcess);
pmanager -> AddDiscreteProcess(elastic_scattering);
// Register the Alpha Inelastic and Binary Cascade Models
theAlphaInelasticProcess.RegisterMe(theAlphaLEInelasticModel);
theAlphaInelasticProcess.RegisterMe(theBinaryCascade);
// Pion Minus processes
particle = G4PionMinus::PionMinus();
pmanager = particle -> GetProcessManager();
// Define the inelastic process for pions minus
G4PionMinusInelasticProcess* thePionMinusInelasticProcess = new G4PionMinusInelasticProcess("inelastic");
// Register the inelastic model for pion minus
thePionMinusInelasticProcess -> RegisterMe(theBertiniModel);
// Active the inelastic process for pion minus
pmanager -> AddDiscreteProcess(thePionMinusInelasticProcess);
// Active Absorption process for pion minus
pmanager -> AddRestProcess(new G4PiMinusAbsorptionAtRest, ordDefault);
pmanager -> AddDiscreteProcess(elastic_scattering);
//HADRON CAPTURE
// Process for capture of neutral hadrons
G4HadronCaptureProcess* neutronCapture = new G4HadronCaptureProcess();
// Final state production model for capture of neutral hadrons in nuclei
G4LCapture* capture_model = new G4LCapture();
// Set the energy range for the capture model
capture_model -> SetMinEnergy(neutronLowLimit);
capture_model -> SetMaxEnergy(neutronHighLimit);
// Register the capture model
neutronCapture -> RegisterMe(capture_model);
// Active the neutron capture process
pmanager -> AddDiscreteProcess(neutronCapture);
//FISSION
// Process for induced fission
G4HadronFissionProcess* fission = new G4HadronFissionProcess();
//Final state production model for induced fission
G4LFission* fission_model = new G4LFission();
// Set the energy range for the fission model
fission_model -> SetMinEnergy(neutronLowLimit);
fission_model -> SetMaxEnergy(neutronHighLimit);
// Register the fission model
fission -> RegisterMe(fission_model);
// Active the fission process
pmanager -> AddDiscreteProcess(fission);
// Activate the alpha inelastic scattering using the parameterised Alpha Inelastic and Binary Cascade models
processManager->AddDiscreteProcess(&theAlphaInelasticProcess);
// Activate the Hadron Elastic Process
processManager->AddDiscreteProcess(elasticScattering);
}
examples/advanced/hadrontherapy/src/HadrontherapyProtonBinary.cc
-272
View File
@@ -1,272 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyProtonBinary.cc; May 2005
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
// Code developed by:
//
// 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
//
// * cirrone@lns.infn.it
// ----------------------------------------------------------------------------
#include "HadrontherapyProtonBinary.hh"
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
#include "G4ProcessVector.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4Material.hh"
#include "G4LElastic.hh"
#include "G4BinaryCascade.hh"
#include "G4CascadeInterface.hh"
#include "G4PionPlusInelasticProcess.hh"
#include "G4LEPionPlusInelastic.hh"
#include "G4LEPionMinusInelastic.hh"
#include "G4HEPionPlusInelastic.hh"
#include "G4HEPionMinusInelastic.hh"
#include "G4PionMinusInelasticProcess.hh"
#include "G4PionPlusInelasticProcess.hh"
#include "G4LEPionMinusInelastic.hh"
#include "G4HEPionMinusInelastic.hh"
#include "G4PiMinusAbsorptionAtRest.hh"
#include "G4AntiProtonInelasticProcess.hh"
#include "G4LEAntiProtonInelastic.hh"
#include "G4HEAntiProtonInelastic.hh"
#include "G4AntiProtonAnnihilationAtRest.hh"
// BINARY + PRECOMPOUND PHYSICS LIST
//
// BINARY + PRECOMPOUND + EVAPORATION(DEFAULT EVAPORATION) FOR PROTONS, NEUTRONS AND PIONS
//
// LEP MODEL UP TO 100 MEV AND BINARY ION MODEL BETWEEN 80 MEV AND 40. GEV
// FOR DEUTERON, TRITON, HE3, ALPHA
//
// FISSION AND HADRON CAPTURE FOR NEUTRONS BETWEEN 0. MEV AND 100. TEV
//
HadrontherapyProtonBinary::HadrontherapyProtonBinary(const G4String& name):
G4VPhysicsConstructor(name)
{
// Energy limits of the model for ions
binaryLightIonLowLimit = 80.*MeV;
binaryLightIonHighLimit = 40.*GeV;
LEPHighLimit = 100.*MeV;
// Energy limits for protons, neutrons and pions
precompoundLowLimit = 0.*MeV;
precompoundHighLimit = 300.*MeV;
neutronLowLimit = 0.*TeV;
neutronHighLimit = 100.*TeV;
binaryLowLimit = 0.*MeV;
binaryHighLimit = 300.*MeV;
}
HadrontherapyProtonBinary::~HadrontherapyProtonBinary()
{}
void HadrontherapyProtonBinary::ConstructProcess()
{
// ELASTIC SCATTERING FOR PROTON, NEUTRON, IONS
G4LElastic* elastic_Model = new G4LElastic();
G4HadronElasticProcess* elastic = new G4HadronElasticProcess();
elastic -> RegisterMe(elastic_Model);
// PRECOMPOUND MODEL
G4PreCompoundModel* thePreEquilib = new G4PreCompoundModel(&theHandler);
thePreEquilib -> SetMinEnergy(precompoundLowLimit);
thePreEquilib -> SetMaxEnergy(precompoundHighLimit);
/////////////////////////////////////////////////////////////////////////////
// HADRONIC PHYSICS FOR PROTONS
G4ParticleDefinition* particle = 0;
G4ProcessManager* pmanager = 0;
particle = G4Proton::Proton();
pmanager = particle -> GetProcessManager();
// INELASTIC SCATTERING:
//BINARY - PRECOMPOUND + DEFAULT EVAPORATION NO FERMI BREAK-UP
G4BinaryCascade* thePBC = new G4BinaryCascade();
thePBC -> SetMinEnergy(binaryLowLimit);
thePBC -> SetMaxEnergy(binaryHighLimit);
theIPProton.RegisterMe(thePBC);
theIPProton.RegisterMe(thePreEquilib);
theIPProton.AddDataSet(&thePXSec);
pmanager -> AddDiscreteProcess(&theIPProton);
// ELASTIC SCATTERING
pmanager -> AddDiscreteProcess(elastic); //ELASIC SCATTERING
/////////////////////////////////////////////////////////////////////////////
////////// VERIFICARE LA POSSIBILITA' DEL BINARY PER PIONI
/////////////////////////////////////////////////////////////////////////////
// HADRONIC PHYSICS FOR PION PLUS
particle = G4PionPlus::PionPlus();
// ELASTIC SCATTERING
pmanager -> AddDiscreteProcess(elastic);
// INELASTIC SCATTERING: BINARY - PRECOMPOUND + DEFAULT EVAPORATION NO FERMI BREAK-UP
pmanager -> AddDiscreteProcess(elastic);
G4PionPlusInelasticProcess* thePionPlusInelasticProcess = new G4PionPlusInelasticProcess("inelastic");
G4PreCompoundModel* theLEPionPlusInelasticModel = new G4PreCompoundModel(&theHandler);
thePionPlusInelasticProcess -> RegisterMe(theLEPionPlusInelasticModel);
pmanager -> AddDiscreteProcess(thePionPlusInelasticProcess);
/////////////////////////////////////////////////////////////////////////////
//HADRONIC PHYSICS FOR PION MINUS
particle = G4PionMinus::PionMinus();
// ELASTIC SCATTERING
pmanager -> AddDiscreteProcess(elastic);
// INELASTIC SCATTERING: BINARY - PRECOMPOUND + DEFAULT EVAPORATION NO FERMI BREAK-UP
G4PionMinusInelasticProcess* thePionMinusInelasticProcess = new G4PionMinusInelasticProcess("inelastic");
G4PreCompoundModel* theLEPionMinusInelasticModel = new G4PreCompoundModel(&theHandler);
thePionMinusInelasticProcess -> RegisterMe(theLEPionMinusInelasticModel);
pmanager -> AddDiscreteProcess(thePionMinusInelasticProcess);
/////////////////////////////////////////////////////////////////////////////
// Neutron
particle = G4Neutron::Neutron();
pmanager = particle->GetProcessManager();
thePreEquilib -> SetMinEnergy(precompoundLowLimit);
thePreEquilib -> SetMaxEnergy(precompoundHighLimit);
G4BinaryCascade* theNBC = new G4BinaryCascade();
theNBC->SetMinEnergy(binaryLowLimit);
theNBC->SetMaxEnergy(binaryHighLimit);
theIPNeutron.RegisterMe(theNBC);
theIPNeutron.RegisterMe(thePreEquilib);
theIPNeutron.AddDataSet(&theNXSec);
pmanager -> AddDiscreteProcess(&theIPNeutron);
pmanager -> AddDiscreteProcess(elastic); // ELASTIC SCATTERING
//Hadron Capture
G4HadronCaptureProcess* neutronCapture = new G4HadronCaptureProcess();
G4LCapture* capture_model = new G4LCapture();
capture_model -> SetMinEnergy(neutronLowLimit);
capture_model -> SetMaxEnergy(neutronHighLimit);
neutronCapture -> RegisterMe(capture_model);
pmanager -> AddDiscreteProcess(neutronCapture);
//Fission
G4HadronFissionProcess* fission = new G4HadronFissionProcess();
G4LFission* fission_model = new G4LFission();
fission_model -> SetMinEnergy(neutronLowLimit);
fission_model -> SetMaxEnergy(neutronHighLimit);
fission -> RegisterMe(fission_model);
pmanager -> AddDiscreteProcess(fission);
/////////////////////////////////////////////////////////////////////////////
// ION HADRONIC PHYSICS LIST
G4TripathiCrossSection * TripathiCrossSection= new G4TripathiCrossSection;
G4IonsShenCrossSection * aShen = new G4IonsShenCrossSection;
// INELASTIC SCATTERING FOR IONS
G4BinaryLightIonReaction* theBC = new G4BinaryLightIonReaction();
theBC -> SetMinEnergy(binaryLightIonLowLimit);
theBC -> SetMaxEnergy(binaryLightIonHighLimit);
/////////////////////////////////////////////////////////////////////////////
// deuteron
particle = G4Deuteron::Deuteron();
pmanager = particle -> GetProcessManager();
// INELASTIC SCATTERING
G4LEDeuteronInelastic* theDIModel = new G4LEDeuteronInelastic;
theDIModel -> SetMaxEnergy(LEPHighLimit);
theIPdeuteron.AddDataSet(TripathiCrossSection);
theIPdeuteron.AddDataSet(aShen);
theIPdeuteron.RegisterMe(theDIModel);
theIPdeuteron.RegisterMe(theBC);
pmanager -> AddDiscreteProcess(&theIPdeuteron);
//ELASTIC SCATTERING
pmanager -> AddDiscreteProcess(elastic);
/////////////////////////////////////////////////////////////////////////////
// triton
particle = G4Triton::Triton();
pmanager = particle->GetProcessManager();
// INELASTIC SCATTERING
G4LETritonInelastic* theTIModel = new G4LETritonInelastic;
theTIModel -> SetMaxEnergy(LEPHighLimit);
theIPtriton.AddDataSet(TripathiCrossSection);
theIPtriton.AddDataSet(aShen);
theIPtriton.RegisterMe(theTIModel);
theIPtriton.RegisterMe(theBC);
pmanager -> AddDiscreteProcess(&theIPtriton);
//ELASTIC SCATTERING
pmanager -> AddDiscreteProcess(elastic); //ELASTIC SCATTERING
/////////////////////////////////////////////////////////////////////////////
// alpha
particle = G4Alpha::Alpha();
pmanager = particle->GetProcessManager();
// INELASTIC SCATTERING
G4LEAlphaInelastic* theAIModel = new G4LEAlphaInelastic;
theAIModel -> SetMaxEnergy(LEPHighLimit);
theIPalpha.AddDataSet(TripathiCrossSection);
theIPalpha.AddDataSet(aShen);
theIPalpha.RegisterMe(theAIModel);
theIPalpha.RegisterMe(theBC);
pmanager -> AddDiscreteProcess(&theIPalpha);
//ELASTIC SCATTERING
pmanager -> AddDiscreteProcess(elastic); //ELASTIC SCATTERING
/////////////////////////////////////////////////////////////////////////////
// He3
// particle = G4He3::He3();
// pmanager = particle->GetProcessManager();
// G4BinaryLightIonReaction * theGenIonBC= new G4BinaryLightIonReaction;
// G4HadronInelasticProcess* theIPHe3 =
// new G4HadronInelasticProcess("He3Inelastic",particle);
// theIPHe3 -> AddDataSet(TripathiCrossSection);
// theIPHe3 -> AddDataSet(aShen);
// theIPHe3 -> RegisterMe(theGenIonBC);
// pmanager -> AddDiscreteProcess(theIPHe3);
// pmanager -> AddDiscreteProcess(elastic); //ELASTIC SCATTERING
}
examples/advanced/hadrontherapy/src/HadrontherapyProtonPrecompound.cc
+84 -121
View File
@@ -50,20 +50,13 @@
#include "G4PiNuclearCrossSection.hh"
#include "G4LFission.hh"
#include "G4LCapture.hh"
#include "G4NeutronInelasticProcess.hh"
#include "G4NeutronInelasticCrossSection.hh"
#include "G4TripathiCrossSection.hh"
#include "G4IonsShenCrossSection.hh"
#include "G4HadronInelasticProcess.hh"
#include "G4LEDeuteronInelastic.hh"
#include "G4DeuteronInelasticProcess.hh"
#include "G4TritonInelasticProcess.hh"
#include "G4LETritonInelastic.hh"
#include "G4AlphaInelasticProcess.hh"
#include "G4LEAlphaInelastic.hh"
#include "G4HadronElasticProcess.hh"
#include "G4ProtonInelasticProcess.hh"
#include "G4ProtonInelasticCrossSection.hh"
#include "G4HadronCaptureProcess.hh"
#include "G4BinaryLightIonReaction.hh"
#include "G4HadronInelasticProcess.hh"
@@ -71,32 +64,12 @@
// PRECOMPOUND PHYSICS LIST
//
// PRECOMPOUND + EVAPORATION(DEFAULT EVAPORATION) FOR PROTONS, NEUTRONS AND PIONS
//
// LEP MODEL UP TO 200 MEV
//
// FISSION AND HADRON CAPTURE FOR NEUTRONS BETWEEN 0. MEV AND 100. TEV
//
HadrontherapyProtonPrecompound::HadrontherapyProtonPrecompound(const G4String& name):
G4VPhysicsConstructor(name)
{
G4cout<<"****** Proton Precompound Physics List is active !!!!!! ******"
<<G4endl;
// Inelastic hadronic process: energy limits
// Protons, neutrons and pions
// Energy limits of the precompound model
precompoundLowLimit = 0.*MeV;
precompoundHighLimit = 300.*MeV;
// Energy limit of the neutron fission and capture
neutronLowLimit = 0.*TeV;
neutronHighLimit = 100.*TeV;
// Ions
// Energy limit of the LEP model for ions
LEPHighLimit = 200.*MeV;
}
HadrontherapyProtonPrecompound::~HadrontherapyProtonPrecompound()
@@ -107,42 +80,26 @@ void HadrontherapyProtonPrecompound::ConstructProcess()
G4ParticleDefinition* particle = 0;
G4ProcessManager* pmanager = 0;
// ELASTIC SCATTERING
// FOR PROTON, NEUTRON, IONS
G4LElastic* elasticScattering_model = new G4LElastic();
G4HadronElasticProcess* elastic_scattering = new G4HadronElasticProcess();
elastic_scattering -> RegisterMe(elasticScattering_model);
// Physics for proton, neutron, pion+ and pion-
// Elastic scattering: Low Energy Parameterised model
G4LElastic* elasticScatteringModel = new G4LElastic();
G4HadronElasticProcess* elasticScattering = new G4HadronElasticProcess();
elasticScattering -> RegisterMe(elasticScatteringModel);
// TRIPATHI CROSS SECTION
// Implementation of formulas in analogy to NASA technical paper 3621 by
// Tripathi, et al. Cross-sections for ion ion scattering
G4TripathiCrossSection* TripathiCrossSection = new G4TripathiCrossSection;
// IONS SHEN CROSS SECTION
// Implementation of formulas
// Shen et al. Nuc. Phys. A 491 130 (1989)
// Total Reaction Cross Section for Heavy-Ion Collisions
G4IonsShenCrossSection* aShen = new G4IonsShenCrossSection;
//------------------------------------------//
// Activate the hadronic physics processes //
//------------------------------------------//
// PRECOMPOUND + EVAPORATION(DEFAULT EVAPORATION)
////////////
// Proton //
////////////
// Inelastic scattering: Inelastic PreCompound model
G4PreCompoundModel* preequilibriumModel = new G4PreCompoundModel(&theHandler);
// Set the minimum and maximum energy value of the pre-equilibrium model
G4double precompoundLowLimit = 0. * MeV;
G4double precompoundHighLimit = 300. * MeV;
preequilibriumModel -> SetMinEnergy(precompoundLowLimit);
preequilibriumModel -> SetMaxEnergy(precompoundHighLimit);
//--------------------------------------------------------------------------------------
// Proton processes
particle = G4Proton::Proton();
pmanager = particle -> GetProcessManager();
G4PreCompoundModel* preequilibriumModel = new G4PreCompoundModel(&theHandler);
// Set the minimum and maximum energy value of the pre-equilibrium model
preequilibriumModel -> SetMinEnergy(precompoundLowLimit);
preequilibriumModel -> SetMaxEnergy(precompoundHighLimit);
// Model Registration
protonInelasticProcess.RegisterMe(preequilibriumModel);
// Activate the cross-sections for proton nuclear scattering
@@ -151,11 +108,10 @@ void HadrontherapyProtonPrecompound::ConstructProcess()
// Activate the proton inelastic scattering using the precompound model
pmanager -> AddDiscreteProcess(&protonInelasticProcess);
// Activate the proton elastic scattering
pmanager -> AddDiscreteProcess(elastic_scattering);
pmanager -> AddDiscreteProcess(elasticScattering);
/////////////
// Neutron //
/////////////
//--------------------------------------------------------------------------------------
// Neutron processes
particle = G4Neutron::Neutron();
pmanager = particle -> GetProcessManager();
@@ -168,11 +124,42 @@ void HadrontherapyProtonPrecompound::ConstructProcess()
// Activate the neutron inelastic process
pmanager -> AddDiscreteProcess(&neutronInelasticProcess);
// Activate the neutron elastic scattering
pmanager -> AddDiscreteProcess(elastic_scattering);
pmanager -> AddDiscreteProcess(elasticScattering);
// Neutron capture process
// Energy limits
G4HadronCaptureProcess* neutronCapture = new G4HadronCaptureProcess();
G4LCapture* captureModel = new G4LCapture();
// Energy limit of the neutron fission and capture
G4double neutronLowLimit = 0.*TeV;
G4double neutronHighLimit = 100.*TeV;
// Set the energy range for the capture model
captureModel -> SetMinEnergy(neutronLowLimit);
captureModel -> SetMaxEnergy(neutronHighLimit);
// Register the capture model
neutronCapture -> RegisterMe(captureModel);
// Active the capture process
pmanager -> AddDiscreteProcess(neutronCapture);
// Process for induced fission
G4HadronFissionProcess* fission = new G4HadronFissionProcess();
//Final state production model for induced fission
G4LFission* fissionModel = new G4LFission();
// Set the energy range for the fission model
fissionModel -> SetMinEnergy(neutronLowLimit);
fissionModel -> SetMaxEnergy(neutronHighLimit);
// Register the fission model
fission -> RegisterMe(fissionModel);
// Active the fission process
pmanager -> AddDiscreteProcess(fission);
//--------------------------
// Pion Plus
////////////////
// Pions plus //
////////////////
particle = G4PionPlus::PionPlus();
pmanager = particle -> GetProcessManager();
@@ -182,11 +169,10 @@ void HadrontherapyProtonPrecompound::ConstructProcess()
// Active the inelastic process for pions plus
pmanager -> AddDiscreteProcess(pionPlusInelasticProcess);
pmanager -> AddDiscreteProcess(elastic_scattering);
////////////////
// Pion Minus //
///////////////
pmanager -> AddDiscreteProcess(elasticScattering);
//-----------------------------
// Pion Minus
particle = G4PionMinus::PionMinus();
pmanager = particle -> GetProcessManager();
@@ -198,11 +184,24 @@ void HadrontherapyProtonPrecompound::ConstructProcess()
// Active the inelastic process for pion minus
pmanager -> AddDiscreteProcess(pionMinusInelasticProcess);
pmanager -> AddDiscreteProcess(elastic_scattering);
pmanager -> AddDiscreteProcess(elasticScattering);
///////////////
// Deuteron //
//////////////
//--------------------------------------------------------------------------------------
// Physics for ions
// Energy limit of the LEP model for ions
G4double LEPHighLimit = 200.*MeV;
// TRIPATHI CROSS SECTION
// Implementation of formulas in analogy to NASA technical paper 3621 by
// Tripathi, et al. Cross-sections for ion ion scattering
G4TripathiCrossSection* TripathiCrossSection = new G4TripathiCrossSection;
// IONS SHEN CROSS SECTION
// Implementation of formulas
// Shen et al. Nuc. Phys. A 491 130 (1989)
// Total Reaction Cross Section for Heavy-Ion Collisions
G4IonsShenCrossSection* aShen = new G4IonsShenCrossSection;
particle = G4Deuteron::Deuteron();
pmanager = particle -> GetProcessManager();
@@ -222,11 +221,9 @@ void HadrontherapyProtonPrecompound::ConstructProcess()
// Active the deuteron inelastic scattering using the deuteron inelastic and binary cascade model
pmanager -> AddDiscreteProcess(&deuteronInelasticProcess);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic_scattering);
pmanager -> AddDiscreteProcess(elasticScattering);
////////////
// Triton //
////////////
// Triton
particle = G4Triton::Triton();
pmanager = particle -> GetProcessManager();
@@ -245,11 +242,9 @@ void HadrontherapyProtonPrecompound::ConstructProcess()
// Active the triton inelastic scattering process
pmanager -> AddDiscreteProcess(&tritonInelasticProcess);
// Active the triton elastic scattering process
pmanager -> AddDiscreteProcess(elastic_scattering);
pmanager -> AddDiscreteProcess(elasticScattering);
///////////
// Alpha //
//////////
// Alpha particles
particle = G4Alpha::Alpha();
pmanager = particle -> GetProcessManager();
@@ -268,56 +263,24 @@ void HadrontherapyProtonPrecompound::ConstructProcess()
// Active the alpha inelastic scattering
pmanager -> AddDiscreteProcess(&alphaInelasticProcess);
// Active the alpha elastic scattering
pmanager -> AddDiscreteProcess(elastic_scattering);
pmanager -> AddDiscreteProcess(elasticScattering);
// He3
// particle = G4He3::He3();
// G4HadronInelasticProcess* He3inelasticProcess =
//new G4HadronInelasticProcess("He3Inelastic",particle);
// new G4HadronInelasticProcess("He3Inelastic",particle);
//G4BinaryLightIonReaction * ionBinaryCascade= new G4BinaryLightIonReaction;
// G4BinaryLightIonReaction * ionBinaryCascade= new G4BinaryLightIonReaction;
//He3inelasticProcess -> AddDataSet(TripathiCrossSection);
// He3inelasticProcess -> AddDataSet(TripathiCrossSection);
//He3inelasticProcess -> AddDataSet(aShen);
//He3inelasticProcess -> RegisterMe(ionBinaryCascade);
//pmanager = particle -> GetProcessManager();
//pmanager -> AddDiscreteProcess(He3inelasticProcess);
//pmanager -> AddDiscreteProcess(elastic_scattering);
////////////////////
// HADRON CAPTURE //
////////////////////
//pmanager -> AddDiscreteProcess(elasticScattering);
G4HadronCaptureProcess* neutronCapture = new G4HadronCaptureProcess();
G4LCapture* capture_model = new G4LCapture();
// Set the energy range for the capture model
capture_model -> SetMinEnergy(neutronLowLimit);
capture_model -> SetMaxEnergy(neutronHighLimit);
// Register the capture model
neutronCapture -> RegisterMe(capture_model);
// Active the capture process
pmanager -> AddDiscreteProcess(neutronCapture);
//////////////
// FISSION //
/////////////
// Process for induced fission
G4HadronFissionProcess* fission = new G4HadronFissionProcess();
//Final state production model for induced fission
G4LFission* fission_model = new G4LFission();
// Set the energy range for the fission model
fission_model -> SetMinEnergy(neutronLowLimit);
fission_model -> SetMaxEnergy(neutronHighLimit);
// Register the fission model
fission -> RegisterMe(fission_model);
// Active the fission process
pmanager -> AddDiscreteProcess(fission);
}
examples/advanced/hadrontherapy/src/HadrontherapyProtonPrecompoundFermi.cc
-302
View File
@@ -1,302 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyProtonPrecompoundFermi.cc; May 2005
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
// Code developed by:
//
// 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
//
// * cirrone@lns.infn.it
// ----------------------------------------------------------------------------
#include "HadrontherapyProtonPrecompoundFermi.hh"
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
#include "G4ProcessVector.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4Material.hh"
#include "G4LElastic.hh"
#include "G4BinaryCascade.hh"
#include "G4CascadeInterface.hh"
#include "G4PionPlusInelasticProcess.hh"
#include "G4LEPionPlusInelastic.hh"
#include "G4LEPionMinusInelastic.hh"
#include "G4HEPionPlusInelastic.hh"
#include "G4HEPionMinusInelastic.hh"
#include "G4PionMinusInelasticProcess.hh"
#include "G4LEPionMinusInelastic.hh"
#include "G4HEPionMinusInelastic.hh"
#include "G4PiMinusAbsorptionAtRest.hh"
#include "G4AntiProtonInelasticProcess.hh"
#include "G4LEAntiProtonInelastic.hh"
#include "G4HEAntiProtonInelastic.hh"
#include "G4AntiProtonAnnihilationAtRest.hh"
#include "G4FermiBreakUp.hh"
#include "G4PiNuclearCrossSection.hh"
//
//
// PRECOMPOUND + FERMI BREAKUP PHYSICS LIST
//
// ELASTIC SCATTERING FOR ALL THE HADRONS AND IONS
// INELASTIC SCATTERING:
// * PRECOMPOUND PHYSICS LIST with DEFAULT EVAPORATION MODEL + FERMI BREAK-UP
// * PRECOMPOUND + EVAPORATION + FERMI BREAK-UP FOR PROTONS, NEUTRONS AND PIONS
// * LEP MODEL UP TO 100 MEV AND BINARY ION MODEL BETWEEN 80 MEV AND 40. GEV
// FOR DEUTERON, TRITON, HE3, ALPHA
// * FISSION AND HADRON CAPTURE FOR NEUTRONS BETWEEN 0. MEV AND 100. TEV
//
//
HadrontherapyProtonPrecompoundFermi::HadrontherapyProtonPrecompoundFermi(const G4String& name):
G4VPhysicsConstructor(name)
{
// Inelastic process, energy limits
// Protons, neutrons and pions
// Energy limit of the precompound model
precompoundLowLimit = 0.*MeV;
precompoundHighLimit = 300.*MeV;
// Energy limit of the neutron fission and capture
neutronLowLimit = 0.*TeV;
neutronHighLimit = 100.*TeV;
// Ions
// Energy limit of the binary ion model
binaryLightIonLowLimit = 80.*MeV;
binaryLightIonHighLimit = 40.*GeV;
// Energy limit of the LEP model for ions
LEPHighLimit = 100.*MeV;
//targetZ should vary between 1 and 8
targetZ = 1;
targetA = 2 * targetZ;
}
HadrontherapyProtonPrecompoundFermi::~HadrontherapyProtonPrecompoundFermi()
{}
void HadrontherapyProtonPrecompoundFermi::ConstructProcess()
{
G4ParticleDefinition* particle = 0;
G4ProcessManager* pmanager = 0;
// LOW ENERGY ELASTIC SCATTERING
// FOR PROTON, NEUTRON, IONS
G4LElastic* elastic_Model = new G4LElastic();
G4HadronElasticProcess* elastic = new G4HadronElasticProcess();
elastic -> RegisterMe(elastic_Model);
// FERMI BREAK-UP MODEL
G4FermiBreakUp* breakup = new G4FermiBreakUp();
// Set the Fermi break up model
theHandler.SetFermiModel(breakup);
// fix the target A and Z;
theHandler.SetMaxAandZForFermiBreakUp(targetA,targetZ);
// INELASTIC SCATTERING
// Binary Cascade
G4BinaryLightIonReaction* theBC = new G4BinaryLightIonReaction();
// Set the min and max energy for the Binary Cascade
theBC -> SetMinEnergy(binaryLightIonLowLimit);
theBC -> SetMaxEnergy(binaryLightIonHighLimit);
// TRIPATHI CROSS SECTION
// Implementation of formulas in analogy to NASA technical paper 3621 by
// Tripathi, et al. Cross-sections for ion ion scattering
G4TripathiCrossSection* TripathiCrossSection = new G4TripathiCrossSection;
// IONS SHEN CROSS SECTION
// Implementation of formulas
// Shen et al. Nuc. Phys. A 491 130 (1989)
// Total Reaction Cross Section for Heavy-Ion Collisions
G4IonsShenCrossSection* aShen = new G4IonsShenCrossSection;
//--------------------------------------------------------------------------------------
// Proton PRECOMPOUND + EVAPORATION(DEFAULT EVAPORATION)+ FERMI BREAK-UP
particle = G4Proton::Proton();
pmanager = particle->GetProcessManager();
G4PreCompoundModel* thePreEquilib = new G4PreCompoundModel(&theHandler);
// Set the range of minimum and maximum energy value
thePreEquilib -> SetMinEnergy(precompoundLowLimit);
thePreEquilib -> SetMaxEnergy(precompoundHighLimit);
// Model Registration
theIPProton.RegisterMe(thePreEquilib);
// Active the Cross-sections for proton nuclear scattering up to 20 GeV
theIPProton.AddDataSet(&thePXSec);
// Active the proton inelastic scattering using the precompound model
pmanager -> AddDiscreteProcess(&theIPProton);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic);
// deuteron
particle = G4Deuteron::Deuteron();
pmanager = particle -> GetProcessManager();
// Final state production model for Deuteron inelastic scattering below 100 MeV
G4LEDeuteronInelastic* theDIModel = new G4LEDeuteronInelastic;
// Set the maximum energy for LEP model
theDIModel -> SetMaxEnergy(LEPHighLimit);
// Active the Tripathi and aShen Cross Section
theIPdeuteron.AddDataSet(TripathiCrossSection);
theIPdeuteron.AddDataSet(aShen);
// Register the Deuteron Inelastic and Binary Cascade Model
theIPdeuteron.RegisterMe(theDIModel);
theIPdeuteron.RegisterMe(theBC);
// Active the deuteron inelastic scattering using the deuteron inelastic and binary cascade model
pmanager -> AddDiscreteProcess(&theIPdeuteron);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic);
// triton
particle = G4Triton::Triton();
pmanager = particle->GetProcessManager();
// Final state production model for Triton inelastic scattering below 100 MeV
G4LETritonInelastic* theTIModel = new G4LETritonInelastic;
// Set the maximum energy for LEP model
theTIModel -> SetMaxEnergy(LEPHighLimit);
// Active the Tripathi and aShen Cross Section
theIPtriton.AddDataSet(TripathiCrossSection);
theIPtriton.AddDataSet(aShen);
// Register the Triton Inelastic and Binary Cascade Model
theIPtriton.RegisterMe(theTIModel);
theIPtriton.RegisterMe(theBC);
// Active the triton inelastic scattering using the triton inelastic and binary cascade model
pmanager -> AddDiscreteProcess(&theIPtriton);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic);
// alpha
particle = G4Alpha::Alpha();
pmanager = particle->GetProcessManager();
// Final state production model for Alpha inelastic scattering below 20 GeV
G4LEAlphaInelastic* theAIModel = new G4LEAlphaInelastic;
// Set the maximum energy for LEP model
theAIModel -> SetMaxEnergy(LEPHighLimit);
// Register the Triton Inelastic and Binary Cascade Model
theIPalpha.AddDataSet(TripathiCrossSection);
theIPalpha.AddDataSet(aShen);
// Register the Alpha Inelastic and Binary Cascade Model
theIPalpha.RegisterMe(theAIModel);
theIPalpha.RegisterMe(theBC);
// Active the alpha inelastic scattering using the alpha inelastic and binary cascade model
pmanager -> AddDiscreteProcess(&theIPalpha);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic);
// He3
// particle = G4He3::He3();
// pmanager = particle->GetProcessManager();
// // Binary Cascade inelastic scattering for ions
// G4BinaryLightIonReaction * theGenIonBC= new G4BinaryLightIonReaction;
// // Inelastic Scattering for ions
// G4HadronInelasticProcess* theIPHe3 = new G4HadronInelasticProcess("He3Inelastic",particle);
// // Active the Tripathi and aShen Cross Section
// theIPHe3 -> AddDataSet(TripathiCrossSection);
// theIPHe3 -> AddDataSet(aShen);
// // Register the Alpha Binary Cascade Model
// theIPHe3 -> RegisterMe(theGenIonBC);
// // Active the Inelastic Process for He3
// pmanager -> AddDiscreteProcess(theIPHe3);
// // Active the Hadron Elastic Process
// pmanager -> AddDiscreteProcess(elastic);
// Neutron
particle = G4Neutron::Neutron();
pmanager = particle->GetProcessManager();
// Register the Precompound model
theIPNeutron.RegisterMe(thePreEquilib);
// Active the Cross-sections for neutron nuclear scattering from 14 MeV up to 20 GeV
theIPNeutron.AddDataSet(&theNXSec);
// Active the neutron inelastic process
pmanager -> AddDiscreteProcess(&theIPNeutron);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic);
// Pions plus
particle = G4PionPlus::PionPlus();
pmanager = particle -> GetProcessManager();
// Define the inelastic process for pions plus
G4PionPlusInelasticProcess* thePionPlusInelasticProcess = new G4PionPlusInelasticProcess("inelastic");
// Register the Low Energy Inelastic Model for pions plus
thePionPlusInelasticProcess -> RegisterMe(thePreEquilib);
// Active the inelastic process for pions plus
pmanager->AddDiscreteProcess(thePionPlusInelasticProcess);
pmanager -> AddDiscreteProcess(elastic);
// Pion Minus
particle = G4PionMinus::PionMinus();
pmanager = particle -> GetProcessManager();
// Define the inelastic process for pions minus
G4PionMinusInelasticProcess* thePionMinusInelasticProcess = new G4PionMinusInelasticProcess("inelastic");
// Register the inelastic model for pion minus
thePionMinusInelasticProcess -> RegisterMe(thePreEquilib);
// Active the inelastic process for pion minus
pmanager -> AddDiscreteProcess(thePionMinusInelasticProcess);
// Active Absorption process for pion minus
pmanager -> AddRestProcess(new G4PiMinusAbsorptionAtRest, ordDefault);
pmanager -> AddDiscreteProcess(elastic);
//HADRON CAPTURE
// Process for capture of neutral hadrons
G4HadronCaptureProcess* neutronCapture = new G4HadronCaptureProcess();
// Final state production model for capture of neutral hadrons in nuclei
G4LCapture* capture_model = new G4LCapture();
// Set the energy range for the capture model
capture_model -> SetMinEnergy(neutronLowLimit);
capture_model -> SetMaxEnergy(neutronHighLimit);
// Register the capture model
neutronCapture -> RegisterMe(capture_model);
// Active the neutron capture process
pmanager -> AddDiscreteProcess(neutronCapture);
//FISSION
// Process for induced fission
G4HadronFissionProcess* fission = new G4HadronFissionProcess();
//Final state production model for induced fission
G4LFission* fission_model = new G4LFission();
// Set the energy range for the fission model
fission_model -> SetMinEnergy(neutronLowLimit);
fission_model -> SetMaxEnergy(neutronHighLimit);
// Register the fission model
fission -> RegisterMe(fission_model);
// Active the fission process
pmanager -> AddDiscreteProcess(fission);
}
examples/advanced/hadrontherapy/src/HadrontherapyProtonPrecompoundGEM.cc
-295
View File
@@ -1,295 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyProtonPrecompoundGEM.cc; May 2005
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
// Code developed by:
//
// 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
//
// * cirrone@lns.infn.it
// ----------------------------------------------------------------------------
#include "HadrontherapyProtonPrecompoundGEM.hh"
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
#include "G4ProcessVector.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4Material.hh"
#include "G4LElastic.hh"
#include "G4BinaryCascade.hh"
#include "G4CascadeInterface.hh"
#include "G4PionPlusInelasticProcess.hh"
#include "G4LEPionPlusInelastic.hh"
#include "G4LEPionMinusInelastic.hh"
#include "G4HEPionPlusInelastic.hh"
#include "G4HEPionMinusInelastic.hh"
#include "G4PionMinusInelasticProcess.hh"
#include "G4LEPionMinusInelastic.hh"
#include "G4HEPionMinusInelastic.hh"
#include "G4PiMinusAbsorptionAtRest.hh"
#include "G4AntiProtonInelasticProcess.hh"
#include "G4LEAntiProtonInelastic.hh"
#include "G4HEAntiProtonInelastic.hh"
#include "G4AntiProtonAnnihilationAtRest.hh"
#include "G4Evaporation.hh"
#include "G4ExcitationHandler.hh"
//
//
// HADRONIC PHYSICS LIST
//
// - ELASTIC SCATTERING FOR ALL THE HADRONS AND IONS
// - INELASTIC SCATTERING:
// * PRECOMPOUND PHYSICS LIST with GEM EVAPORATION MODEL
// * PRECOMPOUND + EVAPORATION(GEM MODEL) NO FERMI BREAK-UP FOR PROTONS, NEUTRONS AND PIONS
// * LEP MODEL UP TO 100 MEV AND BINARY ION MODEL BETWEEN 80 MEV AND 40. GEV
// FOR DEUTERON, TRITON, HE3, ALPHA
// * FISSION AND HADRON CAPTURE FOR NEUTRONS BETWEEN 0. MEV AND 100. TEV
//
//
HadrontherapyProtonPrecompoundGEM::HadrontherapyProtonPrecompoundGEM(const G4String& name):
G4VPhysicsConstructor(name)
{
// Inelastic process, energy limits
// Protons, neutrons and pions
// Energy limit of the precompound model
precompoundLowLimit = 0.*MeV;
precompoundHighLimit = 300.*MeV;
// Energy limit of the neutron fission and capture
neutronLowLimit = 0.*TeV;
neutronHighLimit = 100.*TeV;
// Ions
// Energy limit of the binary ion model
binaryLightIonLowLimit = 80.*MeV;
binaryLightIonHighLimit = 40.*GeV;
// Energy limit of the LEP model for ions
LEPHighLimit = 100.*MeV;
}
HadrontherapyProtonPrecompoundGEM::~HadrontherapyProtonPrecompoundGEM()
{}
void HadrontherapyProtonPrecompoundGEM::ConstructProcess()
{
G4ParticleDefinition* particle = 0;
G4ProcessManager* pmanager = 0;
// LOW ENERGY ELASTIC SCATTERING
// FOR PROTON, NEUTRON, IONS
G4LElastic* elastic_Model = new G4LElastic();
G4HadronElasticProcess* elastic = new G4HadronElasticProcess();
elastic -> RegisterMe(elastic_Model);
// GEM EVAPORATION MODEL
G4Evaporation* evaporation = new G4Evaporation();
evaporation -> SetGEMChannel();
theHandler.SetEvaporation(evaporation);
// INELASTIC SCATTERING
// Binary Cascade
G4BinaryLightIonReaction* theBC = new G4BinaryLightIonReaction();
// Set the min and max energy for the Binary Cascade
theBC -> SetMinEnergy(binaryLightIonLowLimit);
theBC -> SetMaxEnergy(binaryLightIonHighLimit);
// TRIPATHI CROSS SECTION
// Implementation of formulas in analogy to NASA technical paper 3621 by
// Tripathi, et al. Cross-sections for ion ion scattering
G4TripathiCrossSection* TripathiCrossSection = new G4TripathiCrossSection;
// IONS SHEN CROSS SECTION
// Implementation of formulas
// Shen et al. Nuc. Phys. A 491 130 (1989)
// Total Reaction Cross Section for Heavy-Ion Collisions
G4IonsShenCrossSection* aShen = new G4IonsShenCrossSection;
//--------------------------------------------------------------------------------------
// Proton PRECOMPOUND + EVAPORATION(DEFAULT EVAPORATION)+ FERMI BREAK-UP
particle = G4Proton::Proton();
pmanager = particle->GetProcessManager();
G4PreCompoundModel* thePreEquilib = new G4PreCompoundModel(&theHandler);
// Set the range of minimum and maximum energy value
thePreEquilib -> SetMinEnergy(precompoundLowLimit);
thePreEquilib -> SetMaxEnergy(precompoundHighLimit);
// Model Registration
theIPProton.RegisterMe(thePreEquilib);
// Active the Cross-sections for proton nuclear scattering up to 20 GeV
theIPProton.AddDataSet(&thePXSec);
// Active the proton inelastic scattering using the precompound model
pmanager -> AddDiscreteProcess(&theIPProton);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic);
// deuteron
particle = G4Deuteron::Deuteron();
pmanager = particle -> GetProcessManager();
// Final state production model for Deuteron inelastic scattering below 100 MeV
G4LEDeuteronInelastic* theDIModel = new G4LEDeuteronInelastic;
// Set the maximum energy for LEP model
theDIModel -> SetMaxEnergy(LEPHighLimit);
// Active the Tripathi and aShen Cross Section
theIPdeuteron.AddDataSet(TripathiCrossSection);
theIPdeuteron.AddDataSet(aShen);
// Register the Deuteron Inelastic and Binary Cascade Model
theIPdeuteron.RegisterMe(theDIModel);
theIPdeuteron.RegisterMe(theBC);
// Active the deuteron inelastic scattering using the deuteron inelastic and binary cascade model
pmanager -> AddDiscreteProcess(&theIPdeuteron);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic);
// triton
particle = G4Triton::Triton();
pmanager = particle->GetProcessManager();
// Final state production model for Triton inelastic scattering below 100 MeV
G4LETritonInelastic* theTIModel = new G4LETritonInelastic;
// Set the maximum energy for LEP model
theTIModel -> SetMaxEnergy(LEPHighLimit);
// Active the Tripathi and aShen Cross Section
theIPtriton.AddDataSet(TripathiCrossSection);
theIPtriton.AddDataSet(aShen);
// Register the Triton Inelastic and Binary Cascade Model
theIPtriton.RegisterMe(theTIModel);
theIPtriton.RegisterMe(theBC);
// Active the triton inelastic scattering using the triton inelastic and binary cascade model
pmanager -> AddDiscreteProcess(&theIPtriton);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic);
// alpha
particle = G4Alpha::Alpha();
pmanager = particle->GetProcessManager();
// Final state production model for Alpha inelastic scattering below 20 GeV
G4LEAlphaInelastic* theAIModel = new G4LEAlphaInelastic;
// Set the maximum energy for LEP model
theAIModel -> SetMaxEnergy(LEPHighLimit);
// Register the Triton Inelastic and Binary Cascade Model
theIPalpha.AddDataSet(TripathiCrossSection);
theIPalpha.AddDataSet(aShen);
// Register the Alpha Inelastic and Binary Cascade Model
theIPalpha.RegisterMe(theAIModel);
theIPalpha.RegisterMe(theBC);
// Active the alpha inelastic scattering using the alpha inelastic and binary cascade model
pmanager -> AddDiscreteProcess(&theIPalpha);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic);
// He3
// particle = G4He3::He3();
// pmanager = particle->GetProcessManager();
// // Binary Cascade inelastic scattering for ions
// G4BinaryLightIonReaction * theGenIonBC= new G4BinaryLightIonReaction;
// // Inelastic Scattering for ions
// G4HadronInelasticProcess* theIPHe3 = new G4HadronInelasticProcess("He3Inelastic",particle);
// // Active the Tripathi and aShen Cross Section
// theIPHe3 -> AddDataSet(TripathiCrossSection);
// theIPHe3 -> AddDataSet(aShen);
// // Register the Alpha Binary Cascade Model
// theIPHe3 -> RegisterMe(theGenIonBC);
// // Active the Inelastic Process for He3
// pmanager -> AddDiscreteProcess(theIPHe3);
// // Active the Hadron Elastic Process
// pmanager -> AddDiscreteProcess(elastic);
// Neutron
particle = G4Neutron::Neutron();
pmanager = particle->GetProcessManager();
// Register the Precompound model
theIPNeutron.RegisterMe(thePreEquilib);
// Active the Cross-sections for neutron nuclear scattering from 14 MeV up to 20 GeV
theIPNeutron.AddDataSet(&theNXSec);
// Active the neutron inelastic process
pmanager -> AddDiscreteProcess(&theIPNeutron);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic);
// Pions plus
particle = G4PionPlus::PionPlus();
pmanager = particle -> GetProcessManager();
// Define the inelastic process for pions plus
G4PionPlusInelasticProcess* thePionPlusInelasticProcess = new G4PionPlusInelasticProcess("inelastic");
// Register the Low Energy Inelastic Model for pions plus
thePionPlusInelasticProcess -> RegisterMe(thePreEquilib);
// Active the inelastic process for pions plus
pmanager->AddDiscreteProcess(thePionPlusInelasticProcess);
pmanager -> AddDiscreteProcess(elastic);
// Pion Minus
particle = G4PionMinus::PionMinus();
pmanager = particle -> GetProcessManager();
// Define the inelastic process for pions minus
G4PionMinusInelasticProcess* thePionMinusInelasticProcess = new G4PionMinusInelasticProcess("inelastic");
// Register the inelastic model for pion minus
thePionMinusInelasticProcess -> RegisterMe(thePreEquilib);
// Active the inelastic process for pion minus
pmanager -> AddDiscreteProcess(thePionMinusInelasticProcess);
// Active Absorption process for pion minus
pmanager -> AddRestProcess(new G4PiMinusAbsorptionAtRest, ordDefault);
pmanager -> AddDiscreteProcess(elastic);
//HADRON CAPTURE
// Process for capture of neutral hadrons
G4HadronCaptureProcess* neutronCapture = new G4HadronCaptureProcess();
// Final state production model for capture of neutral hadrons in nuclei
G4LCapture* capture_model = new G4LCapture();
// Set the energy range for the capture model
capture_model -> SetMinEnergy(neutronLowLimit);
capture_model -> SetMaxEnergy(neutronHighLimit);
// Register the capture model
neutronCapture -> RegisterMe(capture_model);
// Active the neutron capture process
pmanager -> AddDiscreteProcess(neutronCapture);
//FISSION
// Process for induced fission
G4HadronFissionProcess* fission = new G4HadronFissionProcess();
//Final state production model for induced fission
G4LFission* fission_model = new G4LFission();
// Set the energy range for the fission model
fission_model -> SetMinEnergy(neutronLowLimit);
fission_model -> SetMaxEnergy(neutronHighLimit);
// Register the fission model
fission -> RegisterMe(fission_model);
// Active the fission process
pmanager -> AddDiscreteProcess(fission);
}
examples/advanced/hadrontherapy/src/HadrontherapyProtonPrecompoundGEMFermi.cc
-308
View File
@@ -1,308 +0,0 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: HadrontherapyProtonPrecompoundGEMFermi.cc; May 2005
// ----------------------------------------------------------------------------
// GEANT 4 - Hadrontherapy example
// ----------------------------------------------------------------------------
// Code developed by:
//
// 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
//
// * cirrone@lns.infn.it
// ----------------------------------------------------------------------------
#include "HadrontherapyProtonPrecompoundGEMFermi.hh"
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
#include "G4ProcessVector.hh"
#include "G4ParticleTypes.hh"
#include "G4ParticleTable.hh"
#include "G4Material.hh"
#include "G4LElastic.hh"
#include "G4BinaryCascade.hh"
#include "G4CascadeInterface.hh"
#include "G4PionPlusInelasticProcess.hh"
#include "G4LEPionPlusInelastic.hh"
#include "G4LEPionMinusInelastic.hh"
#include "G4HEPionPlusInelastic.hh"
#include "G4HEPionMinusInelastic.hh"
#include "G4PionMinusInelasticProcess.hh"
#include "G4LEPionMinusInelastic.hh"
#include "G4HEPionMinusInelastic.hh"
#include "G4PiMinusAbsorptionAtRest.hh"
#include "G4AntiProtonInelasticProcess.hh"
#include "G4LEAntiProtonInelastic.hh"
#include "G4HEAntiProtonInelastic.hh"
#include "G4AntiProtonAnnihilationAtRest.hh"
#include "G4Evaporation.hh"
#include "G4ExcitationHandler.hh"
#include "G4FermiBreakUp.hh"
//
//
// HADRONIC PHYSICS LIST
//
// - ELASTIC SCATTERING FOR ALL THE HADRONS AND IONS
// - INELASTIC SCATTERING:
// * PRECOMPOUND PHYSICS LIST with GEM EVAPORATION MODEL + FERMI BREAKUP
// * PRECOMPOUND + GEM EVAPORATION MODEL + FERMI BREAK-UP FOR PROTONS, NEUTRONS AND PIONS
// * LEP MODEL UP TO 100 MEV AND BINARY ION MODEL BETWEEN 80 MEV AND 40. GEV
// FOR DEUTERON, TRITON, HE3, ALPHA
// * FISSION AND HADRON CAPTURE FOR NEUTRONS BETWEEN 0. MEV AND 100. TEV
//
//
HadrontherapyProtonPrecompoundGEMFermi::HadrontherapyProtonPrecompoundGEMFermi(const G4String& name):
G4VPhysicsConstructor(name)
{
// Inelastic process, energy limits
// Protons, neutrons and pions
// Energy limit of the precompound model
precompoundLowLimit = 0.*MeV;
precompoundHighLimit = 300.*MeV;
// Energy limit of the neutron fission and capture
neutronLowLimit = 0.*TeV;
neutronHighLimit = 100.*TeV;
// Ions
// Energy limit of the binary ion model
binaryLightIonLowLimit = 80.*MeV;
binaryLightIonHighLimit = 40.*GeV;
// Energy limit of the LEP model for ions
LEPHighLimit = 100.*MeV;
//targetZ should vary between 1 and 8
targetZ = 1;
targetA = 2 * targetZ;
}
HadrontherapyProtonPrecompoundGEMFermi::~HadrontherapyProtonPrecompoundGEMFermi()
{}
void HadrontherapyProtonPrecompoundGEMFermi::ConstructProcess()
{
G4ParticleDefinition* particle = 0;
G4ProcessManager* pmanager = 0;
// LOW ENERGY ELASTIC SCATTERING
// FOR PROTON, NEUTRON, IONS
G4LElastic* elastic_Model = new G4LElastic();
G4HadronElasticProcess* elastic = new G4HadronElasticProcess();
elastic -> RegisterMe(elastic_Model);
// GEM EVAPORATION MODEL
G4Evaporation* evaporation = new G4Evaporation();
evaporation -> SetGEMChannel();
theHandler.SetEvaporation(evaporation);
// FERMI BREAK-UP MODEL
G4FermiBreakUp* breakup = new G4FermiBreakUp();
// Set the Fermi break up model
theHandler.SetFermiModel(breakup);
// fix the target A and Z;
theHandler.SetMaxAandZForFermiBreakUp(targetA,targetZ);
// INELASTIC SCATTERING
// Binary Cascade
G4BinaryLightIonReaction* theBC = new G4BinaryLightIonReaction();
// Set the min and max energy for the Binary Cascade
theBC -> SetMinEnergy(binaryLightIonLowLimit);
theBC -> SetMaxEnergy(binaryLightIonHighLimit);
// TRIPATHI CROSS SECTION
// Implementation of formulas in analogy to NASA technical paper 3621 by
// Tripathi, et al. Cross-sections for ion ion scattering
G4TripathiCrossSection* TripathiCrossSection = new G4TripathiCrossSection;
// IONS SHEN CROSS SECTION
// Implementation of formulas
// Shen et al. Nuc. Phys. A 491 130 (1989)
// Total Reaction Cross Section for Heavy-Ion Collisions
G4IonsShenCrossSection* aShen = new G4IonsShenCrossSection;
//--------------------------------------------------------------------------------------
// Proton PRECOMPOUND + EVAPORATION(DEFAULT EVAPORATION)+ FERMI BREAK-UP
particle = G4Proton::Proton();
pmanager = particle->GetProcessManager();
G4PreCompoundModel* thePreEquilib = new G4PreCompoundModel(&theHandler);
// Set the range of minimum and maximum energy value
thePreEquilib -> SetMinEnergy(precompoundLowLimit);
thePreEquilib -> SetMaxEnergy(precompoundHighLimit);
// Model Registration
theIPProton.RegisterMe(thePreEquilib);
// Active the Cross-sections for proton nuclear scattering up to 20 GeV
theIPProton.AddDataSet(&thePXSec);
// Active the proton inelastic scattering using the precompound model
pmanager -> AddDiscreteProcess(&theIPProton);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic);
// deuteron
particle = G4Deuteron::Deuteron();
pmanager = particle -> GetProcessManager();
// Final state production model for Deuteron inelastic scattering below 100 MeV
G4LEDeuteronInelastic* theDIModel = new G4LEDeuteronInelastic;
// Set the maximum energy for LEP model
theDIModel -> SetMaxEnergy(LEPHighLimit);
// Active the Tripathi and aShen Cross Section
theIPdeuteron.AddDataSet(TripathiCrossSection);
theIPdeuteron.AddDataSet(aShen);
// Register the Deuteron Inelastic and Binary Cascade Model
theIPdeuteron.RegisterMe(theDIModel);
theIPdeuteron.RegisterMe(theBC);
// Active the deuteron inelastic scattering using the deuteron inelastic and binary cascade model
pmanager -> AddDiscreteProcess(&theIPdeuteron);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic);
// triton
particle = G4Triton::Triton();
pmanager = particle->GetProcessManager();
// Final state production model for Triton inelastic scattering below 100 MeV
G4LETritonInelastic* theTIModel = new G4LETritonInelastic;
// Set the maximum energy for LEP model
theTIModel -> SetMaxEnergy(LEPHighLimit);
// Active the Tripathi and aShen Cross Section
theIPtriton.AddDataSet(TripathiCrossSection);
theIPtriton.AddDataSet(aShen);
// Register the Triton Inelastic and Binary Cascade Model
theIPtriton.RegisterMe(theTIModel);
theIPtriton.RegisterMe(theBC);
// Active the triton inelastic scattering using the triton inelastic and binary cascade model
pmanager -> AddDiscreteProcess(&theIPtriton);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic);
// alpha
particle = G4Alpha::Alpha();
pmanager = particle->GetProcessManager();
// Final state production model for Alpha inelastic scattering below 20 GeV
G4LEAlphaInelastic* theAIModel = new G4LEAlphaInelastic;
// Set the maximum energy for LEP model
theAIModel -> SetMaxEnergy(LEPHighLimit);
// Register the Triton Inelastic and Binary Cascade Model
theIPalpha.AddDataSet(TripathiCrossSection);
theIPalpha.AddDataSet(aShen);
// Register the Alpha Inelastic and Binary Cascade Model
theIPalpha.RegisterMe(theAIModel);
theIPalpha.RegisterMe(theBC);
// Active the alpha inelastic scattering using the alpha inelastic and binary cascade model
pmanager -> AddDiscreteProcess(&theIPalpha);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic);
// He3
// particle = G4He3::He3();
// pmanager = particle->GetProcessManager();
// // Binary Cascade inelastic scattering for ions
// G4BinaryLightIonReaction * theGenIonBC= new G4BinaryLightIonReaction;
// // Inelastic Scattering for ions
// G4HadronInelasticProcess* theIPHe3 = new G4HadronInelasticProcess("He3Inelastic",particle);
// // Active the Tripathi and aShen Cross Section
// theIPHe3 -> AddDataSet(TripathiCrossSection);
// theIPHe3 -> AddDataSet(aShen);
// // Register the Alpha Binary Cascade Model
// theIPHe3 -> RegisterMe(theGenIonBC);
// // Active the Inelastic Process for He3
// pmanager -> AddDiscreteProcess(theIPHe3);
// // Active the Hadron Elastic Process
// pmanager -> AddDiscreteProcess(elastic);
// Neutron
particle = G4Neutron::Neutron();
pmanager = particle->GetProcessManager();
// Register the Precompound model
theIPNeutron.RegisterMe(thePreEquilib);
// Active the Cross-sections for neutron nuclear scattering from 14 MeV up to 20 GeV
theIPNeutron.AddDataSet(&theNXSec);
// Active the neutron inelastic process
pmanager -> AddDiscreteProcess(&theIPNeutron);
// Active the Hadron Elastic Process
pmanager -> AddDiscreteProcess(elastic);
// Pions plus
particle = G4PionPlus::PionPlus();
pmanager = particle -> GetProcessManager();
// Define the inelastic process for pions plus
G4PionPlusInelasticProcess* thePionPlusInelasticProcess = new G4PionPlusInelasticProcess("inelastic");
// Register the Low Energy Inelastic Model for pions plus
thePionPlusInelasticProcess -> RegisterMe(thePreEquilib);
// Active the inelastic process for pions plus
pmanager->AddDiscreteProcess(thePionPlusInelasticProcess);
pmanager -> AddDiscreteProcess(elastic);
// Pion Minus
particle = G4PionMinus::PionMinus();
pmanager = particle -> GetProcessManager();
// Define the inelastic process for pions minus
G4PionMinusInelasticProcess* thePionMinusInelasticProcess = new G4PionMinusInelasticProcess("inelastic");
// Register the inelastic model for pion minus
thePionMinusInelasticProcess -> RegisterMe(thePreEquilib);
// Active the inelastic process for pion minus
pmanager -> AddDiscreteProcess(thePionMinusInelasticProcess);
// Active Absorption process for pion minus
pmanager -> AddRestProcess(new G4PiMinusAbsorptionAtRest, ordDefault);
pmanager -> AddDiscreteProcess(elastic);
//HADRON CAPTURE
// Process for capture of neutral hadrons
G4HadronCaptureProcess* neutronCapture = new G4HadronCaptureProcess();
// Final state production model for capture of neutral hadrons in nuclei
G4LCapture* capture_model = new G4LCapture();
// Set the energy range for the capture model
capture_model -> SetMinEnergy(neutronLowLimit);
capture_model -> SetMaxEnergy(neutronHighLimit);
// Register the capture model
neutronCapture -> RegisterMe(capture_model);
// Active the neutron capture process
pmanager -> AddDiscreteProcess(neutronCapture);
//FISSION
// Process for induced fission
G4HadronFissionProcess* fission = new G4HadronFissionProcess();
//Final state production model for induced fission
G4LFission* fission_model = new G4LFission();
// Set the energy range for the fission model
fission_model -> SetMinEnergy(neutronLowLimit);
fission_model -> SetMaxEnergy(neutronHighLimit);
// Register the fission model
fission -> RegisterMe(fission_model);
// Active the fission process
pmanager -> AddDiscreteProcess(fission);
}
examples/advanced/hadrontherapy/src/HadrontherapySteppingAction.cc
+1 -1
View File
@@ -87,7 +87,7 @@ void HadrontherapySteppingAction::UserSteppingAction(const G4Step* aStep)
{
runAction -> AddHadronicProcess();
if ( (process != "LElastic") && (process != "ProtonInelastic"))
if ( (process != "LElastic") && (process != "ProtonInelastic") && (process != "hElastic") )
G4cout << "Warning! Unknown proton process: "<< process << G4endl;
}
}