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