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

Import Geant4 10.2.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-10 14:11:04 +02:00
parent c9b32a6c0a
commit d4af681f38
4886 changed files with 420149 additions and 1023309 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/physics_lists/constructors/electromagnetic/src/G4EmDNAChemistry.cc
+120 -59
View File
@@ -45,12 +45,16 @@
#include "G4DNAElastic.hh"
#include "G4DNAChampionElasticModel.hh"
#include "G4DNAScreenedRutherfordElasticModel.hh"
#include "G4DNAUeharaScreenedRutherfordElasticModel.hh"
#include "G4DNAMolecularDissociation.hh"
#include "G4DNABrownianTransportation.hh"
#include "G4DNAMolecularReactionTable.hh"
#include "G4DNAMolecularStepByStepModel.hh"
#include "G4VDNAReactionModel.hh"
#include "G4DNASmoluchowskiReactionModel.hh"
#include "G4DNAElectronHoleRecombination.hh"
// particles
@@ -70,9 +74,6 @@
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
#include "G4DNAMolecularStepByStepModel.hh"
#include "G4DNASmoluchowskiReactionModel.hh"
/****/
#include "G4DNAMoleculeEncounterStepper.hh"
#include "G4ProcessVector.hh"
@@ -117,33 +118,65 @@ void G4EmDNAChemistry::ConstructMolecule()
G4H2O2::Definition();
G4H2::Definition();
G4MoleculeTable::Instance()->CreateMoleculeModel("H3Op", G4H3O::Definition());
G4Molecule* OHm = G4MoleculeTable::Instance()->
CreateMoleculeModel("OHm", // just a tag to store and retrieve from
// G4MoleculeTable::Instance()->CreateMoleculeModel("H3Op", G4H3O::Definition());
// G4Molecule* OHm = G4MoleculeTable::Instance()->
// CreateMoleculeModel("OHm", // just a tag to store and retrieve from
// // G4MoleculeTable
// G4OH::Definition(), -1, 5.0e-9 * (m2 / s));
// OHm->SetMass(17.0079 * g / Avogadro * c_squared);
// G4MoleculeTable::Instance()->CreateMoleculeModel("OH", G4OH::Definition());
// G4MoleculeTable::Instance()->CreateMoleculeModel("e_aq",
// G4Electron_aq::Definition());
// G4MoleculeTable::Instance()->CreateMoleculeModel("H",
// G4Hydrogen::Definition());
// G4MoleculeTable::Instance()->CreateMoleculeModel("H2", G4H2::Definition());
// G4MoleculeTable::Instance()->CreateMoleculeModel("H2O2", G4H2O2::Definition());
//____________________________________________________________________________
G4MoleculeTable::Instance()->CreateConfiguration("H3Op", G4H3O::Definition());
G4MolecularConfiguration* OHm = G4MoleculeTable::Instance()->
CreateConfiguration("OHm", // just a tag to store and retrieve from
// G4MoleculeTable
G4OH::Definition(), -1, 5.0e-9 * (m2 / s));
G4OH::Definition(),
-1, // charge
5.0e-9 * (m2 / s));
OHm->SetMass(17.0079 * g / Avogadro * c_squared);
G4MoleculeTable::Instance()->CreateMoleculeModel("OH", G4OH::Definition());
G4MoleculeTable::Instance()->CreateMoleculeModel("e_aq",
G4MoleculeTable::Instance()->CreateConfiguration("OH", G4OH::Definition());
G4MoleculeTable::Instance()->CreateConfiguration("e_aq",
G4Electron_aq::Definition());
G4MoleculeTable::Instance()->CreateMoleculeModel("H",
G4MoleculeTable::Instance()->CreateConfiguration("H",
G4Hydrogen::Definition());
G4MoleculeTable::Instance()->CreateMoleculeModel("H2", G4H2::Definition());
G4MoleculeTable::Instance()->CreateMoleculeModel("H2O2", G4H2O2::Definition());
G4MoleculeTable::Instance()->CreateConfiguration("H2", G4H2::Definition());
G4MoleculeTable::Instance()->CreateConfiguration("H2O2", G4H2O2::Definition());
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAChemistry::ConstructDissociationChannels()
{
// //-----------------------------------
// //Create the dynamic objects
// G4Molecule* OH = G4MoleculeTable::Instance()->GetMoleculeModel("OH");
// G4Molecule* OHm = G4MoleculeTable::Instance()->GetMoleculeModel("OHm");
// G4Molecule* e_aq = G4MoleculeTable::Instance()->GetMoleculeModel("e_aq");
// G4Molecule* H2 = G4MoleculeTable::Instance()->GetMoleculeModel("H2");
// G4Molecule* H3O = G4MoleculeTable::Instance()->GetMoleculeModel("H3Op");
// G4Molecule* H = G4MoleculeTable::Instance()->GetMoleculeModel("H");
//-----------------------------------
//Create the dynamic objects
G4Molecule* OH = G4MoleculeTable::Instance()->GetMoleculeModel("OH");
G4Molecule* OHm = G4MoleculeTable::Instance()->GetMoleculeModel("OHm");
G4Molecule* e_aq = G4MoleculeTable::Instance()->GetMoleculeModel("e_aq");
G4Molecule* H2 = G4MoleculeTable::Instance()->GetMoleculeModel("H2");
G4Molecule* H3O = G4MoleculeTable::Instance()->GetMoleculeModel("H3Op");
G4Molecule* H = G4MoleculeTable::Instance()->GetMoleculeModel("H");
//Get the molecular configuration
G4MolecularConfiguration* OH =
G4MoleculeTable::Instance()->GetConfiguration("OH");
G4MolecularConfiguration* OHm =
G4MoleculeTable::Instance()->GetConfiguration("OHm");
G4MolecularConfiguration* e_aq =
G4MoleculeTable::Instance()->GetConfiguration("e_aq");
G4MolecularConfiguration* H2 =
G4MoleculeTable::Instance()->GetConfiguration("H2");
G4MolecularConfiguration* H3O =
G4MoleculeTable::Instance()->GetConfiguration("H3Op");
G4MolecularConfiguration* H =
G4MoleculeTable::Instance()->GetConfiguration("H");
//-------------------------------------
//Define the decay channels
@@ -174,14 +207,13 @@ void G4EmDNAChemistry::ConstructDissociationChannels()
decCh2->SetDisplacementType(
G4DNAWaterDissociationDisplacer::A1B1_DissociationDecay);
water->AddExcitedState("A^1B_1");
water->AddDecayChannel("A^1B_1", decCh1);
water->AddDecayChannel("A^1B_1", decCh2);
// water->AddExcitedState("A^1B_1");
occ->RemoveElectron(4, 1); // this is the transition form ground state to
occ->AddElectron(5, 1); // the first unoccupied orbital: A^1B_1
water->AddeConfToExcitedState("A^1B_1", *occ);
water->NewConfigurationWithElectronOccupancy("A^1B_1", *occ);
water->AddDecayChannel("A^1B_1", decCh1);
water->AddDecayChannel("A^1B_1", decCh2);
//--------------------------------------------------------
//---------------Excitation on the fourth layer-----------
@@ -190,8 +222,6 @@ void G4EmDNAChemistry::ConstructDissociationChannels()
G4MolecularDissociationChannel* decCh3 = new G4MolecularDissociationChannel(
"B^1A_1_AutoIonisation_Channel");
water->AddExcitedState("B^1A_1");
//Decay 1 : energy
decCh1->SetEnergy(waterExcitation.ExcitationEnergy(1));
decCh1->SetProbability(0.3);
@@ -215,7 +245,7 @@ void G4EmDNAChemistry::ConstructDissociationChannels()
occ->RemoveElectron(3); // this is the transition form ground state to
occ->AddElectron(5, 1); // the first unoccupied orbital: B^1A_1
water->AddeConfToExcitedState("B^1A_1", *occ);
water->NewConfigurationWithElectronOccupancy("B^1A_1", *occ);
water->AddDecayChannel("B^1A_1", decCh1);
water->AddDecayChannel("B^1A_1", decCh2);
water->AddDecayChannel("B^1A_1", decCh3);
@@ -227,8 +257,6 @@ void G4EmDNAChemistry::ConstructDissociationChannels()
decCh2 = new G4MolecularDissociationChannel(
"Excitation3rdLayer_Relaxation_Channel");
water->AddExcitedState("Excitation3rdLayer");
//Decay channel 1 : : OH + H_3Op + e_aq
decCh1->AddProduct(OH);
decCh1->AddProduct(H3O);
@@ -247,7 +275,7 @@ void G4EmDNAChemistry::ConstructDissociationChannels()
occ->AddElectron(5, 1);
//Configure the water molecule
water->AddeConfToExcitedState("Excitation3rdLayer", *occ);
water->NewConfigurationWithElectronOccupancy("Excitation3rdLayer", *occ);
water->AddDecayChannel("Excitation3rdLayer", decCh1);
water->AddDecayChannel("Excitation3rdLayer", decCh2);
@@ -258,8 +286,6 @@ void G4EmDNAChemistry::ConstructDissociationChannels()
decCh2 = new G4MolecularDissociationChannel(
"Excitation2ndLayer_Relaxation_Channel");
water->AddExcitedState("Excitation2ndLayer");
//Decay Channel 1 : : OH + H_3Op + e_aq
decCh1->AddProduct(OH);
decCh1->AddProduct(H3O);
@@ -276,7 +302,7 @@ void G4EmDNAChemistry::ConstructDissociationChannels()
occ->RemoveElectron(1, 1);
occ->AddElectron(5, 1);
water->AddeConfToExcitedState("Excitation2ndLayer", *occ);
water->NewConfigurationWithElectronOccupancy("Excitation2ndLayer", *occ);
water->AddDecayChannel("Excitation2ndLayer", decCh1);
water->AddDecayChannel("Excitation2ndLayer", decCh2);
@@ -291,9 +317,6 @@ void G4EmDNAChemistry::ConstructDissociationChannels()
occ->RemoveElectron(0, 1);
occ->AddElectron(5, 1);
water->AddExcitedState("Excitation1stLayer");
water->AddeConfToExcitedState("Excitation1stLayer", *occ);
//Decay Channel 1 : : OH + H_3Op + e_aq
decCh1->AddProduct(OH);
decCh1->AddProduct(H3O);
@@ -304,6 +327,8 @@ void G4EmDNAChemistry::ConstructDissociationChannels()
//Decay channel 2 : energy
decCh2->SetEnergy(waterExcitation.ExcitationEnergy(4));
decCh2->SetProbability(0.5);
water->NewConfigurationWithElectronOccupancy("Excitation1stLayer", *occ);
water->AddDecayChannel("Excitation1stLayer", decCh1);
water->AddDecayChannel("Excitation1stLayer", decCh2);
@@ -312,7 +337,6 @@ void G4EmDNAChemistry::ConstructDissociationChannels()
/////////////////////////////////////////////////////////
//--------------------------------------------------------
//------------------- Ionisation -------------------------
water->AddExcitedState("Ionisation");
decCh1 = new G4MolecularDissociationChannel("Ionisation_Channel");
@@ -326,24 +350,33 @@ void G4EmDNAChemistry::ConstructDissociationChannels()
*occ = *(water->GetGroundStateElectronOccupancy());
occ->RemoveElectron(4, 1);
// this is a ionized h2O with a hole in its last orbital
water->AddeConfToExcitedState("Ionisation", *occ);
water->NewConfigurationWithElectronOccupancy("Ionisation5", *occ);
water->AddDecayChannel("Ionisation5",
decCh1);
*occ = *(water->GetGroundStateElectronOccupancy());
occ->RemoveElectron(3, 1);
water->AddeConfToExcitedState("Ionisation", *occ);
water->NewConfigurationWithElectronOccupancy("Ionisation4", *occ);
water->AddDecayChannel("Ionisation4",
new G4MolecularDissociationChannel(*decCh1));
*occ = *(water->GetGroundStateElectronOccupancy());
occ->RemoveElectron(2, 1);
water->AddeConfToExcitedState("Ionisation", *occ);
water->NewConfigurationWithElectronOccupancy("Ionisation3", *occ);
water->AddDecayChannel("Ionisation3",
new G4MolecularDissociationChannel(*decCh1));
*occ = *(water->GetGroundStateElectronOccupancy());
occ->RemoveElectron(1, 1);
water->AddeConfToExcitedState("Ionisation", *occ);
water->NewConfigurationWithElectronOccupancy("Ionisation2", *occ);
water->AddDecayChannel("Ionisation2",
new G4MolecularDissociationChannel(*decCh1));
*occ = *(water->GetGroundStateElectronOccupancy());
occ->RemoveElectron(0, 1);
water->AddeConfToExcitedState("Ionisation", *occ);
water->AddDecayChannel("Ionisation", decCh1);
water->NewConfigurationWithElectronOccupancy("Ionisation1", *occ);
water->AddDecayChannel("Ionisation1",
new G4MolecularDissociationChannel(*decCh1));
//////////////////////////////////////////////////////////
// Dissociative Attachment //
@@ -355,13 +388,12 @@ void G4EmDNAChemistry::ConstructDissociationChannels()
decCh1->AddProduct(OHm);
decCh1->AddProduct(OH);
decCh1->SetProbability(1);
//decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::
// DissociativeAttachment);
decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::
DissociativeAttachment);
*occ = *(water->GetGroundStateElectronOccupancy());
occ->AddElectron(5, 1); // H_2O^-
water->AddExcitedState("DissociativeAttachment");
water->AddeConfToExcitedState("DissociativeAttachment", *occ);
water->NewConfigurationWithElectronOccupancy("DissociativeAttachment", *occ);
water->AddDecayChannel("DissociativeAttachment", decCh1);
delete occ;
@@ -372,13 +404,30 @@ void G4EmDNAChemistry::ConstructDissociationChannels()
void G4EmDNAChemistry::ConstructReactionTable(G4DNAMolecularReactionTable*
theReactionTable)
{
G4Molecule* OH = G4MoleculeTable::Instance()->GetMoleculeModel("OH");
G4Molecule* e_aq = G4MoleculeTable::Instance()->GetMoleculeModel("e_aq");
G4Molecule* H2 = G4MoleculeTable::Instance()->GetMoleculeModel("H2");
G4Molecule* H3Op = G4MoleculeTable::Instance()->GetMoleculeModel("H3Op");
G4Molecule* OHm = G4MoleculeTable::Instance()->GetMoleculeModel("OHm");
G4Molecule* H2O2 = G4MoleculeTable::Instance()->GetMoleculeModel("H2O2");
G4Molecule* H = G4MoleculeTable::Instance()->GetMoleculeModel("H");
// //-----------------------------------
// G4Molecule* OH = G4MoleculeTable::Instance()->GetMoleculeModel("OH");
// G4Molecule* e_aq = G4MoleculeTable::Instance()->GetMoleculeModel("e_aq");
// G4Molecule* H2 = G4MoleculeTable::Instance()->GetMoleculeModel("H2");
// G4Molecule* H3Op = G4MoleculeTable::Instance()->GetMoleculeModel("H3Op");
// G4Molecule* OHm = G4MoleculeTable::Instance()->GetMoleculeModel("OHm");
// G4Molecule* H2O2 = G4MoleculeTable::Instance()->GetMoleculeModel("H2O2");
// G4Molecule* H = G4MoleculeTable::Instance()->GetMoleculeModel("H");
//-----------------------------------
//Get the molecular configuration
G4MolecularConfiguration* OH =
G4MoleculeTable::Instance()->GetConfiguration("OH");
G4MolecularConfiguration* OHm =
G4MoleculeTable::Instance()->GetConfiguration("OHm");
G4MolecularConfiguration* e_aq =
G4MoleculeTable::Instance()->GetConfiguration("e_aq");
G4MolecularConfiguration* H2 =
G4MoleculeTable::Instance()->GetConfiguration("H2");
G4MolecularConfiguration* H3Op =
G4MoleculeTable::Instance()->GetConfiguration("H3Op");
G4MolecularConfiguration* H =
G4MoleculeTable::Instance()->GetConfiguration("H");
G4MolecularConfiguration* H2O2 =
G4MoleculeTable::Instance()->GetConfiguration("H2O2");
//------------------------------------------------------------------
// e_aq + e_aq + 2H2O -> H2 + 2OH-
@@ -446,8 +495,9 @@ void G4EmDNAChemistry::ConstructProcess()
// Anyway, solvation of electrons is taken into account from 7.4 eV
// So below this threshold, for now, no accurate modeling is done
//
G4VProcess* process = G4ProcessTable::GetProcessTable()->FindProcess(
"e-_G4DNAVibExcitation", "e-");
G4VProcess* process =
G4ProcessTable::GetProcessTable()->
FindProcess("e-_G4DNAVibExcitation", "e-");
if (process)
{
@@ -465,8 +515,9 @@ void G4EmDNAChemistry::ConstructProcess()
// Modify elastic scattering models to avoid killing electrons
// at low energy
//
process = G4ProcessTable::GetProcessTable()->FindProcess(
"e-_G4DNAElastic", "e-");
process =
G4ProcessTable::GetProcessTable()->
FindProcess("e-_G4DNAElastic", "e-");
if (process)
{
@@ -483,6 +534,11 @@ void G4EmDNAChemistry::ConstructProcess()
{
screenRutherfordMod->SetKillBelowThreshold(-1);
}
else if (G4DNAUeharaScreenedRutherfordElasticModel* ueharaScreenRutherfordMod =
dynamic_cast<G4DNAUeharaScreenedRutherfordElasticModel*>(model))
{
ueharaScreenRutherfordMod->SetKillBelowThreshold(-1);
}
}
//===============================================================
@@ -513,12 +569,17 @@ void G4EmDNAChemistry::ConstructProcess()
}
else
{
moleculeDef->GetProcessManager()
->AddRestProcess(new G4DNAElectronHoleRecombination(), 2);
G4DNAMolecularDissociation* dissociationProcess =
new G4DNAMolecularDissociation("H2O_DNAMolecularDecay");
dissociationProcess->SetDecayDisplacer(
moleculeDef, new G4DNAWaterDissociationDisplacer);
dissociationProcess->SetVerboseLevel(1);
ph->RegisterProcess(dissociationProcess, moleculeDef);
// ph->RegisterProcess(dissociationProcess, moleculeDef);
moleculeDef->GetProcessManager()
->AddRestProcess(dissociationProcess, 1);
}
/*
* Warning : end of particles and processes are needed by
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics.cc
+8 -1
View File
@@ -23,7 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmDNAPhysics.cc 82360 2014-06-17 15:16:30Z gcosmo $
// $Id: G4EmDNAPhysics.cc 87702 2014-12-17 09:55:28Z gcosmo $
// add elastic scattering processes of proton, hydrogen, helium, alpha+, alpha++
#include "G4EmDNAPhysics.hh"
@@ -36,6 +37,7 @@
#include "G4DNAElastic.hh"
#include "G4DNAChampionElasticModel.hh"
#include "G4DNAScreenedRutherfordElasticModel.hh"
#include "G4DNAIonElasticModel.hh"
#include "G4DNAExcitation.hh"
#include "G4DNAAttachment.hh"
@@ -170,27 +172,32 @@ void G4EmDNAPhysics::ConstructProcess()
ph->RegisterProcess(new G4DNAAttachment("e-_G4DNAAttachment"), particle);
} else if ( particleName == "proton" ) {
//ph->RegisterProcess(new G4DNAElastic("proton_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("proton_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("proton_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeDecrease("proton_G4DNAChargeDecrease"), particle);
} else if ( particleName == "hydrogen" ) {
//ph->RegisterProcess(new G4DNAElastic("hydrogen_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("hydrogen_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("hydrogen_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("hydrogen_G4DNAChargeIncrease"), particle);
} else if ( particleName == "alpha" ) {
//ph->RegisterProcess(new G4DNAElastic("alpha_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("alpha_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("alpha_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeDecrease("alpha_G4DNAChargeDecrease"), particle);
} else if ( particleName == "alpha+" ) {
//ph->RegisterProcess(new G4DNAElastic("alpha+_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("alpha+_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("alpha+_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeDecrease("alpha+_G4DNAChargeDecrease"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("alpha+_G4DNAChargeIncrease"), particle);
} else if ( particleName == "helium" ) {
//ph->RegisterProcess(new G4DNAElastic("helium_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("helium_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("helium_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("helium_G4DNAChargeIncrease"), particle);
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_option1.cc
+20 -5
View File
@@ -70,6 +70,8 @@
#include "G4LivermoreGammaConversionModel.hh"
#include "G4RayleighScattering.hh"
#include "G4LivermoreRayleighModel.hh"
#include "G4EmParameters.hh"
// end of warning
#include "G4LossTableManager.hh"
@@ -88,6 +90,7 @@ G4_DECLARE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_option1);
G4EmDNAPhysics_option1::G4EmDNAPhysics_option1(G4int ver)
: G4VPhysicsConstructor("G4EmDNAPhysics_option1"), verbose(ver)
{
G4EmParameters::Instance()->SetDefaults();
SetPhysicsType(bElectromagnetic);
}
@@ -96,6 +99,7 @@ G4EmDNAPhysics_option1::G4EmDNAPhysics_option1(G4int ver)
G4EmDNAPhysics_option1::G4EmDNAPhysics_option1(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmDNAPhysics_option1"), verbose(ver)
{
G4EmParameters::Instance()->SetDefaults();
SetPhysicsType(bElectromagnetic);
}
@@ -126,10 +130,10 @@ void G4EmDNAPhysics_option1::ConstructParticle()
genericIonsManager->GetIon("alpha+");
genericIonsManager->GetIon("helium");
genericIonsManager->GetIon("hydrogen");
genericIonsManager->GetIon("carbon");
genericIonsManager->GetIon("nitrogen");
genericIonsManager->GetIon("oxygen");
genericIonsManager->GetIon("iron");
//genericIonsManager->GetIon("carbon");
//genericIonsManager->GetIon("nitrogen");
//genericIonsManager->GetIon("oxygen");
//genericIonsManager->GetIon("iron");
}
@@ -220,6 +224,17 @@ void G4EmDNAPhysics_option1::ConstructProcess()
// Extension to HZE proposed by Z. Francis
// S. Incerti
} else if ( particleName == "GenericIon" ) {
G4hMultipleScattering* msc = new G4hMultipleScattering();
msc->SetEmModel(new G4LowEWentzelVIModel(), 1);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(new G4DNAIonisation("GenericIon_G4DNAIonisation"), particle);
/*
} else if ( particleName == "carbon" ) {
G4hMultipleScattering* msc = new G4hMultipleScattering();
@@ -251,7 +266,7 @@ void G4EmDNAPhysics_option1::ConstructProcess()
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(new G4DNAIonisation("iron_G4DNAIonisation"), particle);
*/
}
// Warning : the following particles and processes are needed by EM Physics builders
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_option2.cc
+315
View File
@@ -0,0 +1,315 @@
//
// ********************************************************************
// * 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: G4EmDNAPhysics_option2.cc 82360 2014-06-17 15:16:30Z gcosmo $
// SI: This constructor uses speedup options of DNA models
#include "G4EmDNAPhysics_option2.hh"
#include "G4SystemOfUnits.hh"
#include "G4DNAGenericIonsManager.hh"
// *** Processes and models for Geant4-DNA
#include "G4DNAElastic.hh"
#include "G4DNAChampionElasticModel.hh"
#include "G4DNAScreenedRutherfordElasticModel.hh"
#include "G4DNAExcitation.hh"
#include "G4DNAAttachment.hh"
#include "G4DNAVibExcitation.hh"
#include "G4DNAIonisation.hh"
#include "G4DNAChargeDecrease.hh"
#include "G4DNAChargeIncrease.hh"
// particles
#include "G4Electron.hh"
#include "G4Proton.hh"
#include "G4GenericIon.hh"
// Warning : the following is needed in order to use EM Physics builders
// e+
#include "G4Positron.hh"
#include "G4eMultipleScattering.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
#include "G4eplusAnnihilation.hh"
// gamma
#include "G4Gamma.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4LivermorePhotoElectricModel.hh"
#include "G4ComptonScattering.hh"
#include "G4LivermoreComptonModel.hh"
#include "G4GammaConversion.hh"
#include "G4LivermoreGammaConversionModel.hh"
#include "G4RayleighScattering.hh"
#include "G4LivermoreRayleighModel.hh"
#include "G4EmParameters.hh"
// end of warning
#include "G4LossTableManager.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_option2);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option2::G4EmDNAPhysics_option2(G4int ver)
: G4VPhysicsConstructor("G4EmDNAPhysics_option2"), verbose(ver)
{
G4EmParameters::Instance()->SetDefaults();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option2::G4EmDNAPhysics_option2(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmDNAPhysics_option2"), verbose(ver)
{
G4EmParameters::Instance()->SetDefaults();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option2::~G4EmDNAPhysics_option2()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_option2::ConstructParticle()
{
// bosons
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
// baryons
G4Proton::Proton();
G4GenericIon::GenericIonDefinition();
G4DNAGenericIonsManager * genericIonsManager;
genericIonsManager=G4DNAGenericIonsManager::Instance();
genericIonsManager->GetIon("alpha++");
genericIonsManager->GetIon("alpha+");
genericIonsManager->GetIon("helium");
genericIonsManager->GetIon("hydrogen");
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_option2::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
aParticleIterator->reset();
while( (*aParticleIterator)() )
{
G4ParticleDefinition* particle = aParticleIterator->value();
G4String particleName = particle->GetParticleName();
if (particleName == "e-") {
// *** Elastic scattering (two alternative models available) ***
G4DNAElastic* theDNAElasticProcess = new G4DNAElastic("e-_G4DNAElastic");
theDNAElasticProcess->SetEmModel(new G4DNAChampionElasticModel());
// or alternative model
//theDNAElasticProcess->SetEmModel(new G4DNAScreenedRutherfordElasticModel());
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
ph->RegisterProcess(new G4DNAExcitation("e-_G4DNAExcitation"), particle);
// *** Ionisation ***
//ph->RegisterProcess(new G4DNAIonisation("e-_G4DNAIonisation"), particle);
G4DNAIonisation* theDNAIonisationProcess = new G4DNAIonisation("e-_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(new G4DNABornIonisationModel());
((G4DNABornIonisationModel*)(theDNAIonisationProcess->EmModel()))->SelectFasterComputation(true);
ph->RegisterProcess(theDNAIonisationProcess, particle);
// *** Vibrational excitation ***
ph->RegisterProcess(new G4DNAVibExcitation("e-_G4DNAVibExcitation"), particle);
// *** Attachment ***
ph->RegisterProcess(new G4DNAAttachment("e-_G4DNAAttachment"), particle);
} else if ( particleName == "proton" ) {
ph->RegisterProcess(new G4DNAExcitation("proton_G4DNAExcitation"), particle);
G4DNAIonisation* theDNAIonisationProcess = new G4DNAIonisation("proton_G4DNAIonisation");
G4VEmModel* mod1;
mod1 = new G4DNARuddIonisationExtendedModel();
mod1->SetLowEnergyLimit(0*eV);
mod1->SetHighEnergyLimit(500*keV);
G4VEmModel* mod2;
mod2= new G4DNABornIonisationModel();
mod2->SetLowEnergyLimit(500*keV);
mod2->SetHighEnergyLimit(100*MeV);
theDNAIonisationProcess->SetEmModel(mod1,1);
theDNAIonisationProcess->SetEmModel(mod2,2);
((G4DNABornIonisationModel*)(theDNAIonisationProcess->EmModel(2)))->SelectFasterComputation(true);
ph->RegisterProcess(theDNAIonisationProcess, particle);
ph->RegisterProcess(new G4DNAChargeDecrease("proton_G4DNAChargeDecrease"), particle);
} else if ( particleName == "hydrogen" ) {
ph->RegisterProcess(new G4DNAExcitation("hydrogen_G4DNAExcitation"), particle);
//ph->RegisterProcess(new G4DNAIonisation("hydrogen_G4DNAIonisation"), particle);
G4DNAIonisation* theDNAIonisationProcess = new G4DNAIonisation("hydrogen_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(new G4DNARuddIonisationExtendedModel());
ph->RegisterProcess(theDNAIonisationProcess, particle);
ph->RegisterProcess(new G4DNAChargeIncrease("hydrogen_G4DNAChargeIncrease"), particle);
} else if ( particleName == "alpha" ) {
ph->RegisterProcess(new G4DNAExcitation("alpha_G4DNAExcitation"), particle);
//ph->RegisterProcess(new G4DNAIonisation("alpha_G4DNAIonisation"), particle);
G4DNAIonisation* theDNAIonisationProcess = new G4DNAIonisation("alpha_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(new G4DNARuddIonisationExtendedModel());
ph->RegisterProcess(theDNAIonisationProcess, particle);
ph->RegisterProcess(new G4DNAChargeDecrease("alpha_G4DNAChargeDecrease"), particle);
} else if ( particleName == "alpha+" ) {
ph->RegisterProcess(new G4DNAExcitation("alpha+_G4DNAExcitation"), particle);
//ph->RegisterProcess(new G4DNAIonisation("alpha+_G4DNAIonisation"), particle);
G4DNAIonisation* theDNAIonisationProcess = new G4DNAIonisation("alpha+_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(new G4DNARuddIonisationExtendedModel());
ph->RegisterProcess(theDNAIonisationProcess, particle);
ph->RegisterProcess(new G4DNAChargeDecrease("alpha+_G4DNAChargeDecrease"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("alpha+_G4DNAChargeIncrease"), particle);
} else if ( particleName == "helium" ) {
ph->RegisterProcess(new G4DNAExcitation("helium_G4DNAExcitation"), particle);
//ph->RegisterProcess(new G4DNAIonisation("helium_G4DNAIonisation"), particle);
G4DNAIonisation* theDNAIonisationProcess = new G4DNAIonisation("helium_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(new G4DNARuddIonisationExtendedModel());
ph->RegisterProcess(theDNAIonisationProcess, particle);
ph->RegisterProcess(new G4DNAChargeIncrease("helium_G4DNAChargeIncrease"), particle);
} else if ( particleName == "GenericIon" ) {
ph->RegisterProcess(new G4DNAIonisation("GenericIon_G4DNAIonisation"), particle);
}
// Warning : the following particles and processes are needed by EM Physics builders
// They are taken from the default Livermore Physics list
// These particles are currently not handled by Geant4-DNA
// e+
else if (particleName == "e+") {
// Identical to G4EmStandardPhysics_option3
G4eMultipleScattering* msc = new G4eMultipleScattering();
msc->SetStepLimitType(fUseDistanceToBoundary);
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eIoni, particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(new G4eplusAnnihilation(), particle);
} else if (particleName == "gamma") {
G4double LivermoreHighEnergyLimit = GeV;
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
G4LivermorePhotoElectricModel* theLivermorePhotoElectricModel =
new G4LivermorePhotoElectricModel();
theLivermorePhotoElectricModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
thePhotoElectricEffect->AddEmModel(0, theLivermorePhotoElectricModel);
ph->RegisterProcess(thePhotoElectricEffect, particle);
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
G4LivermoreComptonModel* theLivermoreComptonModel =
new G4LivermoreComptonModel();
theLivermoreComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theComptonScattering->AddEmModel(0, theLivermoreComptonModel);
ph->RegisterProcess(theComptonScattering, particle);
G4GammaConversion* theGammaConversion = new G4GammaConversion();
G4LivermoreGammaConversionModel* theLivermoreGammaConversionModel =
new G4LivermoreGammaConversionModel();
theLivermoreGammaConversionModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theGammaConversion->AddEmModel(0, theLivermoreGammaConversionModel);
ph->RegisterProcess(theGammaConversion, particle);
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
G4LivermoreRayleighModel* theRayleighModel = new G4LivermoreRayleighModel();
theRayleighModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theRayleigh->AddEmModel(0, theRayleighModel);
ph->RegisterProcess(theRayleigh, particle);
}
// Warning : end of particles and processes are needed by EM Physics builders
}
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
de->SetFluo(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_option3.cc
+272
View File
@@ -0,0 +1,272 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// added elastic scattering processes of proton, hydrogen, helium, alpha+, alpha
#include "G4EmDNAPhysics_option3.hh"
#include "G4SystemOfUnits.hh"
#include "G4DNAGenericIonsManager.hh"
// *** Processes and models for Geant4-DNA
#include "G4DNAElastic.hh"
#include "G4DNAChampionElasticModel.hh"
#include "G4DNAScreenedRutherfordElasticModel.hh"
#include "G4DNAIonElasticModel.hh"
#include "G4DNAExcitation.hh"
#include "G4DNAAttachment.hh"
#include "G4DNAVibExcitation.hh"
#include "G4DNAIonisation.hh"
#include "G4DNAChargeDecrease.hh"
#include "G4DNAChargeIncrease.hh"
// particles
#include "G4Electron.hh"
#include "G4Proton.hh"
#include "G4GenericIon.hh"
// Warning : the following is needed in order to use EM Physics builders
// e+
#include "G4Positron.hh"
#include "G4eMultipleScattering.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
#include "G4eplusAnnihilation.hh"
// gamma
#include "G4Gamma.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4LivermorePhotoElectricModel.hh"
#include "G4ComptonScattering.hh"
#include "G4LivermoreComptonModel.hh"
#include "G4GammaConversion.hh"
#include "G4LivermoreGammaConversionModel.hh"
#include "G4RayleighScattering.hh"
#include "G4LivermoreRayleighModel.hh"
#include "G4EmParameters.hh"
// end of warning
#include "G4LossTableManager.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_option3);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option3::G4EmDNAPhysics_option3(G4int ver)
: G4VPhysicsConstructor("G4EmDNAPhysics_option3"), verbose(ver)
{
G4EmParameters::Instance()->SetDefaults();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option3::G4EmDNAPhysics_option3(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmDNAPhysics_option3"), verbose(ver)
{
G4EmParameters::Instance()->SetDefaults();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option3::~G4EmDNAPhysics_option3()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_option3::ConstructParticle()
{
// bosons
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
// baryons
G4Proton::Proton();
G4GenericIon::GenericIonDefinition();
G4DNAGenericIonsManager * genericIonsManager;
genericIonsManager=G4DNAGenericIonsManager::Instance();
genericIonsManager->GetIon("alpha++");
genericIonsManager->GetIon("alpha+");
genericIonsManager->GetIon("helium");
genericIonsManager->GetIon("hydrogen");
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_option3::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
aParticleIterator->reset();
while( (*aParticleIterator)() )
{
G4ParticleDefinition* particle = aParticleIterator->value();
G4String particleName = particle->GetParticleName();
if (particleName == "e-") {
// *** Elastic scattering (two alternative models available) ***
G4DNAElastic* theDNAElasticProcess = new G4DNAElastic("e-_G4DNAElastic");
theDNAElasticProcess->SetEmModel(new G4DNAChampionElasticModel());
// or alternative model
//theDNAElasticProcess->SetEmModel(new G4DNAScreenedRutherfordElasticModel());
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
ph->RegisterProcess(new G4DNAExcitation("e-_G4DNAExcitation"), particle);
// *** Ionisation ***
ph->RegisterProcess(new G4DNAIonisation("e-_G4DNAIonisation"), particle);
// *** Vibrational excitation ***
ph->RegisterProcess(new G4DNAVibExcitation("e-_G4DNAVibExcitation"), particle);
// *** Attachment ***
ph->RegisterProcess(new G4DNAAttachment("e-_G4DNAAttachment"), particle);
} else if ( particleName == "proton" ) {
ph->RegisterProcess(new G4DNAElastic("proton_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("proton_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("proton_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeDecrease("proton_G4DNAChargeDecrease"), particle);
} else if ( particleName == "hydrogen" ) {
ph->RegisterProcess(new G4DNAElastic("hydrogen_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("hydrogen_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("hydrogen_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("hydrogen_G4DNAChargeIncrease"), particle);
} else if ( particleName == "alpha" ) {
ph->RegisterProcess(new G4DNAElastic("alpha_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("alpha_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("alpha_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeDecrease("alpha_G4DNAChargeDecrease"), particle);
} else if ( particleName == "alpha+" ) {
ph->RegisterProcess(new G4DNAElastic("alpha+_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("alpha+_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("alpha+_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeDecrease("alpha+_G4DNAChargeDecrease"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("alpha+_G4DNAChargeIncrease"), particle);
} else if ( particleName == "helium" ) {
ph->RegisterProcess(new G4DNAElastic("helium_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("helium_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("helium_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("helium_G4DNAChargeIncrease"), particle);
} else if ( particleName == "GenericIon" ) {
ph->RegisterProcess(new G4DNAIonisation("GenericIon_G4DNAIonisation"), particle);
}
// Warning : the following particles and processes are needed by EM Physics builders
// They are taken from the default Livermore Physics list
// These particles are currently not handled by Geant4-DNA
// e+
else if (particleName == "e+") {
// Identical to G4EmStandardPhysics_option3
G4eMultipleScattering* msc = new G4eMultipleScattering();
msc->SetStepLimitType(fUseDistanceToBoundary);
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eIoni, particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(new G4eplusAnnihilation(), particle);
} else if (particleName == "gamma") {
G4double LivermoreHighEnergyLimit = GeV;
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
G4LivermorePhotoElectricModel* theLivermorePhotoElectricModel =
new G4LivermorePhotoElectricModel();
theLivermorePhotoElectricModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
thePhotoElectricEffect->AddEmModel(0, theLivermorePhotoElectricModel);
ph->RegisterProcess(thePhotoElectricEffect, particle);
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
G4LivermoreComptonModel* theLivermoreComptonModel =
new G4LivermoreComptonModel();
theLivermoreComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theComptonScattering->AddEmModel(0, theLivermoreComptonModel);
ph->RegisterProcess(theComptonScattering, particle);
G4GammaConversion* theGammaConversion = new G4GammaConversion();
G4LivermoreGammaConversionModel* theLivermoreGammaConversionModel =
new G4LivermoreGammaConversionModel();
theLivermoreGammaConversionModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theGammaConversion->AddEmModel(0, theLivermoreGammaConversionModel);
ph->RegisterProcess(theGammaConversion, particle);
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
G4LivermoreRayleighModel* theRayleighModel = new G4LivermoreRayleighModel();
theRayleighModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theRayleigh->AddEmModel(0, theRayleighModel);
ph->RegisterProcess(theRayleigh, particle);
}
// Warning : end of particles and processes are needed by EM Physics builders
}
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
de->SetFluo(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_option4.cc
+278
View File
@@ -0,0 +1,278 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// S. Incerti (incerti@cenbg.in2p3.fr)
//
#include "G4EmDNAPhysics_option4.hh"
#include "G4SystemOfUnits.hh"
#include "G4DNAGenericIonsManager.hh"
// *** Processes and models for Geant4-DNA
#include "G4DNAElastic.hh"
#include "G4DNAChampionElasticModel.hh"
#include "G4DNAUeharaScreenedRutherfordElasticModel.hh"
#include "G4DNAScreenedRutherfordElasticModel.hh"
#include "G4DNAIonisation.hh"
#include "G4DNAEmfietzoglouIonisationModel.hh"
#include "G4DNAExcitation.hh"
#include "G4DNAEmfietzoglouExcitationModel.hh"
#include "G4DNAAttachment.hh"
#include "G4DNAVibExcitation.hh"
#include "G4DNAChargeDecrease.hh"
#include "G4DNAChargeIncrease.hh"
// particles
#include "G4Electron.hh"
#include "G4Proton.hh"
#include "G4GenericIon.hh"
// Warning : the following is needed in order to use EM Physics builders
// e+
#include "G4Positron.hh"
#include "G4eMultipleScattering.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
#include "G4eplusAnnihilation.hh"
// gamma
#include "G4Gamma.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4LivermorePhotoElectricModel.hh"
#include "G4ComptonScattering.hh"
#include "G4LivermoreComptonModel.hh"
#include "G4GammaConversion.hh"
#include "G4LivermoreGammaConversionModel.hh"
#include "G4RayleighScattering.hh"
#include "G4LivermoreRayleighModel.hh"
#include "G4EmParameters.hh"
// end of warning
#include "G4LossTableManager.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_option4);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option4::G4EmDNAPhysics_option4(G4int ver)
: G4VPhysicsConstructor("G4EmDNAPhysics_option4"), verbose(ver)
{
G4EmParameters::Instance()->SetDefaults();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option4::G4EmDNAPhysics_option4(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmDNAPhysics_option4"), verbose(ver)
{
G4EmParameters::Instance()->SetDefaults();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option4::~G4EmDNAPhysics_option4()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_option4::ConstructParticle()
{
// bosons
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
// baryons
G4Proton::Proton();
G4GenericIon::GenericIonDefinition();
G4DNAGenericIonsManager * genericIonsManager;
genericIonsManager=G4DNAGenericIonsManager::Instance();
genericIonsManager->GetIon("alpha++");
genericIonsManager->GetIon("alpha+");
genericIonsManager->GetIon("helium");
genericIonsManager->GetIon("hydrogen");
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_option4::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
aParticleIterator->reset();
while( (*aParticleIterator)() )
{
G4ParticleDefinition* particle = aParticleIterator->value();
G4String particleName = particle->GetParticleName();
if (particleName == "e-") {
// *** Elastic scattering (two alternative models available) ***
G4DNAElastic* theDNAElasticProcess = new G4DNAElastic("e-_G4DNAElastic");
//theDNAElasticProcess->SetEmModel(new G4DNAChampionElasticModel());
theDNAElasticProcess->SetEmModel(new G4DNAUeharaScreenedRutherfordElasticModel());
//theDNAElasticProcess->SetEmModel(new G4DNAScreenedRutherfordElasticModel());
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess = new G4DNAExcitation("e-_G4DNAExcitation");
theDNAExcitationProcess->SetEmModel(new G4DNAEmfietzoglouExcitationModel());
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess = new G4DNAIonisation("e-_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(new G4DNAEmfietzoglouIonisationModel());
ph->RegisterProcess(theDNAIonisationProcess, particle);
// *** Vibrational excitation ***
//ph->RegisterProcess(new G4DNAVibExcitation("e-_G4DNAVibExcitation"), particle);
// *** Attachment ***
//ph->RegisterProcess(new G4DNAAttachment("e-_G4DNAAttachment"), particle);
} else if ( particleName == "proton" ) {
ph->RegisterProcess(new G4DNAExcitation("proton_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("proton_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeDecrease("proton_G4DNAChargeDecrease"), particle);
} else if ( particleName == "hydrogen" ) {
ph->RegisterProcess(new G4DNAExcitation("hydrogen_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("hydrogen_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("hydrogen_G4DNAChargeIncrease"), particle);
} else if ( particleName == "alpha" ) {
ph->RegisterProcess(new G4DNAExcitation("alpha_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("alpha_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeDecrease("alpha_G4DNAChargeDecrease"), particle);
} else if ( particleName == "alpha+" ) {
ph->RegisterProcess(new G4DNAExcitation("alpha+_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("alpha+_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeDecrease("alpha+_G4DNAChargeDecrease"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("alpha+_G4DNAChargeIncrease"), particle);
} else if ( particleName == "helium" ) {
ph->RegisterProcess(new G4DNAExcitation("helium_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("helium_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("helium_G4DNAChargeIncrease"), particle);
// Extension to HZE proposed by Z. Francis
} else if ( particleName == "GenericIon" ) {
ph->RegisterProcess(new G4DNAIonisation("GenericIon_G4DNAIonisation"), particle);
}
// Warning : the following particles and processes are needed by EM Physics builders
// They are taken from the default Livermore Physics list
// These particles are currently not handled by Geant4-DNA
// e+
else if (particleName == "e+") {
// Identical to G4EmStandardPhysics_option3
G4eMultipleScattering* msc = new G4eMultipleScattering();
msc->SetStepLimitType(fUseDistanceToBoundary);
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eIoni, particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(new G4eplusAnnihilation(), particle);
} else if (particleName == "gamma") {
G4double LivermoreHighEnergyLimit = GeV;
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
G4LivermorePhotoElectricModel* theLivermorePhotoElectricModel =
new G4LivermorePhotoElectricModel();
theLivermorePhotoElectricModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
thePhotoElectricEffect->AddEmModel(0, theLivermorePhotoElectricModel);
ph->RegisterProcess(thePhotoElectricEffect, particle);
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
G4LivermoreComptonModel* theLivermoreComptonModel =
new G4LivermoreComptonModel();
theLivermoreComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theComptonScattering->AddEmModel(0, theLivermoreComptonModel);
ph->RegisterProcess(theComptonScattering, particle);
G4GammaConversion* theGammaConversion = new G4GammaConversion();
G4LivermoreGammaConversionModel* theLivermoreGammaConversionModel =
new G4LivermoreGammaConversionModel();
theLivermoreGammaConversionModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theGammaConversion->AddEmModel(0, theLivermoreGammaConversionModel);
ph->RegisterProcess(theGammaConversion, particle);
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
G4LivermoreRayleighModel* theRayleighModel = new G4LivermoreRayleighModel();
theRayleighModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theRayleigh->AddEmModel(0, theRayleighModel);
ph->RegisterProcess(theRayleigh, particle);
}
// Warning : end of particles and processes are needed by EM Physics builders
}
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
de->SetFluo(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_option5.cc
+363
View File
@@ -0,0 +1,363 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// S. Incerti (incerti@cenbg.in2p3.fr)
//
#include "G4EmDNAPhysics_option5.hh"
#include "G4SystemOfUnits.hh"
#include "G4DNAGenericIonsManager.hh"
// *** Processes and models for Geant4-DNA
#include "G4DNAElastic.hh"
#include "G4DNAChampionElasticModel.hh"
#include "G4DNAUeharaScreenedRutherfordElasticModel.hh"
#include "G4DNAScreenedRutherfordElasticModel.hh"
#include "G4DNAIonisation.hh"
#include "G4DNAEmfietzoglouIonisationModel.hh"
#include "G4DNAExcitation.hh"
#include "G4DNAEmfietzoglouExcitationModel.hh"
#include "G4DNAAttachment.hh"
#include "G4DNAVibExcitation.hh"
#include "G4DNAChargeDecrease.hh"
#include "G4DNAChargeIncrease.hh"
// particles
#include "G4Electron.hh"
#include "G4Proton.hh"
#include "G4GenericIon.hh"
// Warning : the following is needed in order to use EM Physics builders
// e+
#include "G4Positron.hh"
#include "G4eMultipleScattering.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
#include "G4eplusAnnihilation.hh"
// gamma
#include "G4Gamma.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4LivermorePhotoElectricModel.hh"
#include "G4ComptonScattering.hh"
#include "G4LivermoreComptonModel.hh"
#include "G4GammaConversion.hh"
#include "G4LivermoreGammaConversionModel.hh"
#include "G4RayleighScattering.hh"
#include "G4LivermoreRayleighModel.hh"
#include "G4EmParameters.hh"
// end of warning
#include "G4LossTableManager.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_option5);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option5::G4EmDNAPhysics_option5(G4int ver) :
G4VPhysicsConstructor("G4EmDNAPhysics_option5"), verbose(ver)
{
G4EmParameters::Instance()->SetDefaults();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option5::G4EmDNAPhysics_option5(G4int ver, const G4String&) :
G4VPhysicsConstructor("G4EmDNAPhysics_option5"), verbose(ver)
{
G4EmParameters::Instance()->SetDefaults();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option5::~G4EmDNAPhysics_option5()
{
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_option5::ConstructParticle()
{
// bosons
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
// baryons
G4Proton::Proton();
G4GenericIon::GenericIonDefinition();
G4DNAGenericIonsManager * genericIonsManager;
genericIonsManager = G4DNAGenericIonsManager::Instance();
genericIonsManager->GetIon("alpha++");
genericIonsManager->GetIon("alpha+");
genericIonsManager->GetIon("helium");
genericIonsManager->GetIon("hydrogen");
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_option5::ConstructProcess()
{
if(verbose > 1)
{
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
aParticleIterator->reset();
while( (*aParticleIterator)() )
{
G4ParticleDefinition* particle = aParticleIterator->value();
G4String particleName = particle->GetParticleName();
if (particleName == "e-")
{
// *** Elastic scattering (two alternative models available) ***
G4DNAElastic* theDNAElasticProcess = new G4DNAElastic("e-_G4DNAElastic");
//theDNAElasticProcess->SetEmModel(new G4DNAChampionElasticModel());
theDNAElasticProcess->SetEmModel(new G4DNAUeharaScreenedRutherfordElasticModel());
//theDNAElasticProcess->SetEmModel(new G4DNAScreenedRutherfordElasticModel());
ph->RegisterProcess(theDNAElasticProcess, particle);
{
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess =
new G4DNAExcitation("e-_G4DNAExcitation");
{
G4DNABornExcitationModel* bornExc = new G4DNABornExcitationModel();
bornExc->SetLowEnergyLimit(10*keV);
bornExc->SetHighEnergyLimit(1.*MeV);
bornExc->SetActivationLowEnergyLimit(10*keV);
bornExc->SetActivationHighEnergyLimit(1.*MeV);
theDNAExcitationProcess->SetEmModel(bornExc,1);
theDNAExcitationProcess->AddEmModel(1, bornExc);
}
{
G4DNAEmfietzoglouExcitationModel* emExc = new G4DNAEmfietzoglouExcitationModel();
emExc->SetActivationLowEnergyLimit(0);
emExc->SetActivationHighEnergyLimit(10.*keV);
theDNAExcitationProcess->SetEmModel(emExc,2);
theDNAExcitationProcess->AddEmModel(2, emExc);
}
ph->RegisterProcess(theDNAExcitationProcess, particle);
}
{
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("e-_G4DNAIonisation");
{
G4DNABornIonisationModel* bornIon = new G4DNABornIonisationModel();
bornIon->SetLowEnergyLimit(10*keV);
bornIon->SetHighEnergyLimit(1.*MeV);
bornIon->SetActivationLowEnergyLimit(10*keV);
bornIon->SetActivationHighEnergyLimit(1.*MeV);
theDNAIonisationProcess->SetEmModel(bornIon,1);
bornIon->SelectFasterComputation(true);
theDNAIonisationProcess->AddEmModel(1,bornIon);
}
{
G4DNAEmfietzoglouIonisationModel* emIonModel = new G4DNAEmfietzoglouIonisationModel();
emIonModel->SetLowEnergyLimit(10*eV);
emIonModel->SetHighEnergyLimit(10.*keV);
emIonModel->SetActivationLowEnergyLimit(0);
emIonModel->SetActivationHighEnergyLimit(10.*keV);
theDNAIonisationProcess->SetEmModel(emIonModel,2);
emIonModel->SelectFasterComputation(true);
theDNAIonisationProcess->AddEmModel(2,emIonModel);
}
ph->RegisterProcess(theDNAIonisationProcess, particle);
}
// *** Vibrational excitation ***
//ph->RegisterProcess(new G4DNAVibExcitation("e-_G4DNAVibExcitation"), particle);
// *** Attachment ***
//ph->RegisterProcess(new G4DNAAttachment("e-_G4DNAAttachment"), particle);
} else if ( particleName == "proton" ) {
ph->RegisterProcess(new G4DNAExcitation("proton_G4DNAExcitation"), particle);
G4DNAIonisation* theDNAIonisationProcess = new G4DNAIonisation("proton_G4DNAIonisation");
G4VEmModel* mod1;
mod1 = new G4DNARuddIonisationExtendedModel();
mod1->SetLowEnergyLimit(0*eV);
mod1->SetHighEnergyLimit(500*keV);
G4VEmModel* mod2;
mod2= new G4DNABornIonisationModel();
mod2->SetLowEnergyLimit(500*keV);
mod2->SetHighEnergyLimit(100*MeV);
theDNAIonisationProcess->SetEmModel(mod1,1);
theDNAIonisationProcess->SetEmModel(mod2,2);
((G4DNABornIonisationModel*)(theDNAIonisationProcess->EmModel(2)))->SelectFasterComputation(true);
ph->RegisterProcess(theDNAIonisationProcess, particle);
ph->RegisterProcess(new G4DNAChargeDecrease("proton_G4DNAChargeDecrease"), particle);
} else if ( particleName == "hydrogen" ) {
ph->RegisterProcess(new G4DNAExcitation("hydrogen_G4DNAExcitation"), particle);
//ph->RegisterProcess(new G4DNAIonisation("hydrogen_G4DNAIonisation"), particle);
G4DNAIonisation* theDNAIonisationProcess = new G4DNAIonisation("hydrogen_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(new G4DNARuddIonisationExtendedModel());
ph->RegisterProcess(theDNAIonisationProcess, particle);
ph->RegisterProcess(new G4DNAChargeIncrease("hydrogen_G4DNAChargeIncrease"), particle);
} else if ( particleName == "alpha" ) {
ph->RegisterProcess(new G4DNAExcitation("alpha_G4DNAExcitation"), particle);
//ph->RegisterProcess(new G4DNAIonisation("alpha_G4DNAIonisation"), particle);
G4DNAIonisation* theDNAIonisationProcess = new G4DNAIonisation("alpha_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(new G4DNARuddIonisationExtendedModel());
ph->RegisterProcess(theDNAIonisationProcess, particle);
ph->RegisterProcess(new G4DNAChargeDecrease("alpha_G4DNAChargeDecrease"), particle);
} else if ( particleName == "alpha+" ) {
ph->RegisterProcess(new G4DNAExcitation("alpha+_G4DNAExcitation"), particle);
//ph->RegisterProcess(new G4DNAIonisation("alpha+_G4DNAIonisation"), particle);
G4DNAIonisation* theDNAIonisationProcess = new G4DNAIonisation("alpha+_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(new G4DNARuddIonisationExtendedModel());
ph->RegisterProcess(theDNAIonisationProcess, particle);
ph->RegisterProcess(new G4DNAChargeDecrease("alpha+_G4DNAChargeDecrease"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("alpha+_G4DNAChargeIncrease"), particle);
} else if ( particleName == "helium" ) {
ph->RegisterProcess(new G4DNAExcitation("helium_G4DNAExcitation"), particle);
//ph->RegisterProcess(new G4DNAIonisation("helium_G4DNAIonisation"), particle);
G4DNAIonisation* theDNAIonisationProcess = new G4DNAIonisation("helium_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(new G4DNARuddIonisationExtendedModel());
ph->RegisterProcess(theDNAIonisationProcess, particle);
ph->RegisterProcess(new G4DNAChargeIncrease("helium_G4DNAChargeIncrease"), particle);
// Extension to HZE proposed by Z. Francis
} else if ( particleName == "GenericIon" ) {
ph->RegisterProcess(new G4DNAIonisation("GenericIon_G4DNAIonisation"), particle);
}
// Warning : the following particles and processes are needed by EM Physics builders
// They are taken from the default Livermore Physics list
// These particles are currently not handled by Geant4-DNA
// e+
else if (particleName == "e+") {
// Identical to G4EmStandardPhysics_option3
G4eMultipleScattering* msc = new G4eMultipleScattering();
msc->SetStepLimitType(fUseDistanceToBoundary);
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eIoni, particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(new G4eplusAnnihilation(), particle);
} else if (particleName == "gamma") {
G4double LivermoreHighEnergyLimit = GeV;
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
G4LivermorePhotoElectricModel* theLivermorePhotoElectricModel =
new G4LivermorePhotoElectricModel();
theLivermorePhotoElectricModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
thePhotoElectricEffect->AddEmModel(0, theLivermorePhotoElectricModel);
ph->RegisterProcess(thePhotoElectricEffect, particle);
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
G4LivermoreComptonModel* theLivermoreComptonModel =
new G4LivermoreComptonModel();
theLivermoreComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theComptonScattering->AddEmModel(0, theLivermoreComptonModel);
ph->RegisterProcess(theComptonScattering, particle);
G4GammaConversion* theGammaConversion = new G4GammaConversion();
G4LivermoreGammaConversionModel* theLivermoreGammaConversionModel =
new G4LivermoreGammaConversionModel();
theLivermoreGammaConversionModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theGammaConversion->AddEmModel(0, theLivermoreGammaConversionModel);
ph->RegisterProcess(theGammaConversion, particle);
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
G4LivermoreRayleighModel* theRayleighModel = new G4LivermoreRayleighModel();
theRayleighModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theRayleigh->AddEmModel(0, theRayleighModel);
ph->RegisterProcess(theRayleigh, particle);
}
// Warning : end of particles and processes are needed by EM Physics builders
}
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
de->SetFluo(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_option7.cc
+316
View File
@@ -0,0 +1,316 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// S. Incerti (incerti@cenbg.in2p3.fr)
//
#include "G4EmDNAPhysics_option7.hh"
#include "G4SystemOfUnits.hh"
#include "G4DNAGenericIonsManager.hh"
// *** Processes and models for Geant4-DNA
#include "G4DNAElastic.hh"
#include "G4DNAChampionElasticModel.hh"
#include "G4DNAUeharaScreenedRutherfordElasticModel.hh"
#include "G4DNAScreenedRutherfordElasticModel.hh"
#include "G4DNAIonisation.hh"
#include "G4DNAEmfietzoglouIonisationModel.hh"
#include "G4DNAExcitation.hh"
#include "G4DNAEmfietzoglouExcitationModel.hh"
#include "G4DNAAttachment.hh"
#include "G4DNAVibExcitation.hh"
#include "G4DNAChargeDecrease.hh"
#include "G4DNAChargeIncrease.hh"
// particles
#include "G4Electron.hh"
#include "G4Proton.hh"
#include "G4GenericIon.hh"
// Warning : the following is needed in order to use EM Physics builders
// e+
#include "G4Positron.hh"
#include "G4eMultipleScattering.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
#include "G4eplusAnnihilation.hh"
// gamma
#include "G4Gamma.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4LivermorePhotoElectricModel.hh"
#include "G4ComptonScattering.hh"
#include "G4LivermoreComptonModel.hh"
#include "G4GammaConversion.hh"
#include "G4LivermoreGammaConversionModel.hh"
#include "G4RayleighScattering.hh"
#include "G4LivermoreRayleighModel.hh"
// end of warning
#include "G4LossTableManager.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_option7);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option7::G4EmDNAPhysics_option7(G4int ver) :
G4VPhysicsConstructor("G4EmDNAPhysics_option7"), verbose(ver)
{
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option7::G4EmDNAPhysics_option7(G4int ver, const G4String&) :
G4VPhysicsConstructor("G4EmDNAPhysics_option7"), verbose(ver)
{
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option7::~G4EmDNAPhysics_option7()
{
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_option7::ConstructParticle()
{
// bosons
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
// baryons
G4Proton::Proton();
G4GenericIon::GenericIonDefinition();
G4DNAGenericIonsManager * genericIonsManager;
genericIonsManager = G4DNAGenericIonsManager::Instance();
genericIonsManager->GetIon("alpha++");
genericIonsManager->GetIon("alpha+");
genericIonsManager->GetIon("helium");
genericIonsManager->GetIon("hydrogen");
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_option7::ConstructProcess()
{
if(verbose > 1)
{
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
aParticleIterator->reset();
while( (*aParticleIterator)() )
{
G4ParticleDefinition* particle = aParticleIterator->value();
G4String particleName = particle->GetParticleName();
if (particleName == "e-")
{
// *** Elastic scattering (two alternative models available) ***
G4DNAElastic* theDNAElasticProcess = new G4DNAElastic("e-_G4DNAElastic");
theDNAElasticProcess->SetEmModel(new G4DNAUeharaScreenedRutherfordElasticModel());
ph->RegisterProcess(theDNAElasticProcess, particle);
{
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess =
new G4DNAExcitation("e-_G4DNAExcitation");
{
G4DNABornExcitationModel* bornExc = new G4DNABornExcitationModel();
bornExc->SetLowEnergyLimit(10*keV);
bornExc->SetHighEnergyLimit(1.*MeV);
bornExc->SetActivationLowEnergyLimit(10*keV);
bornExc->SetActivationHighEnergyLimit(1.*MeV);
theDNAExcitationProcess->SetEmModel(bornExc,1);
theDNAExcitationProcess->AddEmModel(1, bornExc);
}
{
G4DNAEmfietzoglouExcitationModel* emExc = new G4DNAEmfietzoglouExcitationModel();
emExc->SetActivationLowEnergyLimit(0);
emExc->SetActivationHighEnergyLimit(10.*keV);
theDNAExcitationProcess->SetEmModel(emExc,2);
theDNAExcitationProcess->AddEmModel(2, emExc);
}
ph->RegisterProcess(theDNAExcitationProcess, particle);
}
{
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("e-_G4DNAIonisation");
{
G4DNABornIonisationModel* bornIon = new G4DNABornIonisationModel();
bornIon->SetLowEnergyLimit(10*keV);
bornIon->SetHighEnergyLimit(1.*MeV);
bornIon->SetActivationLowEnergyLimit(10*keV);
bornIon->SetActivationHighEnergyLimit(1.*MeV);
theDNAIonisationProcess->SetEmModel(bornIon,1);
theDNAIonisationProcess->AddEmModel(1,bornIon);
}
{
G4DNAEmfietzoglouIonisationModel* emIonModel = new G4DNAEmfietzoglouIonisationModel();
emIonModel->SetLowEnergyLimit(10*eV);
emIonModel->SetHighEnergyLimit(10.*keV);
emIonModel->SetActivationLowEnergyLimit(0);
emIonModel->SetActivationHighEnergyLimit(10.*keV);
theDNAIonisationProcess->SetEmModel(emIonModel,2);
emIonModel->SelectFasterComputation(true);
theDNAIonisationProcess->AddEmModel(2,emIonModel);
}
ph->RegisterProcess(theDNAIonisationProcess, particle);
}
// *** Vibrational excitation ***
ph->RegisterProcess(new G4DNAVibExcitation("e-_G4DNAVibExcitation"), particle);
// *** Attachment ***
ph->RegisterProcess(new G4DNAAttachment("e-_G4DNAAttachment"), particle);
} else if ( particleName == "proton" ) {
ph->RegisterProcess(new G4DNAElastic("proton_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("proton_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("proton_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeDecrease("proton_G4DNAChargeDecrease"), particle);
} else if ( particleName == "hydrogen" ) {
ph->RegisterProcess(new G4DNAElastic("hydrogen_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("hydrogen_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("hydrogen_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("hydrogen_G4DNAChargeIncrease"), particle);
} else if ( particleName == "alpha" ) {
ph->RegisterProcess(new G4DNAElastic("alpha_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("alpha_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("alpha_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeDecrease("alpha_G4DNAChargeDecrease"), particle);
} else if ( particleName == "alpha+" ) {
ph->RegisterProcess(new G4DNAElastic("alpha+_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("alpha+_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("alpha+_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeDecrease("alpha+_G4DNAChargeDecrease"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("alpha+_G4DNAChargeIncrease"), particle);
} else if ( particleName == "helium" ) {
ph->RegisterProcess(new G4DNAElastic("helium_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("helium_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("helium_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("helium_G4DNAChargeIncrease"), particle);
}
// Extension to HZE proposed by Z. Francis
else if ( particleName == "GenericIon" ) {
ph->RegisterProcess(new G4DNAIonisation("GenericIon_G4DNAIonisation"), particle);
}
// Warning : the following particles and processes are needed by EM Physics builders
// They are taken from the default Livermore Physics list
// These particles are currently not handled by Geant4-DNA
// e+
else if (particleName == "e+") {
// Identical to G4EmStandardPhysics_option3
G4eMultipleScattering* msc = new G4eMultipleScattering();
msc->SetStepLimitType(fUseDistanceToBoundary);
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eIoni, particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(new G4eplusAnnihilation(), particle);
} else if (particleName == "gamma") {
G4double LivermoreHighEnergyLimit = GeV;
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
G4LivermorePhotoElectricModel* theLivermorePhotoElectricModel =
new G4LivermorePhotoElectricModel();
theLivermorePhotoElectricModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
thePhotoElectricEffect->AddEmModel(0, theLivermorePhotoElectricModel);
ph->RegisterProcess(thePhotoElectricEffect, particle);
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
G4LivermoreComptonModel* theLivermoreComptonModel =
new G4LivermoreComptonModel();
theLivermoreComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theComptonScattering->AddEmModel(0, theLivermoreComptonModel);
ph->RegisterProcess(theComptonScattering, particle);
G4GammaConversion* theGammaConversion = new G4GammaConversion();
G4LivermoreGammaConversionModel* theLivermoreGammaConversionModel =
new G4LivermoreGammaConversionModel();
theLivermoreGammaConversionModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theGammaConversion->AddEmModel(0, theLivermoreGammaConversionModel);
ph->RegisterProcess(theGammaConversion, particle);
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
G4LivermoreRayleighModel* theRayleighModel = new G4LivermoreRayleighModel();
theRayleighModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theRayleigh->AddEmModel(0, theRayleighModel);
ph->RegisterProcess(theRayleigh, particle);
}
// Warning : end of particles and processes are needed by EM Physics builders
}
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
de->SetFluo(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmLEPTSPhysics.cc
+2
View File
@@ -60,6 +60,7 @@
#include "G4GenericIon.hh"
#include "G4LossTableManager.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4EmParameters.hh"
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
@@ -67,6 +68,7 @@
G4EmLEPTSPhysics::G4EmLEPTSPhysics( const G4String& name)
: G4VPhysicsConstructor(name)
{
G4EmParameters::Instance()->SetDefaults();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmLivermorePhysics.cc
+24 -11
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmLivermorePhysics.cc 86233 2014-11-07 17:21:03Z gcosmo $
// $Id: G4EmLivermorePhysics.cc 92821 2015-09-17 15:23:49Z gcosmo $
#include "G4EmLivermorePhysics.hh"
#include "G4ParticleDefinition.hh"
@@ -116,6 +116,7 @@
//
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
#include "G4EmModelActivator.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
@@ -129,11 +130,16 @@ G4EmLivermorePhysics::G4EmLivermorePhysics(G4int ver)
: G4VPhysicsConstructor("G4EmLivermorePhysics"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
param->SetMinEnergy(100*eV);
param->SetMaxEnergy(10*TeV);
param->SetLowestElectronEnergy(100*eV);
param->SetNumberOfBinsPerDecade(20);
param->ActivateAngularGeneratorForIonisation(true);
param->SetMscRangeFactor(0.02);
param->SetMscStepLimitType(fUseDistanceToBoundary);
param->SetFluo(true);
SetPhysicsType(bElectromagnetic);
}
@@ -143,11 +149,16 @@ G4EmLivermorePhysics::G4EmLivermorePhysics(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmLivermorePhysics"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
param->SetMinEnergy(100*eV);
param->SetMaxEnergy(10*TeV);
param->SetLowestElectronEnergy(100*eV);
param->SetNumberOfBinsPerDecade(20);
param->ActivateAngularGeneratorForIonisation(true);
param->SetMscRangeFactor(0.02);
param->SetMscStepLimitType(fUseDistanceToBoundary);
param->SetFluo(true);
SetPhysicsType(bElectromagnetic);
}
@@ -160,31 +171,35 @@ G4EmLivermorePhysics::~G4EmLivermorePhysics()
void G4EmLivermorePhysics::ConstructParticle()
{
// gamma
// gamma
G4Gamma::Gamma();
// leptons
// leptons
G4Electron::Electron();
G4Positron::Positron();
G4MuonPlus::MuonPlus();
G4MuonMinus::MuonMinus();
// mesons
// mesons
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
// baryons
// baryons
G4Proton::Proton();
G4AntiProton::AntiProton();
// ions
// ions
G4Deuteron::Deuteron();
G4Triton::Triton();
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
// dna
G4EmModelActivator mact;
mact.ConstructParticle();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
@@ -256,12 +271,10 @@ void G4EmLivermorePhysics::ConstructProcess()
// multiple scattering
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fUseDistanceToBoundary);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->SetRangeFactor(0.01);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
@@ -297,12 +310,10 @@ void G4EmLivermorePhysics::ConstructProcess()
// multiple scattering
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fUseDistanceToBoundary);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->SetRangeFactor(0.01);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
@@ -438,7 +449,9 @@ void G4EmLivermorePhysics::ConstructProcess()
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
de->SetFluo(true);
G4EmModelActivator mact;
mact.ConstructProcess();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmLivermorePolarizedPhysics.cc
+19 -7
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmLivermorePolarizedPhysics.cc 86233 2014-11-07 17:21:03Z gcosmo $
// $Id: G4EmLivermorePolarizedPhysics.cc 92821 2015-09-17 15:23:49Z gcosmo $
#include "G4EmLivermorePolarizedPhysics.hh"
#include "G4ParticleDefinition.hh"
@@ -114,6 +114,7 @@
//
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
#include "G4EmModelActivator.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
@@ -127,11 +128,14 @@ G4EmLivermorePolarizedPhysics::G4EmLivermorePolarizedPhysics(G4int ver)
: G4VPhysicsConstructor("G4EmLivermorePolarizedPhysics"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
param->SetMinEnergy(100*eV);
param->SetMaxEnergy(10*TeV);
param->SetLowestElectronEnergy(100*eV);
param->SetNumberOfBinsPerDecade(20);
param->ActivateAngularGeneratorForIonisation(true);
param->SetFluo(true);
SetPhysicsType(bElectromagnetic);
}
@@ -141,11 +145,13 @@ G4EmLivermorePolarizedPhysics::G4EmLivermorePolarizedPhysics(G4int ver, const G4
: G4VPhysicsConstructor("G4EmLivermorePolarizedPhysics"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
param->SetMinEnergy(100*eV);
param->SetMaxEnergy(10*TeV);
param->SetNumberOfBinsPerDecade(20);
param->ActivateAngularGeneratorForIonisation(true);
param->SetFluo(true);
SetPhysicsType(bElectromagnetic);
}
@@ -158,31 +164,35 @@ G4EmLivermorePolarizedPhysics::~G4EmLivermorePolarizedPhysics()
void G4EmLivermorePolarizedPhysics::ConstructParticle()
{
// gamma
// gamma
G4Gamma::Gamma();
// leptons
// leptons
G4Electron::Electron();
G4Positron::Positron();
G4MuonPlus::MuonPlus();
G4MuonMinus::MuonMinus();
// mesons
// mesons
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
// baryons
// baryons
G4Proton::Proton();
G4AntiProton::AntiProton();
// ions
// ions
G4Deuteron::Deuteron();
G4Triton::Triton();
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
// dna
G4EmModelActivator mact;
mact.ConstructParticle();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
@@ -445,7 +455,9 @@ void G4EmLivermorePolarizedPhysics::ConstructProcess()
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
de->SetFluo(true);
G4EmModelActivator mact;
mact.ConstructProcess();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmLowEPPhysics.cc
+23 -14
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmLowEPPhysics.cc 86233 2014-11-07 17:21:03Z gcosmo $
// $Id: G4EmLowEPPhysics.cc 92821 2015-09-17 15:23:49Z gcosmo $
#include "G4EmLowEPPhysics.hh"
#include "G4ParticleDefinition.hh"
@@ -64,11 +64,6 @@
#include "G4MuIonisation.hh"
#include "G4MuBremsstrahlung.hh"
#include "G4MuPairProduction.hh"
//#include "G4MuBremsstrahlungModel.hh"
//#include "G4MuPairProductionModel.hh"
//#include "G4hBremsstrahlungModel.hh"
//#include "G4hPairProductionModel.hh"
#include "G4SeltzerBergerModel.hh"
// hadrons
@@ -119,6 +114,7 @@
//
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
#include "G4EmModelActivator.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
@@ -131,11 +127,14 @@ G4EmLowEPPhysics::G4EmLowEPPhysics(G4int ver)
: G4VPhysicsConstructor("G4EmLowEPPhysics"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
param->SetMinEnergy(100*eV);
param->SetMaxEnergy(10*TeV);
param->SetLowestElectronEnergy(100*eV);
param->SetNumberOfBinsPerDecade(20);
param->ActivateAngularGeneratorForIonisation(true);
param->SetFluo(true);
SetPhysicsType(bElectromagnetic);
}
@@ -145,11 +144,14 @@ G4EmLowEPPhysics::G4EmLowEPPhysics(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmLowEPPhysics"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
param->SetMinEnergy(100*eV);
param->SetMaxEnergy(10*TeV);
param->SetLowestElectronEnergy(100*eV);
param->SetNumberOfBinsPerDecade(20);
param->ActivateAngularGeneratorForIonisation(true);
param->SetFluo(true);
SetPhysicsType(bElectromagnetic);
}
@@ -162,31 +164,35 @@ G4EmLowEPPhysics::~G4EmLowEPPhysics()
void G4EmLowEPPhysics::ConstructParticle()
{
// gamma
// gamma
G4Gamma::Gamma();
// leptons
// leptons
G4Electron::Electron();
G4Positron::Positron();
G4MuonPlus::MuonPlus();
G4MuonMinus::MuonMinus();
// mesons
// mesons
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
// baryons
// baryons
G4Proton::Proton();
G4AntiProton::AntiProton();
// ions
// ions
G4Deuteron::Deuteron();
G4Triton::Triton();
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
// dna
G4EmModelActivator mact;
mact.ConstructParticle();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
@@ -209,10 +215,13 @@ void G4EmLowEPPhysics::ConstructProcess()
G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();
mumsc->SetEmModel(new G4LowEWentzelVIModel());
G4hMultipleScattering* hmsc = new G4hMultipleScattering();
hmsc->SetEmModel(new G4LowEWentzelVIModel());
G4hMultipleScattering* pmsc = new G4hMultipleScattering();
pmsc->SetEmModel(new G4LowEWentzelVIModel());
G4hMultipleScattering* pimsc = new G4hMultipleScattering();
pimsc->SetEmModel(new G4LowEWentzelVIModel());
G4hMultipleScattering* kmsc = new G4hMultipleScattering();
kmsc->SetEmModel(new G4LowEWentzelVIModel());
// nuclear stopping
G4NuclearStopping* ionnuc = new G4NuclearStopping();
@@ -259,7 +268,6 @@ void G4EmLowEPPhysics::ConstructProcess()
// multiple scattering
G4eMultipleScattering* msc = new G4eMultipleScattering();
msc->SetRangeFactor(0.01);
msc->SetEmModel(new G4LowEWentzelVIModel(), 1);
// Ionisation - Livermore should be used only for low energies
@@ -286,7 +294,6 @@ void G4EmLowEPPhysics::ConstructProcess()
// multiple scattering
G4eMultipleScattering* msc = new G4eMultipleScattering();
msc->SetRangeFactor(0.01);
msc->SetEmModel(new G4LowEWentzelVIModel(), 1);
// Standard ionisation
@@ -415,7 +422,9 @@ void G4EmLowEPPhysics::ConstructProcess()
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
de->SetFluo(true);
G4EmModelActivator mact;
mact.ConstructProcess();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmModelActivator.cc
Executable
+1035
View File
File diff suppressed because it is too large Load Diff
source/physics_lists/constructors/electromagnetic/src/G4EmPenelopePhysics.cc
+26 -11
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmPenelopePhysics.cc 86233 2014-11-07 17:21:03Z gcosmo $
// $Id: G4EmPenelopePhysics.cc 92821 2015-09-17 15:23:49Z gcosmo $
#include "G4EmPenelopePhysics.hh"
#include "G4ParticleDefinition.hh"
@@ -121,6 +121,7 @@
//
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
#include "G4EmModelActivator.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
@@ -133,10 +134,16 @@ G4EmPenelopePhysics::G4EmPenelopePhysics(G4int ver)
: G4VPhysicsConstructor("G4EmPenelopePhysics"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
param->SetMinEnergy(100*eV);
param->SetMaxEnergy(10*TeV);
param->SetLowestElectronEnergy(100*eV);
param->SetNumberOfBinsPerDecade(20);
param->SetMscRangeFactor(0.02);
param->SetMscStepLimitType(fUseDistanceToBoundary);
param->SetFluo(true);
param->SetPIXEElectronCrossSectionModel("Penelope");
SetPhysicsType(bElectromagnetic);
}
@@ -146,10 +153,16 @@ G4EmPenelopePhysics::G4EmPenelopePhysics(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmPenelopePhysics"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
param->SetMinEnergy(100*eV);
param->SetMaxEnergy(10*TeV);
param->SetLowestElectronEnergy(100*eV);
param->SetNumberOfBinsPerDecade(20);
param->SetMscRangeFactor(0.02);
param->SetMscStepLimitType(fUseDistanceToBoundary);
param->SetFluo(true);
param->SetPIXEElectronCrossSectionModel("Penelope");
SetPhysicsType(bElectromagnetic);
}
@@ -162,31 +175,35 @@ G4EmPenelopePhysics::~G4EmPenelopePhysics()
void G4EmPenelopePhysics::ConstructParticle()
{
// gamma
// gamma
G4Gamma::Gamma();
// leptons
// leptons
G4Electron::Electron();
G4Positron::Positron();
G4MuonPlus::MuonPlus();
G4MuonMinus::MuonMinus();
// mesons
// mesons
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
// baryons
// baryons
G4Proton::Proton();
G4AntiProton::AntiProton();
// ions
// ions
G4Deuteron::Deuteron();
G4Triton::Triton();
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
// dna
G4EmModelActivator mact;
mact.ConstructParticle();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
@@ -274,12 +291,10 @@ void G4EmPenelopePhysics::ConstructProcess()
// multiple scattering
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fUseDistanceToBoundary);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->SetRangeFactor(0.01);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
@@ -315,12 +330,10 @@ void G4EmPenelopePhysics::ConstructProcess()
// multiple scattering
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fUseDistanceToBoundary);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->SetRangeFactor(0.01);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
@@ -473,7 +486,9 @@ void G4EmPenelopePhysics::ConstructProcess()
//
G4VAtomDeexcitation* deexcitation = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(deexcitation);
deexcitation->SetFluo(true);
G4EmModelActivator mact;
mact.ConstructProcess();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysics.cc
+17 -3
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmStandardPhysics.cc 84662 2014-10-17 14:32:32Z gcosmo $
// $Id: G4EmStandardPhysics.cc 92821 2015-09-17 15:23:49Z gcosmo $
//
//---------------------------------------------------------------------------
//
@@ -99,6 +99,7 @@
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
#include "G4EmModelActivator.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
@@ -110,7 +111,9 @@ G4_DECLARE_PHYSCONSTR_FACTORY(G4EmStandardPhysics);
G4EmStandardPhysics::G4EmStandardPhysics(G4int ver)
: G4VPhysicsConstructor("G4EmStandard"), verbose(ver)
{
G4EmParameters::Instance()->SetVerbose(verbose);
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
SetPhysicsType(bElectromagnetic);
}
@@ -119,7 +122,9 @@ G4EmStandardPhysics::G4EmStandardPhysics(G4int ver)
G4EmStandardPhysics::G4EmStandardPhysics(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmStandard"), verbose(ver)
{
G4EmParameters::Instance()->SetVerbose(verbose);
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
SetPhysicsType(bElectromagnetic);
}
@@ -157,6 +162,10 @@ void G4EmStandardPhysics::ConstructParticle()
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
// dna
G4EmModelActivator mact;
mact.ConstructParticle();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
@@ -217,6 +226,7 @@ void G4EmStandardPhysics::ConstructProcess()
G4eMultipleScattering* msc = new G4eMultipleScattering;
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetNewDisplacementFlag(false);
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
@@ -239,6 +249,7 @@ void G4EmStandardPhysics::ConstructProcess()
G4eMultipleScattering* msc = new G4eMultipleScattering;
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetNewDisplacementFlag(false);
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
@@ -348,6 +359,9 @@ void G4EmStandardPhysics::ConstructProcess()
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
G4EmModelActivator mact;
mact.ConstructProcess();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysicsGS.cc
+388
View File
@@ -0,0 +1,388 @@
//
// ********************************************************************
// * 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: G4EmStandardPhysicsGS.cc 90470 2015-06-01 10:44:59Z vnivanch $
//
//---------------------------------------------------------------------------
//
// ClassName: G4EmStandardPhysicsGS
//
// Author: V.Ivanchenko 05.06.2015
//
// Modified:
//
//----------------------------------------------------------------------------
//
#include "G4EmStandardPhysicsGS.hh"
#include "G4SystemOfUnits.hh"
#include "G4ParticleDefinition.hh"
#include "G4EmParameters.hh"
#include "G4LossTableManager.hh"
#include "G4ComptonScattering.hh"
#include "G4GammaConversion.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4RayleighScattering.hh"
#include "G4KleinNishinaModel.hh"
#include "G4LivermorePhotoElectricModel.hh"
#include "G4eMultipleScattering.hh"
#include "G4MuMultipleScattering.hh"
#include "G4hMultipleScattering.hh"
#include "G4CoulombScattering.hh"
#include "G4eCoulombScatteringModel.hh"
#include "G4WentzelVIModel.hh"
#include "G4UrbanMscModel.hh"
#include "G4GoudsmitSaundersonMscModel.hh"
#include "G4MuBremsstrahlungModel.hh"
#include "G4MuPairProductionModel.hh"
#include "G4hBremsstrahlungModel.hh"
#include "G4hPairProductionModel.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
#include "G4eplusAnnihilation.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4MuIonisation.hh"
#include "G4MuBremsstrahlung.hh"
#include "G4MuPairProduction.hh"
#include "G4hBremsstrahlung.hh"
#include "G4hPairProduction.hh"
#include "G4hIonisation.hh"
#include "G4ionIonisation.hh"
#include "G4alphaIonisation.hh"
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4Proton.hh"
#include "G4AntiProton.hh"
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4He3.hh"
#include "G4Alpha.hh"
#include "G4GenericIon.hh"
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
#include "G4EmModelActivator.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4EmStandardPhysicsGS);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmStandardPhysicsGS::G4EmStandardPhysicsGS(G4int ver)
: G4VPhysicsConstructor("G4EmStandard"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
param->SetLowestElectronEnergy(10*eV);
param->SetMscRangeFactor(0.12);
param->SetMscStepLimitType(fUseSafetyPlus);// corresponds to Urban fUseSafety
// param->SetFluo(true);
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmStandardPhysicsGS::G4EmStandardPhysicsGS(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmStandard"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
param->SetLowestElectronEnergy(10*eV);
param->SetMscRangeFactor(0.12);
param->SetMscStepLimitType(fUseSafetyPlus);// corresponds to Urban fUseSafety
// param->SetFluo(true);
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmStandardPhysicsGS::~G4EmStandardPhysicsGS()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmStandardPhysicsGS::ConstructParticle()
{
// gamma
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
G4MuonPlus::MuonPlus();
G4MuonMinus::MuonMinus();
// mesons
G4PionPlus::PionPlusDefinition();
G4PionMinus::PionMinusDefinition();
G4KaonPlus::KaonPlusDefinition();
G4KaonMinus::KaonMinusDefinition();
// barions
G4Proton::Proton();
G4AntiProton::AntiProton();
// ions
G4Deuteron::Deuteron();
G4Triton::Triton();
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
// dna
G4EmModelActivator mact;
mact.ConstructParticle();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmStandardPhysicsGS::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
// muon & hadron bremsstrahlung and pair production
G4MuBremsstrahlung* mub = new G4MuBremsstrahlung();
G4MuPairProduction* mup = new G4MuPairProduction();
G4hBremsstrahlung* pib = new G4hBremsstrahlung();
G4hPairProduction* pip = new G4hPairProduction();
G4hBremsstrahlung* kb = new G4hBremsstrahlung();
G4hPairProduction* kp = new G4hPairProduction();
G4hBremsstrahlung* pb = new G4hBremsstrahlung();
G4hPairProduction* pp = new G4hPairProduction();
// muon & hadron multiple scattering
G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();
mumsc->AddEmModel(0, new G4WentzelVIModel());
G4CoulombScattering* muss = new G4CoulombScattering();
G4MuMultipleScattering* pimsc = new G4MuMultipleScattering();
pimsc->AddEmModel(0, new G4WentzelVIModel());
G4CoulombScattering* piss = new G4CoulombScattering();
G4MuMultipleScattering* kmsc = new G4MuMultipleScattering();
kmsc->AddEmModel(0, new G4WentzelVIModel());
G4CoulombScattering* kss = new G4CoulombScattering();
G4MuMultipleScattering* pmsc = new G4MuMultipleScattering();
pmsc->AddEmModel(0, new G4WentzelVIModel());
G4CoulombScattering* pss = new G4CoulombScattering();
G4hMultipleScattering* hmsc = new G4hMultipleScattering("ionmsc");
// high energy limit for e+- scattering models
G4double highEnergyLimit = 100*MeV;
// Add standard EM Processes
aParticleIterator->reset();
while( (*aParticleIterator)() ){
G4ParticleDefinition* particle = aParticleIterator->value();
G4String particleName = particle->GetParticleName();
if (particleName == "gamma") {
ph->RegisterProcess(new G4PhotoElectricEffect(), particle);
ph->RegisterProcess(new G4ComptonScattering(), particle);
ph->RegisterProcess(new G4GammaConversion(), particle);
/*
G4ComptonScattering* cs = new G4ComptonScattering;
cs->SetEmModel(new G4KleinNishinaModel(), 1);
G4PhotoElectricEffect* pee = new G4PhotoElectricEffect();
pee->SetEmModel(new G4LivermorePhotoElectricModel(), 1);
ph->RegisterProcess(cs, particle);
ph->RegisterProcess(pee, particle);
ph->RegisterProcess(new G4GammaConversion(), particle);
ph->RegisterProcess(new G4RayleighScattering(), particle);
*/
} else if (particleName == "e-") {
G4eMultipleScattering* msc = new G4eMultipleScattering;
G4GoudsmitSaundersonMscModel* msc1 = new G4GoudsmitSaundersonMscModel();
msc1->SetOptionPWAScreening(false);
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
ss->SetEmModel(ssm, 1);
ss->SetMinKinEnergy(highEnergyLimit);
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(new G4eIonisation(), particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(ss, particle);
} else if (particleName == "e+") {
G4eMultipleScattering* msc = new G4eMultipleScattering;
G4GoudsmitSaundersonMscModel* msc1 = new G4GoudsmitSaundersonMscModel();
msc1->SetOptionPWAScreening(true);
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
ss->SetEmModel(ssm, 1);
ss->SetMinKinEnergy(highEnergyLimit);
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(new G4eIonisation(), particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(new G4eplusAnnihilation(), particle);
ph->RegisterProcess(ss, particle);
} else if (particleName == "mu+" ||
particleName == "mu-" ) {
ph->RegisterProcess(mumsc, particle);
ph->RegisterProcess(new G4MuIonisation(), particle);
ph->RegisterProcess(mub, particle);
ph->RegisterProcess(mup, particle);
ph->RegisterProcess(muss, particle);
} else if (particleName == "alpha" ||
particleName == "He3") {
//ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(new G4hMultipleScattering(), particle);
ph->RegisterProcess(new G4ionIonisation(), particle);
} else if (particleName == "GenericIon") {
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(new G4ionIonisation(), particle);
} else if (particleName == "pi+" ||
particleName == "pi-" ) {
//G4hMultipleScattering* pimsc = new G4hMultipleScattering();
ph->RegisterProcess(pimsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
ph->RegisterProcess(pib, particle);
ph->RegisterProcess(pip, particle);
ph->RegisterProcess(piss, particle);
} else if (particleName == "kaon+" ||
particleName == "kaon-" ) {
//G4hMultipleScattering* kmsc = new G4hMultipleScattering();
ph->RegisterProcess(kmsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
ph->RegisterProcess(kb, particle);
ph->RegisterProcess(kp, particle);
ph->RegisterProcess(kss, particle);
} else if (particleName == "proton" ||
particleName == "anti_proton") {
//G4hMultipleScattering* pmsc = new G4hMultipleScattering();
ph->RegisterProcess(pmsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
ph->RegisterProcess(pb, particle);
ph->RegisterProcess(pp, particle);
ph->RegisterProcess(pss, particle);
} else if (particleName == "B+" ||
particleName == "B-" ||
particleName == "D+" ||
particleName == "D-" ||
particleName == "Ds+" ||
particleName == "Ds-" ||
particleName == "anti_He3" ||
particleName == "anti_alpha" ||
particleName == "anti_deuteron" ||
particleName == "anti_lambda_c+" ||
particleName == "anti_omega-" ||
particleName == "anti_sigma_c+" ||
particleName == "anti_sigma_c++" ||
particleName == "anti_sigma+" ||
particleName == "anti_sigma-" ||
particleName == "anti_triton" ||
particleName == "anti_xi_c+" ||
particleName == "anti_xi-" ||
particleName == "deuteron" ||
particleName == "lambda_c+" ||
particleName == "omega-" ||
particleName == "sigma_c+" ||
particleName == "sigma_c++" ||
particleName == "sigma+" ||
particleName == "sigma-" ||
particleName == "tau+" ||
particleName == "tau-" ||
particleName == "triton" ||
particleName == "xi_c+" ||
particleName == "xi-" ) {
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
}
}
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
G4EmModelActivator mact;
mact.ConstructProcess();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysicsSS.cc
+32 -9
View File
@@ -47,12 +47,14 @@
#include "G4ParticleDefinition.hh"
#include "G4EmParameters.hh"
#include "G4LossTableManager.hh"
//#include "G4EmProcessOptions.hh"
#include "G4ComptonScattering.hh"
#include "G4GammaConversion.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4RayleighScattering.hh"
#include "G4KleinNishinaModel.hh"
#include "G4LivermorePhotoElectricModel.hh"
#include "G4eMultipleScattering.hh"
#include "G4MuMultipleScattering.hh"
#include "G4hMultipleScattering.hh"
@@ -65,6 +67,7 @@
#include "G4MuPairProductionModel.hh"
#include "G4hBremsstrahlungModel.hh"
#include "G4hPairProductionModel.hh"
#include "G4eSingleCoulombScatteringModel.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
@@ -100,6 +103,7 @@
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
#include "G4EmModelActivator.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
@@ -111,8 +115,14 @@ G4_DECLARE_PHYSCONSTR_FACTORY(G4EmStandardPhysicsSS);
G4EmStandardPhysicsSS::G4EmStandardPhysicsSS(G4int ver)
: G4VPhysicsConstructor("G4EmStandardSS"), verbose(ver)
{
G4EmParameters::Instance()->SetVerbose(verbose);
G4EmParameters::Instance()->SetMscThetaLimit(0.0);
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
param->SetLowestElectronEnergy(10*eV);
param->SetMscThetaLimit(0.0);
param->SetFluo(true);
param->SetAuger(true);
param->SetPixe(true);
SetPhysicsType(bElectromagnetic);
}
@@ -150,6 +160,10 @@ void G4EmStandardPhysicsSS::ConstructParticle()
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
// dna
G4EmModelActivator mact;
mact.ConstructParticle();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
@@ -188,13 +202,23 @@ void G4EmStandardPhysicsSS::ConstructProcess()
if (particleName == "gamma") {
ph->RegisterProcess(new G4PhotoElectricEffect(), particle);
ph->RegisterProcess(new G4ComptonScattering(), particle);
G4ComptonScattering* cs = new G4ComptonScattering;
cs->SetEmModel(new G4KleinNishinaModel(), 1);
G4PhotoElectricEffect* pee = new G4PhotoElectricEffect();
pee->SetEmModel(new G4LivermorePhotoElectricModel(), 1);
ph->RegisterProcess(cs, particle);
ph->RegisterProcess(pee, particle);
ph->RegisterProcess(new G4GammaConversion(), particle);
ph->RegisterProcess(new G4RayleighScattering(), particle);
} else if (particleName == "e-") {
G4CoulombScattering* ss = new G4CoulombScattering();
if(G4EmParameters::Instance()->UseMottCorrection()) {
ss->SetEmModel(new G4eSingleCoulombScatteringModel(), 1);
}
ph->RegisterProcess(new G4eIonisation(), particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
@@ -287,15 +311,14 @@ void G4EmStandardPhysicsSS::ConstructProcess()
ph->RegisterProcess(new G4hIonisation(), particle);
}
}
// G4EmProcessOptions opt;
// opt.SetVerbose(verbose);
// opt.SetApplyCuts(true);
// opt.SetPolarAngleLimit(CLHEP::pi);
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
G4EmModelActivator mact;
mact.ConstructProcess();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysicsWVI.cc
+25 -6
View File
@@ -47,19 +47,19 @@
#include "G4ParticleDefinition.hh"
#include "G4EmParameters.hh"
#include "G4LossTableManager.hh"
//#include "G4EmProcessOptions.hh"
#include "G4ComptonScattering.hh"
#include "G4GammaConversion.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4RayleighScattering.hh"
#include "G4KleinNishinaModel.hh"
#include "G4LivermorePhotoElectricModel.hh"
#include "G4eMultipleScattering.hh"
#include "G4MuMultipleScattering.hh"
#include "G4hMultipleScattering.hh"
#include "G4CoulombScattering.hh"
//#include "G4eCoulombScatteringModel.hh"
#include "G4WentzelVIModel.hh"
//#include "G4UrbanMscModel.hh"
#include "G4MuBremsstrahlungModel.hh"
#include "G4MuPairProductionModel.hh"
@@ -100,6 +100,7 @@
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
#include "G4EmModelActivator.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
@@ -112,10 +113,14 @@ G4EmStandardPhysicsWVI::G4EmStandardPhysicsWVI(G4int ver)
: G4VPhysicsConstructor("G4EmStandardWVI"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
param->SetLatDisplacementBeyondSafety(true);
param->SetLowestElectronEnergy(10*eV);
// param->SetLatDisplacementBeyondSafety(true);
param->SetMuHadLateralDisplacement(false);
param->ActivateAngularGeneratorForIonisation(true);
param->SetMscThetaLimit(0.15);
param->SetFluo(true);
SetPhysicsType(bElectromagnetic);
}
@@ -153,6 +158,10 @@ void G4EmStandardPhysicsWVI::ConstructParticle()
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
// dna
G4EmModelActivator mact;
mact.ConstructParticle();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
@@ -201,9 +210,16 @@ void G4EmStandardPhysicsWVI::ConstructProcess()
if (particleName == "gamma") {
ph->RegisterProcess(new G4PhotoElectricEffect(), particle);
ph->RegisterProcess(new G4ComptonScattering(), particle);
G4ComptonScattering* cs = new G4ComptonScattering;
cs->SetEmModel(new G4KleinNishinaModel(), 1);
G4PhotoElectricEffect* pee = new G4PhotoElectricEffect();
pee->SetEmModel(new G4LivermorePhotoElectricModel(), 1);
ph->RegisterProcess(cs, particle);
ph->RegisterProcess(pee, particle);
ph->RegisterProcess(new G4GammaConversion(), particle);
ph->RegisterProcess(new G4RayleighScattering(), particle);
} else if (particleName == "e-") {
@@ -319,6 +335,9 @@ void G4EmStandardPhysicsWVI::ConstructProcess()
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
G4EmModelActivator mact;
mact.ConstructProcess();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysics_option1.cc
+23 -8
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmStandardPhysics_option1.cc 84662 2014-10-17 14:32:32Z gcosmo $
// $Id: G4EmStandardPhysics_option1.cc 92821 2015-09-17 15:23:49Z gcosmo $
//
//---------------------------------------------------------------------------
//
@@ -50,7 +50,6 @@
#include "G4SystemOfUnits.hh"
#include "G4ParticleDefinition.hh"
#include "G4LossTableManager.hh"
//#include "G4EmProcessOptions.hh"
#include "G4EmParameters.hh"
#include "G4ComptonScattering.hh"
@@ -104,6 +103,7 @@
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
#include "G4EmModelActivator.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
@@ -115,8 +115,12 @@ G4_DECLARE_PHYSCONSTR_FACTORY(G4EmStandardPhysics_option1);
G4EmStandardPhysics_option1::G4EmStandardPhysics_option1(G4int ver)
: G4VPhysicsConstructor("G4EmStandard_opt1"), verbose(ver)
{
G4EmParameters::Instance()->SetVerbose(verbose);
G4EmParameters::Instance()->SetApplyCuts(true);
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
param->SetApplyCuts(true);
param->SetMscRangeFactor(0.2);
param->SetMscStepLimitType(fMinimal);
SetPhysicsType(bElectromagnetic);
}
@@ -126,8 +130,12 @@ G4EmStandardPhysics_option1::G4EmStandardPhysics_option1(G4int ver,
const G4String&)
: G4VPhysicsConstructor("G4EmStandard_opt1"), verbose(ver)
{
G4EmParameters::Instance()->SetVerbose(verbose);
G4EmParameters::Instance()->SetApplyCuts(true);
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
param->SetApplyCuts(true);
param->SetMscRangeFactor(0.2);
param->SetMscStepLimitType(fMinimal);
SetPhysicsType(bElectromagnetic);
}
@@ -165,6 +173,10 @@ void G4EmStandardPhysics_option1::ConstructParticle()
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
// dna
G4EmModelActivator mact;
mact.ConstructParticle();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
@@ -226,9 +238,9 @@ void G4EmStandardPhysics_option1::ConstructProcess()
eioni->SetStepFunction(0.8, 1.0*mm);
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fMinimal);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetNewDisplacementFlag(false);
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
@@ -252,9 +264,9 @@ void G4EmStandardPhysics_option1::ConstructProcess()
eioni->SetStepFunction(0.8, 1.0*mm);
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fMinimal);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetNewDisplacementFlag(false);
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
@@ -365,6 +377,9 @@ void G4EmStandardPhysics_option1::ConstructProcess()
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
G4EmModelActivator mact;
mact.ConstructProcess();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysics_option2.cc
+22 -5
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmStandardPhysics_option2.cc 84662 2014-10-17 14:32:32Z gcosmo $
// $Id: G4EmStandardPhysics_option2.cc 92821 2015-09-17 15:23:49Z gcosmo $
//
//---------------------------------------------------------------------------
//
@@ -109,6 +109,7 @@
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
#include "G4EmModelActivator.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
@@ -120,7 +121,12 @@ G4_DECLARE_PHYSCONSTR_FACTORY(G4EmStandardPhysics_option2);
G4EmStandardPhysics_option2::G4EmStandardPhysics_option2(G4int ver)
: G4VPhysicsConstructor("G4EmStandard_opt2"), verbose(ver)
{
G4EmParameters::Instance()->SetVerbose(verbose);
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
param->SetApplyCuts(false);
param->SetMscRangeFactor(0.2);
param->SetMscStepLimitType(fMinimal);
SetPhysicsType(bElectromagnetic);
}
@@ -130,7 +136,12 @@ G4EmStandardPhysics_option2::G4EmStandardPhysics_option2(G4int ver,
const G4String&)
: G4VPhysicsConstructor("G4EmStandard_opt2"), verbose(ver)
{
G4EmParameters::Instance()->SetVerbose(verbose);
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
param->SetApplyCuts(false);
param->SetMscRangeFactor(0.2);
param->SetMscStepLimitType(fMinimal);
SetPhysicsType(bElectromagnetic);
}
@@ -168,6 +179,10 @@ void G4EmStandardPhysics_option2::ConstructParticle()
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
// dna
G4EmModelActivator mact;
mact.ConstructParticle();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
@@ -230,9 +245,9 @@ void G4EmStandardPhysics_option2::ConstructProcess()
eioni->SetStepFunction(0.8, 1.0*mm);
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fMinimal);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetNewDisplacementFlag(false);
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
@@ -265,9 +280,9 @@ void G4EmStandardPhysics_option2::ConstructProcess()
eioni->SetStepFunction(0.8, 1.0*mm);
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fMinimal);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetNewDisplacementFlag(false);
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->AddEmModel(0, msc1);
@@ -388,6 +403,8 @@ void G4EmStandardPhysics_option2::ConstructProcess()
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
G4EmModelActivator mact;
mact.ConstructProcess();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysics_option3.cc
+26 -9
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmStandardPhysics_option3.cc 84662 2014-10-17 14:32:32Z gcosmo $
// $Id: G4EmStandardPhysics_option3.cc 92821 2015-09-17 15:23:49Z gcosmo $
//
//---------------------------------------------------------------------------
//
@@ -51,6 +51,7 @@
#include "G4RayleighScattering.hh"
#include "G4PEEffectFluoModel.hh"
#include "G4KleinNishinaModel.hh"
#include "G4LivermorePhotoElectricModel.hh"
#include "G4eMultipleScattering.hh"
#include "G4MuMultipleScattering.hh"
@@ -104,6 +105,7 @@
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
#include "G4EmModelActivator.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
@@ -116,10 +118,14 @@ G4EmStandardPhysics_option3::G4EmStandardPhysics_option3(G4int ver)
: G4VPhysicsConstructor("G4EmStandard_opt3"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
param->SetMinEnergy(10*eV);
param->SetMaxEnergy(10*TeV);
param->SetLowestElectronEnergy(100*eV);
param->SetNumberOfBinsPerDecade(20);
param->SetMscStepLimitType(fUseDistanceToBoundary);
param->SetFluo(true);
SetPhysicsType(bElectromagnetic);
}
@@ -130,10 +136,14 @@ G4EmStandardPhysics_option3::G4EmStandardPhysics_option3(G4int ver,
: G4VPhysicsConstructor("G4EmStandard_opt3"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
param->SetMinEnergy(10*eV);
param->SetMaxEnergy(10*TeV);
param->SetLowestElectronEnergy(100*eV);
param->SetNumberOfBinsPerDecade(20);
param->SetMscStepLimitType(fUseDistanceToBoundary);
param->SetFluo(true);
SetPhysicsType(bElectromagnetic);
}
@@ -171,6 +181,10 @@ void G4EmStandardPhysics_option3::ConstructParticle()
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
// dna
G4EmModelActivator mact;
mact.ConstructParticle();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
@@ -215,18 +229,20 @@ void G4EmStandardPhysics_option3::ConstructProcess()
if (particleName == "gamma") {
G4ComptonScattering* cs = new G4ComptonScattering;
cs->SetEmModel(new G4KleinNishinaModel());
cs->SetEmModel(new G4KleinNishinaModel(), 1);
ph->RegisterProcess(new G4PhotoElectricEffect(), particle);
ph->RegisterProcess(cs, particle);
G4PhotoElectricEffect* pee = new G4PhotoElectricEffect();
pee->SetEmModel(new G4LivermorePhotoElectricModel(), 1);
ph->RegisterProcess(pee, particle);
ph->RegisterProcess(cs, particle);
ph->RegisterProcess(new G4GammaConversion(), particle);
ph->RegisterProcess(new G4RayleighScattering(), particle);
} else if (particleName == "e-") {
G4eMultipleScattering* msc = new G4eMultipleScattering();
//msc->AddEmModel(0, new G4UrbanMscModel());
msc->SetStepLimitType(fUseDistanceToBoundary);
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
@@ -247,8 +263,7 @@ void G4EmStandardPhysics_option3::ConstructProcess()
} else if (particleName == "e+") {
G4eMultipleScattering* msc = new G4eMultipleScattering();
//msc->AddEmModel(0, new G4UrbanMscModel());
msc->SetStepLimitType(fUseDistanceToBoundary);
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
@@ -381,7 +396,9 @@ void G4EmStandardPhysics_option3::ConstructProcess()
// Deexcitation
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
de->SetFluo(true);
G4EmModelActivator mact;
mact.ConstructProcess();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysics_option4.cc
+36 -17
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmStandardPhysics_option4.cc 86233 2014-11-07 17:21:03Z gcosmo $
// $Id: G4EmStandardPhysics_option4.cc 92821 2015-09-17 15:23:49Z gcosmo $
//
//---------------------------------------------------------------------------
//
@@ -109,6 +109,7 @@
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
#include "G4EmModelActivator.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
@@ -121,13 +122,17 @@ G4EmStandardPhysics_option4::G4EmStandardPhysics_option4(G4int ver)
: G4VPhysicsConstructor("G4EmStandard_opt4"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
param->SetMinEnergy(100*eV);
param->SetMaxEnergy(10*TeV);
param->SetLowestElectronEnergy(100*eV);
param->SetNumberOfBinsPerDecade(20);
param->ActivateAngularGeneratorForIonisation(true);
//param->SetMuHadLateralDisplacement(false);
param->SetLatDisplacementBeyondSafety(true);
param->SetMscRangeFactor(0.02);
param->SetMscStepLimitType(fUseDistanceToBoundary);
//param->SetLatDisplacementBeyondSafety(true);
param->SetFluo(true);
SetPhysicsType(bElectromagnetic);
}
@@ -138,13 +143,17 @@ G4EmStandardPhysics_option4::G4EmStandardPhysics_option4(G4int ver,
: G4VPhysicsConstructor("G4EmStandard_opt4"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(verbose);
param->SetMinEnergy(100*eV);
param->SetMaxEnergy(10*TeV);
param->SetLowestElectronEnergy(100*eV);
param->SetNumberOfBinsPerDecade(20);
param->ActivateAngularGeneratorForIonisation(true);
//param->SetMuHadLateralDisplacement(false);
param->SetMscRangeFactor(0.02);
param->SetMscStepLimitType(fUseDistanceToBoundary);
// param->SetLatDisplacementBeyondSafety(true);
param->SetFluo(true);
SetPhysicsType(bElectromagnetic);
}
@@ -182,6 +191,10 @@ void G4EmStandardPhysics_option4::ConstructParticle()
G4He3::He3();
G4Alpha::Alpha();
G4GenericIon::GenericIonDefinition();
// dna
G4EmModelActivator mact;
mact.ConstructParticle();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
@@ -207,7 +220,7 @@ void G4EmStandardPhysics_option4::ConstructProcess()
G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();
mumsc->AddEmModel(0, new G4WentzelVIModel());
G4CoulombScattering* muss = new G4CoulombScattering();
/*
G4MuMultipleScattering* pimsc = new G4MuMultipleScattering();
pimsc->AddEmModel(0, new G4WentzelVIModel());
G4CoulombScattering* piss = new G4CoulombScattering();
@@ -219,11 +232,13 @@ void G4EmStandardPhysics_option4::ConstructProcess()
G4MuMultipleScattering* pmsc = new G4MuMultipleScattering();
pmsc->AddEmModel(0, new G4WentzelVIModel());
G4CoulombScattering* pss = new G4CoulombScattering();
*/
G4hMultipleScattering* hmsc = new G4hMultipleScattering("ionmsc");
// energy limits for e+- scattering models
G4double highEnergyLimit = 100*MeV;
// energy limits for e+- ionisation models
G4double penEnergyLimit = 1*MeV;
// nuclear stopping
G4NuclearStopping* pnuc = new G4NuclearStopping();
@@ -264,12 +279,10 @@ void G4EmStandardPhysics_option4::ConstructProcess()
// multiple scattering
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fUseSafetyPlus);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->SetRangeFactor(0.02);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
@@ -283,6 +296,9 @@ void G4EmStandardPhysics_option4::ConstructProcess()
// ionisation
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
G4PenelopeIonisationModel* pen = new G4PenelopeIonisationModel();
pen->SetHighEnergyLimit(penEnergyLimit);
eIoni->AddEmModel(0, pen, new G4UniversalFluctuation());
// bremsstrahlung
G4eBremsstrahlung* brem = new G4eBremsstrahlung();
@@ -304,12 +320,10 @@ void G4EmStandardPhysics_option4::ConstructProcess()
// multiple scattering
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetStepLimitType(fUseSafetyPlus);
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->SetRangeFactor(0.02);
msc->AddEmModel(0, msc1);
msc->AddEmModel(0, msc2);
@@ -323,6 +337,9 @@ void G4EmStandardPhysics_option4::ConstructProcess()
// ionisation
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
G4PenelopeIonisationModel* pen = new G4PenelopeIonisationModel();
pen->SetHighEnergyLimit(penEnergyLimit);
eIoni->AddEmModel(0, pen, new G4UniversalFluctuation());
// bremsstrahlung
G4eBremsstrahlung* brem = new G4eBremsstrahlung();
@@ -377,7 +394,7 @@ void G4EmStandardPhysics_option4::ConstructProcess()
} else if (particleName == "pi+" ||
particleName == "pi-" ) {
G4hMultipleScattering* pimsc = new G4hMultipleScattering();
//G4hMultipleScattering* pimsc = new G4hMultipleScattering();
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
@@ -385,12 +402,12 @@ void G4EmStandardPhysics_option4::ConstructProcess()
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(pib, particle);
ph->RegisterProcess(pip, particle);
//ph->RegisterProcess(piss, particle);
ph->RegisterProcess(piss, particle);
} else if (particleName == "kaon+" ||
particleName == "kaon-" ) {
G4hMultipleScattering* kmsc = new G4hMultipleScattering();
//G4hMultipleScattering* kmsc = new G4hMultipleScattering();
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
@@ -398,12 +415,12 @@ void G4EmStandardPhysics_option4::ConstructProcess()
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(kb, particle);
ph->RegisterProcess(kp, particle);
//ph->RegisterProcess(kss, particle);
ph->RegisterProcess(kss, particle);
} else if (particleName == "proton" ||
particleName == "anti_proton") {
G4hMultipleScattering* pmsc = new G4hMultipleScattering();
//G4hMultipleScattering* pmsc = new G4hMultipleScattering();
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.1, 20*um);
@@ -411,7 +428,7 @@ void G4EmStandardPhysics_option4::ConstructProcess()
ph->RegisterProcess(hIoni, particle);
ph->RegisterProcess(pb, particle);
ph->RegisterProcess(pp, particle);
//ph->RegisterProcess(pss, particle);
ph->RegisterProcess(pss, particle);
ph->RegisterProcess(pnuc, particle);
} else if (particleName == "B+" ||
@@ -457,7 +474,9 @@ void G4EmStandardPhysics_option4::ConstructProcess()
// Deexcitation
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
de->SetFluo(true);
G4EmModelActivator mact;
mact.ConstructProcess();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......