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

Import Geant4 11.1.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2022-07-01 10:44:02 +02:00
parent b3bf75a2a1
commit c07cea1fe0
2172 changed files with 183300 additions and 123938 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/physics_lists/constructors/electromagnetic/src/G4EmBuilder.cc
+38
View File
@@ -36,11 +36,16 @@
#include "G4EmParameters.hh"
#include "G4VEnergyLossProcess.hh"
#include "G4eMultipleScattering.hh"
#include "G4MuMultipleScattering.hh"
#include "G4hMultipleScattering.hh"
#include "G4CoulombScattering.hh"
#include "G4WentzelVIModel.hh"
#include "G4ProcessManager.hh"
#include "G4TransportationWithMsc.hh"
#include "G4TransportationProcessType.hh"
#include "G4MuBremsstrahlungModel.hh"
#include "G4MuPairProductionModel.hh"
#include "G4hBremsstrahlungModel.hh"
@@ -381,3 +386,36 @@ void G4EmBuilder::PrepareEMPhysics()
man->SetAtomDeexcitation(ad);
}
}
void G4EmBuilder::ConstructElectronMscProcess(G4VMscModel* msc1, G4VMscModel* msc2,
G4ParticleDefinition* particle)
{
G4TransportationWithMscType type =
G4EmParameters::Instance()->TransportationWithMsc();
G4ProcessManager* procManager = particle->GetProcessManager();
auto plist = procManager->GetProcessList();
G4int ptype = (0 < plist->size()) ? (*plist)[0]->GetProcessSubType() : 0;
if(type != G4TransportationWithMscType::fDisabled && ptype == TRANSPORTATION) {
// Remove default G4Transportation and replace with G4TransportationWithMsc.
procManager->RemoveProcess(0);
G4TransportationWithMsc* transportWithMsc = new G4TransportationWithMsc(
G4TransportationWithMsc::ScatteringType::MultipleScattering);
if(type == G4TransportationWithMscType::fMultipleSteps) {
transportWithMsc->SetMultipleSteps(true);
}
transportWithMsc->AddMscModel(msc1);
if(msc2 != nullptr) {
transportWithMsc->AddMscModel(msc2);
}
procManager->AddProcess(transportWithMsc, -1, 0, 0);
} else {
// Register as a separate process.
G4eMultipleScattering* msc = new G4eMultipleScattering;
msc->SetEmModel(msc1);
if(msc2 != nullptr) {
msc->SetEmModel(msc2);
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
ph->RegisterProcess(msc, particle);
}
}
source/physics_lists/constructors/electromagnetic/src/G4EmDNABuilder.cc
+752
View File
@@ -0,0 +1,752 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
// Geant4 class G4EmDNABuilder
//
// Author V.Ivanchenko 22.05.2020
//
#include "G4EmDNABuilder.hh"
#include "G4SystemOfUnits.hh"
// particles
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4Proton.hh"
#include "G4Alpha.hh"
#include "G4GenericIon.hh"
#include "G4DNAGenericIonsManager.hh"
#include "G4ParticleDefinition.hh"
// utilities
#include "G4SystemOfUnits.hh"
#include "G4EmParameters.hh"
#include "G4EmBuilder.hh"
#include "G4PhysicsListHelper.hh"
#include "G4LowEnergyEmProcessSubType.hh"
#include "G4PhysListUtil.hh"
#include "G4ProcessManager.hh"
#include "G4Region.hh"
// standard processes
#include "G4ComptonScattering.hh"
#include "G4GammaConversion.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4RayleighScattering.hh"
#include "G4eMultipleScattering.hh"
#include "G4hMultipleScattering.hh"
#include "G4eIonisation.hh"
#include "G4hIonisation.hh"
#include "G4ionIonisation.hh"
#include "G4eBremsstrahlung.hh"
// standard models
#include "G4LivermorePhotoElectricModel.hh"
#include "G4KleinNishinaModel.hh"
#include "G4LowEPComptonModel.hh"
#include "G4UrbanMscModel.hh"
#include "G4LowEWentzelVIModel.hh"
#include "G4GoudsmitSaundersonMscModel.hh"
#include "G4MollerBhabhaModel.hh"
#include "G4SeltzerBergerModel.hh"
#include "G4Generator2BS.hh"
#include "G4BraggModel.hh"
#include "G4BraggIonModel.hh"
#include "G4BetheBlochModel.hh"
// DNA models
#include "G4DNAOneStepThermalizationModel.hh"
#include "G4DNAUeharaScreenedRutherfordElasticModel.hh"
#include "G4DNACPA100ElasticModel.hh"
#include "G4DNAChampionElasticModel.hh"
#include "G4DNAEmfietzoglouExcitationModel.hh"
#include "G4DNACPA100ExcitationModel.hh"
#include "G4DNASancheExcitationModel.hh"
#include "G4DNAEmfietzoglouIonisationModel.hh"
#include "G4DNACPA100IonisationModel.hh"
#include "G4DNABornIonisationModel1.hh"
#include "G4DNAMeltonAttachmentModel.hh"
#include "G4DNAIonElasticModel.hh"
#include "G4DNAMillerGreenExcitationModel.hh"
#include "G4DNABornExcitationModel.hh"
#include "G4DNARuddIonisationModel.hh"
#include "G4DNARuddIonisationExtendedModel.hh"
#include "G4DNADingfelderChargeDecreaseModel.hh"
#include "G4DNADingfelderChargeIncreaseModel.hh"
#include "G4DummyModel.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNABuilder::ConstructDNAParticles()
{
// bosons
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
// baryons
G4Proton::Proton();
// generic ions
G4GenericIon::GenericIon();
G4Alpha::Alpha();
// DNA ions
G4DNAGenericIonsManager* genericIonsManager
= G4DNAGenericIonsManager::Instance();
genericIonsManager->GetIon("alpha+");
genericIonsManager->GetIon("helium");
genericIonsManager->GetIon("hydrogen");
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void
G4EmDNABuilder::ConstructStandardEmPhysics(const G4double emin_elec,
const G4double emin_proton,
const G4double emin_alpha,
const G4double emin_ion,
const G4EmDNAMscModelType mscType,
const G4bool)
{
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
G4EmParameters* param = G4EmParameters::Instance();
const G4double emax = param->MaxKinEnergy();
G4EmBuilder::PrepareEMPhysics();
// gamma
G4ParticleDefinition* gamma = G4Gamma::Gamma();
// photoelectric effect - Livermore model
G4PhotoElectricEffect* thePEEffect = new G4PhotoElectricEffect();
thePEEffect->SetEmModel(new G4LivermorePhotoElectricModel());
ph->RegisterProcess(thePEEffect, gamma);
// Compton scattering - Klein-Nishina
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
theComptonScattering->SetEmModel(new G4KleinNishinaModel());
auto cModel = new G4LowEPComptonModel();
cModel->SetHighEnergyLimit(20*CLHEP::MeV);
theComptonScattering->AddEmModel(0, cModel);
ph->RegisterProcess(theComptonScattering, gamma);
// gamma conversion - 5D model
G4GammaConversion* theGammaConversion = new G4GammaConversion();
ph->RegisterProcess(theGammaConversion, gamma);
// Rayleigh scattering - Livermore model
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
ph->RegisterProcess(theRayleigh, gamma);
// electron
if(emin_elec < 0.5*MeV) {
G4ParticleDefinition* elec = G4Electron::Electron();
G4eMultipleScattering* msc_el = new G4eMultipleScattering();
G4VMscModel* msc_model_el;
if(mscType == dnaWVI) {
msc_model_el = new G4LowEWentzelVIModel();
} else if(mscType == dnaGS) {
msc_model_el = new G4GoudsmitSaundersonMscModel();
} else {
msc_model_el = new G4UrbanMscModel();
}
msc_model_el->SetActivationLowEnergyLimit(emin_elec);
msc_model_el->SetHighEnergyLimit(emax);
msc_el->SetEmModel(msc_model_el);
ph->RegisterProcess(msc_el, elec);
G4eIonisation* ioni = new G4eIonisation();
G4VEmModel* mb_el = new G4MollerBhabhaModel();
mb_el->SetActivationLowEnergyLimit(emin_elec);
mb_el->SetHighEnergyLimit(emax);
ioni->SetEmModel(mb_el);
ph->RegisterProcess(ioni, elec);
G4eBremsstrahlung* brem = new G4eBremsstrahlung();
G4VEmModel* sb_el = new G4SeltzerBergerModel();
sb_el->SetActivationLowEnergyLimit(emin_elec);
sb_el->SetHighEnergyLimit(emax);
sb_el->SetAngularDistribution(new G4Generator2BS());
brem->SetEmModel(sb_el);
ph->RegisterProcess(brem, elec);
}
// positron
G4ParticleDefinition* posi = G4Positron::Positron();
G4eMultipleScattering* msc_pos = new G4eMultipleScattering();
G4VMscModel* msc_model_pos;
if(mscType == dnaWVI) {
msc_model_pos = new G4LowEWentzelVIModel();
} else if(mscType == dnaGS) {
msc_model_pos = new G4GoudsmitSaundersonMscModel();
} else {
msc_model_pos = new G4UrbanMscModel();
}
msc_pos->SetEmModel(msc_model_pos);
ph->RegisterProcess(msc_pos, posi);
ph->RegisterProcess(new G4eIonisation(), posi);
ph->RegisterProcess(new G4eBremsstrahlung(), posi);
// proton
G4ParticleDefinition* part = G4Proton::Proton();
if(emin_proton < 0.5*CLHEP::MeV) {
G4hMultipleScattering* msc_p = new G4hMultipleScattering();
G4VMscModel* msc_model_p;
if(mscType == dnaWVI) {
msc_model_p = new G4LowEWentzelVIModel();
} else {
msc_model_p = new G4UrbanMscModel();
}
msc_model_p->SetActivationLowEnergyLimit(emin_proton);
msc_p->SetEmModel(msc_model_p);
ph->RegisterProcess(msc_p, part);
G4hIonisation* ioni = new G4hIonisation();
G4VEmModel* br = new G4BraggModel();
br->SetActivationLowEnergyLimit(emin_proton);
ioni->SetEmModel(br);
G4VEmModel* be = new G4BetheBlochModel();
be->SetActivationLowEnergyLimit(emin_proton);
be->SetHighEnergyLimit(emax);
ioni->SetEmModel(be);
ph->RegisterProcess(ioni, part);
}
// GenericIon
if(emin_ion < 0.5*MeV) {
G4ParticleDefinition* ion = G4GenericIon::GenericIon();
G4hMultipleScattering* msc_ion = new G4hMultipleScattering();
auto imsc = new G4UrbanMscModel();
msc_ion->SetEmModel(imsc);
ph->RegisterProcess(msc_ion, ion);
G4ionIonisation* ioni = new G4ionIonisation();
G4VEmModel* br = new G4BraggIonModel();
br->SetActivationLowEnergyLimit(emin_ion);
ioni->SetEmModel(br);
G4VEmModel* be = new G4BetheBlochModel();
be->SetActivationLowEnergyLimit(emin_ion);
be->SetHighEnergyLimit(emax);
ioni->SetEmModel(be);
ph->RegisterProcess(ioni, ion);
}
// alpha
part = G4Alpha::Alpha();
if(emin_alpha < emax) {
G4hMultipleScattering* msc_a = new G4hMultipleScattering();
G4VMscModel* msc_model_a = new G4UrbanMscModel();
msc_model_a->SetActivationLowEnergyLimit(emin_alpha);
msc_a->SetEmModel(msc_model_a);
ph->RegisterProcess(msc_a, part);
G4ionIonisation* ioni = new G4ionIonisation();
G4VEmModel* br = new G4BraggIonModel();
br->SetActivationLowEnergyLimit(emin_alpha);
ioni->SetEmModel(br);
G4VEmModel* be = new G4BetheBlochModel();
be->SetActivationLowEnergyLimit(emin_alpha);
be->SetHighEnergyLimit(emax);
ioni->SetEmModel(be);
ph->RegisterProcess(ioni, part);
}
// alpha+
G4DNAGenericIonsManager* genericIonsManager
= G4DNAGenericIonsManager::Instance();
part = genericIonsManager->GetIon("alpha+");
if(emin_alpha < emax) {
G4hMultipleScattering* msc_a = new G4hMultipleScattering();
G4VMscModel* msc_model_a = new G4UrbanMscModel();
msc_model_a->SetActivationLowEnergyLimit(emin_alpha);
msc_a->SetEmModel(msc_model_a);
ph->RegisterProcess(msc_a, part);
G4hIonisation* ioni = new G4hIonisation();
G4VEmModel* br = new G4BraggModel();
br->SetActivationLowEnergyLimit(emin_alpha);
ioni->SetEmModel(br);
G4VEmModel* be = new G4BetheBlochModel();
be->SetActivationLowEnergyLimit(emin_alpha);
be->SetHighEnergyLimit(emax);
ioni->SetEmModel(be);
ph->RegisterProcess(ioni, part);
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void
G4EmDNABuilder::ConstructDNAElectronPhysics(const G4double emaxDNA,
const G4int opt,
const G4bool fast,
const G4bool stationary,
const G4Region* reg)
{
G4ParticleDefinition* part = G4Electron::Electron();
// limit of the Emfietzoglou models
G4double emaxE = 0.0;
// limit of the elastic and solvation models
G4double emaxT = 7.4*CLHEP::eV;
// limit for CPA100 models
G4double emaxCPA100 = 250*CLHEP::keV;
if(4 == opt) {
emaxE = 10.*CLHEP::keV;
emaxT = 10.*CLHEP::eV;
} else if(5 < opt) {
emaxT = 11.*CLHEP::eV;
}
// *** Solvation ***
G4DNAElectronSolvation* pSolvation = FindOrBuildElectronSolvation();
auto therm = G4DNASolvationModelFactory::GetMacroDefinedModel();
therm->SetHighEnergyLimit(emaxT);
pSolvation->AddEmModel(-1, therm, reg);
// *** Elastic scattering ***
auto pElasticProcess = FindOrBuildElastic(part, "e-_G4DNAElastic");
G4VEmModel* elast = nullptr;
G4VEmModel* elast2 = nullptr;
if(4 == opt) {
elast = new G4DNAUeharaScreenedRutherfordElasticModel();
} else if(5 < opt) {
auto mod = new G4DNACPA100ElasticModel();
mod->SelectStationary(stationary);
elast = mod;
elast2 = new G4DNAChampionElasticModel();
} else {
elast = new G4DNAChampionElasticModel();
}
elast->SetHighEnergyLimit(emaxDNA);
pElasticProcess->AddEmModel(-2, elast, reg);
if(nullptr != elast2) {
elast->SetHighEnergyLimit(emaxCPA100);
elast2->SetLowEnergyLimit(emaxCPA100);
elast2->SetHighEnergyLimit(emaxDNA);
pElasticProcess->AddEmModel(-3, elast2, reg);
}
// *** Excitation ***
auto theDNAExc = FindOrBuildExcitation(part, "e-_G4DNAExcitation");
if(emaxE > 0.0) {
auto modE = new G4DNAEmfietzoglouExcitationModel();
theDNAExc->AddEmModel(-1, modE, reg);
modE->SelectStationary(stationary);
modE->SetHighEnergyLimit(emaxE);
}
G4VEmModel* modB = nullptr;
G4VEmModel* modB2 = nullptr;
if(6 == opt) {
auto mod = new G4DNACPA100ExcitationModel();
mod->SelectStationary(stationary);
modB = mod;
auto mod1 = new G4DNABornExcitationModel();
mod1->SelectStationary(stationary);
modB2 = mod1;
} else {
auto mod = new G4DNABornExcitationModel();
mod->SelectStationary(stationary);
modB = mod;
}
modB->SetLowEnergyLimit(emaxE);
modB->SetHighEnergyLimit(emaxDNA);
theDNAExc->AddEmModel(-2, modB, reg);
if(nullptr != modB2) {
modB->SetHighEnergyLimit(emaxCPA100);
modB2->SetLowEnergyLimit(emaxCPA100);
modB2->SetHighEnergyLimit(emaxDNA);
theDNAExc->AddEmModel(-3, modB2, reg);
}
// *** Ionisation ***
auto theDNAIoni = FindOrBuildIonisation(part, "e-_G4DNAIonisation");
if(emaxE > 0.0) {
auto modE = new G4DNAEmfietzoglouIonisationModel();
theDNAIoni->AddEmModel(-1, modE, reg);
modE->SelectFasterComputation(fast);
modE->SelectStationary(stationary);
modE->SetHighEnergyLimit(emaxE);
}
G4VEmModel* modI = nullptr;
G4VEmModel* modI2 = nullptr;
if(6 == opt) {
auto mod = new G4DNACPA100IonisationModel();
mod->SelectStationary(stationary);
mod->SelectFasterComputation(fast);
modI = mod;
auto mod1 = new G4DNABornIonisationModel();
mod1->SelectStationary(stationary);
modI2 = mod1;
} else {
auto mod = new G4DNABornIonisationModel1();
mod->SelectStationary(stationary);
mod->SelectFasterComputation(fast);
modI = mod;
}
modI->SetLowEnergyLimit(emaxE);
modI->SetHighEnergyLimit(emaxDNA);
theDNAIoni->AddEmModel(-2, modI, reg);
if(nullptr != modI2) {
modI->SetHighEnergyLimit(emaxCPA100);
modI2->SetLowEnergyLimit(emaxCPA100);
modI2->SetHighEnergyLimit(emaxDNA);
theDNAIoni->AddEmModel(-3, modI2, reg);
}
if(4 != opt && 6 != opt) {
// *** Vibrational excitation ***
auto theDNAVibExc = FindOrBuildVibExcitation(part, "e-_G4DNAVibExcitation");
auto modS = new G4DNASancheExcitationModel();
theDNAVibExc->AddEmModel(-1, modS, reg);
modS->SelectStationary(stationary);
// *** Attachment ***
auto theDNAAttach = FindOrBuildAttachment(part, "e-_G4DNAAttachment");
auto modM = new G4DNAMeltonAttachmentModel();
theDNAAttach->AddEmModel(-1, modM, reg);
modM->SelectStationary(stationary);
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void
G4EmDNABuilder::ConstructDNAProtonPhysics(const G4double e1DNA,
const G4double emaxDNA,
const G4int opt,
const G4bool fast,
const G4bool stationary,
const G4Region* reg)
{
G4EmParameters* param = G4EmParameters::Instance();
const G4double emax = param->MaxKinEnergy();
G4ParticleDefinition* part = G4Proton::Proton();
// *** Elastic scattering ***
auto pElasticProcess = FindOrBuildElastic(part, "proton_G4DNAElastic");
auto modE = new G4DNAIonElasticModel();
modE->SetHighEnergyLimit(emaxDNA);
modE->SelectStationary(stationary);
pElasticProcess->AddEmModel(-1, modE, reg);
// *** Excitation ***
auto theDNAExc = FindOrBuildExcitation(part, "proton_G4DNAExcitation");
auto modMGE = new G4DNAMillerGreenExcitationModel();
modMGE->SetHighEnergyLimit(e1DNA);
modMGE->SelectStationary(stationary);
theDNAExc->AddEmModel(-1, modMGE, reg);
auto modB = new G4DNABornExcitationModel();
modB->SelectStationary(stationary);
modB->SetLowEnergyLimit(e1DNA);
modB->SetHighEnergyLimit(emax);
theDNAExc->AddEmModel(-2, modB, reg);
// *** Ionisation ***
auto theDNAIoni = FindOrBuildIonisation(part, "proton_G4DNAIonisation");
G4VEmModel* modRI = nullptr;
if(2 == opt) {
auto mod = new G4DNARuddIonisationExtendedModel();
mod->SelectStationary(stationary);
modRI = mod;
} else {
auto mod = new G4DNARuddIonisationModel();
mod->SelectStationary(stationary);
modRI = mod;
}
modRI->SetHighEnergyLimit(e1DNA);
theDNAIoni->AddEmModel(-1, modRI, reg);
auto modI = new G4DNABornIonisationModel1();
theDNAIoni->SetEmModel(modI);
modI->SelectFasterComputation(fast);
modI->SelectStationary(stationary);
modI->SetLowEnergyLimit(e1DNA);
modI->SetHighEnergyLimit(emaxDNA);
theDNAIoni->AddEmModel(-2, modI, reg);
// *** Charge decrease ***
auto theDNAChargeDecreaseProcess =
FindOrBuildChargeDecrease(part, "proton_G4DNAChargeDecrease");
auto modDCD = new G4DNADingfelderChargeDecreaseModel();
modDCD->SelectStationary(stationary);
modDCD->SetLowEnergyLimit(0.0);
modDCD->SetHighEnergyLimit(emax);
theDNAChargeDecreaseProcess->AddEmModel(-1, modDCD, reg);
FindOrBuildCapture(0.1*CLHEP::keV, part);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void
G4EmDNABuilder::ConstructDNAIonPhysics(const G4double emaxDNA,
const G4bool stationary,
const G4Region* reg)
{
G4ParticleDefinition* part = G4GenericIon::GenericIon();
// *** Ionisation ***
auto theDNAIoni = FindOrBuildIonisation(part, "GenericIon_G4DNAIonisation");
auto mod = new G4DNARuddIonisationExtendedModel();
mod->SelectStationary(stationary);
mod->SetHighEnergyLimit(emaxDNA);
theDNAIoni->AddEmModel(-1, mod, reg);
FindOrBuildCapture(25.0*CLHEP::keV, part);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void
G4EmDNABuilder::ConstructDNALightIonPhysics(G4ParticleDefinition* part,
const G4int charge,
const G4int opt,
const G4double emaxDNA,
const G4bool,
const G4bool stationary,
const G4Region* reg)
{
G4EmParameters* param = G4EmParameters::Instance();
const G4double emax = param->MaxKinEnergy();
const G4String& name = part->GetParticleName();
// *** Elastic ***
auto theDNAElastic = FindOrBuildElastic(part, name + "_G4DNAElastic");
auto modEI = new G4DNAIonElasticModel();
modEI->SelectStationary(stationary);
modEI->SetHighEnergyLimit(emaxDNA);
theDNAElastic->AddEmModel(-1, modEI, reg);
// *** Excitation ***
auto theDNAExc = FindOrBuildExcitation(part, name + "_G4DNAExcitation");
auto modMGE = new G4DNAMillerGreenExcitationModel();
modMGE->SelectStationary(stationary);
modMGE->SetLowEnergyLimit(0.0);
modMGE->SetHighEnergyLimit(emax);
theDNAExc->AddEmModel(-1, modMGE, reg);
// *** Ionisation ***
auto theDNAIoni = FindOrBuildIonisation(part, name + "_G4DNAIonisation");
G4VEmModel* modRI = nullptr;
if(2 == opt) {
auto mod = new G4DNARuddIonisationExtendedModel();
mod->SelectStationary(stationary);
modRI = mod;
} else {
auto mod = new G4DNARuddIonisationModel();
mod->SelectStationary(stationary);
modRI = mod;
}
modRI->SetHighEnergyLimit(emaxDNA);
theDNAIoni->AddEmModel(-1, modRI, reg);
// *** Charge increase ***
if(2 > charge) {
auto theDNAChargeIncrease =
FindOrBuildChargeIncrease(part, name + "_G4DNAChargeIncrease");
auto modDCI = new G4DNADingfelderChargeIncreaseModel();
modDCI->SelectStationary(stationary);
modDCI->SetLowEnergyLimit(0.0);
modDCI->SetHighEnergyLimit(emax);
theDNAChargeIncrease->AddEmModel(-1, modDCI, reg);
}
// *** Charge decrease ***
if(0 < charge) {
auto theDNAChargeDecrease =
FindOrBuildChargeDecrease(part, name + "_G4DNAChargeDecrease");
auto modDCD = new G4DNADingfelderChargeDecreaseModel();
modDCD->SelectStationary(stationary);
modDCD->SetLowEnergyLimit(0.0);
modDCD->SetHighEnergyLimit(emax);
theDNAChargeDecrease->AddEmModel(-1, modDCD, reg);
}
FindOrBuildCapture(1*CLHEP::keV, part);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4DNAElectronSolvation* G4EmDNABuilder::FindOrBuildElectronSolvation()
{
auto elec = G4Electron::Electron();
auto* p = G4PhysListUtil::FindProcess(elec, fLowEnergyElectronSolvation);
G4DNAElectronSolvation* ptr = dynamic_cast<G4DNAElectronSolvation*>(p);
if(nullptr == ptr) {
ptr = new G4DNAElectronSolvation("e-_G4DNAElectronSolvation");
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
ph->RegisterProcess(ptr, elec);
ptr->SetEmModel(new G4DummyModel());
}
return ptr;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4DNAElastic*
G4EmDNABuilder::FindOrBuildElastic(G4ParticleDefinition* part,
const G4String& name)
{
auto p = G4PhysListUtil::FindProcess(part, fLowEnergyElastic);
G4DNAElastic* ptr = dynamic_cast<G4DNAElastic*>(p);
if(nullptr == ptr) {
ptr = new G4DNAElastic(name);
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
ph->RegisterProcess(ptr, part);
ptr->SetEmModel(new G4DummyModel());
}
return ptr;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4DNAExcitation*
G4EmDNABuilder::FindOrBuildExcitation(G4ParticleDefinition* part,
const G4String& name)
{
auto p = G4PhysListUtil::FindProcess(part, fLowEnergyExcitation);
G4DNAExcitation* ptr = dynamic_cast<G4DNAExcitation*>(p);
if(nullptr == ptr) {
ptr = new G4DNAExcitation(name);
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
ph->RegisterProcess(ptr, part);
ptr->SetEmModel(new G4DummyModel());
}
return ptr;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4DNAVibExcitation*
G4EmDNABuilder::FindOrBuildVibExcitation(G4ParticleDefinition* part,
const G4String& name)
{
auto p = G4PhysListUtil::FindProcess(part, fLowEnergyVibrationalExcitation);
G4DNAVibExcitation* ptr = dynamic_cast<G4DNAVibExcitation*>(p);
if(nullptr == ptr) {
ptr = new G4DNAVibExcitation(name);
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
ph->RegisterProcess(ptr, part);
ptr->SetEmModel(new G4DummyModel());
}
return ptr;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4DNAIonisation*
G4EmDNABuilder::FindOrBuildIonisation(G4ParticleDefinition* part,
const G4String& name)
{
auto p = G4PhysListUtil::FindProcess(part, fLowEnergyIonisation);
G4DNAIonisation* ptr = dynamic_cast<G4DNAIonisation*>(p);
if(nullptr == ptr) {
ptr = new G4DNAIonisation(name);
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
ph->RegisterProcess(ptr, part);
ptr->SetEmModel(new G4DummyModel());
}
return ptr;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4DNAAttachment*
G4EmDNABuilder::FindOrBuildAttachment(G4ParticleDefinition* part,
const G4String& name)
{
auto p = G4PhysListUtil::FindProcess(part, fLowEnergyAttachment);
G4DNAAttachment* ptr = dynamic_cast<G4DNAAttachment*>(p);
if(nullptr == ptr) {
ptr = new G4DNAAttachment(name);
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
ph->RegisterProcess(ptr, part);
ptr->SetEmModel(new G4DummyModel());
}
return ptr;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4DNAChargeDecrease*
G4EmDNABuilder::FindOrBuildChargeDecrease(G4ParticleDefinition* part,
const G4String& name)
{
auto p = G4PhysListUtil::FindProcess(part, fLowEnergyChargeDecrease);
G4DNAChargeDecrease* ptr = dynamic_cast<G4DNAChargeDecrease*>(p);
if(nullptr == ptr) {
ptr = new G4DNAChargeDecrease(name);
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
ph->RegisterProcess(ptr, part);
ptr->SetEmModel(new G4DummyModel());
}
return ptr;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4DNAChargeIncrease*
G4EmDNABuilder::FindOrBuildChargeIncrease(G4ParticleDefinition* part,
const G4String& name)
{
auto p = G4PhysListUtil::FindProcess(part, fLowEnergyChargeIncrease);
G4DNAChargeIncrease* ptr = dynamic_cast<G4DNAChargeIncrease*>(p);
if(nullptr == ptr) {
ptr = new G4DNAChargeIncrease(name);
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
ph->RegisterProcess(ptr, part);
ptr->SetEmModel(new G4DummyModel());
}
return ptr;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4LowECapture*
G4EmDNABuilder::FindOrBuildCapture(const G4double elim, G4ParticleDefinition* part)
{
auto p = G4PhysListUtil::FindProcess(part, 66);
G4LowECapture* ptr = dynamic_cast<G4LowECapture*>(p);
if(nullptr == ptr) {
ptr = new G4LowECapture(elim);
auto mng = part->GetProcessManager();
mng->AddDiscreteProcess(ptr);
}
return ptr;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmDNAChemistry_option3.cc
+187 -53
View File
@@ -29,6 +29,7 @@
* Created on: Jul 23, 2019
* Author: W. G. Shin
* J. Ramos-Mendez and B. Faddegon
* Updated: Hoang Tran : add SBS and IRT_syn models
*/
#include "G4EmDNAChemistry_option3.hh"
@@ -61,6 +62,7 @@
#include "G4DNAMolecularStepByStepModel.hh"
#include "G4DNAMolecularIRTModel.hh"
#include "G4DNAIndependentReactionTimeModel.hh"
#include "G4VDNAReactionModel.hh"
#include "G4DNASmoluchowskiReactionModel.hh"
@@ -689,84 +691,121 @@ void G4EmDNAChemistry_option3::ConstructReactionTable(G4DNAMolecularReactionTabl
// *OH + *H -> H2O
reactionData = new G4DNAMolecularReactionData(
1.55e10 * (1e-3 * m3 / (mole * s)), OH, H);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// H + H2O2 -> OH
reactionData = new G4DNAMolecularReactionData(
3.50e7 * (1e-3 * m3 / (mole * s)), H, H2O2);
reactionData->AddProduct(OH);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// H + OH- -> eaq-
reactionData = new G4DNAMolecularReactionData(
2.51e7 * (1e-3 * m3 / (mole * s)), H, OHm);
reactionData->AddProduct(e_aq);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// H + O2 -> HO2
reactionData = new G4DNAMolecularReactionData(
2.10e10 * (1e-3 * m3 / (mole * s)), H, O2);
reactionData->AddProduct(HO2);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// H + HO2 -> H2O2
reactionData = new G4DNAMolecularReactionData(
1.00e10 * (1e-3 * m3 / (mole * s)), H, HO2);
reactionData->AddProduct(H2O2);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// H + O2- -> HO2-
reactionData = new G4DNAMolecularReactionData(
1.00e10 * (1e-3 * m3 / (mole * s)), H, O2m);
reactionData->AddProduct(HO2m);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// *OH + *OH -> H2O2
reactionData = new G4DNAMolecularReactionData(
0.55e10 * (1e-3 * m3 / (mole * s)), OH, OH);
reactionData->AddProduct(H2O2);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// OH + H2O2 -> HO2
reactionData = new G4DNAMolecularReactionData(
2.88e7 * (1e-3 * m3 / (mole * s)), OH, H2O2);
reactionData->AddProduct(HO2);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// OH + H2 -> H
reactionData = new G4DNAMolecularReactionData(
3.28e7 * (1e-3 * m3 / (mole * s)), OH, H2);
reactionData->AddProduct(H);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// e_aq + *OH -> OH-
reactionData = new G4DNAMolecularReactionData(
2.95e10 * (1e-3 * m3 / (mole * s)), e_aq, OH);
reactionData->AddProduct(OHm);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// OH + OH- -> O-
reactionData = new G4DNAMolecularReactionData(
6.30e9 * (1e-3 * m3 / (mole * s)), OH, OHm);
reactionData->AddProduct(Om);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// OH + HO2 -> O2
reactionData = new G4DNAMolecularReactionData(
7.90e9 * (1e-3 * m3 / (mole * s)), OH, HO2);
reactionData->AddProduct(O2);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// OH + O2- -> O2 + OH-
@@ -774,7 +813,10 @@ void G4EmDNAChemistry_option3::ConstructReactionTable(G4DNAMolecularReactionTabl
1.07e10 * (1e-3 * m3 / (mole * s)), OH, O2m);
reactionData->AddProduct(O2);
reactionData->AddProduct(OHm);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// OH + HO2- -> HO2 + OH-
@@ -782,14 +824,20 @@ void G4EmDNAChemistry_option3::ConstructReactionTable(G4DNAMolecularReactionTabl
8.32e9 * (1e-3 * m3 / (mole * s)), OH, HO2m);
reactionData->AddProduct(HO2);
reactionData->AddProduct(OHm);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// OH + O- -> HO2-
reactionData = new G4DNAMolecularReactionData(
1.00e9 * (1e-3 * m3 / (mole * s)), OH, Om);
reactionData->AddProduct(HO2m);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// OH + O3- -> O2- + HO2
@@ -797,7 +845,10 @@ void G4EmDNAChemistry_option3::ConstructReactionTable(G4DNAMolecularReactionTabl
8.50e9 * (1e-3 * m3 / (mole * s)), OH, O3m);
reactionData->AddProduct(O2m);
reactionData->AddProduct(HO2);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// e_aq + H2O2 -> OH- + *OH
@@ -805,14 +856,20 @@ void G4EmDNAChemistry_option3::ConstructReactionTable(G4DNAMolecularReactionTabl
1.10e10 * (1e-3 * m3 / (mole * s)), e_aq, H2O2);
reactionData->AddProduct(OHm);
reactionData->AddProduct(OH);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// H2O2 + OH- -> HO2-
reactionData = new G4DNAMolecularReactionData(
4.71e8 * (1e-3 * m3 / (mole * s)), H2O2, OHm);
reactionData->AddProduct(HO2m);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// H2O2 + O(3p) -> HO2 + OH
@@ -820,7 +877,10 @@ void G4EmDNAChemistry_option3::ConstructReactionTable(G4DNAMolecularReactionTabl
1.60e9 * (1e-3 * m3 / (mole * s)), H2O2, O);
reactionData->AddProduct(HO2);
reactionData->AddProduct(OH);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// H2O2 + O- -> HO2 + OH-
@@ -828,7 +888,10 @@ void G4EmDNAChemistry_option3::ConstructReactionTable(G4DNAMolecularReactionTabl
5.55e8 * (1e-3 * m3 / (mole * s)), H2O2, Om);
reactionData->AddProduct(HO2);
reactionData->AddProduct(OHm);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// H2 + O(3p) -> H + OH
@@ -836,7 +899,10 @@ void G4EmDNAChemistry_option3::ConstructReactionTable(G4DNAMolecularReactionTabl
4.77e3 * (1e-3 * m3 / (mole * s)), H2, O);
reactionData->AddProduct(H);
reactionData->AddProduct(OH);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// H2 + O- -> H + OH-
@@ -844,49 +910,70 @@ void G4EmDNAChemistry_option3::ConstructReactionTable(G4DNAMolecularReactionTabl
1.21e8 * (1e-3 * m3 / (mole * s)), H2, Om);
reactionData->AddProduct(H);
reactionData->AddProduct(OHm);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// eaq- + O2 -> O2-
reactionData = new G4DNAMolecularReactionData(
1.74e10 * (1e-3 * m3 / (mole * s)), e_aq, O2);
reactionData->AddProduct(O2m);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// eaq + HO2 -> HO2-
reactionData = new G4DNAMolecularReactionData(
1.29e10 * (1e-3 * m3 / (mole * s)), e_aq, HO2);
reactionData->AddProduct(HO2m);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// OH- + HO2 -> O2-
reactionData = new G4DNAMolecularReactionData(
6.30e9 * (1e-3 * m3 / (mole * s)), OHm, HO2);
reactionData->AddProduct(O2m);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// OH- + O(3p) -> HO2-
reactionData = new G4DNAMolecularReactionData(
4.20e8 * (1e-3 * m3 / (mole * s)), OHm, O);
reactionData->AddProduct(HO2m);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// O2 + O(3p) -> O3
reactionData = new G4DNAMolecularReactionData(
4.00e9 * (1e-3 * m3 / (mole * s)), O2, O);
reactionData->AddProduct(O3);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// O2 + O- -> O3-
reactionData = new G4DNAMolecularReactionData(
3.70e9 * (1e-3 * m3 / (mole * s)), O2, Om);
reactionData->AddProduct(O3m);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// HO2 + HO2 -> H2O2 + O2
@@ -894,7 +981,10 @@ void G4EmDNAChemistry_option3::ConstructReactionTable(G4DNAMolecularReactionTabl
9.80e5 * (1e-3 * m3 / (mole * s)), HO2, HO2);
reactionData->AddProduct(H2O2);
reactionData->AddProduct(O2);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// HO2 + O2- -> HO2- + O2
@@ -902,7 +992,10 @@ void G4EmDNAChemistry_option3::ConstructReactionTable(G4DNAMolecularReactionTabl
9.70e7 * (1e-3 * m3 / (mole * s)), HO2, O2m);
reactionData->AddProduct(HO2m);
reactionData->AddProduct(O2);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// HO2- + O(3p) -> O2- + OH
@@ -910,7 +1003,10 @@ void G4EmDNAChemistry_option3::ConstructReactionTable(G4DNAMolecularReactionTabl
5.30e9 * (1e-3 * m3 / (mole * s)), HO2m, O);
reactionData->AddProduct(O2m);
reactionData->AddProduct(OH);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
// Type IV //
@@ -919,7 +1015,10 @@ void G4EmDNAChemistry_option3::ConstructReactionTable(G4DNAMolecularReactionTabl
reactionData = new G4DNAMolecularReactionData(
2.11e10 * (1e-3 * m3 / (mole * s)), e_aq, H3Op);
reactionData->AddProduct(H);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// e_aq + O2- -> H2O2 + OH- + OH-
@@ -928,7 +1027,10 @@ void G4EmDNAChemistry_option3::ConstructReactionTable(G4DNAMolecularReactionTabl
reactionData->AddProduct(H2O2);
reactionData->AddProduct(OHm);
reactionData->AddProduct(OHm);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// e_aq + HO2- -> O- + OH-
@@ -936,7 +1038,10 @@ void G4EmDNAChemistry_option3::ConstructReactionTable(G4DNAMolecularReactionTabl
3.51e9 * (1e-3 * m3 / (mole * s)), e_aq, HO2m);
reactionData->AddProduct(Om);
reactionData->AddProduct(OHm);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// e_aq + O- -> OH- + OH-
@@ -944,28 +1049,40 @@ void G4EmDNAChemistry_option3::ConstructReactionTable(G4DNAMolecularReactionTabl
2.31e10 * (1e-3 * m3 / (mole * s)), e_aq, Om);
reactionData->AddProduct(OHm);
reactionData->AddProduct(OHm);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// H3O+ + O2- -> HO2
reactionData = new G4DNAMolecularReactionData(
4.78e10 * (1e-3 * m3 / (mole * s)), H3Op, O2m);
reactionData->AddProduct(HO2);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// H3O+ + HO2- -> H2O2
reactionData = new G4DNAMolecularReactionData(
5.00e10 * (1e-3 * m3 / (mole * s)), H3Op, HO2m);
reactionData->AddProduct(H2O2);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// H3O+ + O- -> OH
reactionData = new G4DNAMolecularReactionData(
4.78e10 * (1e-3 * m3 / (mole * s)), H3Op, Om);
reactionData->AddProduct(OH);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// O2- + O- -> O2 + OH- + OH-
@@ -974,7 +1091,10 @@ void G4EmDNAChemistry_option3::ConstructReactionTable(G4DNAMolecularReactionTabl
reactionData->AddProduct(O2);
reactionData->AddProduct(OHm);
reactionData->AddProduct(OHm);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// HO2- + O- -> O2- + OH-
@@ -982,7 +1102,10 @@ void G4EmDNAChemistry_option3::ConstructReactionTable(G4DNAMolecularReactionTabl
3.50e8 * (1e-3 * m3 / (mole * s)), HO2m, Om);
reactionData->AddProduct(O2m);
reactionData->AddProduct(OHm);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// O- + O- -> H2O2 + OH- + OH-
@@ -991,7 +1114,10 @@ void G4EmDNAChemistry_option3::ConstructReactionTable(G4DNAMolecularReactionTabl
reactionData->AddProduct(H2O2);
reactionData->AddProduct(OHm);
reactionData->AddProduct(OHm);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
//------------------------------------------------------------------
// O- + O3- -> O2- + O2-
@@ -999,7 +1125,10 @@ void G4EmDNAChemistry_option3::ConstructReactionTable(G4DNAMolecularReactionTabl
7.00e8 * (1e-3 * m3 / (mole * s)), Om, O3m);
reactionData->AddProduct(O2m);
reactionData->AddProduct(O2m);
reactionData->SetReactionType(1);
if(fTimeStepModel != fSBS)
{
reactionData->SetReactionType(1);
}
theReactionTable->SetReaction(reactionData);
// Type VI
@@ -1195,15 +1324,17 @@ void G4EmDNAChemistry_option3::ConstructProcess()
if (moleculeDef != G4H2O::Definition())
{
// G4cout << "Brownian motion added for: "<< moleculeDef->GetName() << G4endl;
// G4DNABrownianTransportation* brown = new G4DNABrownianTransportation();
// ph->RegisterProcess(brown, moleculeDef);
if(fTimeStepModel != fIRT)
{
auto* brown = new G4DNABrownianTransportation();
ph->RegisterProcess(brown, moleculeDef);
}
}
else
{
moleculeDef->GetProcessManager()
->AddRestProcess(new G4DNAElectronHoleRecombination(), 2);
G4DNAMolecularDissociation* dissociationProcess =
auto* dissociationProcess =
new G4DNAMolecularDissociation("H2O_DNAMolecularDecay");
dissociationProcess->SetDisplacer(
moleculeDef, new G4DNAWaterDissociationDisplacer);
@@ -1226,12 +1357,15 @@ void G4EmDNAChemistry_option3::ConstructProcess()
void G4EmDNAChemistry_option3::ConstructTimeStepModel(G4DNAMolecularReactionTable*
/*reactionTable*/)
{
if(fTimeStepModel == fIRT)
{
RegisterTimeStepModel(new G4DNAMolecularIRTModel(), 0);
}else if(fTimeStepModel == fSBS)
{
RegisterTimeStepModel(new G4DNAMolecularStepByStepModel(), 0);
}else if(fTimeStepModel == fIRT_syn)
{
RegisterTimeStepModel(new G4DNAIndependentReactionTimeModel(), 0);
}
G4DNAMolecularIRTModel* irt =
new G4DNAMolecularIRTModel();
/*
G4DNAMolecularStepByStepModel* sbs =
new G4DNAMolecularStepByStepModel();
*/
RegisterTimeStepModel(irt, 0);
}
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics.cc
+41 -173
View File
@@ -23,50 +23,17 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// add elastic scattering processes of proton, hydrogen, helium, alpha+, alpha++
// S. Incerti (incerti@cenbg.in2p3.fr)
//
#include "G4EmDNAPhysics.hh"
#include "G4EmDNABuilder.hh"
#include "G4SystemOfUnits.hh"
// *** Processes and models for Geant4-DNA
#include "G4DNAElectronSolvation.hh"
#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"
// ions
#include "G4Alpha.hh"
#include "G4GenericIon.hh"
#include "G4DNAGenericIonsManager.hh"
// 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 "G4KleinNishinaModel.hh"
#include "G4GammaConversion.hh"
#include "G4RayleighScattering.hh"
#include "G4BetheHeitler5DModel.hh"
// utilities
#include "G4EmParameters.hh"
#include "G4PhysicsListHelper.hh"
@@ -88,176 +55,77 @@ G4EmDNAPhysics::G4EmDNAPhysics(G4int ver, const G4String& name)
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetMinEnergy(10*CLHEP::eV);
param->SetMaxEnergy(100*CLHEP::MeV);
param->SetLowestElectronEnergy(0*CLHEP::eV);
param->SetNumberOfBinsPerDecade(20);
param->SetStepFunction(0.2, 100*CLHEP::um);
param->SetMscStepLimitType(fUseDistanceToBoundary);
param->SetLateralDisplacementAlg96(true);
param->ActivateAngularGeneratorForIonisation(true);
param->SetStepFunction(0.2, 10*CLHEP::um);
param->SetStepFunctionMuHad(0.1, 50*CLHEP::um);
param->SetStepFunctionLightIons(0.1, 20*CLHEP::um);
param->SetStepFunctionIons(0.1, 1*CLHEP::um);
param->SetUseICRU90Data(true);
param->SetUseMottCorrection(true);
param->SetMscStepLimitType(fUseSafetyPlus);
param->SetMscSkin(3);
param->SetMscRangeFactor(0.08);
param->SetFluo(true);
param->SetAuger(true);
param->SetDeexcitationIgnoreCut(true);
param->ActivateDNA();
param->SetDNAFast(false);
param->SetDNAStationary(false);
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics::~G4EmDNAPhysics()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics::ConstructParticle()
{
// bosons
G4Gamma::Gamma();
// leptons
G4Electron::Electron();
G4Positron::Positron();
// baryons
G4Proton::Proton();
G4GenericIon::GenericIonDefinition();
G4Alpha::Alpha();
G4DNAGenericIonsManager* genericIonsManager
= G4DNAGenericIonsManager::Instance();
//genericIonsManager->GetIon("alpha++");
genericIonsManager->GetIon("alpha+");
genericIonsManager->GetIon("helium");
genericIonsManager->GetIon("hydrogen");
//genericIonsManager->GetIon("carbon");
//genericIonsManager->GetIon("nitrogen");
//genericIonsManager->GetIon("oxygen");
//genericIonsManager->GetIon("iron");
G4EmDNABuilder::ConstructDNAParticles();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics::ConstructProcess()
{
// parameters
G4EmParameters* param = G4EmParameters::Instance();
const G4double emaxDNA = 1.*CLHEP::MeV;
const G4double emaxIonDNA = 100.*CLHEP::MeV;
const G4double eminBorn = 500.*CLHEP::keV;
const G4bool fast = param->DNAFast();
const G4bool st = param->DNAStationary();
if(verboseLevel > 1) {
G4cout << "### " << GetPhysicsName()
<< " Construct Processes " << G4endl;
<< " Construct Processes EmaxDNA(MeV)= "
<< emaxDNA/CLHEP::MeV << "; useMSC: " << fast
<< "; stationary: " << st << G4endl;
}
ConstructGammaPositronProcesses();
G4PhysicsListHelper* helper =
G4PhysicsListHelper::GetPhysicsListHelper();
G4DNAGenericIonsManager* genericIonsManager
= G4DNAGenericIonsManager::Instance();
// e-
G4ParticleDefinition* part = G4Electron::Electron();
// standard physics
G4EmDNABuilder::ConstructStandardEmPhysics(emaxDNA, emaxDNA,
emaxIonDNA, emaxIonDNA,
dnaGS, fast);
// *** Solvation ***
G4DNAElectronSolvation* pSolvation =
new G4DNAElectronSolvation("e-_G4DNAElectronSolvation");
auto pSolvationModel = G4DNASolvationModelFactory::GetMacroDefinedModel();
pSolvationModel->SetHighEnergyLimit(7.4*eV); // limit of the Champion's model
pSolvation->SetEmModel(pSolvationModel);
helper->RegisterProcess(pSolvation, part);
// *** Elastic scattering ***
G4DNAElastic* pElasticProcess = new G4DNAElastic("e-_G4DNAElastic");
pElasticProcess->SetEmModel(new G4DNAChampionElasticModel());
helper->RegisterProcess(pElasticProcess, part);
// DNA physics
G4EmDNABuilder::ConstructDNAElectronPhysics(emaxDNA, 0, fast, st);
G4EmDNABuilder::ConstructDNAProtonPhysics(eminBorn, emaxDNA, 0, fast, st);
G4EmDNABuilder::ConstructDNAIonPhysics(emaxIonDNA, st);
// *** Excitation ***
helper->RegisterProcess(new G4DNAExcitation("e-_G4DNAExcitation"), part);
G4ParticleDefinition* part = genericIonsManager->GetIon("hydrogen");
G4EmDNABuilder::ConstructDNALightIonPhysics(part, 0, 0, emaxDNA, fast, st);
// *** Ionisation ***
helper->RegisterProcess(new G4DNAIonisation("e-_G4DNAIonisation"), part);
// *** Vibrational excitation ***
helper->RegisterProcess(new G4DNAVibExcitation("e-_G4DNAVibExcitation"), part);
// *** Attachment ***
helper->RegisterProcess(new G4DNAAttachment("e-_G4DNAAttachment"), part);
// proton
part = G4Proton::Proton();
helper->RegisterProcess(new G4DNAElastic("proton_G4DNAElastic"), part);
helper->RegisterProcess(new G4DNAExcitation("proton_G4DNAExcitation"), part);
helper->RegisterProcess(new G4DNAIonisation("proton_G4DNAIonisation"), part);
helper->RegisterProcess(new G4DNAChargeDecrease("proton_G4DNAChargeDecrease"), part);
// hydrogen
part = genericIonsManager->GetIon("hydrogen");
helper->RegisterProcess(new G4DNAElastic("hydrogen_G4DNAElastic"), part);
helper->RegisterProcess(new G4DNAExcitation("hydrogen_G4DNAExcitation"), part);
helper->RegisterProcess(new G4DNAIonisation("hydrogen_G4DNAIonisation"), part);
helper->RegisterProcess(new G4DNAChargeIncrease("hydrogen_G4DNAChargeIncrease"), part);
// alpha++
part = G4Alpha::Alpha();
G4EmDNABuilder::ConstructDNALightIonPhysics(part, 2, 0, emaxDNA, fast, st);
helper->RegisterProcess(new G4DNAElastic("alpha_G4DNAElastic"), part);
helper->RegisterProcess(new G4DNAExcitation("alpha_G4DNAExcitation"), part);
helper->RegisterProcess(new G4DNAIonisation("alpha_G4DNAIonisation"), part);
helper->RegisterProcess(new G4DNAChargeDecrease("alpha_G4DNAChargeDecrease"), part);
// alpha+
part = genericIonsManager->GetIon("alpha+");
G4EmDNABuilder::ConstructDNALightIonPhysics(part, 1, 0, emaxDNA, fast, st);
helper->RegisterProcess(new G4DNAElastic("alpha+_G4DNAElastic"), part);
helper->RegisterProcess(new G4DNAExcitation("alpha+_G4DNAExcitation"), part);
helper->RegisterProcess(new G4DNAIonisation("alpha+_G4DNAIonisation"), part);
helper->RegisterProcess(new G4DNAChargeDecrease("alpha+_G4DNAChargeDecrease"), part);
helper->RegisterProcess(new G4DNAChargeIncrease("alpha+_G4DNAChargeIncrease"), part);
// helium
part = genericIonsManager->GetIon("helium");
helper->RegisterProcess(new G4DNAElastic("helium_G4DNAElastic"), part);
helper->RegisterProcess(new G4DNAExcitation("helium_G4DNAExcitation"), part);
helper->RegisterProcess(new G4DNAIonisation("helium_G4DNAIonisation"), part);
helper->RegisterProcess(new G4DNAChargeIncrease("helium_G4DNAChargeIncrease"), part);
// other ions
part = G4GenericIon::GenericIon();
helper->RegisterProcess(new G4DNAIonisation("GenericIon_G4DNAIonisation"), part);
}
void G4EmDNAPhysics::ConstructGammaPositronProcesses()
{
// this construction is based on G4EmStandardPhysics_option3
G4EmBuilder::PrepareEMPhysics();
G4PhysicsListHelper* helper = G4PhysicsListHelper::GetPhysicsListHelper();
G4ParticleDefinition* part = G4Gamma::Gamma();
// photoelectric effect - Livermore model
G4PhotoElectricEffect* thePEEffect = new G4PhotoElectricEffect();
thePEEffect->SetEmModel(new G4LivermorePhotoElectricModel());
helper->RegisterProcess(thePEEffect, part);
// Compton scattering - Klein-Nishina
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
theComptonScattering->SetEmModel(new G4KleinNishinaModel());
helper->RegisterProcess(theComptonScattering, part);
// gamma conversion - 5D model
G4GammaConversion* theGammaConversion = new G4GammaConversion();
theGammaConversion->SetEmModel(new G4BetheHeitler5DModel());
helper->RegisterProcess(theGammaConversion, part);
// Rayleigh scattering - Livermore model
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
helper->RegisterProcess(theRayleigh, part);
part = G4Positron::Positron();
helper->RegisterProcess(new G4eMultipleScattering(), part);
helper->RegisterProcess(new G4eIonisation(), part);
helper->RegisterProcess(new G4eBremsstrahlung(), part);
helper->RegisterProcess(new G4eplusAnnihilation(), part);
G4EmDNABuilder::ConstructDNALightIonPhysics(part, 0, 0, emaxDNA, fast, st);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysicsActivator.cc
+201 -1059
View File
File diff suppressed because it is too large Load Diff
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_option1.cc
+3 -288
View File
@@ -25,59 +25,7 @@
//
#include "G4EmDNAPhysics_option1.hh"
#include "G4SystemOfUnits.hh"
#include "G4DNAGenericIonsManager.hh"
// *** Processes and models for Geant4-DNA
#include "G4DNAElectronSolvation.hh"
#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"
#include "G4hMultipleScattering.hh"
#include "G4LowEWentzelVIModel.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"
@@ -86,17 +34,11 @@ G4_DECLARE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_option1);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option1::G4EmDNAPhysics_option1(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmDNAPhysics_option1"), verbose(ver)
G4EmDNAPhysics_option1::G4EmDNAPhysics_option1(G4int ver, const G4String& nam)
: G4EmDNAPhysics(ver, nam)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetFluo(true);
param->SetAuger(true);
param->SetDeexcitationIgnoreCut(true);
param->ActivateDNA();
SetPhysicsType(bElectromagnetic);
param->SetDNAFast(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
@@ -105,230 +47,3 @@ G4EmDNAPhysics_option1::~G4EmDNAPhysics_option1()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_option1::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");
//genericIonsManager->GetIon("carbon");
//genericIonsManager->GetIon("nitrogen");
//genericIonsManager->GetIon("oxygen");
//genericIonsManager->GetIon("iron");
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_option1::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
auto myParticleIterator=GetParticleIterator();
myParticleIterator->reset();
while( (*myParticleIterator)() )
{
G4ParticleDefinition* particle = myParticleIterator->value();
G4String particleName = particle->GetParticleName();
if (particleName == "e-") {
ph->RegisterProcess(new G4DNAElectronSolvation("e-_G4DNAElectronSolvation"),
particle);
/*
// THESE LINES MUST BE TESTED:
G4DNAElectronSolvation* solvation =
new G4DNAElectronSolvation("e-_G4DNAElectronSolvation");
auto therm = G4DNASolvationModelFactory::GetMacroDefinedModel();
therm->SetHighEnergyLimit(7.4*eV); // limit of the Champion's model
solvation->SetEmModel(therm);
ph->RegisterProcess(solvation, particle);
*/
// *** 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);
G4eMultipleScattering* msc = new G4eMultipleScattering();
msc->SetEmModel(new G4LowEWentzelVIModel());
ph->RegisterProcess(msc, 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" ) {
G4hMultipleScattering* msc = new G4hMultipleScattering();
msc->SetEmModel(new G4LowEWentzelVIModel());
ph->RegisterProcess(msc, 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 G4DNAExcitation("hydrogen_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("hydrogen_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("hydrogen_G4DNAChargeIncrease"), particle);
} else if ( particleName == "alpha" ) {
G4hMultipleScattering* msc = new G4hMultipleScattering();
msc->SetEmModel(new G4LowEWentzelVIModel());
ph->RegisterProcess(msc, 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+" ) {
G4hMultipleScattering* msc = new G4hMultipleScattering();
msc->SetEmModel(new G4LowEWentzelVIModel());
ph->RegisterProcess(msc, 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 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
// S. Incerti
} else if ( particleName == "GenericIon" ) {
G4hMultipleScattering* msc = new G4hMultipleScattering();
msc->SetEmModel(new G4LowEWentzelVIModel());
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(new G4DNAIonisation("GenericIon_G4DNAIonisation"), particle);
/*
} else if ( particleName == "carbon" ) {
G4hMultipleScattering* msc = new G4hMultipleScattering();
msc->SetEmModel(new G4LowEWentzelVIModel());
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(new G4DNAIonisation("carbon_G4DNAIonisation"), particle);
} else if ( particleName == "nitrogen" ) {
G4hMultipleScattering* msc = new G4hMultipleScattering();
msc->SetEmModel(new G4LowEWentzelVIModel());
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(new G4DNAIonisation("nitrogen_G4DNAIonisation"), particle);
} else if ( particleName == "oxygen" ) {
G4hMultipleScattering* msc = new G4hMultipleScattering();
msc->SetEmModel(new G4LowEWentzelVIModel());
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(new G4DNAIonisation("oxygen_G4DNAIonisation"), particle);
} else if ( particleName == "iron" ) {
G4hMultipleScattering* msc = new G4hMultipleScattering();
msc->SetEmModel(new G4LowEWentzelVIModel());
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(new G4DNAIonisation("iron_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") {
// photoelectric effect - Livermore model only
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());
ph->RegisterProcess(thePhotoElectricEffect, particle);
// Compton scattering - Livermore model only
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
theComptonScattering->SetEmModel(new G4LivermoreComptonModel());
ph->RegisterProcess(theComptonScattering, particle);
// gamma conversion - Livermore model below 80 GeV
G4GammaConversion* theGammaConversion = new G4GammaConversion();
theGammaConversion->SetEmModel(new G4LivermoreGammaConversionModel());
ph->RegisterProcess(theGammaConversion, particle);
// default Rayleigh scattering is Livermore
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
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);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_option2.cc
+38 -253
View File
@@ -27,57 +27,18 @@
// SI: This constructor uses speedup options of DNA models
#include "G4EmDNAPhysics_option2.hh"
#include "G4EmDNABuilder.hh"
#include "G4SystemOfUnits.hh"
// ions
#include "G4Alpha.hh"
#include "G4DNAGenericIonsManager.hh"
// *** Processes and models for Geant4-DNA
#include "G4DNAElectronSolvation.hh"
#include "G4DNAElastic.hh"
#include "G4DNAChampionElasticModel.hh"
#include "G4DNAScreenedRutherfordElasticModel.hh"
#include "G4DNAELSEPAElasticModel.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"
// utilities
#include "G4EmParameters.hh"
// end of warning
#include "G4LossTableManager.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
#include "G4EmBuilder.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
@@ -86,230 +47,54 @@ G4_DECLARE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_option2);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option2::G4EmDNAPhysics_option2(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmDNAPhysics_option2"), verbose(ver)
G4EmDNAPhysics_option2::G4EmDNAPhysics_option2(G4int ver, const G4String& nam)
: G4EmDNAPhysics(ver, nam)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetFluo(true);
param->SetAuger(true);
param->SetDeexcitationIgnoreCut(true);
param->ActivateDNA();
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");
param->SetDNAFast(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_option2::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
// parameters
G4EmParameters* param = G4EmParameters::Instance();
const G4double emaxDNA = 1.*CLHEP::MeV;
const G4double emaxIonDNA = 100.*CLHEP::MeV;
const G4double eminBorn = 500.*CLHEP::keV;
const G4bool fast = param->DNAFast();
const G4bool st = param->DNAStationary();
if(verboseLevel > 1) {
G4cout << "### " << GetPhysicsName()
<< " Construct Processes EmaxDNA(MeV)= "
<< emaxDNA/CLHEP::MeV << "; useMSC: " << fast
<< "; stationary: " << st << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
G4DNAGenericIonsManager* genericIonsManager
= G4DNAGenericIonsManager::Instance();
auto myParticleIterator=GetParticleIterator();
myParticleIterator->reset();
while( (*myParticleIterator)() )
{
G4ParticleDefinition* particle = myParticleIterator->value();
G4String particleName = particle->GetParticleName();
// standard physics
G4EmDNABuilder::ConstructStandardEmPhysics(emaxDNA, emaxDNA,
emaxIonDNA, emaxIonDNA,
dnaGS, fast);
if (particleName == "e-") {
// DNA physics
G4EmDNABuilder::ConstructDNAElectronPhysics(emaxDNA, 2, fast, st);
G4EmDNABuilder::ConstructDNAProtonPhysics(eminBorn, emaxIonDNA, 2, fast, st);
G4EmDNABuilder::ConstructDNAIonPhysics(emaxIonDNA, st);
G4DNAElectronSolvation* solvation =
new G4DNAElectronSolvation("e-_G4DNAElectronSolvation");
G4ParticleDefinition* part = genericIonsManager->GetIon("hydrogen");
G4EmDNABuilder::ConstructDNALightIonPhysics(part, 0, 2, emaxIonDNA, fast, st);
auto therm = G4DNASolvationModelFactory::GetMacroDefinedModel();
therm->SetHighEnergyLimit(7.4*eV); // limit of the Champion's model
//therm->SetHighEnergyLimit(10*eV); // limit of the ELSEPA model
solvation->SetEmModel(therm);
ph->RegisterProcess(solvation, particle);
// *** Elastic scattering (two alternative models available) ***
G4DNAElastic* theDNAElasticProcess = new G4DNAElastic("e-_G4DNAElastic");
theDNAElasticProcess->SetEmModel(new G4DNAChampionElasticModel());
// or alternative model
//theDNAElasticProcess->SetEmModel(new G4DNAELSEPAElasticModel());
//theDNAElasticProcess->SetEmModel(new G4DNAScreenedRutherfordElasticModel());
ph->RegisterProcess(theDNAElasticProcess, particle);
part = G4Alpha::Alpha();
G4EmDNABuilder::ConstructDNALightIonPhysics(part, 2, 2, emaxIonDNA, fast, st);
// *** Excitation ***
ph->RegisterProcess(new G4DNAExcitation("e-_G4DNAExcitation"), particle);
part = genericIonsManager->GetIon("alpha+");
G4EmDNABuilder::ConstructDNALightIonPhysics(part, 1, 2, emaxIonDNA, fast, st);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess = new G4DNAIonisation("e-_G4DNAIonisation");
G4DNABornIonisationModel* mod = new G4DNABornIonisationModel();
mod->SelectFasterComputation(true);
theDNAIonisationProcess->SetEmModel(mod);
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);
G4DNAIonisation* theDNAIonisationProcess = new G4DNAIonisation("proton_G4DNAIonisation");
G4VEmModel* mod1 = new G4DNARuddIonisationExtendedModel();
mod1->SetLowEnergyLimit(0*eV);
mod1->SetHighEnergyLimit(500*keV);
G4DNABornIonisationModel* mod2 = new G4DNABornIonisationModel();
mod2->SetLowEnergyLimit(500*keV);
mod2->SetHighEnergyLimit(100*MeV);
mod2->SelectFasterComputation(true);
theDNAIonisationProcess->SetEmModel(mod1);
theDNAIonisationProcess->SetEmModel(mod2);
ph->RegisterProcess(theDNAIonisationProcess, 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);
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 G4DNAElastic("alpha_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("alpha_G4DNAExcitation"), 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 G4DNAElastic("alpha+_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("alpha+_G4DNAExcitation"), 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 G4DNAElastic("helium_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("helium_G4DNAExcitation"), 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+") {
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") {
// photoelectric effect - Livermore model only
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());
ph->RegisterProcess(thePhotoElectricEffect, particle);
// Compton scattering - Livermore model only
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
theComptonScattering->SetEmModel(new G4LivermoreComptonModel());
ph->RegisterProcess(theComptonScattering, particle);
// gamma conversion - Livermore model below 80 GeV
G4GammaConversion* theGammaConversion = new G4GammaConversion();
theGammaConversion->SetEmModel(new G4LivermoreGammaConversionModel());
ph->RegisterProcess(theGammaConversion, particle);
// default Rayleigh scattering is Livermore
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
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);
part = genericIonsManager->GetIon("helium");
G4EmDNABuilder::ConstructDNALightIonPhysics(part, 0, 2, emaxIonDNA, fast, st);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_option3.cc
+5 -225
View File
@@ -23,60 +23,11 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// added elastic scattering processes of proton, hydrogen, helium, alpha+, alpha
// S. Incerti (incerti@cenbg.in2p3.fr)
//
#include "G4EmDNAPhysics_option3.hh"
#include "G4SystemOfUnits.hh"
#include "G4DNAGenericIonsManager.hh"
// *** Processes and models for Geant4-DNA
#include "G4DNAElectronSolvation.hh"
#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"
@@ -85,182 +36,11 @@ G4_DECLARE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_option3);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option3::G4EmDNAPhysics_option3(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmDNAPhysics_option3"), verbose(ver)
G4EmDNAPhysics_option3::G4EmDNAPhysics_option3(G4int ver, const G4String& nam)
: G4EmDNAPhysics_option2(ver, nam)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetFluo(true);
param->SetAuger(true);
param->SetDeexcitationIgnoreCut(true);
param->ActivateDNA();
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();
auto myParticleIterator=GetParticleIterator();
myParticleIterator->reset();
while( (*myParticleIterator)() )
{
G4ParticleDefinition* particle = myParticleIterator->value();
G4String particleName = particle->GetParticleName();
if (particleName == "e-") {
G4DNAElectronSolvation* solvation =
new G4DNAElectronSolvation("e-_G4DNAElectronSolvation");
auto therm = G4DNASolvationModelFactory::GetMacroDefinedModel();
therm->SetHighEnergyLimit(7.4*eV); // limit of the Champion's model
solvation->SetEmModel(therm);
ph->RegisterProcess(solvation, particle);
// *** 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") {
// photoelectric effect - Livermore model only
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());
ph->RegisterProcess(thePhotoElectricEffect, particle);
// Compton scattering - Livermore model only
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
theComptonScattering->SetEmModel(new G4LivermoreComptonModel());
ph->RegisterProcess(theComptonScattering, particle);
// gamma conversion - Livermore model below 80 GeV
G4GammaConversion* theGammaConversion = new G4GammaConversion();
theGammaConversion->SetEmModel(new G4LivermoreGammaConversionModel());
ph->RegisterProcess(theGammaConversion, particle);
// default Rayleigh scattering is Livermore
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
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);
param->SetDNAFast(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_option4.cc
+37 -220
View File
@@ -27,62 +27,18 @@
//
#include "G4EmDNAPhysics_option4.hh"
#include "G4EmDNABuilder.hh"
#include "G4SystemOfUnits.hh"
// ions
#include "G4Alpha.hh"
#include "G4DNAGenericIonsManager.hh"
// *** Processes and models for Geant4-DNA
#include "G4DNAElectronSolvation.hh"
#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"
// utilities
#include "G4EmParameters.hh"
// end of warning
#include "G4LossTableManager.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
#include "G4EmBuilder.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
@@ -91,190 +47,51 @@ G4_DECLARE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_option4);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option4::G4EmDNAPhysics_option4(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmDNAPhysics_option4"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetFluo(true);
param->SetAuger(true);
param->SetDeexcitationIgnoreCut(true);
param->ActivateDNA();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option4::~G4EmDNAPhysics_option4()
G4EmDNAPhysics_option4::G4EmDNAPhysics_option4(G4int ver, const G4String& nam)
: G4EmDNAPhysics(ver, nam)
{}
//....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;
// parameters
G4EmParameters* param = G4EmParameters::Instance();
const G4double emaxDNA = 1.*CLHEP::MeV;
const G4double emaxIonDNA = 100.*CLHEP::MeV;
const G4double eminBorn = 500.*CLHEP::keV;
const G4bool fast = param->DNAFast();
const G4bool st = param->DNAStationary();
if(verboseLevel > 1) {
G4cout << "### " << GetPhysicsName()
<< " Construct Processes EmaxDNA(MeV)= "
<< emaxDNA/CLHEP::MeV << "; useMSC: " << fast
<< "; stationary: " << st << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
G4DNAGenericIonsManager* genericIonsManager
= G4DNAGenericIonsManager::Instance();
auto myParticleIterator=GetParticleIterator();
myParticleIterator->reset();
while( (*myParticleIterator)() )
{
G4ParticleDefinition* particle = myParticleIterator->value();
G4String particleName = particle->GetParticleName();
// standard physics
G4EmDNABuilder::ConstructStandardEmPhysics(emaxDNA, emaxDNA,
emaxIonDNA, emaxIonDNA,
dnaGS, fast);
if (particleName == "e-") {
// *** Solvation ***
G4DNAElectronSolvation* solvation =
new G4DNAElectronSolvation("e-_G4DNAElectronSolvation");
// DNA physics
G4EmDNABuilder::ConstructDNAElectronPhysics(emaxDNA, 4, fast, st);
G4EmDNABuilder::ConstructDNAProtonPhysics(eminBorn, emaxIonDNA, 4, fast, st);
G4EmDNABuilder::ConstructDNAIonPhysics(emaxIonDNA, st);
auto therm = G4DNASolvationModelFactory::GetMacroDefinedModel();
therm->SetHighEnergyLimit(10.*eV); // limit of the Uehara's model
solvation->SetEmModel(therm);
ph->RegisterProcess(solvation, particle);
// *** Elastic scattering (two alternative models available) ***
G4DNAElastic* theDNAElasticProcess = new G4DNAElastic("e-_G4DNAElastic");
G4ParticleDefinition* part = genericIonsManager->GetIon("hydrogen");
G4EmDNABuilder::ConstructDNALightIonPhysics(part, 0, 4, emaxIonDNA, fast, st);
//theDNAElasticProcess->SetEmModel(new G4DNAChampionElasticModel());
theDNAElasticProcess->SetEmModel(new G4DNAUeharaScreenedRutherfordElasticModel());
//theDNAElasticProcess->SetEmModel(new G4DNAScreenedRutherfordElasticModel());
ph->RegisterProcess(theDNAElasticProcess, particle);
part = G4Alpha::Alpha();
G4EmDNABuilder::ConstructDNALightIonPhysics(part, 2, 4, emaxIonDNA, fast, st);
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess = new G4DNAExcitation("e-_G4DNAExcitation");
theDNAExcitationProcess->SetEmModel(new G4DNAEmfietzoglouExcitationModel());
ph->RegisterProcess(theDNAExcitationProcess, particle);
part = genericIonsManager->GetIon("alpha+");
G4EmDNABuilder::ConstructDNALightIonPhysics(part, 1, 4, emaxIonDNA, fast, st);
// *** 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 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") {
// photoelectric effect - Livermore model only
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());
ph->RegisterProcess(thePhotoElectricEffect, particle);
// Compton scattering - Livermore model only
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
theComptonScattering->SetEmModel(new G4LivermoreComptonModel());
ph->RegisterProcess(theComptonScattering, particle);
// gamma conversion - Livermore model below 80 GeV
G4GammaConversion* theGammaConversion = new G4GammaConversion();
theGammaConversion->SetEmModel(new G4LivermoreGammaConversionModel());
ph->RegisterProcess(theGammaConversion, particle);
// default Rayleigh scattering is Livermore
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
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);
part = genericIonsManager->GetIon("helium");
G4EmDNABuilder::ConstructDNALightIonPhysics(part, 0, 4, emaxIonDNA, fast, st);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_option5.cc
+3 -277
View File
@@ -27,62 +27,7 @@
//
#include "G4EmDNAPhysics_option5.hh"
#include "G4SystemOfUnits.hh"
#include "G4DNAGenericIonsManager.hh"
// *** Processes and models for Geant4-DNA
#include "G4DNAElectronSolvation.hh"
#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"
@@ -91,230 +36,11 @@ G4_DECLARE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_option5);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option5::G4EmDNAPhysics_option5(G4int ver, const G4String&) :
G4VPhysicsConstructor("G4EmDNAPhysics_option5"), verbose(ver)
G4EmDNAPhysics_option5::G4EmDNAPhysics_option5(G4int ver, const G4String& nam)
: G4EmDNAPhysics_option4(ver, nam)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetFluo(true);
param->SetAuger(true);
param->SetDeexcitationIgnoreCut(true);
param->ActivateDNA();
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();
auto myParticleIterator=GetParticleIterator();
myParticleIterator->reset();
while( (*myParticleIterator)() )
{
G4ParticleDefinition* particle = myParticleIterator->value();
G4String particleName = particle->GetParticleName();
if (particleName == "e-")
{
// *** Solvation ***
G4DNAElectronSolvation* solvation =
new G4DNAElectronSolvation("e-_G4DNAElectronSolvation");
auto therm = G4DNASolvationModelFactory::GetMacroDefinedModel();
therm->SetHighEnergyLimit(10.*eV); // limit of the Uehara's model
solvation->SetEmModel(therm);
ph->RegisterProcess(solvation, particle);
// *** Elastic scattering ***
G4DNAElastic* theDNAElasticProcess = new G4DNAElastic("e-_G4DNAElastic");
G4DNAUeharaScreenedRutherfordElasticModel* mod = new G4DNAUeharaScreenedRutherfordElasticModel();
mod->SelectFasterComputation(true);
theDNAElasticProcess->SetEmModel(mod);
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");
G4DNAEmfietzoglouIonisationModel* modE = new G4DNAEmfietzoglouIonisationModel();
theDNAIonisationProcess->SetEmModel(modE);
modE->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 G4DNAElastic("proton_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("proton_G4DNAExcitation"), particle);
G4DNAIonisation* theDNAIonisationProcess = new G4DNAIonisation("proton_G4DNAIonisation");
G4VEmModel* mod1 = new G4DNARuddIonisationExtendedModel();
mod1->SetLowEnergyLimit(0*eV);
mod1->SetHighEnergyLimit(500*keV);
G4DNABornIonisationModel* mod2 = new G4DNABornIonisationModel();
mod2->SetLowEnergyLimit(500*keV);
mod2->SetHighEnergyLimit(100*MeV);
mod2->SelectFasterComputation(true);
theDNAIonisationProcess->SetEmModel(mod1);
theDNAIonisationProcess->SetEmModel(mod2);
ph->RegisterProcess(theDNAIonisationProcess, 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);
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 G4DNAElastic("alpha_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("alpha_G4DNAExcitation"), 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 G4DNAElastic("alpha+_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("alpha+_G4DNAExcitation"), 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 G4DNAElastic("helium_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("helium_G4DNAExcitation"), 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+") {
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") {
// photoelectric effect - Livermore model only
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());
ph->RegisterProcess(thePhotoElectricEffect, particle);
// Compton scattering - Livermore model only
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
theComptonScattering->SetEmModel(new G4LivermoreComptonModel());
ph->RegisterProcess(theComptonScattering, particle);
// gamma conversion - Livermore model below 80 GeV
G4GammaConversion* theGammaConversion = new G4GammaConversion();
theGammaConversion->SetEmModel(new G4LivermoreGammaConversionModel());
ph->RegisterProcess(theGammaConversion, particle);
// default Rayleigh scattering is Livermore
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
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);
param->SetDNAFast(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_option6.cc
+38 -214
View File
@@ -37,250 +37,74 @@
//
#include "G4EmDNAPhysics_option6.hh"
#include "G4EmDNABuilder.hh"
#include "G4SystemOfUnits.hh"
// ions
#include "G4Alpha.hh"
#include "G4DNAGenericIonsManager.hh"
// *** Processes and models for Geant4-DNA
#include "G4DNAElectronSolvation.hh"
#include "G4DNAOneStepThermalizationModel.hh"
#include "G4DNAElastic.hh"
#include "G4DNACPA100ElasticModel.hh"
#include "G4DNAIonisation.hh"
#include "G4DNACPA100IonisationModel.hh"
#include "G4DNAExcitation.hh"
#include "G4DNACPA100ExcitationModel.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"
// utilities
#include "G4EmParameters.hh"
// end of warning
#include "G4LossTableManager.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
#include "G4EmBuilder.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_option6);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option6::G4EmDNAPhysics_option6(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmDNAPhysics_option6"), verbose(ver)
G4EmDNAPhysics_option6::G4EmDNAPhysics_option6(G4int ver, const G4String& nam)
: G4EmDNAPhysics(ver, nam)
{
// G4EmParameters::Instance()->SetDefaults();
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetFluo(true);
param->SetAuger(true);
param->SetDeexcitationIgnoreCut(true);
param->ActivateDNA();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option6::~G4EmDNAPhysics_option6()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_option6::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");
param->SetDNAFast(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_option6::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
// parameters
G4EmParameters* param = G4EmParameters::Instance();
const G4double emaxDNA = 1.*CLHEP::MeV;
const G4double emaxIonDNA = 100.*CLHEP::MeV;
const G4double eminBorn = 500.*CLHEP::keV;
const G4bool fast = param->DNAFast();
const G4bool st = param->DNAStationary();
if(verboseLevel > 1) {
G4cout << "### " << GetPhysicsName()
<< " Construct Processes EmaxDNA(MeV)= "
<< emaxDNA/CLHEP::MeV << "; useMSC: " << fast
<< "; stationary: " << st << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
G4DNAGenericIonsManager* genericIonsManager
= G4DNAGenericIonsManager::Instance();
auto myParticleIterator=GetParticleIterator();
myParticleIterator->reset();
while( (*myParticleIterator)() )
{
G4ParticleDefinition* particle = myParticleIterator->value();
G4String particleName = particle->GetParticleName();
// standard physics
G4EmDNABuilder::ConstructStandardEmPhysics(emaxDNA, emaxDNA,
emaxIonDNA, emaxIonDNA,
dnaUrban, fast);
if (particleName == "e-") {
// DNA physics
G4EmDNABuilder::ConstructDNAElectronPhysics(emaxDNA, 6, fast, st);
G4EmDNABuilder::ConstructDNAProtonPhysics(eminBorn, emaxIonDNA, 6, fast, st);
G4EmDNABuilder::ConstructDNAIonPhysics(emaxIonDNA, st);
// *** Solvation ***
G4DNAElectronSolvation* solvation =
new G4DNAElectronSolvation("e-_G4DNAElectronSolvation");
G4ParticleDefinition* part = genericIonsManager->GetIon("hydrogen");
G4EmDNABuilder::ConstructDNALightIonPhysics(part, 0, 6, emaxIonDNA, fast, st);
auto therm = G4DNASolvationModelFactory::GetMacroDefinedModel();
therm->SetHighEnergyLimit(11.*eV); // limit of the CPA100 elastic model
solvation->SetEmModel(therm);
ph->RegisterProcess(solvation, particle);
// *** Elastic scattering (two alternative models available) ***
G4DNAElastic* theDNAElasticProcess = new G4DNAElastic("e-_G4DNAElastic");
theDNAElasticProcess->SetEmModel(new G4DNACPA100ElasticModel());
ph->RegisterProcess(theDNAElasticProcess, particle);
part = G4Alpha::Alpha();
G4EmDNABuilder::ConstructDNALightIonPhysics(part, 2, 6, emaxIonDNA, fast, st);
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess = new G4DNAExcitation("e-_G4DNAExcitation");
theDNAExcitationProcess->SetEmModel(new G4DNACPA100ExcitationModel());
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess = new G4DNAIonisation("e-_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(new G4DNACPA100IonisationModel());
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);
} 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") {
// photoelectric effect - Livermore model only
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());
ph->RegisterProcess(thePhotoElectricEffect, particle);
// Compton scattering - Livermore model only
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
theComptonScattering->SetEmModel(new G4LivermoreComptonModel());
ph->RegisterProcess(theComptonScattering, particle);
// gamma conversion - Livermore model below 80 GeV
G4GammaConversion* theGammaConversion = new G4GammaConversion();
theGammaConversion->SetEmModel(new G4LivermoreGammaConversionModel());
ph->RegisterProcess(theGammaConversion, particle);
// default Rayleigh scattering is Livermore
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
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);
part = genericIonsManager->GetIon("alpha+");
G4EmDNABuilder::ConstructDNALightIonPhysics(part, 1, 6, emaxIonDNA, fast, st);
part = genericIonsManager->GetIon("helium");
G4EmDNABuilder::ConstructDNALightIonPhysics(part, 0, 6, emaxIonDNA, fast, st);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_option7.cc
+3 -268
View File
@@ -27,62 +27,7 @@
//
#include "G4EmDNAPhysics_option7.hh"
#include "G4SystemOfUnits.hh"
#include "G4DNAGenericIonsManager.hh"
// *** Processes and models for Geant4-DNA
#include "G4DNAElectronSolvation.hh"
#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"
@@ -91,221 +36,11 @@ G4_DECLARE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_option7);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option7::G4EmDNAPhysics_option7(G4int ver, const G4String&) :
G4VPhysicsConstructor("G4EmDNAPhysics_option7"), verbose(ver)
G4EmDNAPhysics_option7::G4EmDNAPhysics_option7(G4int ver, const G4String& nam)
: G4EmDNAPhysics_option6(ver, nam)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetFluo(true);
param->SetAuger(true);
param->SetDeexcitationIgnoreCut(true);
param->ActivateDNA();
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();
auto myParticleIterator=GetParticleIterator();
myParticleIterator->reset();
while( (*myParticleIterator)() )
{
G4ParticleDefinition* particle = myParticleIterator->value();
G4String particleName = particle->GetParticleName();
if (particleName == "e-")
{
// *** Electron solvation ***
// Either kills the electron track or transform the electron to
// a solvated electron, depending on whether the chemistry is
// activated
G4DNAElectronSolvation* solvation =
new G4DNAElectronSolvation("e-_G4DNAElectronSolvation");
auto therm = G4DNASolvationModelFactory::GetMacroDefinedModel();
therm->SetHighEnergyLimit(10.*eV); // limit of the Uehara's model
solvation->SetEmModel(therm);
ph->RegisterProcess(solvation, particle);
// *** Elastic scattering ***
G4DNAElastic* theDNAElasticProcess =
new G4DNAElastic("e-_G4DNAElastic");
G4DNAUeharaScreenedRutherfordElasticModel* emElast =
new G4DNAUeharaScreenedRutherfordElasticModel();
emElast->SetHighEnergyLimit(1*MeV);
theDNAElasticProcess->SetEmModel(emElast);
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess =
new G4DNAExcitation("e-_G4DNAExcitation");
// 1-st model should be Set
G4DNAEmfietzoglouExcitationModel* emExc = new G4DNAEmfietzoglouExcitationModel();
emExc->SetActivationLowEnergyLimit(8*eV);
emExc->SetActivationHighEnergyLimit(10.*keV);
theDNAExcitationProcess->SetEmModel(emExc);
// 2-nd model should be Add
G4DNABornExcitationModel* bornExc = new G4DNABornExcitationModel();
bornExc->SetActivationLowEnergyLimit(10*keV);
bornExc->SetActivationHighEnergyLimit(1.*MeV);
theDNAExcitationProcess->AddEmModel(2, bornExc);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("e-_G4DNAIonisation");
// 1-st model should be Set
G4DNAEmfietzoglouIonisationModel* emIonModel = new G4DNAEmfietzoglouIonisationModel();
emIonModel->SetActivationLowEnergyLimit(10.*eV);
emIonModel->SetActivationHighEnergyLimit(10.*keV);
theDNAIonisationProcess->SetEmModel(emIonModel);
// 2-nd model should be Add
G4DNABornIonisationModel* bornIon = new G4DNABornIonisationModel();
bornIon->SetActivationLowEnergyLimit(10*keV);
bornIon->SetActivationHighEnergyLimit(1.*MeV);
theDNAIonisationProcess->AddEmModel(2,bornIon);
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") {
// photoelectric effect - Livermore model only
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());
ph->RegisterProcess(thePhotoElectricEffect, particle);
// Compton scattering - Livermore model only
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
theComptonScattering->SetEmModel(new G4LivermoreComptonModel());
ph->RegisterProcess(theComptonScattering, particle);
// gamma conversion - Livermore model below 80 GeV
G4GammaConversion* theGammaConversion = new G4GammaConversion();
theGammaConversion->SetEmModel(new G4LivermoreGammaConversionModel());
ph->RegisterProcess(theGammaConversion, particle);
// default Rayleigh scattering is Livermore
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
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);
param->SetDNAFast(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_option8.cc
+38 -215
View File
@@ -27,58 +27,18 @@
//
#include "G4EmDNAPhysics_option8.hh"
#include "G4EmDNABuilder.hh"
#include "G4SystemOfUnits.hh"
// ions
#include "G4Alpha.hh"
#include "G4DNAGenericIonsManager.hh"
// *** Processes and models for Geant4-DNA
#include "G4DNAElectronSolvation.hh"
#include "G4DNAElastic.hh"
#include "G4DNACPA100ElasticModel.hh"
#include "G4DNAIonisation.hh"
#include "G4DNAExcitation.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"
// utilities
#include "G4EmParameters.hh"
// end of warning
#include "G4LossTableManager.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
#include "G4EmBuilder.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
@@ -87,191 +47,54 @@ G4_DECLARE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_option8);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option8::G4EmDNAPhysics_option8(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmDNAPhysics_option8"), verbose(ver)
G4EmDNAPhysics_option8::G4EmDNAPhysics_option8(G4int ver, const G4String& nam)
: G4EmDNAPhysics(ver, nam)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetFluo(true);
param->SetAuger(true);
param->SetDeexcitationIgnoreCut(true);
param->ActivateDNA();
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option8::~G4EmDNAPhysics_option8()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_option8::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");
param->SetDNAFast(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_option8::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
// parameters
G4EmParameters* param = G4EmParameters::Instance();
const G4double emaxDNA = 1.*CLHEP::MeV;
const G4double emaxIonDNA = 100.*CLHEP::MeV;
const G4double eminBorn = 500.*CLHEP::keV;
const G4bool fast = param->DNAFast();
const G4bool st = param->DNAStationary();
if(verboseLevel > 1) {
G4cout << "### " << GetPhysicsName()
<< " Construct Processes EmaxDNA(MeV)= "
<< emaxDNA/CLHEP::MeV << "; useMSC: " << fast
<< "; stationary: " << st << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
G4DNAGenericIonsManager* genericIonsManager
= G4DNAGenericIonsManager::Instance();
auto myParticleIterator=GetParticleIterator();
myParticleIterator->reset();
while( (*myParticleIterator)() )
{
G4ParticleDefinition* particle = myParticleIterator->value();
G4String particleName = particle->GetParticleName();
// standard physics
G4EmDNABuilder::ConstructStandardEmPhysics(emaxDNA, emaxDNA,
emaxIonDNA, emaxIonDNA,
dnaUrban, fast);
if (particleName == "e-") {
// *** Solvation ***
G4DNAElectronSolvation* solvation =
new G4DNAElectronSolvation("e-_G4DNAElectronSolvation");
auto therm = G4DNASolvationModelFactory::GetMacroDefinedModel();
therm->SetHighEnergyLimit(11.*eV); // limit of the CPA100 model
solvation->SetEmModel(therm);
ph->RegisterProcess(solvation, particle);
// *** Elastic scattering using CPA100 model ***
G4DNAElastic* theDNAElasticProcess = new G4DNAElastic("e-_G4DNAElastic");
G4VEmModel* model1 = new G4DNACPA100ElasticModel();
G4VEmModel* model2 = new G4DNAChampionElasticModel();
model1->SetActivationLowEnergyLimit(11*eV);
model1->SetActivationHighEnergyLimit(255.955*keV);
theDNAElasticProcess->SetEmModel(model1);
model2->SetActivationLowEnergyLimit(255.955*keV);
model2->SetActivationHighEnergyLimit(1*MeV);
theDNAElasticProcess->AddEmModel(2,model2);
ph->RegisterProcess(theDNAElasticProcess, particle);
// DNA physics
G4EmDNABuilder::ConstructDNAElectronPhysics(emaxDNA, 8, fast, st);
G4EmDNABuilder::ConstructDNAProtonPhysics(eminBorn, emaxIonDNA, 8, fast, st);
G4EmDNABuilder::ConstructDNAIonPhysics(emaxIonDNA, st);
// *** Excitation ***
ph->RegisterProcess(new G4DNAExcitation("e-_G4DNAExcitation"), particle);
G4ParticleDefinition* part = genericIonsManager->GetIon("hydrogen");
G4EmDNABuilder::ConstructDNALightIonPhysics(part, 0, 8, emaxIonDNA, fast, st);
// *** Ionisation ***
ph->RegisterProcess(new G4DNAIonisation("e-_G4DNAIonisation"), particle);
part = G4Alpha::Alpha();
G4EmDNABuilder::ConstructDNALightIonPhysics(part, 2, 8, emaxIonDNA, fast, st);
// *** 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);
part = genericIonsManager->GetIon("alpha+");
G4EmDNABuilder::ConstructDNALightIonPhysics(part, 1, 8, emaxIonDNA, fast, st);
} 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") {
// photoelectric effect - Livermore model only
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());
ph->RegisterProcess(thePhotoElectricEffect, particle);
// Compton scattering - Livermore model only
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
theComptonScattering->SetEmModel(new G4LivermoreComptonModel());
ph->RegisterProcess(theComptonScattering, particle);
// gamma conversion - Livermore model below 80 GeV
G4GammaConversion* theGammaConversion = new G4GammaConversion();
theGammaConversion->SetEmModel(new G4LivermoreGammaConversionModel());
ph->RegisterProcess(theGammaConversion, particle);
// default Rayleigh scattering is Livermore
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
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);
part = genericIonsManager->GetIon("helium");
G4EmDNABuilder::ConstructDNALightIonPhysics(part, 0, 8, emaxIonDNA, fast, st);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_stationary.cc
-276
View File
@@ -24,43 +24,13 @@
// ********************************************************************
#include "G4EmDNAPhysics_stationary.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 "G4Alpha.hh"
#include "G4GenericIon.hh"
#include "G4EmParameters.hh"
#include "G4PhysicsListHelper.hh"
#include "G4BuilderType.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_stationary);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_stationary::G4EmDNAPhysics_stationary(G4int ver, const G4String& nam)
@@ -76,249 +46,3 @@ G4EmDNAPhysics_stationary::~G4EmDNAPhysics_stationary()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_stationary::ConstructProcess()
{
if(verboseLevel > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
ConstructGammaPositronProcesses();
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
G4DNAGenericIonsManager* genericIonsManager
= G4DNAGenericIonsManager::Instance();
// e-
G4ParticleDefinition* part = G4Electron::Electron();
// *** Elastic scattering ***
G4DNAElastic* theDNAElastic = new G4DNAElastic("e-_G4DNAElastic");
theDNAElastic->SetEmModel(new G4DNAChampionElasticModel());
ph->RegisterProcess(theDNAElastic, part);
// *** Excitation ***
G4DNAExcitation* theDNAExc = new G4DNAExcitation("e-_G4DNAExcitation");
G4DNABornExcitationModel* modB = new G4DNABornExcitationModel();
theDNAExc->SetEmModel(modB);
modB->SelectStationary(true);
ph->RegisterProcess(theDNAExc, part);
// *** Ionisation ***
G4DNAIonisation* theDNAIoni = new G4DNAIonisation("e-_G4DNAIonisation");
G4DNABornIonisationModel* modI = new G4DNABornIonisationModel();
theDNAIoni->SetEmModel(modI);
modI->SelectStationary(true);
ph->RegisterProcess(theDNAIoni, part);
// *** Vibrational excitation ***
G4DNAVibExcitation* theDNAVibExc =
new G4DNAVibExcitation("e-_G4DNAVibExcitation");
G4DNASancheExcitationModel* modS = new G4DNASancheExcitationModel();
theDNAVibExc->SetEmModel(modS);
modS->SelectStationary(true);
ph->RegisterProcess(theDNAVibExc, part);
// *** Attachment ***
G4DNAAttachment* theDNAAttach = new G4DNAAttachment("e-_G4DNAAttachment");
G4DNAMeltonAttachmentModel* modM = new G4DNAMeltonAttachmentModel();
theDNAAttach->SetEmModel(modM);
modM->SelectStationary(true);
ph->RegisterProcess(theDNAAttach, part);
// proton
part = G4Proton::Proton();
// *** Elastic ***
theDNAElastic = new G4DNAElastic("proton_G4DNAElastic");
G4DNAIonElasticModel* modE = new G4DNAIonElasticModel();
theDNAElastic->SetEmModel(modE);
modE->SelectStationary(true);
ph->RegisterProcess(theDNAElastic, part);
// *** Excitation ***
theDNAExc = new G4DNAExcitation("proton_G4DNAExcitation");
G4DNAMillerGreenExcitationModel* modMGE =
new G4DNAMillerGreenExcitationModel();
modMGE->SetLowEnergyLimit(10*eV);
modMGE->SetHighEnergyLimit(500*keV);
modMGE->SelectStationary(true);
theDNAExc->SetEmModel(modMGE);
G4DNABornExcitationModel* modBE = new G4DNABornExcitationModel();
modBE->SetLowEnergyLimit(500*keV);
modBE->SetHighEnergyLimit(100*MeV);
modBE->SelectStationary(true);
theDNAExc->SetEmModel(modBE);
ph->RegisterProcess(theDNAExc, part);
// *** Ionisation ***
theDNAIoni = new G4DNAIonisation("proton_G4DNAIonisation");
G4DNARuddIonisationModel* modRI = new G4DNARuddIonisationModel();
modRI->SetLowEnergyLimit(0*eV);
modRI->SetHighEnergyLimit(500*keV);
modRI->SelectStationary(true);
theDNAIoni->SetEmModel(modRI);
G4DNABornIonisationModel* modBI = new G4DNABornIonisationModel();
modBI->SetLowEnergyLimit(500*keV);
modBI->SetHighEnergyLimit(100*MeV);
modBI->SelectStationary(true);
theDNAIoni->SetEmModel(modBI);
ph->RegisterProcess(theDNAIoni, part);
// *** Charge decrease ***
G4DNAChargeDecrease* theDNAChargeDecreaseProcess =
new G4DNAChargeDecrease("proton_G4DNAChargeDecrease");
G4DNADingfelderChargeDecreaseModel* modDCD =
new G4DNADingfelderChargeDecreaseModel();
modDCD->SelectStationary(true);
theDNAChargeDecreaseProcess->SetEmModel(modDCD);
ph->RegisterProcess(theDNAChargeDecreaseProcess, part);
// hydrogen
part = genericIonsManager->GetIon("hydrogen");
// *** Elastic ***
theDNAElastic = new G4DNAElastic("hydrogen_G4DNAElastic");
G4DNAIonElasticModel* modEI = new G4DNAIonElasticModel();
modEI->SelectStationary(true);
theDNAElastic->SetEmModel(modEI);
ph->RegisterProcess(theDNAElastic, part);
// *** Excitation ***
theDNAExc = new G4DNAExcitation("hydrogen_G4DNAExcitation");
modMGE = new G4DNAMillerGreenExcitationModel();
modMGE->SelectStationary(true);
theDNAExc->SetEmModel(modMGE);
ph->RegisterProcess(theDNAExc, part);
// *** Ionisation ***
theDNAIoni = new G4DNAIonisation("hydrogen_G4DNAIonisation");
modRI = new G4DNARuddIonisationModel();
theDNAIoni->SetEmModel(new G4DNARuddIonisationModel());
modRI->SelectStationary(true);
ph->RegisterProcess(theDNAIoni, part);
// *** Charge increase ***
G4DNAChargeIncrease* theDNAChargeIncreaseProcess =
new G4DNAChargeIncrease("hydrogen_G4DNAChargeIncrease");
G4DNADingfelderChargeIncreaseModel* modDCI =
new G4DNADingfelderChargeIncreaseModel();
modDCI->SelectStationary(true);
theDNAChargeIncreaseProcess->SetEmModel(modDCI);
ph->RegisterProcess(theDNAChargeIncreaseProcess, part);
// alpha++
part = G4Alpha::Alpha();
// *** Elastic ***
theDNAElastic = new G4DNAElastic("alpha_G4DNAElastic");
modEI = new G4DNAIonElasticModel();
modEI->SelectStationary(true);
theDNAElastic->SetEmModel(modEI);
ph->RegisterProcess(theDNAElastic, part);
// *** Excitation ***
theDNAExc = new G4DNAExcitation("alpha_G4DNAExcitation");
modMGE = new G4DNAMillerGreenExcitationModel();
modMGE->SelectStationary(true);
theDNAExc->SetEmModel(modMGE);
ph->RegisterProcess(theDNAExc, part);
// *** Ionisation ***
theDNAIoni = new G4DNAIonisation("alpha_G4DNAIonisation");
modRI = new G4DNARuddIonisationModel();
theDNAIoni->SetEmModel(new G4DNARuddIonisationModel());
modRI->SelectStationary(true);
ph->RegisterProcess(theDNAIoni, part);
// *** Charge decrease ***
theDNAChargeDecreaseProcess =
new G4DNAChargeDecrease("alpha_G4DNAChargeDecrease");
modDCD = new G4DNADingfelderChargeDecreaseModel();
modDCD->SelectStationary(true);
theDNAChargeDecreaseProcess->SetEmModel(modDCD);
ph->RegisterProcess(theDNAChargeDecreaseProcess, part);
// alpha+
part = genericIonsManager->GetIon("alpha+");
// *** Elastic ***
theDNAElastic = new G4DNAElastic("alpha+_G4DNAElastic");
modEI = new G4DNAIonElasticModel();
modEI->SelectStationary(true);
theDNAElastic->SetEmModel(modEI);
ph->RegisterProcess(theDNAElastic, part);
// *** Excitation ***
theDNAExc = new G4DNAExcitation("alpha+_G4DNAExcitation");
modMGE = new G4DNAMillerGreenExcitationModel();
modMGE->SelectStationary(true);
theDNAExc->SetEmModel(modMGE);
ph->RegisterProcess(theDNAExc, part);
// *** Ionisation ***
theDNAIoni = new G4DNAIonisation("alpha+_G4DNAIonisation");
modRI = new G4DNARuddIonisationModel();
theDNAIoni->SetEmModel(new G4DNARuddIonisationModel());
modRI->SelectStationary(true);
ph->RegisterProcess(theDNAIoni, part);
// *** Charge decrease ***
theDNAChargeDecreaseProcess =
new G4DNAChargeDecrease("alpha+_G4DNAChargeDecrease");
modDCD = new G4DNADingfelderChargeDecreaseModel();
modDCD->SelectStationary(true);
theDNAChargeDecreaseProcess->SetEmModel(modDCD);
ph->RegisterProcess(theDNAChargeDecreaseProcess, part);
// *** Charge increase ***
theDNAChargeIncreaseProcess =
new G4DNAChargeIncrease("alpha+_G4DNAChargeIncrease");
modDCI = new G4DNADingfelderChargeIncreaseModel();
modDCI->SelectStationary(true);
theDNAChargeIncreaseProcess->SetEmModel(modDCI);
ph->RegisterProcess(theDNAChargeIncreaseProcess, part);
// helium
part = genericIonsManager->GetIon("helium");
// *** Elastic ***
theDNAElastic = new G4DNAElastic("helium_G4DNAElastic");
modEI = new G4DNAIonElasticModel();
modEI->SelectStationary(true);
theDNAElastic->SetEmModel(modEI);
ph->RegisterProcess(theDNAElastic, part);
// *** Excitation ***
theDNAExc = new G4DNAExcitation("helium_G4DNAExcitation");
modMGE = new G4DNAMillerGreenExcitationModel();
modMGE->SelectStationary(true);
theDNAExc->SetEmModel(modMGE);
ph->RegisterProcess(theDNAExc, part);
// *** Ionisation ***
theDNAIoni = new G4DNAIonisation("helium_G4DNAIonisation");
modRI = new G4DNARuddIonisationModel();
theDNAIoni->SetEmModel(new G4DNARuddIonisationModel());
modRI->SelectStationary(true);
ph->RegisterProcess(theDNAIoni, part);
// *** Charge increase ***
theDNAChargeIncreaseProcess =
new G4DNAChargeIncrease("helium_G4DNAChargeIncrease");
modDCI = new G4DNADingfelderChargeIncreaseModel();
modDCI->SelectStationary(true);
theDNAChargeIncreaseProcess->SetEmModel(modDCI);
ph->RegisterProcess(theDNAChargeIncreaseProcess, part);
// other ions
part = G4GenericIon::GenericIon();
// *** Ionisation ***
theDNAIoni = new G4DNAIonisation("GenericIon_G4DNAIonisation");
G4DNARuddIonisationExtendedModel* mod =
new G4DNARuddIonisationExtendedModel();
mod->SelectStationary(true);
theDNAIoni->SetEmModel(mod);
ph->RegisterProcess(theDNAIoni, part);
}
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_stationary_option2.cc
+8 -483
View File
@@ -22,503 +22,28 @@
// * 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_stationary_option2.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_stationary_option2);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_stationary_option2::G4EmDNAPhysics_stationary_option2(G4int ver)
: G4VPhysicsConstructor("G4EmDNAPhysics_stationary_option2"), verbose(ver)
G4EmDNAPhysics_stationary_option2::G4EmDNAPhysics_stationary_option2(G4int ver, const G4String& nam)
: G4EmDNAPhysics_option2(ver, nam)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetFluo(true);
param->SetAuger(true);
param->SetDeexcitationIgnoreCut(true);
param->ActivateDNA();
SetPhysicsType(bElectromagnetic);
param->SetDNAStationary(true);
param->SetDNAFast(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_stationary_option2::G4EmDNAPhysics_stationary_option2(G4int ver,
const G4String&)
: G4EmDNAPhysics_stationary_option2(ver)
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_stationary_option2::~G4EmDNAPhysics_stationary_option2()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_stationary_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_stationary_option2::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
auto myParticleIterator=GetParticleIterator();
myParticleIterator->reset();
while( (*myParticleIterator)() )
{
G4ParticleDefinition* particle = myParticleIterator->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 ***
G4DNAExcitation* theDNAExcitationProcess =
new G4DNAExcitation("e-_G4DNAExcitation");
theDNAExcitationProcess->SetEmModel(new G4DNABornExcitationModel());
((G4DNABornExcitationModel*)(theDNAExcitationProcess->EmModel()))
->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("e-_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(new G4DNABornIonisationModel());
((G4DNABornIonisationModel*)(theDNAIonisationProcess->EmModel()))
->SelectStationary(true);
//
((G4DNABornIonisationModel*)(theDNAIonisationProcess->EmModel()))
->SelectFasterComputation(true);
//
ph->RegisterProcess(theDNAIonisationProcess, particle);
// *** Vibrational excitation ***
G4DNAVibExcitation* theDNAVibExcitationProcess =
new G4DNAVibExcitation("e-_G4DNAVibExcitation");
theDNAVibExcitationProcess->SetEmModel(new G4DNASancheExcitationModel());
((G4DNASancheExcitationModel*)(theDNAVibExcitationProcess->EmModel()))
->SelectStationary(true);
ph->RegisterProcess(theDNAVibExcitationProcess, particle);
// *** Attachment ***
G4DNAAttachment* theDNAAttachmentProcess =
new G4DNAAttachment("e-_G4DNAAttachment");
theDNAAttachmentProcess->SetEmModel(new G4DNAMeltonAttachmentModel());
((G4DNAMeltonAttachmentModel*)(theDNAAttachmentProcess->EmModel()))
->SelectStationary(true);
ph->RegisterProcess(theDNAAttachmentProcess, particle);
} else if ( particleName == "proton" ) {
// *** Elastic ***
G4DNAElastic* theDNAElasticProcess =
new G4DNAElastic("proton_G4DNAElastic");
theDNAElasticProcess->SetEmModel(new G4DNAIonElasticModel());
((G4DNAIonElasticModel*)(theDNAElasticProcess->EmModel()))
->SelectStationary(true);
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess =
new G4DNAExcitation("proton_G4DNAExcitation");
theDNAExcitationProcess->SetEmModel
(new G4DNAMillerGreenExcitationModel());
theDNAExcitationProcess->SetEmModel
(new G4DNABornExcitationModel());
((G4DNAMillerGreenExcitationModel*)(theDNAExcitationProcess->EmModel()))
->SetLowEnergyLimit(10*eV);
((G4DNAMillerGreenExcitationModel*)(theDNAExcitationProcess->EmModel()))
->SetHighEnergyLimit(500*keV);
((G4DNAMillerGreenExcitationModel*)(theDNAExcitationProcess->EmModel()))
->SelectStationary(true);
((G4DNABornExcitationModel*)(theDNAExcitationProcess->EmModel(1)))
->SetLowEnergyLimit(500*keV);
((G4DNABornExcitationModel*)(theDNAExcitationProcess->EmModel(1)))
->SetHighEnergyLimit(100*MeV);
((G4DNABornExcitationModel*)(theDNAExcitationProcess->EmModel(1)))
->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("proton_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel);
theDNAIonisationProcess->SetEmModel(
new G4DNABornIonisationModel);
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SetLowEnergyLimit(0*eV);
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SetHighEnergyLimit(500*keV);
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SelectStationary(true);
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(1)))->SetLowEnergyLimit(500*keV);
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(1)))->SetHighEnergyLimit(100*MeV);
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(1)))->SelectStationary(true);
//
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(1)))->SelectFasterComputation(true);
//
ph->RegisterProcess(theDNAIonisationProcess, particle);
// *** Charge decrease ***
G4DNAChargeDecrease* theDNAChargeDecreaseProcess =
new G4DNAChargeDecrease("proton_G4DNAChargeDecrease");
theDNAChargeDecreaseProcess->SetEmModel(
new G4DNADingfelderChargeDecreaseModel());
((G4DNADingfelderChargeDecreaseModel*)
(theDNAChargeDecreaseProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAChargeDecreaseProcess, particle);
} else if ( particleName == "hydrogen" ) {
// *** Elastic ***
G4DNAElastic* theDNAElasticProcess =
new G4DNAElastic("hydrogen_G4DNAElastic");
theDNAElasticProcess->SetEmModel(new G4DNAIonElasticModel());
((G4DNAIonElasticModel*)(theDNAElasticProcess->EmModel()))
->SelectStationary(true);
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess =
new G4DNAExcitation("hydrogen_G4DNAExcitation");
theDNAExcitationProcess->SetEmModel(
new G4DNAMillerGreenExcitationModel());
((G4DNAMillerGreenExcitationModel*)(theDNAExcitationProcess->EmModel()))
->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("hydrogen_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel());
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAIonisationProcess, particle);
// *** Charge increase ***
G4DNAChargeIncrease* theDNAChargeIncreaseProcess =
new G4DNAChargeIncrease("hydrogen_G4DNAChargeIncrease");
theDNAChargeIncreaseProcess->SetEmModel(
new G4DNADingfelderChargeIncreaseModel());
((G4DNADingfelderChargeIncreaseModel*)
(theDNAChargeIncreaseProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAChargeIncreaseProcess, particle);
} else if ( particleName == "alpha" ) {
// *** Elastic ***
G4DNAElastic* theDNAElasticProcess =
new G4DNAElastic("alpha_G4DNAElastic");
theDNAElasticProcess->SetEmModel(new G4DNAIonElasticModel());
((G4DNAIonElasticModel*)
(theDNAElasticProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess =
new G4DNAExcitation("alpha_G4DNAExcitation");
theDNAExcitationProcess->SetEmModel(
new G4DNAMillerGreenExcitationModel());
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("alpha_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel());
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAIonisationProcess, particle);
// *** Charge decrease ***
G4DNAChargeDecrease* theDNAChargeDecreaseProcess =
new G4DNAChargeDecrease("alpha_G4DNAChargeDecrease");
theDNAChargeDecreaseProcess->SetEmModel(
new G4DNADingfelderChargeDecreaseModel());
((G4DNADingfelderChargeDecreaseModel*)
(theDNAChargeDecreaseProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAChargeDecreaseProcess, particle);
} else if ( particleName == "alpha+" ) {
// *** Elastic ***
G4DNAElastic* theDNAElasticProcess =
new G4DNAElastic("alpha+_G4DNAElastic");
theDNAElasticProcess->SetEmModel(new G4DNAIonElasticModel());
((G4DNAIonElasticModel*)
(theDNAElasticProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess =
new G4DNAExcitation("alpha+_G4DNAExcitation");
theDNAExcitationProcess->SetEmModel(
new G4DNAMillerGreenExcitationModel());
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("alpha+_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel());
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAIonisationProcess, particle);
// *** Charge decrease ***
G4DNAChargeDecrease* theDNAChargeDecreaseProcess =
new G4DNAChargeDecrease("alpha+_G4DNAChargeDecrease");
theDNAChargeDecreaseProcess->SetEmModel(
new G4DNADingfelderChargeDecreaseModel());
((G4DNADingfelderChargeDecreaseModel*)
(theDNAChargeDecreaseProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAChargeDecreaseProcess, particle);
// *** Charge increase ***
G4DNAChargeIncrease* theDNAChargeIncreaseProcess =
new G4DNAChargeIncrease("alpha+_G4DNAChargeIncrease");
theDNAChargeIncreaseProcess->SetEmModel(
new G4DNADingfelderChargeIncreaseModel());
((G4DNADingfelderChargeIncreaseModel*)
(theDNAChargeIncreaseProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAChargeIncreaseProcess, particle);
} else if ( particleName == "helium" ) {
// *** Elastic ***
G4DNAElastic* theDNAElasticProcess =
new G4DNAElastic("helium_G4DNAElastic");
theDNAElasticProcess->SetEmModel(
new G4DNAIonElasticModel());
((G4DNAIonElasticModel*)
(theDNAElasticProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess =
new G4DNAExcitation("helium_G4DNAExcitation");
theDNAExcitationProcess->SetEmModel(
new G4DNAMillerGreenExcitationModel());
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("helium_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel());
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAIonisationProcess, particle);
// *** Charge increase ***
G4DNAChargeIncrease* theDNAChargeIncreaseProcess =
new G4DNAChargeIncrease("helium_G4DNAChargeIncrease");
theDNAChargeIncreaseProcess->SetEmModel(
new G4DNADingfelderChargeIncreaseModel());
((G4DNADingfelderChargeIncreaseModel*)
(theDNAChargeIncreaseProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAChargeIncreaseProcess, particle);
} else if ( particleName == "GenericIon" ) {
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("GenericIon_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel());
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAIonisationProcess, 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_stationary
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") {
// photoelectric effect - Livermore model only
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());
ph->RegisterProcess(thePhotoElectricEffect, particle);
// Compton scattering - Livermore model only
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
theComptonScattering->SetEmModel(new G4LivermoreComptonModel());
ph->RegisterProcess(theComptonScattering, particle);
// gamma conversion - Livermore model below 80 GeV
G4GammaConversion* theGammaConversion = new G4GammaConversion();
theGammaConversion->SetEmModel(new G4LivermoreGammaConversionModel());
ph->RegisterProcess(theGammaConversion, particle);
// default Rayleigh scattering is Livermore
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
ph->RegisterProcess(theRayleigh, particle);
}
// Warning : end of particles and processes are needed by EM Physics build.
}
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
de->SetFluo(true);
}
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_stationary_option4.cc
+7 -486
View File
@@ -22,505 +22,26 @@
// * 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_stationary_option4.hh"
#include "G4SystemOfUnits.hh"
#include "G4DNAGenericIonsManager.hh"
// *** Processes and models for Geant4-DNA
#include "G4DNAElastic.hh"
#include "G4DNAUeharaScreenedRutherfordElasticModel.hh"
#include "G4DNAIonElasticModel.hh"
#include "G4DNAExcitation.hh"
#include "G4DNAAttachment.hh"
#include "G4DNAVibExcitation.hh"
#include "G4DNAIonisation.hh"
#include "G4DNAChargeDecrease.hh"
#include "G4DNAChargeIncrease.hh"
#include "G4DNAEmfietzoglouIonisationModel.hh"
#include "G4DNAEmfietzoglouExcitationModel.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_stationary_option4);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_stationary_option4::G4EmDNAPhysics_stationary_option4(G4int ver)
: G4VPhysicsConstructor("G4EmDNAPhysics_stationary_option4"), verbose(ver)
G4EmDNAPhysics_stationary_option4::G4EmDNAPhysics_stationary_option4(G4int ver, const G4String& nam)
: G4EmDNAPhysics_option4(ver, nam)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetFluo(true);
param->SetAuger(true);
param->SetDeexcitationIgnoreCut(true);
param->ActivateDNA();
SetPhysicsType(bElectromagnetic);
param->SetDNAStationary(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_stationary_option4::G4EmDNAPhysics_stationary_option4(G4int ver,
const G4String&)
: G4EmDNAPhysics_stationary_option4(ver)
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_stationary_option4::~G4EmDNAPhysics_stationary_option4()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_stationary_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_stationary_option4::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
auto myParticleIterator=GetParticleIterator();
myParticleIterator->reset();
while( (*myParticleIterator)() )
{
G4ParticleDefinition* particle = myParticleIterator->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");
theDNAExcitationProcess->SetEmModel(
new G4DNAEmfietzoglouExcitationModel());
((G4DNAEmfietzoglouExcitationModel*)
(theDNAExcitationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("e-_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNAEmfietzoglouIonisationModel());
((G4DNAEmfietzoglouIonisationModel*)
(theDNAIonisationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAIonisationProcess, particle);
// *** Vibrational excitation ***
G4DNAVibExcitation* theDNAVibExcitationProcess =
new G4DNAVibExcitation("e-_G4DNAVibExcitation");
theDNAVibExcitationProcess->SetEmModel(
new G4DNASancheExcitationModel());
((G4DNASancheExcitationModel*)
(theDNAVibExcitationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAVibExcitationProcess, particle);
// *** Attachment ***
G4DNAAttachment* theDNAAttachmentProcess =
new G4DNAAttachment("e-_G4DNAAttachment");
theDNAAttachmentProcess->SetEmModel(
new G4DNAMeltonAttachmentModel());
((G4DNAMeltonAttachmentModel*)
(theDNAAttachmentProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAAttachmentProcess, particle);
} else if ( particleName == "proton" ) {
// *** Elastic ***
G4DNAElastic* theDNAElasticProcess =
new G4DNAElastic("proton_G4DNAElastic");
theDNAElasticProcess->SetEmModel(
new G4DNAIonElasticModel());
((G4DNAIonElasticModel*)
(theDNAElasticProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess =
new G4DNAExcitation("proton_G4DNAExcitation");
theDNAExcitationProcess->SetEmModel(
new G4DNAMillerGreenExcitationModel());
theDNAExcitationProcess->SetEmModel(
new G4DNABornExcitationModel());
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel()))->SetLowEnergyLimit(10*eV);
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel()))->SetHighEnergyLimit(500*keV);
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel()))->SelectStationary(true);
((G4DNABornExcitationModel*)
(theDNAExcitationProcess->EmModel(1)))->SetLowEnergyLimit(500*keV);
((G4DNABornExcitationModel*)
(theDNAExcitationProcess->EmModel(1)))->SetHighEnergyLimit(100*MeV);
((G4DNABornExcitationModel*)
(theDNAExcitationProcess->EmModel(1)))->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("proton_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel);
theDNAIonisationProcess->SetEmModel(
new G4DNABornIonisationModel);
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SetLowEnergyLimit(0*eV);
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SetHighEnergyLimit(500*keV);
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SelectStationary(true);
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(1)))->SetLowEnergyLimit(500*keV);
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(1)))->SetHighEnergyLimit(100*MeV);
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(1)))->SelectStationary(true);
//
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(1)))->SelectFasterComputation(true);
//
ph->RegisterProcess(theDNAIonisationProcess, particle);
// *** Charge decrease ***
G4DNAChargeDecrease* theDNAChargeDecreaseProcess =
new G4DNAChargeDecrease("proton_G4DNAChargeDecrease");
theDNAChargeDecreaseProcess->SetEmModel(
new G4DNADingfelderChargeDecreaseModel());
((G4DNADingfelderChargeDecreaseModel*)
(theDNAChargeDecreaseProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAChargeDecreaseProcess, particle);
} else if ( particleName == "hydrogen" ) {
// *** Elastic ***
G4DNAElastic* theDNAElasticProcess =
new G4DNAElastic("hydrogen_G4DNAElastic");
theDNAElasticProcess->SetEmModel(
new G4DNAIonElasticModel());
((G4DNAIonElasticModel*)
(theDNAElasticProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess =
new G4DNAExcitation("hydrogen_G4DNAExcitation");
theDNAExcitationProcess->SetEmModel(
new G4DNAMillerGreenExcitationModel());
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("hydrogen_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel());
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAIonisationProcess, particle);
// *** Charge increase ***
G4DNAChargeIncrease* theDNAChargeIncreaseProcess =
new G4DNAChargeIncrease("hydrogen_G4DNAChargeIncrease");
theDNAChargeIncreaseProcess->SetEmModel(
new G4DNADingfelderChargeIncreaseModel());
((G4DNADingfelderChargeIncreaseModel*)
(theDNAChargeIncreaseProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAChargeIncreaseProcess, particle);
} else if ( particleName == "alpha" ) {
// *** Elastic ***
G4DNAElastic* theDNAElasticProcess =
new G4DNAElastic("alpha_G4DNAElastic");
theDNAElasticProcess->SetEmModel(
new G4DNAIonElasticModel());
((G4DNAIonElasticModel*)
(theDNAElasticProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess =
new G4DNAExcitation("alpha_G4DNAExcitation");
theDNAExcitationProcess->SetEmModel(
new G4DNAMillerGreenExcitationModel());
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("alpha_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel());
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAIonisationProcess, particle);
// *** Charge decrease ***
G4DNAChargeDecrease* theDNAChargeDecreaseProcess =
new G4DNAChargeDecrease("alpha_G4DNAChargeDecrease");
theDNAChargeDecreaseProcess->SetEmModel(
new G4DNADingfelderChargeDecreaseModel());
((G4DNADingfelderChargeDecreaseModel*)
(theDNAChargeDecreaseProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAChargeDecreaseProcess, particle);
} else if ( particleName == "alpha+" ) {
// *** Elastic ***
G4DNAElastic* theDNAElasticProcess =
new G4DNAElastic("alpha+_G4DNAElastic");
theDNAElasticProcess->SetEmModel(
new G4DNAIonElasticModel());
((G4DNAIonElasticModel*)
(theDNAElasticProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess =
new G4DNAExcitation("alpha+_G4DNAExcitation");
theDNAExcitationProcess->SetEmModel(
new G4DNAMillerGreenExcitationModel());
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("alpha+_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel());
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAIonisationProcess, particle);
// *** Charge decrease ***
G4DNAChargeDecrease* theDNAChargeDecreaseProcess =
new G4DNAChargeDecrease("alpha+_G4DNAChargeDecrease");
theDNAChargeDecreaseProcess->SetEmModel(
new G4DNADingfelderChargeDecreaseModel());
((G4DNADingfelderChargeDecreaseModel*)
(theDNAChargeDecreaseProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAChargeDecreaseProcess, particle);
// *** Charge increase ***
G4DNAChargeIncrease* theDNAChargeIncreaseProcess =
new G4DNAChargeIncrease("alpha+_G4DNAChargeIncrease");
theDNAChargeIncreaseProcess->SetEmModel(
new G4DNADingfelderChargeIncreaseModel());
((G4DNADingfelderChargeIncreaseModel*)
(theDNAChargeIncreaseProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAChargeIncreaseProcess, particle);
} else if ( particleName == "helium" ) {
// *** Elastic ***
G4DNAElastic* theDNAElasticProcess =
new G4DNAElastic("helium_G4DNAElastic");
theDNAElasticProcess->SetEmModel(
new G4DNAIonElasticModel());
((G4DNAIonElasticModel*)
(theDNAElasticProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess =
new G4DNAExcitation("helium_G4DNAExcitation");
theDNAExcitationProcess->SetEmModel(
new G4DNAMillerGreenExcitationModel());
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("helium_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel());
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAIonisationProcess, particle);
// *** Charge increase ***
G4DNAChargeIncrease* theDNAChargeIncreaseProcess =
new G4DNAChargeIncrease("helium_G4DNAChargeIncrease");
theDNAChargeIncreaseProcess->SetEmModel(
new G4DNADingfelderChargeIncreaseModel());
((G4DNADingfelderChargeIncreaseModel*)
(theDNAChargeIncreaseProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAChargeIncreaseProcess, particle);
} else if ( particleName == "GenericIon" ) {
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("GenericIon_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel());
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAIonisationProcess, 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_stationary
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") {
// photoelectric effect - Livermore model only
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());
ph->RegisterProcess(thePhotoElectricEffect, particle);
// Compton scattering - Livermore model only
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
theComptonScattering->SetEmModel(new G4LivermoreComptonModel());
ph->RegisterProcess(theComptonScattering, particle);
// gamma conversion - Livermore model below 80 GeV
G4GammaConversion* theGammaConversion = new G4GammaConversion();
theGammaConversion->SetEmModel(new G4LivermoreGammaConversionModel());
ph->RegisterProcess(theGammaConversion, particle);
// default Rayleigh scattering is Livermore
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
ph->RegisterProcess(theRayleigh, particle);
}
// Warning : end of particles and processes are needed by EM Physics build.
}
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
}
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_stationary_option6.cc
+4 -482
View File
@@ -24,498 +24,20 @@
// ********************************************************************
#include "G4EmDNAPhysics_stationary_option6.hh"
#include "G4SystemOfUnits.hh"
#include "G4DNAGenericIonsManager.hh"
// *** Processes and models for Geant4-DNA
#include "G4DNAElastic.hh"
#include "G4DNAUeharaScreenedRutherfordElasticModel.hh"
#include "G4DNAIonElasticModel.hh"
#include "G4DNAExcitation.hh"
#include "G4DNAAttachment.hh"
#include "G4DNAVibExcitation.hh"
#include "G4DNAIonisation.hh"
#include "G4DNAChargeDecrease.hh"
#include "G4DNAChargeIncrease.hh"
#include "G4DNACPA100IonisationModel.hh"
#include "G4DNACPA100ExcitationModel.hh"
#include "G4DNACPA100ElasticModel.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_stationary_option6);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_stationary_option6::G4EmDNAPhysics_stationary_option6(G4int ver)
: G4VPhysicsConstructor("G4EmDNAPhysics_stationary_option6"), verbose(ver)
G4EmDNAPhysics_stationary_option6::G4EmDNAPhysics_stationary_option6(G4int ver, const G4String& nam)
: G4EmDNAPhysics_option6(ver, nam)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetFluo(true);
param->SetAuger(true);
param->SetDeexcitationIgnoreCut(true);
param->ActivateDNA();
SetPhysicsType(bElectromagnetic);
param->SetDNAStationary(true);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_stationary_option6::G4EmDNAPhysics_stationary_option6(G4int ver,
const G4String&)
: G4EmDNAPhysics_stationary_option6(ver)
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_stationary_option6::~G4EmDNAPhysics_stationary_option6()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_stationary_option6::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_stationary_option6::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
auto myParticleIterator=GetParticleIterator();
myParticleIterator->reset();
while( (*myParticleIterator)() )
{
G4ParticleDefinition* particle = myParticleIterator->value();
G4String particleName = particle->GetParticleName();
if (particleName == "e-") {
// *** Elastic scattering (two alternative models available) ***
G4DNAElastic* theDNAElasticProcess =
new G4DNAElastic("e-_G4DNAElastic");
theDNAElasticProcess->SetEmModel(new G4DNACPA100ElasticModel());
((G4DNACPA100ElasticModel*)
(theDNAElasticProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess =
new G4DNAExcitation("e-_G4DNAExcitation");
theDNAExcitationProcess->SetEmModel(new G4DNACPA100ExcitationModel());
((G4DNACPA100ExcitationModel*)
(theDNAExcitationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("e-_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(new G4DNACPA100IonisationModel());
((G4DNACPA100IonisationModel*)
(theDNAIonisationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAIonisationProcess, particle);
// *** Vibrational excitation ***
G4DNAVibExcitation* theDNAVibExcitationProcess =
new G4DNAVibExcitation("e-_G4DNAVibExcitation");
theDNAVibExcitationProcess->SetEmModel(new G4DNASancheExcitationModel());
((G4DNASancheExcitationModel*)
(theDNAVibExcitationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAVibExcitationProcess, particle);
// *** Attachment ***
G4DNAAttachment* theDNAAttachmentProcess =
new G4DNAAttachment("e-_G4DNAAttachment");
theDNAAttachmentProcess->SetEmModel(new G4DNAMeltonAttachmentModel());
((G4DNAMeltonAttachmentModel*)
(theDNAAttachmentProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAAttachmentProcess, particle);
} else if ( particleName == "proton" ) {
// *** Elastic ***
G4DNAElastic* theDNAElasticProcess =
new G4DNAElastic("proton_G4DNAElastic");
theDNAElasticProcess->SetEmModel(new G4DNAIonElasticModel());
((G4DNAIonElasticModel*)
(theDNAElasticProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess =
new G4DNAExcitation("proton_G4DNAExcitation");
theDNAExcitationProcess->SetEmModel(
new G4DNAMillerGreenExcitationModel());
theDNAExcitationProcess->SetEmModel(
new G4DNABornExcitationModel());
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel()))->SetLowEnergyLimit(10*eV);
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel()))->SetHighEnergyLimit(500*keV);
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel()))->SelectStationary(true);
((G4DNABornExcitationModel*)
(theDNAExcitationProcess->EmModel(1)))->SetLowEnergyLimit(500*keV);
((G4DNABornExcitationModel*)
(theDNAExcitationProcess->EmModel(1)))->SetHighEnergyLimit(100*MeV);
((G4DNABornExcitationModel*)
(theDNAExcitationProcess->EmModel(1)))->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("proton_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel);
theDNAIonisationProcess->SetEmModel(
new G4DNABornIonisationModel);
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SetLowEnergyLimit(0*eV);
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SetHighEnergyLimit(500*keV);
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SelectStationary(true);
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(1)))->SetLowEnergyLimit(500*keV);
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(1)))->SetHighEnergyLimit(100*MeV);
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(1)))->SelectStationary(true);
//
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(1)))->SelectFasterComputation(true);
//
ph->RegisterProcess(theDNAIonisationProcess, particle);
// *** Charge decrease ***
G4DNAChargeDecrease* theDNAChargeDecreaseProcess =
new G4DNAChargeDecrease("proton_G4DNAChargeDecrease");
theDNAChargeDecreaseProcess->SetEmModel(
new G4DNADingfelderChargeDecreaseModel());
((G4DNADingfelderChargeDecreaseModel*)
(theDNAChargeDecreaseProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAChargeDecreaseProcess, particle);
} else if ( particleName == "hydrogen" ) {
// *** Elastic ***
G4DNAElastic* theDNAElasticProcess =
new G4DNAElastic("hydrogen_G4DNAElastic");
theDNAElasticProcess->SetEmModel(
new G4DNAIonElasticModel());
((G4DNAIonElasticModel*)
(theDNAElasticProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess =
new G4DNAExcitation("hydrogen_G4DNAExcitation");
theDNAExcitationProcess->SetEmModel(
new G4DNAMillerGreenExcitationModel());
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("hydrogen_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel());
((G4DNARuddIonisationExtendedModel*)(
theDNAIonisationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAIonisationProcess, particle);
// *** Charge increase ***
G4DNAChargeIncrease* theDNAChargeIncreaseProcess =
new G4DNAChargeIncrease("hydrogen_G4DNAChargeIncrease");
theDNAChargeIncreaseProcess->SetEmModel(
new G4DNADingfelderChargeIncreaseModel());
((G4DNADingfelderChargeIncreaseModel*)(
theDNAChargeIncreaseProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAChargeIncreaseProcess, particle);
} else if ( particleName == "alpha" ) {
// *** Elastic ***
G4DNAElastic* theDNAElasticProcess =
new G4DNAElastic("alpha_G4DNAElastic");
theDNAElasticProcess->SetEmModel(new G4DNAIonElasticModel());
((G4DNAIonElasticModel*)
(theDNAElasticProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess =
new G4DNAExcitation("alpha_G4DNAExcitation");
theDNAExcitationProcess->SetEmModel(
new G4DNAMillerGreenExcitationModel());
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("alpha_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel());
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAIonisationProcess, particle);
// *** Charge decrease ***
G4DNAChargeDecrease* theDNAChargeDecreaseProcess =
new G4DNAChargeDecrease("alpha_G4DNAChargeDecrease");
theDNAChargeDecreaseProcess->SetEmModel(
new G4DNADingfelderChargeDecreaseModel());
((G4DNADingfelderChargeDecreaseModel*)
(theDNAChargeDecreaseProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAChargeDecreaseProcess, particle);
} else if ( particleName == "alpha+" ) {
// *** Elastic ***
G4DNAElastic* theDNAElasticProcess =
new G4DNAElastic("alpha+_G4DNAElastic");
theDNAElasticProcess->SetEmModel(
new G4DNAIonElasticModel());
((G4DNAIonElasticModel*)
(theDNAElasticProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess =
new G4DNAExcitation("alpha+_G4DNAExcitation");
theDNAExcitationProcess->SetEmModel(
new G4DNAMillerGreenExcitationModel());
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("alpha+_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel());
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAIonisationProcess, particle);
// *** Charge decrease ***
G4DNAChargeDecrease* theDNAChargeDecreaseProcess =
new G4DNAChargeDecrease("alpha+_G4DNAChargeDecrease");
theDNAChargeDecreaseProcess->SetEmModel(
new G4DNADingfelderChargeDecreaseModel());
((G4DNADingfelderChargeDecreaseModel*)
(theDNAChargeDecreaseProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAChargeDecreaseProcess, particle);
// *** Charge increase ***
G4DNAChargeIncrease* theDNAChargeIncreaseProcess =
new G4DNAChargeIncrease("alpha+_G4DNAChargeIncrease");
theDNAChargeIncreaseProcess->SetEmModel(
new G4DNADingfelderChargeIncreaseModel());
((G4DNADingfelderChargeIncreaseModel*)
(theDNAChargeIncreaseProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAChargeIncreaseProcess, particle);
} else if ( particleName == "helium" ) {
// *** Elastic ***
G4DNAElastic* theDNAElasticProcess =
new G4DNAElastic("helium_G4DNAElastic");
theDNAElasticProcess->SetEmModel(new G4DNAIonElasticModel());
((G4DNAIonElasticModel*)
(theDNAElasticProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAElasticProcess, particle);
// *** Excitation ***
G4DNAExcitation* theDNAExcitationProcess =
new G4DNAExcitation("helium_G4DNAExcitation");
theDNAExcitationProcess->SetEmModel(
new G4DNAMillerGreenExcitationModel());
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("helium_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel());
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAIonisationProcess, particle);
// *** Charge increase ***
G4DNAChargeIncrease* theDNAChargeIncreaseProcess =
new G4DNAChargeIncrease("helium_G4DNAChargeIncrease");
theDNAChargeIncreaseProcess->SetEmModel(
new G4DNADingfelderChargeIncreaseModel());
((G4DNADingfelderChargeIncreaseModel*)
(theDNAChargeIncreaseProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAChargeIncreaseProcess, particle);
} else if ( particleName == "GenericIon" ) {
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("GenericIon_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel());
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel()))->SelectStationary(true);
ph->RegisterProcess(theDNAIonisationProcess, 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_stationary
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") {
// photoelectric effect - Livermore model only
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());
ph->RegisterProcess(thePhotoElectricEffect, particle);
// Compton scattering - Livermore model only
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
theComptonScattering->SetEmModel(new G4LivermoreComptonModel());
ph->RegisterProcess(theComptonScattering, particle);
// gamma conversion - Livermore model below 80 GeV
G4GammaConversion* theGammaConversion = new G4GammaConversion();
theGammaConversion->SetEmModel(new G4LivermoreGammaConversionModel());
ph->RegisterProcess(theGammaConversion, particle);
// default Rayleigh scattering is Livermore
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
ph->RegisterProcess(theRayleigh, particle);
}
// Warning : end of particles and processes are needed by EM Physics build.
}
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
}
source/physics_lists/constructors/electromagnetic/src/G4EmLivermorePhysics.cc
+9 -12
View File
@@ -53,8 +53,6 @@
// e+-
#include "G4eMultipleScattering.hh"
#include "G4UniversalFluctuation.hh"
#include "G4eIonisation.hh"
#include "G4LivermoreIonisationModel.hh"
@@ -77,6 +75,7 @@
#include "G4ionIonisation.hh"
#include "G4IonParametrisedLossModel.hh"
#include "G4NuclearStopping.hh"
#include "G4LindhardSorensenIonModel.hh"
// msc models
#include "G4UrbanMscModel.hh"
@@ -88,6 +87,7 @@
// interfaces
#include "G4EmParameters.hh"
#include "G4EmBuilder.hh"
#include "G4EmStandUtil.hh"
// particles
@@ -129,6 +129,8 @@ G4EmLivermorePhysics::G4EmLivermorePhysics(G4int ver, const G4String& pname)
param->SetMscRangeFactor(0.08);
param->SetMuHadLateralDisplacement(true);
param->SetFluo(true);
param->SetUseICRU90Data(true);
param->SetFluctuationType(fUrbanFluctuation);
param->SetMaxNIELEnergy(1*CLHEP::MeV);
SetPhysicsType(bElectromagnetic);
}
@@ -219,13 +221,11 @@ void G4EmLivermorePhysics::ConstructProcess()
particle = G4Electron::Electron();
// multiple and single scattering
G4eMultipleScattering* msc = new G4eMultipleScattering;
G4GoudsmitSaundersonMscModel* msc1 = new G4GoudsmitSaundersonMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->SetEmModel(msc1);
msc->SetEmModel(msc2);
G4EmBuilder::ConstructElectronMscProcess(msc1, msc2, particle);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
@@ -236,9 +236,10 @@ void G4EmLivermorePhysics::ConstructProcess()
// Ionisation - Livermore should be used only for low energies
G4eIonisation* eioni = new G4eIonisation();
eioni->SetFluctModel(G4EmStandUtil::ModelOfFluctuations());
G4VEmModel* theIoniLiv = new G4LivermoreIonisationModel();
theIoniLiv->SetHighEnergyLimit(0.1*CLHEP::MeV);
eioni->AddEmModel(0, theIoniLiv, new G4UniversalFluctuation() );
eioni->AddEmModel(0, theIoniLiv);
// Bremsstrahlung
G4eBremsstrahlung* brem = new G4eBremsstrahlung();
@@ -253,7 +254,6 @@ void G4EmLivermorePhysics::ConstructProcess()
G4ePairProduction* ee = new G4ePairProduction();
// register processes
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eioni, particle);
ph->RegisterProcess(brem, particle);
ph->RegisterProcess(ee, particle);
@@ -263,13 +263,11 @@ void G4EmLivermorePhysics::ConstructProcess()
particle = G4Positron::Positron();
// multiple and single scattering
msc = new G4eMultipleScattering;
msc1 = new G4GoudsmitSaundersonMscModel();
msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->SetEmModel(msc1);
msc->SetEmModel(msc2);
G4EmBuilder::ConstructElectronMscProcess(msc1, msc2, particle);
ssm = new G4eCoulombScatteringModel();
ss = new G4CoulombScattering();
@@ -292,7 +290,6 @@ void G4EmLivermorePhysics::ConstructProcess()
br1->SetHighEnergyLimit(GeV);
// register processes
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eioni, particle);
ph->RegisterProcess(brem, particle);
ph->RegisterProcess(ee, particle);
@@ -302,7 +299,7 @@ void G4EmLivermorePhysics::ConstructProcess()
// generic ion
particle = G4GenericIon::GenericIon();
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetEmModel(new G4IonParametrisedLossModel());
ionIoni->SetEmModel(new G4LindhardSorensenIonModel());
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(ionIoni, particle);
if(nullptr != pnuc) { ph->RegisterProcess(pnuc, particle); }
source/physics_lists/constructors/electromagnetic/src/G4EmModelActivator.cc
+22 -13
View File
@@ -97,6 +97,7 @@
#include "G4GoudsmitSaundersonMscModel.hh"
#include "G4LowEPComptonModel.hh"
#include "G4BetheHeitler5DModel.hh"
#include "G4LindhardSorensenIonModel.hh"
#include "G4LivermorePhotoElectricModel.hh"
#include "G4LivermoreComptonModel.hh"
@@ -469,24 +470,32 @@ void G4EmModelActivator::ActivatePAI()
em = mod;
fm = mod;
}
// added PAI model above low energy limit
em->SetLowEnergyLimit(emin);
proc->AddEmModel(0, em, fm, r);
// added low energy model
// first added the default model for world
// second added low energy model below PAI threshold in the region
// finally added PAI for the region
G4VEmModel* em0 = nullptr;
G4VEmFluctuationModel* fm0 = nullptr;
if(namep == "eIoni") {
em = new G4MollerBhabhaModel();
fm = new G4UniversalFluctuation();
fm0 = new G4UniversalFluctuation();
proc->SetEmModel(new G4MollerBhabhaModel());
proc->SetFluctModel(fm0);
em0 = new G4MollerBhabhaModel();
} else if(namep == "ionIoni") {
em = new G4BraggIonModel();
fm = new G4IonFluctuations();
fm0 = new G4IonFluctuations();
proc->SetEmModel(new G4LindhardSorensenIonModel());
proc->SetFluctModel(fm0);
em0 = new G4LindhardSorensenIonModel();
} else {
em = new G4BraggModel();
fm = new G4UniversalFluctuation();
fm0 = new G4UniversalFluctuation();
proc->SetEmModel(new G4BraggModel());
proc->SetEmModel(new G4BetheBlochModel());
proc->SetFluctModel(fm0);
em0 = new G4BraggModel();
}
em->SetHighEnergyLimit(emin);
em0->SetHighEnergyLimit(emin);
proc->AddEmModel(-1, em0, fm0, r);
em->SetLowEnergyLimit(emin);
proc->AddEmModel(-1, em, fm, r);
if(verbose > 0) {
G4cout << "### G4EmModelActivator: add <" << typesPAI[i]
<< "> model for " << particlesPAI[i]
source/physics_lists/constructors/electromagnetic/src/G4EmPenelopePhysics.cc
+12 -18
View File
@@ -31,7 +31,6 @@
// *** Processes and models
// gamma
#include "G4PhotoElectricEffect.hh"
#include "G4PenelopePhotoElectricModel.hh"
@@ -48,9 +47,7 @@
#include "G4KleinNishinaModel.hh"
// e- and e+
#include "G4eMultipleScattering.hh"
#include "G4UniversalFluctuation.hh"
#include "G4eIonisation.hh"
#include "G4PenelopeIonisationModel.hh"
@@ -59,12 +56,10 @@
#include "G4PenelopeBremsstrahlungModel.hh"
// e+ only
#include "G4eplusAnnihilation.hh"
#include "G4PenelopeAnnihilationModel.hh"
// hadrons
#include "G4hMultipleScattering.hh"
#include "G4MscStepLimitType.hh"
@@ -74,6 +69,7 @@
#include "G4ionIonisation.hh"
#include "G4IonParametrisedLossModel.hh"
#include "G4NuclearStopping.hh"
#include "G4LindhardSorensenIonModel.hh"
// msc models
#include "G4UrbanMscModel.hh"
@@ -81,12 +77,12 @@
#include "G4WentzelVIModel.hh"
#include "G4CoulombScattering.hh"
#include "G4eCoulombScatteringModel.hh"
//
// utilities
#include "G4EmBuilder.hh"
#include "G4EmStandUtil.hh"
// particles
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
@@ -125,6 +121,8 @@ G4EmPenelopePhysics::G4EmPenelopePhysics(G4int ver, const G4String&)
param->SetMscRangeFactor(0.08);
param->SetMuHadLateralDisplacement(true);
param->SetFluo(true);
param->SetUseICRU90Data(true);
param->SetFluctuationType(fUrbanFluctuation);
param->SetMaxNIELEnergy(1*CLHEP::MeV);
param->SetPIXEElectronCrossSectionModel("Penelope");
SetPhysicsType(bElectromagnetic);
@@ -209,13 +207,11 @@ void G4EmPenelopePhysics::ConstructProcess()
particle = G4Electron::Electron();
// multiple scattering
G4eMultipleScattering* msc = new G4eMultipleScattering;
G4GoudsmitSaundersonMscModel* msc1 = new G4GoudsmitSaundersonMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->SetEmModel(msc1);
msc->SetEmModel(msc2);
G4EmBuilder::ConstructElectronMscProcess(msc1, msc2, particle);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
@@ -226,9 +222,10 @@ void G4EmPenelopePhysics::ConstructProcess()
//Ionisation
G4eIonisation* eioni = new G4eIonisation();
eioni->SetFluctModel(G4EmStandUtil::ModelOfFluctuations());
G4PenelopeIonisationModel* theIoniPenelope = new G4PenelopeIonisationModel();
theIoniPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
eioni->AddEmModel(0, theIoniPenelope, new G4UniversalFluctuation());
eioni->AddEmModel(0, theIoniPenelope);
//Bremsstrahlung
G4eBremsstrahlung* brem = new G4eBremsstrahlung();
@@ -239,7 +236,6 @@ void G4EmPenelopePhysics::ConstructProcess()
G4ePairProduction* ee = new G4ePairProduction();
// register processes
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eioni, particle);
ph->RegisterProcess(brem, particle);
ph->RegisterProcess(ee, particle);
@@ -249,13 +245,11 @@ void G4EmPenelopePhysics::ConstructProcess()
particle = G4Positron::Positron();
// multiple scattering
msc = new G4eMultipleScattering;
msc1 = new G4GoudsmitSaundersonMscModel();
msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->SetEmModel(msc1);
msc->SetEmModel(msc2);
G4EmBuilder::ConstructElectronMscProcess(msc1, msc2, particle);
ssm = new G4eCoulombScatteringModel();
ss = new G4CoulombScattering();
@@ -266,9 +260,10 @@ void G4EmPenelopePhysics::ConstructProcess()
//Ionisation
eioni = new G4eIonisation();
eioni->SetFluctModel(G4EmStandUtil::ModelOfFluctuations());
theIoniPenelope = new G4PenelopeIonisationModel();
theIoniPenelope->SetHighEnergyLimit(PenelopeHighEnergyLimit);
eioni->AddEmModel(0,theIoniPenelope, new G4UniversalFluctuation());
eioni->AddEmModel(0,theIoniPenelope);
//Bremsstrahlung
brem = new G4eBremsstrahlung();
@@ -283,7 +278,6 @@ void G4EmPenelopePhysics::ConstructProcess()
anni->AddEmModel(0, theAnnPenelope);
// register processes
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eioni, particle);
ph->RegisterProcess(brem, particle);
ph->RegisterProcess(ee, particle);
@@ -293,7 +287,7 @@ void G4EmPenelopePhysics::ConstructProcess()
// generic ion
particle = G4GenericIon::GenericIon();
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetEmModel(new G4IonParametrisedLossModel());
ionIoni->SetEmModel(new G4LindhardSorensenIonModel());
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(ionIoni, particle);
if(nullptr != pnuc) { ph->RegisterProcess(pnuc, particle); }
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysics.cc
+4 -9
View File
@@ -51,7 +51,6 @@
#include "G4LivermorePolarizedRayleighModel.hh"
#include "G4PhotoElectricAngularGeneratorPolarized.hh"
#include "G4eMultipleScattering.hh"
#include "G4hMultipleScattering.hh"
#include "G4CoulombScattering.hh"
#include "G4eCoulombScatteringModel.hh"
@@ -90,6 +89,8 @@ G4EmStandardPhysics::G4EmStandardPhysics(G4int ver, const G4String&)
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(ver);
param->SetGeneralProcessActive(true);
param->SetFluctuationType(fUrbanFluctuation);
SetPhysicsType(bElectromagnetic);
}
@@ -175,13 +176,11 @@ void G4EmStandardPhysics::ConstructProcess()
// e-
particle = G4Electron::Electron();
G4eMultipleScattering* msc = new G4eMultipleScattering;
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->SetEmModel(msc1);
msc->SetEmModel(msc2);
G4EmBuilder::ConstructElectronMscProcess(msc1, msc2, particle);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
@@ -190,7 +189,6 @@ void G4EmStandardPhysics::ConstructProcess()
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(new G4eIonisation(), particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(ss, particle);
@@ -198,13 +196,11 @@ void G4EmStandardPhysics::ConstructProcess()
// e+
particle = G4Positron::Positron();
msc = new G4eMultipleScattering;
msc1 = new G4UrbanMscModel();
msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->SetEmModel(msc1);
msc->SetEmModel(msc2);
G4EmBuilder::ConstructElectronMscProcess(msc1, msc2, particle);
ssm = new G4eCoulombScatteringModel();
ss = new G4CoulombScattering();
@@ -213,7 +209,6 @@ void G4EmStandardPhysics::ConstructProcess()
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);
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysicsSS.cc
+5
View File
@@ -63,6 +63,8 @@
#include "G4LivermorePhotoElectricModel.hh"
#include "G4LivermorePolarizedRayleighModel.hh"
#include "G4PhotoElectricAngularGeneratorPolarized.hh"
#include "G4LindhardSorensenIonModel.hh"
#include "G4IonFluctuations.hh"
//#include "G4eSingleCoulombScatteringModel.hh"
#include "G4eDPWACoulombScatteringModel.hh"
@@ -211,6 +213,9 @@ void G4EmStandardPhysicsSS::ConstructProcess()
// generic ion
particle = G4GenericIon::GenericIon();
G4ionIonisation* ionIoni = new G4ionIonisation();
auto fluc = new G4IonFluctuations();
ionIoni->SetFluctModel(fluc);
ionIoni->SetEmModel(new G4LindhardSorensenIonModel());
ph->RegisterProcess(ionIoni, particle);
ph->RegisterProcess(new G4CoulombScattering(), particle);
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysicsWVI.cc
+3
View File
@@ -73,6 +73,7 @@
#include "G4IonParametrisedLossModel.hh"
#include "G4LindhardSorensenIonModel.hh"
#include "G4BraggIonModel.hh"
#include "G4IonFluctuations.hh"
#include "G4NuclearStopping.hh"
#include "G4eplusTo2GammaOKVIModel.hh"
@@ -225,6 +226,8 @@ void G4EmStandardPhysicsWVI::ConstructProcess()
// generic ion
particle = G4GenericIon::GenericIon();
G4ionIonisation* ionIoni = new G4ionIonisation();
auto fluc = new G4IonFluctuations();
ionIoni->SetFluctModel(fluc);
ionIoni->SetEmModel(new G4LindhardSorensenIonModel());
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(ionIoni, particle);
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysics_option1.cc
+4 -9
View File
@@ -46,7 +46,6 @@
#include "G4PhotoElectricEffect.hh"
#include "G4LivermorePhotoElectricModel.hh"
#include "G4eMultipleScattering.hh"
#include "G4hMultipleScattering.hh"
#include "G4eCoulombScatteringModel.hh"
#include "G4CoulombScattering.hh"
@@ -90,6 +89,8 @@ G4EmStandardPhysics_option1::G4EmStandardPhysics_option1(G4int ver,
param->SetVerbose(ver);
param->SetApplyCuts(true);
param->SetGeneralProcessActive(true);
// Enable the combined G4TransportationWithMsc, but not the internal stepping.
param->SetTransportationWithMsc(G4TransportationWithMscType::fEnabled);
param->SetStepFunction(0.8, 1*CLHEP::mm);
param->SetMscRangeFactor(0.2);
param->SetMscStepLimitType(fMinimal);
@@ -152,13 +153,11 @@ void G4EmStandardPhysics_option1::ConstructProcess()
G4eIonisation* eioni = new G4eIonisation();
G4eMultipleScattering* msc = new G4eMultipleScattering;
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->SetEmModel(msc1);
msc->SetEmModel(msc2);
G4EmBuilder::ConstructElectronMscProcess(msc1, msc2, particle);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
@@ -167,7 +166,6 @@ void G4EmStandardPhysics_option1::ConstructProcess()
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eioni, particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(ss, particle);
@@ -176,13 +174,11 @@ void G4EmStandardPhysics_option1::ConstructProcess()
particle = G4Positron::Positron();
eioni = new G4eIonisation();
msc = new G4eMultipleScattering;
msc1 = new G4UrbanMscModel();
msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->SetEmModel(msc1);
msc->SetEmModel(msc2);
G4EmBuilder::ConstructElectronMscProcess(msc1, msc2, particle);
ssm = new G4eCoulombScatteringModel();
ss = new G4CoulombScattering();
@@ -191,7 +187,6 @@ void G4EmStandardPhysics_option1::ConstructProcess()
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eioni, particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(new G4eplusAnnihilation(), particle);
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysics_option2.cc
+2 -9
View File
@@ -59,7 +59,6 @@
#include "G4KleinNishinaModel.hh"
#include "G4RayleighScattering.hh"
#include "G4eMultipleScattering.hh"
#include "G4hMultipleScattering.hh"
#include "G4CoulombScattering.hh"
#include "G4eCoulombScatteringModel.hh"
@@ -166,13 +165,11 @@ void G4EmStandardPhysics_option2::ConstructProcess()
G4eIonisation* eioni = new G4eIonisation();
G4eMultipleScattering* msc = new G4eMultipleScattering;
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->SetEmModel(msc1);
msc->SetEmModel(msc2);
G4EmBuilder::ConstructElectronMscProcess(msc1, msc2, particle);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
@@ -181,7 +178,6 @@ void G4EmStandardPhysics_option2::ConstructProcess()
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eioni, particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(ss, particle);
@@ -190,13 +186,11 @@ void G4EmStandardPhysics_option2::ConstructProcess()
particle = G4Positron::Positron();
eioni = new G4eIonisation();
msc = new G4eMultipleScattering;
msc1 = new G4UrbanMscModel();
msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->SetEmModel(msc1);
msc->SetEmModel(msc2);
G4EmBuilder::ConstructElectronMscProcess(msc1, msc2, particle);
ssm = new G4eCoulombScatteringModel();
ss = new G4CoulombScattering();
@@ -205,7 +199,6 @@ void G4EmStandardPhysics_option2::ConstructProcess()
ssm->SetLowEnergyLimit(highEnergyLimit);
ssm->SetActivationLowEnergyLimit(highEnergyLimit);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eioni, particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(new G4eplusAnnihilation(), particle);
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysics_option3.cc
+13 -5
View File
@@ -75,6 +75,8 @@
#include "G4ePairProduction.hh"
#include "G4ionIonisation.hh"
#include "G4IonParametrisedLossModel.hh"
#include "G4LindhardSorensenIonModel.hh"
#include "G4IonFluctuations.hh"
#include "G4NuclearStopping.hh"
#include "G4ParticleTable.hh"
@@ -103,6 +105,7 @@ G4EmStandardPhysics_option3::G4EmStandardPhysics_option3(G4int ver,
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(ver);
param->SetGeneralProcessActive(true);
param->SetMinEnergy(10*CLHEP::eV);
param->SetLowestElectronEnergy(100*CLHEP::eV);
param->SetNumberOfBinsPerDecade(20);
@@ -117,6 +120,7 @@ G4EmStandardPhysics_option3::G4EmStandardPhysics_option3(G4int ver,
param->SetMuHadLateralDisplacement(true);
param->SetLateralDisplacementAlg96(true);
param->SetUseICRU90Data(true);
param->SetFluctuationType(fUrbanFluctuation);
param->SetFluo(true);
param->SetMaxNIELEnergy(1*CLHEP::MeV);
SetPhysicsType(bElectromagnetic);
@@ -199,7 +203,9 @@ void G4EmStandardPhysics_option3::ConstructProcess()
// e-
particle = G4Electron::Electron();
G4eMultipleScattering* msc = new G4eMultipleScattering();
G4UrbanMscModel* msc1 = new G4UrbanMscModel();
G4EmBuilder::ConstructElectronMscProcess(msc1, nullptr, particle);
G4eIonisation* eIoni = new G4eIonisation();
G4eBremsstrahlung* brem = new G4eBremsstrahlung();
@@ -213,7 +219,6 @@ void G4EmStandardPhysics_option3::ConstructProcess()
G4ePairProduction* ee = new G4ePairProduction();
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eIoni, particle);
ph->RegisterProcess(brem, particle);
ph->RegisterProcess(ee, particle);
@@ -221,7 +226,9 @@ void G4EmStandardPhysics_option3::ConstructProcess()
// e+
particle = G4Positron::Positron();
msc = new G4eMultipleScattering();
msc1 = new G4UrbanMscModel();
G4EmBuilder::ConstructElectronMscProcess(msc1, nullptr, particle);
eIoni = new G4eIonisation();
brem = new G4eBremsstrahlung();
@@ -233,7 +240,6 @@ void G4EmStandardPhysics_option3::ConstructProcess()
brem->SetEmModel(br2);
br2->SetLowEnergyLimit(CLHEP::GeV);
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eIoni, particle);
ph->RegisterProcess(brem, particle);
ph->RegisterProcess(ee, particle);
@@ -242,7 +248,9 @@ void G4EmStandardPhysics_option3::ConstructProcess()
// generic ion
particle = G4GenericIon::GenericIon();
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetEmModel(new G4IonParametrisedLossModel());
auto fluc = new G4IonFluctuations();
ionIoni->SetFluctModel(fluc);
ionIoni->SetEmModel(new G4LindhardSorensenIonModel());
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(ionIoni, particle);
if(nullptr != pnuc) { ph->RegisterProcess(pnuc, particle); }
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysics_option4.cc
+13 -20
View File
@@ -46,6 +46,7 @@
#include "G4LossTableManager.hh"
#include "G4EmParameters.hh"
#include "G4EmBuilder.hh"
#include "G4EmStandUtil.hh"
#include "G4ComptonScattering.hh"
#include "G4GammaConversion.hh"
@@ -60,7 +61,6 @@
#include "G4LowEPComptonModel.hh"
#include "G4LowEPPolarizedComptonModel.hh"
#include "G4eMultipleScattering.hh"
#include "G4hMultipleScattering.hh"
#include "G4MscStepLimitType.hh"
#include "G4UrbanMscModel.hh"
@@ -78,14 +78,13 @@
#include "G4ePairProduction.hh"
#include "G4LivermoreIonisationModel.hh"
#include "G4PenelopeIonisationModel.hh"
#include "G4UniversalFluctuation.hh"
#include "G4UrbanFluctuation.hh"
#include "G4eplusAnnihilation.hh"
#include "G4hIonisation.hh"
#include "G4ionIonisation.hh"
#include "G4IonParametrisedLossModel.hh"
#include "G4LindhardSorensenIonModel.hh"
#include "G4NuclearStopping.hh"
#include "G4Gamma.hh"
@@ -113,6 +112,7 @@ G4EmStandardPhysics_option4::G4EmStandardPhysics_option4(G4int ver,
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetVerbose(ver);
param->SetGeneralProcessActive(true);
param->SetMinEnergy(100*CLHEP::eV);
param->SetLowestElectronEnergy(100*CLHEP::eV);
param->SetNumberOfBinsPerDecade(20);
@@ -128,6 +128,7 @@ G4EmStandardPhysics_option4::G4EmStandardPhysics_option4(G4int ver,
param->SetMuHadLateralDisplacement(true);
param->SetFluo(true);
param->SetUseICRU90Data(true);
param->SetFluctuationType(fUrbanFluctuation);
param->SetMaxNIELEnergy(1*CLHEP::MeV);
SetPhysicsType(bElectromagnetic);
}
@@ -224,16 +225,13 @@ void G4EmStandardPhysics_option4::ConstructProcess()
// e-
particle = G4Electron::Electron();
// multiple scattering
G4eMultipleScattering* msc = new G4eMultipleScattering();
// e-/e+ msc gs with Mott-correction
// (Mott-correction is set through G4EmParameters)
G4GoudsmitSaundersonMscModel* msc1 = new G4GoudsmitSaundersonMscModel();
G4WentzelVIModel* msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->SetEmModel(msc1);
msc->SetEmModel(msc2);
G4EmBuilder::ConstructElectronMscProcess(msc1, msc2, particle);
G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();
G4CoulombScattering* ss = new G4CoulombScattering();
@@ -244,10 +242,10 @@ void G4EmStandardPhysics_option4::ConstructProcess()
// ionisation
G4eIonisation* eioni = new G4eIonisation();
G4VEmModel* theIoniLiv = new G4LivermoreIonisationModel();
eioni->SetFluctModel(new G4UrbanFluctuation());
theIoniLiv->SetHighEnergyLimit(0.1*CLHEP::MeV);
eioni->AddEmModel(0, theIoniLiv, new G4UniversalFluctuation() );
eioni->SetFluctModel(G4EmStandUtil::ModelOfFluctuations());
G4VEmModel* theIoniMod = new G4PenelopeIonisationModel();
theIoniMod->SetHighEnergyLimit(0.1*CLHEP::MeV);
eioni->AddEmModel(0, theIoniMod);
// bremsstrahlung
G4eBremsstrahlung* brem = new G4eBremsstrahlung();
@@ -262,7 +260,6 @@ void G4EmStandardPhysics_option4::ConstructProcess()
G4ePairProduction* ee = new G4ePairProduction();
// register processes
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eioni, particle);
ph->RegisterProcess(brem, particle);
ph->RegisterProcess(ee, particle);
@@ -271,16 +268,13 @@ void G4EmStandardPhysics_option4::ConstructProcess()
// e+
particle = G4Positron::Positron();
// multiple scattering
msc = new G4eMultipleScattering();
// e-/e+ msc gs with Mott-correction
// (Mott-correction is set through G4EmParameters)
msc1 = new G4GoudsmitSaundersonMscModel();
msc2 = new G4WentzelVIModel();
msc1->SetHighEnergyLimit(highEnergyLimit);
msc2->SetLowEnergyLimit(highEnergyLimit);
msc->SetEmModel(msc1);
msc->SetEmModel(msc2);
G4EmBuilder::ConstructElectronMscProcess(msc1, msc2, particle);
ssm = new G4eCoulombScatteringModel();
ss = new G4CoulombScattering();
@@ -291,10 +285,10 @@ void G4EmStandardPhysics_option4::ConstructProcess()
// ionisation
eioni = new G4eIonisation();
eioni->SetFluctModel(new G4UrbanFluctuation());
eioni->SetFluctModel(G4EmStandUtil::ModelOfFluctuations());
G4VEmModel* pen = new G4PenelopeIonisationModel();
pen->SetHighEnergyLimit(0.1*CLHEP::MeV);
eioni->AddEmModel(0, pen, new G4UniversalFluctuation());
eioni->AddEmModel(0, pen);
// bremsstrahlung
brem = new G4eBremsstrahlung();
@@ -307,7 +301,6 @@ void G4EmStandardPhysics_option4::ConstructProcess()
br1->SetHighEnergyLimit(CLHEP::GeV);
// register processes
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(eioni, particle);
ph->RegisterProcess(brem, particle);
ph->RegisterProcess(ee, particle);
@@ -317,7 +310,7 @@ void G4EmStandardPhysics_option4::ConstructProcess()
// generic ion
particle = G4GenericIon::GenericIon();
G4ionIonisation* ionIoni = new G4ionIonisation();
ionIoni->SetEmModel(new G4IonParametrisedLossModel());
ionIoni->SetEmModel(new G4LindhardSorensenIonModel());
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(ionIoni, particle);
if(nullptr != pnuc) { ph->RegisterProcess(pnuc, particle); }
source/physics_lists/constructors/electromagnetic/src/G4GammaGeneralProcess.cc
+7
View File
@@ -774,3 +774,10 @@ G4VEmProcess* G4GammaGeneralProcess::GetEmProcess(const G4String& name)
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
const G4VProcess* G4GammaGeneralProcess::GetCreatorProcess() const
{
return selectedProc;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....