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

Import Geant4 10.4.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2017-06-30 10:49:55 +02:00
parent 3a5407696b
commit 1a1316fea4
2180 changed files with 237880 additions and 59109 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/physics_lists/constructors/decay/History
+10 -4
View File
@@ -1,4 +1,4 @@
$Id: History 102586 2017-02-09 09:51:41Z gcosmo $
$Id: History 104632 2017-06-08 13:51:09Z gcosmo $
-------------------------------------------------------------------
=========================================================
@@ -14,13 +14,19 @@ introduced in the code and keeptrack of all tags.
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
23-Dec-2016, Laurent Desorgher (phys-ctor-decay-V10-02-09)
27-Feb-2017, Vladimir Ivanchenko (phys-ctor-decay-V10-03-02)
- G4RadioactiveDecayPhysics - set time limit for the de-excitation module
the same as in G4NuclideTable, so only states from this table will
be created as ions
23-Dec-2016, Laurent Desorgher (phys-ctor-decay-V10-03-01)
-G4RadioactiveDecayPhysics switch on the storing of all internal conversion data vector
(G4NuclearLevelData::GetInstance()->GetParameters()->SetStoreAllLevels(true)) for
correct gamma deexcitation modeling in radioactive decay.
16-Dec-2016, Vladimir Ivanchenko (phys-ctor-decay-V10-02-08)
- G4RadioactiveDecayPhysics - simplified list of EM parameters.
16-Dec-2016, Vladimir Ivanchenko (phys-ctor-decay-V10-03-00)
- G4RadioactiveDecayPhysics - simplified list of EM parameters;
use a new method AddPhysics() instead of old AddMsc()
02-Dec-2016, Vladimir Ivanchenko (phys-ctor-decay-V10-02-07)
- G4RadioactiveDecayPhysics - fixed initialisation (also for the
source/physics_lists/constructors/decay/src/G4RadioactiveDecayPhysics.cc
+7 -3
View File
@@ -38,6 +38,7 @@
#include "G4LossTableManager.hh"
#include "G4NuclearLevelData.hh"
#include "G4DeexPrecoParameters.hh"
#include "G4NuclideTable.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
@@ -52,10 +53,13 @@ G4RadioactiveDecayPhysics::G4RadioactiveDecayPhysics(G4int)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetAugerCascade(true);
param->AddMsc("world","G4RadioactiveDecay");
param->AddPhysics("world","G4RadioactiveDecay");
G4NuclearLevelData::GetInstance()->GetParameters()->SetUseFilesNEW(true);
G4NuclearLevelData::GetInstance()->GetParameters()->SetStoreAllLevels(true);
G4DeexPrecoParameters* deex = G4NuclearLevelData::GetInstance()->GetParameters();
deex->SetUseFilesNEW(true);
deex->SetStoreAllLevels(true);
deex->SetMaxLifeTime(G4NuclideTable::GetInstance()->GetThresholdOfHalfLife()
/std::log(2.));
}
G4RadioactiveDecayPhysics::G4RadioactiveDecayPhysics(const G4String&)
source/physics_lists/constructors/electromagnetic/History
+52 -2
View File
@@ -1,4 +1,4 @@
$Id: History 102543 2017-02-08 14:16:52Z gcosmo $
$Id: History 104571 2017-06-06 13:45:47Z gcosmo $
-------------------------------------------------------------------
=========================================================
@@ -14,10 +14,60 @@ introduced in the code and keeptrack of all tags.
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
19-January-2017 P. Gumplinger (phys-ctor-em-V10-02-39)
06-June-2017 V.Ivanchenko (phys-ctor-em-V10-03-12)
- G4EmStandardPhysics_option3 - use G4UniversalFluctuation2017
for energy loss fluctuation of e+-, protons, anti_protons
01-June-2017 V.Ivanchenko (phys-ctor-em-V10-03-11)
- G4EmStandardPhysicsSS - use G4hCoulombScatteringModel to take into
account relativistic corrections
01-June-2017 V.Ivanchenko (phys-ctor-em-V10-03-10)
- G4EmStandardPhysicsWVI - use G4WentzelVIRelModel and
G4hCoulombScatteringModel to take into account relativistic
corrections
08-May-2017 V.Ivanchenko (phys-ctor-em-V10-03-09)
- G4EmStandardPhysics - use RayleighScattering and LivermorePhotoElectricModel
04-May-2017 V.Ivanchenko (phys-ctor-em-V10-03-08)
- G4EmStandardPhysics_option4 - set finalStep for all changed
10 um (except GenericIon), this will somehow slow down the
simulation but increase accuracy of range simulation
- G4EmParticleList - new class with the list of particles,
for whichg EM processes are instantiated
- G4EmModelActivator - fixed Opt4 and SS per region
29-April-2017 S.Incerti (phys-ctor-em-V10-03-07)
- added stationary Geant4-DNA constructors
25-April-2017 V.Ivanchenko (phys-ctor-em-V10-03-06)
- G4EmStandardPhysicsWVI - revert back
- G4EmStandardPhysicsSS - apply single scattering to all particles
(bug fix #1966)
27-March-2017 V.Ivanchenko (phys-ctor-em-V10-03-05)
- G4EmStandardPhysicsWVI - use G4WentzelVIRelModel and
G4hCoulombScatteringModel to take into account relativistic
corrections
19-January-2017 P. Gumplinger (phys-ctor-em-V10-03-04)
- add setCerenkov/ScintillationStackPhotons commands to
G4OpticalPhysicsMessenger and use them in G4OpticalPhysics
02-January-2017 S. Incerti (phys-ctor-em-V10-03-03)
- added elastic scattering process for ions to all DNA constructors
27-December-2016 S. Incerti (phys-ctor-em-V10-03-02)
- fixed compilation error
27-December-2016 S. Incerti (phys-ctor-em-V10-03-01)
- added G4EmDNAPhysics_option6
16-December-2016 V.Ivanchenko (phys-ctor-em-V10-03-00)
- G4EmModelActivator - use new access methods RegionsPhysics() and
TypesPhysics() instead of RegionsMsc() and TypesMsc()
02-December-2016 V.Ivanchenko (phys-ctor-em-V10-02-38)
- G4EmModelActivator - added initialisation of atomic deexcitation
for radioactive decay (also for the cases when radioactive
source/physics_lists/constructors/electromagnetic/include/G4EmDNAPhysics_option6.hh
+70
View File
@@ -0,0 +1,70 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// Based on the work of M. Terrissol and M. C. Bordage
//
// Users are requested to cite the following papers:
// - M. Terrissol, A. Baudre, Radiat. Prot. Dosim. 31 (1990) 175-177
// - M.C. Bordage, J. Bordes, S. Edel, M. Terrissol, X. Franceries,
// M. Bardies, N. Lampe, S. Incerti, Phys. Med. 32 (2016) 1833-1840
//
// Authors of this class:
// M.C. Bordage, M. Terrissol, S. Edel, J. Bordes, S. Incerti
//
// 15.01.2014: creation
//
#ifndef G4EmDNAPhysics_option6_h
#define G4EmDNAPhysics_option6_h 1
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class G4EmDNAPhysics_option6 : public G4VPhysicsConstructor
{
public:
G4EmDNAPhysics_option6(G4int ver=1, const G4String& name="");
virtual ~G4EmDNAPhysics_option6();
virtual void ConstructParticle();
virtual void ConstructProcess();
private:
G4int verbose;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
source/physics_lists/constructors/electromagnetic/include/G4EmDNAPhysics_stationary.hh
+57
View File
@@ -0,0 +1,57 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
#ifndef G4EmDNAPhysics_stationary_h
#define G4EmDNAPhysics_stationary_h 1
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class G4EmDNAPhysics_stationary : public G4VPhysicsConstructor
{
public:
G4EmDNAPhysics_stationary(G4int ver = 1);
G4EmDNAPhysics_stationary(G4int ver, const G4String& name);
virtual ~G4EmDNAPhysics_stationary();
virtual void ConstructParticle();
virtual void ConstructProcess();
private:
G4int verbose;
};
#endif
source/physics_lists/constructors/electromagnetic/include/G4EmDNAPhysics_stationary_option2.hh
+57
View File
@@ -0,0 +1,57 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
#ifndef G4EmDNAPhysics_stationary_option2_h
#define G4EmDNAPhysics_stationary_option2_h 1
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class G4EmDNAPhysics_stationary_option2 : public G4VPhysicsConstructor
{
public:
G4EmDNAPhysics_stationary_option2(G4int ver = 1);
G4EmDNAPhysics_stationary_option2(G4int ver, const G4String& name);
virtual ~G4EmDNAPhysics_stationary_option2();
virtual void ConstructParticle();
virtual void ConstructProcess();
private:
G4int verbose;
};
#endif
source/physics_lists/constructors/electromagnetic/include/G4EmDNAPhysics_stationary_option4.hh
+57
View File
@@ -0,0 +1,57 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
#ifndef G4EmDNAPhysics_stationary_option4_h
#define G4EmDNAPhysics_stationary_option4_h 1
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class G4EmDNAPhysics_stationary_option4 : public G4VPhysicsConstructor
{
public:
G4EmDNAPhysics_stationary_option4(G4int ver = 1);
G4EmDNAPhysics_stationary_option4(G4int ver, const G4String& name);
virtual ~G4EmDNAPhysics_stationary_option4();
virtual void ConstructParticle();
virtual void ConstructProcess();
private:
G4int verbose;
};
#endif
source/physics_lists/constructors/electromagnetic/include/G4EmDNAPhysics_stationary_option6.hh
+57
View File
@@ -0,0 +1,57 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
#ifndef G4EmDNAPhysics_stationary_option6_h
#define G4EmDNAPhysics_stationary_option6_h 1
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class G4EmDNAPhysics_stationary_option6 : public G4VPhysicsConstructor
{
public:
G4EmDNAPhysics_stationary_option6(G4int ver = 1);
G4EmDNAPhysics_stationary_option6(G4int ver, const G4String& name);
virtual ~G4EmDNAPhysics_stationary_option6();
virtual void ConstructParticle();
virtual void ConstructProcess();
private:
G4int verbose;
};
#endif
source/physics_lists/constructors/electromagnetic/include/G4EmParticleList.hh
+67
View File
@@ -0,0 +1,67 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmParticleList 99930 2016-10-11 16:34:52Z gunter $
//
//---------------------------------------------------------------------------
//
// ClassName: G4EmParticleList
//
// Author: V.Ivanchenko 04.05.2017
//
// Modified:
//
//----------------------------------------------------------------------------
//
// class description
//
// The class provides list of particles which have EM interactions
//
// class description - end
#ifndef G4EmParticleList_h
#define G4EmParticleList_h 1
#include "globals.hh"
#include <vector>
class G4EmParticleList {
public:
explicit G4EmParticleList();
~G4EmParticleList();
const std::vector<G4String>& PartNames() const;
private:
std::vector<G4String> pNames;
};
#endif
source/physics_lists/constructors/electromagnetic/sources.cmake
+13 -1
View File
@@ -11,7 +11,7 @@
#
# Generated on : 10/01/2013
#
# $Id: sources.cmake 98736 2016-08-09 10:55:12Z gcosmo $
# $Id: sources.cmake 104020 2017-05-08 07:34:58Z gcosmo $
#
#------------------------------------------------------------------------------
@@ -75,13 +75,19 @@ GEANT4_DEFINE_MODULE(NAME G4phys_ctor_em
G4EmDNAPhysics_option3.hh
G4EmDNAPhysics_option4.hh
G4EmDNAPhysics_option5.hh
G4EmDNAPhysics_option6.hh
G4EmDNAPhysics_option7.hh
G4EmDNAPhysics_stationary.hh
G4EmDNAPhysics_stationary_option2.hh
G4EmDNAPhysics_stationary_option4.hh
G4EmDNAPhysics_stationary_option6.hh
G4EmDNAPhysicsActivator.hh
G4EmLEPTSPhysics.hh
G4EmLivermorePhysics.hh
G4EmLivermorePolarizedPhysics.hh
G4EmLowEPPhysics.hh
G4EmModelActivator.hh
G4EmParticleList.hh
G4EmPenelopePhysics.hh
G4EmStandardPhysics.hh
G4EmStandardPhysicsGS.hh
@@ -102,13 +108,19 @@ GEANT4_DEFINE_MODULE(NAME G4phys_ctor_em
G4EmDNAPhysics_option3.cc
G4EmDNAPhysics_option4.cc
G4EmDNAPhysics_option5.cc
G4EmDNAPhysics_option6.cc
G4EmDNAPhysics_option7.cc
G4EmDNAPhysics_stationary.cc
G4EmDNAPhysics_stationary_option2.cc
G4EmDNAPhysics_stationary_option4.cc
G4EmDNAPhysics_stationary_option6.cc
G4EmDNAPhysicsActivator.cc
G4EmLEPTSPhysics.cc
G4EmLivermorePhysics.cc
G4EmLivermorePolarizedPhysics.cc
G4EmLowEPPhysics.cc
G4EmModelActivator.cc
G4EmParticleList.cc
G4EmPenelopePhysics.cc
G4EmStandardPhysics.cc
G4EmStandardPhysicsGS.cc
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics.cc
+6 -9
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmDNAPhysics.cc 99938 2016-10-12 08:06:52Z gcosmo $
// $Id: G4EmDNAPhysics.cc 102173 2017-01-09 13:19:42Z gcosmo $
// add elastic scattering processes of proton, hydrogen, helium, alpha+, alpha++
#include "G4EmDNAPhysics.hh"
@@ -182,39 +182,36 @@ void G4EmDNAPhysics::ConstructProcess()
ph->RegisterProcess(new G4DNAAttachment("e-_G4DNAAttachment"), particle);
} else if ( particleName == "proton" ) {
//ph->RegisterProcess(new G4DNAElastic("proton_G4DNAElastic"), particle);
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 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 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 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 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
//SEB
} else if ( particleName == "GenericIon" ) {
ph->RegisterProcess(new G4DNAIonisation("GenericIon_G4DNAIonisation"), particle);
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_option2.cc
+10
View File
@@ -184,6 +184,8 @@ void G4EmDNAPhysics_option2::ConstructProcess()
} else if ( particleName == "proton" ) {
ph->RegisterProcess(new G4DNAElastic("proton_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("proton_G4DNAExcitation"), particle);
G4DNAIonisation* theDNAIonisationProcess = new G4DNAIonisation("proton_G4DNAIonisation");
@@ -208,6 +210,8 @@ void G4EmDNAPhysics_option2::ConstructProcess()
} 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);
@@ -219,6 +223,8 @@ void G4EmDNAPhysics_option2::ConstructProcess()
} 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);
@@ -230,6 +236,8 @@ void G4EmDNAPhysics_option2::ConstructProcess()
} 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);
@@ -242,6 +250,8 @@ void G4EmDNAPhysics_option2::ConstructProcess()
} 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);
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_option4.cc
+5
View File
@@ -189,27 +189,32 @@ void G4EmDNAPhysics_option4::ConstructProcess()
//ph->RegisterProcess(new G4DNAAttachment("e-_G4DNAAttachment"), particle);
} else if ( particleName == "proton" ) {
ph->RegisterProcess(new G4DNAElastic("proton_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("proton_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("proton_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeDecrease("proton_G4DNAChargeDecrease"), particle);
} else if ( particleName == "hydrogen" ) {
ph->RegisterProcess(new G4DNAElastic("hydrogen_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("hydrogen_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("hydrogen_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("hydrogen_G4DNAChargeIncrease"), particle);
} else if ( particleName == "alpha" ) {
ph->RegisterProcess(new G4DNAElastic("alpha_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("alpha_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("alpha_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeDecrease("alpha_G4DNAChargeDecrease"), particle);
} else if ( particleName == "alpha+" ) {
ph->RegisterProcess(new G4DNAElastic("alpha+_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("alpha+_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("alpha+_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeDecrease("alpha+_G4DNAChargeDecrease"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("alpha+_G4DNAChargeIncrease"), particle);
} else if ( particleName == "helium" ) {
ph->RegisterProcess(new G4DNAElastic("helium_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("helium_G4DNAExcitation"), particle);
ph->RegisterProcess(new G4DNAIonisation("helium_G4DNAIonisation"), particle);
ph->RegisterProcess(new G4DNAChargeIncrease("helium_G4DNAChargeIncrease"), particle);
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_option5.cc
+10
View File
@@ -189,6 +189,8 @@ void G4EmDNAPhysics_option5::ConstructProcess()
} else if ( particleName == "proton" ) {
ph->RegisterProcess(new G4DNAElastic("proton_G4DNAElastic"), particle);
ph->RegisterProcess(new G4DNAExcitation("proton_G4DNAExcitation"), particle);
G4DNAIonisation* theDNAIonisationProcess = new G4DNAIonisation("proton_G4DNAIonisation");
@@ -213,6 +215,8 @@ void G4EmDNAPhysics_option5::ConstructProcess()
} 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);
@@ -224,6 +228,8 @@ void G4EmDNAPhysics_option5::ConstructProcess()
} 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);
@@ -235,6 +241,8 @@ void G4EmDNAPhysics_option5::ConstructProcess()
} 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);
@@ -247,6 +255,8 @@ void G4EmDNAPhysics_option5::ConstructProcess()
} 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);
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_option6.cc
+302
View File
@@ -0,0 +1,302 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// Based on the work of M. Terrissol and M. C. Bordage
//
// Users are requested to cite the following papers:
// - M. Terrissol, A. Baudre, Radiat. Prot. Dosim. 31 (1990) 175-177
// - M.C. Bordage, J. Bordes, S. Edel, M. Terrissol, X. Franceries,
// M. Bardies, N. Lampe, S. Incerti, Phys. Med. 32 (2016) 1833-1840
//
// Authors of this class:
// M.C. Bordage, M. Terrissol, S. Edel, J. Bordes, S. Incerti
//
// 15.01.2014: creation
//
#include "G4EmDNAPhysics_option6.hh"
#include "G4SystemOfUnits.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"
#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_option6);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_option6::G4EmDNAPhysics_option6(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmDNAPhysics_option6"), verbose(ver)
{
// G4EmParameters::Instance()->SetDefaults();
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetFluo(true);
param->SetAuger(true);
param->SetAugerCascade(true);
param->SetDeexcitationIgnoreCut(true);
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");
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_option6::ConstructProcess()
{
if(verbose > 1) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
//OLD
//aParticleIterator->reset();
//while( (*aParticleIterator)() )
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");
G4DNAOneStepThermalizationModel* therm =
new G4DNAOneStepThermalizationModel();
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);
// *** 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") {
G4double LivermoreHighEnergyLimit = GeV;
G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
G4LivermorePhotoElectricModel* theLivermorePhotoElectricModel =
new G4LivermorePhotoElectricModel();
theLivermorePhotoElectricModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
thePhotoElectricEffect->AddEmModel(0, theLivermorePhotoElectricModel);
ph->RegisterProcess(thePhotoElectricEffect, particle);
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
G4LivermoreComptonModel* theLivermoreComptonModel =
new G4LivermoreComptonModel();
theLivermoreComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theComptonScattering->AddEmModel(0, theLivermoreComptonModel);
ph->RegisterProcess(theComptonScattering, particle);
G4GammaConversion* theGammaConversion = new G4GammaConversion();
G4LivermoreGammaConversionModel* theLivermoreGammaConversionModel =
new G4LivermoreGammaConversionModel();
theLivermoreGammaConversionModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theGammaConversion->AddEmModel(0, theLivermoreGammaConversionModel);
ph->RegisterProcess(theGammaConversion, particle);
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
G4LivermoreRayleighModel* theRayleighModel = new G4LivermoreRayleighModel();
theRayleighModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theRayleigh->AddEmModel(0, theRayleighModel);
ph->RegisterProcess(theRayleigh, particle);
}
// Warning : end of particles and processes are needed by EM Physics builders
}
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_stationary.cc
+535
View File
@@ -0,0 +1,535 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
#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 "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);
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_stationary::G4EmDNAPhysics_stationary(G4int ver)
: G4VPhysicsConstructor("G4EmDNAPhysics_stationary"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetFluo(true);
param->SetAuger(true);
param->SetAugerCascade(true);
param->SetDeexcitationIgnoreCut(true);
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_stationary::G4EmDNAPhysics_stationary(G4int ver, const G4String&)
: G4VPhysicsConstructor("G4EmDNAPhysics_stationary"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetFluo(true);
param->SetAuger(true);
param->SetAugerCascade(true);
param->SetDeexcitationIgnoreCut(true);
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_stationary::~G4EmDNAPhysics_stationary()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4EmDNAPhysics_stationary::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::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);
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(),1);
theDNAExcitationProcess
->SetEmModel(new G4DNABornExcitationModel(),2);
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel(1)))->SetLowEnergyLimit(10*eV);
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel(1)))->SetHighEnergyLimit(500*keV);
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel(1)))->SelectStationary(true);
((G4DNABornExcitationModel*)
(theDNAExcitationProcess->EmModel(2)))->SetLowEnergyLimit(500*keV);
((G4DNABornExcitationModel*)
(theDNAExcitationProcess->EmModel(2)))->SetHighEnergyLimit(100*MeV);
((G4DNABornExcitationModel*)
(theDNAExcitationProcess->EmModel(2)))->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("proton_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(new G4DNARuddIonisationModel,1);
theDNAIonisationProcess->SetEmModel(new G4DNABornIonisationModel,2);
((G4DNARuddIonisationModel*)(theDNAIonisationProcess->EmModel(1)))
->SetLowEnergyLimit(0*eV);
((G4DNARuddIonisationModel*)(theDNAIonisationProcess->EmModel(1)))
->SetHighEnergyLimit(500*keV);
((G4DNARuddIonisationModel*)(theDNAIonisationProcess->EmModel(1)))
->SelectStationary(true);
((G4DNABornIonisationModel*)(theDNAIonisationProcess->EmModel(2)))
->SetLowEnergyLimit(500*keV);
((G4DNABornIonisationModel*)(theDNAIonisationProcess->EmModel(2)))
->SetHighEnergyLimit(100*MeV);
((G4DNABornIonisationModel*)(theDNAIonisationProcess->EmModel(2)))
->SelectStationary(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 G4DNARuddIonisationModel());
((G4DNARuddIonisationModel*)(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 G4DNARuddIonisationModel());
((G4DNARuddIonisationModel*)(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 G4DNARuddIonisationModel());
((G4DNARuddIonisationModel*)(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 G4DNARuddIonisationModel());
((G4DNARuddIonisationModel*)(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") {
G4double LivermoreHighEnergyLimit = GeV;
G4PhotoElectricEffect*
thePhotoElectricEffect = new G4PhotoElectricEffect();
G4LivermorePhotoElectricModel* theLivermorePhotoElectricModel =
new G4LivermorePhotoElectricModel();
theLivermorePhotoElectricModel
->SetHighEnergyLimit(LivermoreHighEnergyLimit);
thePhotoElectricEffect->AddEmModel(0, theLivermorePhotoElectricModel);
ph->RegisterProcess(thePhotoElectricEffect, particle);
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
G4LivermoreComptonModel* theLivermoreComptonModel =
new G4LivermoreComptonModel();
theLivermoreComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theComptonScattering->AddEmModel(0, theLivermoreComptonModel);
ph->RegisterProcess(theComptonScattering, particle);
G4GammaConversion* theGammaConversion = new G4GammaConversion();
G4LivermoreGammaConversionModel* theLivermoreGammaConversionModel =
new G4LivermoreGammaConversionModel();
theLivermoreGammaConversionModel
->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theGammaConversion->AddEmModel(0, theLivermoreGammaConversionModel);
ph->RegisterProcess(theGammaConversion, particle);
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
G4LivermoreRayleighModel* theRayleighModel =
new G4LivermoreRayleighModel();
theRayleighModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theRayleigh->AddEmModel(0, theRayleighModel);
ph->RegisterProcess(theRayleigh, particle);
}
// Warning : end of particles and processes are needed by EM Physics build.
}
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
}
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_stationary_option2.cc
+547
View File
@@ -0,0 +1,547 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
#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)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetFluo(true);
param->SetAuger(true);
param->SetAugerCascade(true);
param->SetDeexcitationIgnoreCut(true);
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_stationary_option2::G4EmDNAPhysics_stationary_option2(G4int ver,
const G4String&)
: G4VPhysicsConstructor("G4EmDNAPhysics_stationary_option2"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetFluo(true);
param->SetAuger(true);
param->SetAugerCascade(true);
param->SetDeexcitationIgnoreCut(true);
SetPhysicsType(bElectromagnetic);
}
//....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(),1);
theDNAExcitationProcess->SetEmModel
(new G4DNABornExcitationModel(),2);
((G4DNAMillerGreenExcitationModel*)(theDNAExcitationProcess->EmModel(1)))
->SetLowEnergyLimit(10*eV);
((G4DNAMillerGreenExcitationModel*)(theDNAExcitationProcess->EmModel(1)))
->SetHighEnergyLimit(500*keV);
((G4DNAMillerGreenExcitationModel*)(theDNAExcitationProcess->EmModel(1)))
->SelectStationary(true);
((G4DNABornExcitationModel*)(theDNAExcitationProcess->EmModel(2)))
->SetLowEnergyLimit(500*keV);
((G4DNABornExcitationModel*)(theDNAExcitationProcess->EmModel(2)))
->SetHighEnergyLimit(100*MeV);
((G4DNABornExcitationModel*)(theDNAExcitationProcess->EmModel(2)))
->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("proton_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel,1);
theDNAIonisationProcess->SetEmModel(
new G4DNABornIonisationModel,2);
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel(1)))->SetLowEnergyLimit(0*eV);
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel(1)))->SetHighEnergyLimit(500*keV);
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel(1)))->SelectStationary(true);
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(2)))->SetLowEnergyLimit(500*keV);
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(2)))->SetHighEnergyLimit(100*MeV);
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(2)))->SelectStationary(true);
//
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(2)))->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") {
G4double LivermoreHighEnergyLimit = GeV;
G4PhotoElectricEffect* thePhotoElectricEffect =
new G4PhotoElectricEffect();
G4LivermorePhotoElectricModel* theLivermorePhotoElectricModel =
new G4LivermorePhotoElectricModel();
theLivermorePhotoElectricModel
->SetHighEnergyLimit(LivermoreHighEnergyLimit);
thePhotoElectricEffect->AddEmModel(0, theLivermorePhotoElectricModel);
ph->RegisterProcess(thePhotoElectricEffect, particle);
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
G4LivermoreComptonModel* theLivermoreComptonModel =
new G4LivermoreComptonModel();
theLivermoreComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theComptonScattering->AddEmModel(0, theLivermoreComptonModel);
ph->RegisterProcess(theComptonScattering, particle);
G4GammaConversion* theGammaConversion = new G4GammaConversion();
G4LivermoreGammaConversionModel* theLivermoreGammaConversionModel =
new G4LivermoreGammaConversionModel();
theLivermoreGammaConversionModel
->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theGammaConversion->AddEmModel(0, theLivermoreGammaConversionModel);
ph->RegisterProcess(theGammaConversion, particle);
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
G4LivermoreRayleighModel* theRayleighModel =
new G4LivermoreRayleighModel();
theRayleighModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theRayleigh->AddEmModel(0, theRayleighModel);
ph->RegisterProcess(theRayleigh, particle);
}
// Warning : end of particles and processes are needed by EM Physics build.
}
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
de->SetFluo(true);
}
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_stationary_option4.cc
+549
View File
@@ -0,0 +1,549 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
#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)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetFluo(true);
param->SetAuger(true);
param->SetAugerCascade(true);
param->SetDeexcitationIgnoreCut(true);
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_stationary_option4::G4EmDNAPhysics_stationary_option4(G4int ver,
const G4String&)
: G4VPhysicsConstructor("G4EmDNAPhysics_stationary_option4"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetFluo(true);
param->SetAuger(true);
param->SetAugerCascade(true);
param->SetDeexcitationIgnoreCut(true);
SetPhysicsType(bElectromagnetic);
}
//....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(),1);
theDNAExcitationProcess->SetEmModel(
new G4DNABornExcitationModel(),2);
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel(1)))->SetLowEnergyLimit(10*eV);
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel(1)))->SetHighEnergyLimit(500*keV);
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel(1)))->SelectStationary(true);
((G4DNABornExcitationModel*)
(theDNAExcitationProcess->EmModel(2)))->SetLowEnergyLimit(500*keV);
((G4DNABornExcitationModel*)
(theDNAExcitationProcess->EmModel(2)))->SetHighEnergyLimit(100*MeV);
((G4DNABornExcitationModel*)
(theDNAExcitationProcess->EmModel(2)))->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("proton_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel,1);
theDNAIonisationProcess->SetEmModel(
new G4DNABornIonisationModel,2);
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel(1)))->SetLowEnergyLimit(0*eV);
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel(1)))->SetHighEnergyLimit(500*keV);
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel(1)))->SelectStationary(true);
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(2)))->SetLowEnergyLimit(500*keV);
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(2)))->SetHighEnergyLimit(100*MeV);
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(2)))->SelectStationary(true);
//
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(2)))->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") {
G4double LivermoreHighEnergyLimit = GeV;
G4PhotoElectricEffect* thePhotoElectricEffect =
new G4PhotoElectricEffect();
G4LivermorePhotoElectricModel* theLivermorePhotoElectricModel =
new G4LivermorePhotoElectricModel();
theLivermorePhotoElectricModel
->SetHighEnergyLimit(LivermoreHighEnergyLimit);
thePhotoElectricEffect->AddEmModel(0, theLivermorePhotoElectricModel);
ph->RegisterProcess(thePhotoElectricEffect, particle);
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
G4LivermoreComptonModel* theLivermoreComptonModel =
new G4LivermoreComptonModel();
theLivermoreComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theComptonScattering->AddEmModel(0, theLivermoreComptonModel);
ph->RegisterProcess(theComptonScattering, particle);
G4GammaConversion* theGammaConversion = new G4GammaConversion();
G4LivermoreGammaConversionModel* theLivermoreGammaConversionModel =
new G4LivermoreGammaConversionModel();
theLivermoreGammaConversionModel
->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theGammaConversion->AddEmModel(0, theLivermoreGammaConversionModel);
ph->RegisterProcess(theGammaConversion, particle);
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
G4LivermoreRayleighModel* theRayleighModel =
new G4LivermoreRayleighModel();
theRayleighModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theRayleigh->AddEmModel(0, theRayleighModel);
ph->RegisterProcess(theRayleigh, particle);
}
// Warning : end of particles and processes are needed by EM Physics build.
}
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
}
source/physics_lists/constructors/electromagnetic/src/G4EmDNAPhysics_stationary_option6.cc
+544
View File
@@ -0,0 +1,544 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
#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)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetFluo(true);
param->SetAuger(true);
param->SetAugerCascade(true);
param->SetDeexcitationIgnoreCut(true);
SetPhysicsType(bElectromagnetic);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4EmDNAPhysics_stationary_option6::G4EmDNAPhysics_stationary_option6(G4int ver,
const G4String&)
: G4VPhysicsConstructor("G4EmDNAPhysics_stationary_option6"), verbose(ver)
{
G4EmParameters* param = G4EmParameters::Instance();
param->SetDefaults();
param->SetFluo(true);
param->SetAuger(true);
param->SetAugerCascade(true);
param->SetDeexcitationIgnoreCut(true);
SetPhysicsType(bElectromagnetic);
}
//....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(),1);
theDNAExcitationProcess->SetEmModel(
new G4DNABornExcitationModel(),2);
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel(1)))->SetLowEnergyLimit(10*eV);
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel(1)))->SetHighEnergyLimit(500*keV);
((G4DNAMillerGreenExcitationModel*)
(theDNAExcitationProcess->EmModel(1)))->SelectStationary(true);
((G4DNABornExcitationModel*)
(theDNAExcitationProcess->EmModel(2)))->SetLowEnergyLimit(500*keV);
((G4DNABornExcitationModel*)
(theDNAExcitationProcess->EmModel(2)))->SetHighEnergyLimit(100*MeV);
((G4DNABornExcitationModel*)
(theDNAExcitationProcess->EmModel(2)))->SelectStationary(true);
ph->RegisterProcess(theDNAExcitationProcess, particle);
// *** Ionisation ***
G4DNAIonisation* theDNAIonisationProcess =
new G4DNAIonisation("proton_G4DNAIonisation");
theDNAIonisationProcess->SetEmModel(
new G4DNARuddIonisationExtendedModel,1);
theDNAIonisationProcess->SetEmModel(
new G4DNABornIonisationModel,2);
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel(1)))->SetLowEnergyLimit(0*eV);
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel(1)))->SetHighEnergyLimit(500*keV);
((G4DNARuddIonisationExtendedModel*)
(theDNAIonisationProcess->EmModel(1)))->SelectStationary(true);
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(2)))->SetLowEnergyLimit(500*keV);
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(2)))->SetHighEnergyLimit(100*MeV);
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(2)))->SelectStationary(true);
//
((G4DNABornIonisationModel*)
(theDNAIonisationProcess->EmModel(2)))->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") {
G4double LivermoreHighEnergyLimit = GeV;
G4PhotoElectricEffect* thePhotoElectricEffect =
new G4PhotoElectricEffect();
G4LivermorePhotoElectricModel* theLivermorePhotoElectricModel =
new G4LivermorePhotoElectricModel();
theLivermorePhotoElectricModel
->SetHighEnergyLimit(LivermoreHighEnergyLimit);
thePhotoElectricEffect->AddEmModel(0, theLivermorePhotoElectricModel);
ph->RegisterProcess(thePhotoElectricEffect, particle);
G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
G4LivermoreComptonModel* theLivermoreComptonModel =
new G4LivermoreComptonModel();
theLivermoreComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theComptonScattering->AddEmModel(0, theLivermoreComptonModel);
ph->RegisterProcess(theComptonScattering, particle);
G4GammaConversion* theGammaConversion = new G4GammaConversion();
G4LivermoreGammaConversionModel* theLivermoreGammaConversionModel =
new G4LivermoreGammaConversionModel();
theLivermoreGammaConversionModel
->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theGammaConversion->AddEmModel(0, theLivermoreGammaConversionModel);
ph->RegisterProcess(theGammaConversion, particle);
G4RayleighScattering* theRayleigh = new G4RayleighScattering();
G4LivermoreRayleighModel* theRayleighModel =
new G4LivermoreRayleighModel();
theRayleighModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
theRayleigh->AddEmModel(0, theRayleighModel);
ph->RegisterProcess(theRayleigh, particle);
}
// Warning : end of particles and processes are needed by EM Physics build.
}
// Deexcitation
//
G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
G4LossTableManager::Instance()->SetAtomDeexcitation(de);
}
source/physics_lists/constructors/electromagnetic/src/G4EmModelActivator.cc
+61 -52
View File
@@ -67,6 +67,7 @@
#include "G4DummyModel.hh"
#include "G4EmProcessSubType.hh"
#include "G4PhysicsListHelper.hh"
#include "G4EmParticleList.hh"
#include "G4MicroElecElastic.hh"
#include "G4MicroElecElasticModel.hh"
@@ -86,6 +87,7 @@
#include "G4eCoulombScatteringModel.hh"
#include "G4IonCoulombScatteringModel.hh"
#include "G4ionIonisation.hh"
#include "G4KleinNishinaModel.hh"
#include "G4CoulombScattering.hh"
#include "G4eCoulombScatteringModel.hh"
@@ -94,6 +96,7 @@
#include "G4RayleighScattering.hh"
#include "G4UrbanMscModel.hh"
#include "G4GoudsmitSaundersonMscModel.hh"
#include "G4LowEPComptonModel.hh"
#include "G4LivermorePhotoElectricModel.hh"
#include "G4LivermoreComptonModel.hh"
@@ -142,15 +145,15 @@ G4EmModelActivator::G4EmModelActivator(const G4String& emphys)
void G4EmModelActivator::ActivateEmOptions()
{
const std::vector<G4String> regnamesMSC = theParameters->RegionsMsc();
G4int nreg = regnamesMSC.size();
const std::vector<G4String> regnamesPhys = theParameters->RegionsPhysics();
G4int nreg = regnamesPhys.size();
if(0 == nreg) { return; }
G4int verbose = theParameters->Verbose() - 1;
if(verbose > 0) {
G4cout << "### G4EmModelActivator::ActivateEmOptions for " << nreg << " regions"
<< G4endl;
}
const std::vector<G4String> typesMSC = theParameters->TypesMsc();
const std::vector<G4String> typesPhys = theParameters->TypesMsc();
// start configuration of models
const G4ParticleDefinition* elec = G4Electron::Electron();
@@ -159,18 +162,19 @@ void G4EmModelActivator::ActivateEmOptions()
G4LossTableManager* man = G4LossTableManager::Instance();
G4EmConfigurator* em_config = man->EmConfigurator();
G4VAtomDeexcitation* adeexc = man->AtomDeexcitation();
G4ParticleTable* table = G4ParticleTable::GetParticleTable();
G4VEmModel* mod;
for(G4int i=0; i<nreg; ++i) {
G4String reg = regnamesMSC[i];
G4String reg = regnamesPhys[i];
if(verbose > 0) {
G4cout << i << ". region <" << reg << ">; type <" << typesMSC[i] << "> "
G4cout << i << ". region <" << reg << ">; type <" << typesPhys[i] << "> "
<< G4endl;
}
if(baseName == typesMSC[i]) { continue; }
if(baseName == typesPhys[i]) { continue; }
if("G4EmStandard" == typesMSC[i]) {
if("G4EmStandard" == typesPhys[i]) {
G4UrbanMscModel* msc = new G4UrbanMscModel();
msc->SetLocked(true);
em_config->SetExtraEmModel("e-", "msc", msc, reg, 0.0, 100*MeV);
@@ -178,8 +182,8 @@ void G4EmModelActivator::ActivateEmOptions()
msc->SetLocked(true);
em_config->SetExtraEmModel("e+", "msc", msc, reg, 0.0, 100*MeV);
} else if("G4EmStandard_opt1" == typesMSC[i] ||
"G4EmStandard_opt2" == typesMSC[i]) {
} else if("G4EmStandard_opt1" == typesPhys[i] ||
"G4EmStandard_opt2" == typesPhys[i]) {
G4UrbanMscModel* msc = new G4UrbanMscModel();
msc->SetStepLimitType(fMinimal);
msc->SetRangeFactor(0.2);
@@ -191,7 +195,7 @@ void G4EmModelActivator::ActivateEmOptions()
msc->SetLocked(true);
em_config->SetExtraEmModel("e+", "msc", msc, reg, 0.0, 100*MeV);
} else if("G4EmStandard_opt3" == typesMSC[i]) {
} else if("G4EmStandard_opt3" == typesPhys[i]) {
G4UrbanMscModel* msc = new G4UrbanMscModel();
msc->SetStepLimitType(fUseDistanceToBoundary);
msc->SetLocked(true);
@@ -212,8 +216,14 @@ void G4EmModelActivator::ActivateEmOptions()
FindOrAddProcess(phot, "Rayl");
mod = new G4LivermoreRayleighModel();
em_config->SetExtraEmModel("gamma", "Rayl", mod, reg);
FindOrAddProcess(phot, "phot");
mod = new G4LivermorePhotoElectricModel();
em_config->SetExtraEmModel("gamma", "phot", mod, reg);
FindOrAddProcess(phot, "compt");
mod = new G4KleinNishinaModel();
em_config->SetExtraEmModel("gamma", "compt", mod, reg);
} else if("G4EmStandard_opt4" == typesMSC[i]) {
} else if("G4EmStandard_opt4" == typesPhys[i]) {
G4UrbanMscModel* msc = new G4UrbanMscModel();
msc->SetStepLimitType(fUseDistanceToBoundary);
msc->SetRangeFactor(0.02);
@@ -226,13 +236,24 @@ void G4EmModelActivator::ActivateEmOptions()
em_config->SetExtraEmModel("e+", "msc", msc, reg, 0.0, 100*MeV);
if(G4Threading::IsMasterThread()) {
theParameters->SetDeexActiveRegion(reg, true, false, false);
theParameters->SetStepFunction(0.2, 10*um);
theParameters->SetStepFunctionMuHad(0.2, 10*um);
}
theParameters->DefineRegParamForDeex(adeexc);
FindOrAddProcess(phot, "Rayl");
mod = new G4LivermoreRayleighModel();
em_config->SetExtraEmModel("gamma", "Rayl", mod, reg);
FindOrAddProcess(phot, "phot");
mod = new G4LivermorePhotoElectricModel();
em_config->SetExtraEmModel("gamma", "phot", mod, reg);
FindOrAddProcess(phot, "compt");
mod = new G4KleinNishinaModel();
em_config->SetExtraEmModel("gamma", "compt", mod, reg);
mod = new G4LowEPComptonModel();
mod->SetHighEnergyLimit(20*MeV);
em_config->SetExtraEmModel("gamma", "compt", mod, reg);
} else if("G4EmStandardGS" == typesMSC[i]) {
} else if("G4EmStandardGS" == typesPhys[i]) {
G4GoudsmitSaundersonMscModel* msc = new G4GoudsmitSaundersonMscModel();
msc->SetStepLimitType(fUseSafetyPlus);
msc->SetRangeFactor(0.1);
@@ -244,7 +265,7 @@ void G4EmModelActivator::ActivateEmOptions()
msc->SetLocked(true);
em_config->SetExtraEmModel("e+", "msc", msc, reg, 0.0, 100*MeV);
} else if("G4EmStandardWVI" == typesMSC[i]) {
} else if("G4EmStandardWVI" == typesPhys[i]) {
G4WentzelVIModel* msc = new G4WentzelVIModel();
msc->SetLocked(true);
em_config->SetExtraEmModel("e-", "msc", msc, reg, 0.0, 100*MeV);
@@ -260,48 +281,36 @@ void G4EmModelActivator::ActivateEmOptions()
em_config->SetExtraEmModel("e+", "CoulombScat", mod, reg, 0.0, 100*MeV);
if(G4Threading::IsMasterThread()) {
theParameters->SetDeexActiveRegion(regnamesMSC[i], true, false, false);
theParameters->SetDeexActiveRegion(regnamesPhys[i], true, false, false);
}
theParameters->DefineRegParamForDeex(adeexc);
} else if("G4EmStandardSS" == typesMSC[i] &&
} else if("G4EmStandardSS" == typesPhys[i] &&
baseName != "G4EmStandard_opt3") {
G4eCoulombScatteringModel* sc = new G4eCoulombScatteringModel();
sc->SetPolarAngleLimit(0.0);
sc->SetLocked(true);
em_config->SetExtraEmModel("e-", "CoulombScat", sc, reg);
sc = new G4eCoulombScatteringModel();
sc->SetPolarAngleLimit(0.0);
sc->SetLocked(true);
em_config->SetExtraEmModel("e+", "CoulombScat", sc, reg);
sc = new G4eCoulombScatteringModel();
sc->SetPolarAngleLimit(0.0);
sc->SetLocked(true);
em_config->SetExtraEmModel("mu+", "CoulombScat", sc, reg);
sc = new G4eCoulombScatteringModel();
sc->SetPolarAngleLimit(0.0);
sc->SetLocked(true);
em_config->SetExtraEmModel("pi+", "CoulombScat", sc, reg);
sc = new G4eCoulombScatteringModel();
sc->SetPolarAngleLimit(0.0);
sc->SetLocked(true);
em_config->SetExtraEmModel("kaon+", "CoulombScat", sc, reg);
sc = new G4eCoulombScatteringModel();
sc->SetPolarAngleLimit(0.0);
sc->SetLocked(true);
em_config->SetExtraEmModel("proton", "CoulombScat", sc, reg);
G4EmParticleList emList;
for(const auto& particleName : emList.PartNames()) {
G4ParticleDefinition* particle = table->FindParticle(particleName);
if(particle && 0.0 != particle->GetPDGCharge()) {
FindOrAddProcess(particle, "CoulombScat");
G4eCoulombScatteringModel* sc = new G4eCoulombScatteringModel();
sc->SetPolarAngleLimit(0.0);
sc->SetLocked(true);
em_config->SetExtraEmModel(particleName, "CoulombScat", sc, reg);
if(particleName == "mu+" || particleName == "mu-") {
em_config->SetExtraEmModel(particleName, "muMsc",
new G4DummyModel(), reg);
} else {
em_config->SetExtraEmModel(particleName, "msc",
new G4DummyModel(), reg);
}
}
}
if(G4Threading::IsMasterThread()) {
theParameters->SetDeexActiveRegion(regnamesMSC[i], true, true, true);
theParameters->SetDeexActiveRegion(regnamesPhys[i], true, true, true);
}
theParameters->DefineRegParamForDeex(adeexc);
} else if("G4EmLivermore" == typesMSC[i]) {
} else if("G4EmLivermore" == typesPhys[i]) {
mod = new G4LivermorePhotoElectricModel();
em_config->SetExtraEmModel("gamma", "phot", mod, reg);
@@ -321,11 +330,11 @@ void G4EmModelActivator::ActivateEmOptions()
em_config->SetExtraEmModel("e-", "eBrem", mod, reg, 0.0, 1*GeV);
if(G4Threading::IsMasterThread()) {
theParameters->SetDeexActiveRegion(regnamesMSC[i], true, false, false);
theParameters->SetDeexActiveRegion(regnamesPhys[i], true, false, false);
}
theParameters->DefineRegParamForDeex(adeexc);
} else if("G4EmPenelope" == typesMSC[i]) {
} else if("G4EmPenelope" == typesPhys[i]) {
mod = new G4PenelopePhotoElectricModel();
em_config->SetExtraEmModel("gamma", "phot", mod, reg);
mod = new G4PenelopeComptonModel();
@@ -352,11 +361,11 @@ void G4EmModelActivator::ActivateEmOptions()
em_config->SetExtraEmModel("e+", "annihil", mod, reg, 0.0, 1*GeV);
if(G4Threading::IsMasterThread()) {
theParameters->SetDeexActiveRegion(regnamesMSC[i], true, false, false);
theParameters->SetDeexActiveRegion(regnamesPhys[i], true, false, false);
}
theParameters->DefineRegParamForDeex(adeexc);
} else if("G4RadioactiveDecay" == typesMSC[i]) {
} else if("G4RadioactiveDecay" == typesPhys[i]) {
if(G4Threading::IsMasterThread()) {
theParameters->SetFluo(true);
@@ -369,7 +378,7 @@ void G4EmModelActivator::ActivateEmOptions()
} else {
if(verbose > 0 && G4Threading::IsMasterThread()) {
G4cout << "### G4EmModelActivator::ActivateEmOptions WARNING: \n"
<< " EM Physics configuration name <" << typesMSC[i]
<< " EM Physics configuration name <" << typesPhys[i]
<< "> is not known - ignored" << G4endl;
}
}
source/physics_lists/constructors/electromagnetic/src/G4EmParticleList.cc
+64
View File
@@ -0,0 +1,64 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmParticleList 99930 2016-10-11 16:34:52Z gunter $
//
//---------------------------------------------------------------------------
//
// ClassName: G4EmParticleList
//
// Author: V.Ivanchenko 04.05.2017
//
// Modified:
//
//----------------------------------------------------------------------------
//
#include "G4EmParticleList.hh"
G4EmParticleList::G4EmParticleList()
{
pNames =
{
"gamma", "e-", "e+", "mu+", "mu-",
"pi+", "pi-", "kaon+", "kaon-", "proton",
"anti_proton", "alpha", "He3", "GenericIon", "B+",
"B-", "D+", "D-", "Ds+", "Ds-",
"anti_He3", "anti_alpha","anti_deuteron","anti_lambda_c+","anti_omega-",
"anti_sigma_c+","anti_sigma_c++", "anti_sigma+", "anti_sigma-","anti_triton",
"anti_xi_c+", "anti_xi-", "deuteron", "lambda_c+", "omega-",
"sigma_c+", "sigma_c++", "sigma+", "sigma-", "tau+",
"tau-", "triton", "xi_c+", "xi-"
};
}
G4EmParticleList::~G4EmParticleList()
{}
const std::vector<G4String>& G4EmParticleList::PartNames() const
{
return pNames;
}
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysics.cc
+8 -2
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmStandardPhysics.cc 99938 2016-10-12 08:06:52Z gcosmo $
// $Id: G4EmStandardPhysics.cc 104043 2017-05-09 07:47:10Z gcosmo $
//
//---------------------------------------------------------------------------
//
@@ -51,6 +51,8 @@
#include "G4ComptonScattering.hh"
#include "G4GammaConversion.hh"
#include "G4PhotoElectricEffect.hh"
#include "G4RayleighScattering.hh"
#include "G4LivermorePhotoElectricModel.hh"
#include "G4eMultipleScattering.hh"
#include "G4MuMultipleScattering.hh"
@@ -203,9 +205,13 @@ void G4EmStandardPhysics::ConstructProcess()
if (particleName == "gamma") {
ph->RegisterProcess(new G4PhotoElectricEffect(), particle);
G4PhotoElectricEffect* pee = new G4PhotoElectricEffect();
pee->SetEmModel(new G4LivermorePhotoElectricModel(), 1);
ph->RegisterProcess(pee, particle);
ph->RegisterProcess(new G4ComptonScattering(), particle);
ph->RegisterProcess(new G4GammaConversion(), particle);
ph->RegisterProcess(new G4RayleighScattering(), particle);
} else if (particleName == "e-") {
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysicsSS.cc
+7 -5
View File
@@ -60,6 +60,7 @@
#include "G4hMultipleScattering.hh"
#include "G4CoulombScattering.hh"
#include "G4eCoulombScatteringModel.hh"
#include "G4hCoulombScatteringModel.hh"
#include "G4WentzelVIModel.hh"
#include "G4UrbanMscModel.hh"
@@ -181,14 +182,15 @@ void G4EmStandardPhysicsSS::ConstructProcess()
G4hBremsstrahlung* pb = new G4hBremsstrahlung();
G4hPairProduction* pp = new G4hPairProduction();
// muon & hadron multiple scattering
// muon & hadron scattering
G4CoulombScattering* muss = new G4CoulombScattering();
muss->SetEmModel(new G4hCoulombScatteringModel(), 1);
G4CoulombScattering* piss = new G4CoulombScattering();
piss->SetEmModel(new G4hCoulombScatteringModel(), 1);
G4CoulombScattering* kss = new G4CoulombScattering();
kss->SetEmModel(new G4hCoulombScatteringModel(), 1);
G4CoulombScattering* pss = new G4CoulombScattering();
G4hMultipleScattering* hmsc = new G4hMultipleScattering("ionmsc");
pss->SetEmModel(new G4hCoulombScatteringModel(), 1);
// Add standard EM Processes
auto myParticleIterator=GetParticleIterator();
@@ -304,8 +306,8 @@ void G4EmStandardPhysicsSS::ConstructProcess()
particleName == "xi_c+" ||
particleName == "xi-" ) {
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(new G4hIonisation(), particle);
ph->RegisterProcess(new G4CoulombScattering(), particle);
}
}
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysicsWVI.cc
+10 -4
View File
@@ -60,6 +60,8 @@
#include "G4hMultipleScattering.hh"
#include "G4CoulombScattering.hh"
#include "G4WentzelVIModel.hh"
#include "G4WentzelVIRelModel.hh"
#include "G4hCoulombScatteringModel.hh"
#include "G4MuBremsstrahlungModel.hh"
#include "G4MuPairProductionModel.hh"
@@ -181,20 +183,24 @@ void G4EmStandardPhysicsWVI::ConstructProcess()
// muon & hadron multiple scattering
G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();
mumsc->SetEmModel(new G4WentzelVIModel());
mumsc->SetEmModel(new G4WentzelVIRelModel());
G4CoulombScattering* muss = new G4CoulombScattering();
muss->SetEmModel(new G4hCoulombScatteringModel(), 1);
G4MuMultipleScattering* pimsc = new G4MuMultipleScattering();
pimsc->SetEmModel(new G4WentzelVIModel());
pimsc->SetEmModel(new G4WentzelVIRelModel());
G4CoulombScattering* piss = new G4CoulombScattering();
piss->SetEmModel(new G4hCoulombScatteringModel(), 1);
G4MuMultipleScattering* kmsc = new G4MuMultipleScattering();
kmsc->SetEmModel(new G4WentzelVIModel());
kmsc->SetEmModel(new G4WentzelVIRelModel());
G4CoulombScattering* kss = new G4CoulombScattering();
kss->SetEmModel(new G4hCoulombScatteringModel(), 1);
G4MuMultipleScattering* pmsc = new G4MuMultipleScattering();
pmsc->SetEmModel(new G4WentzelVIModel());
pmsc->SetEmModel(new G4WentzelVIRelModel());
G4CoulombScattering* pss = new G4CoulombScattering();
pss->SetEmModel(new G4hCoulombScatteringModel(), 1);
G4hMultipleScattering* hmsc = new G4hMultipleScattering("ionmsc");
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysics_option3.cc
+6 -2
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmStandardPhysics_option3.cc 99938 2016-10-12 08:06:52Z gcosmo $
// $Id: G4EmStandardPhysics_option3.cc 104571 2017-06-06 13:45:47Z gcosmo $
//
//---------------------------------------------------------------------------
//
@@ -61,6 +61,7 @@
#include "G4DummyModel.hh"
#include "G4WentzelVIModel.hh"
#include "G4CoulombScattering.hh"
#include "G4UniversalFluctuation2017.hh"
#include "G4eIonisation.hh"
#include "G4eBremsstrahlung.hh"
@@ -227,7 +228,8 @@ void G4EmStandardPhysics_option3::ConstructProcess()
G4eMultipleScattering* msc = new G4eMultipleScattering();
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
eIoni->SetStepFunction(0.2, 100*um);
eIoni->SetFluctModel(new G4UniversalFluctuation2017());
G4eBremsstrahlung* brem = new G4eBremsstrahlung();
G4SeltzerBergerModel* br1 = new G4SeltzerBergerModel();
@@ -250,6 +252,7 @@ void G4EmStandardPhysics_option3::ConstructProcess()
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
eIoni->SetFluctModel(new G4UniversalFluctuation2017());
G4eBremsstrahlung* brem = new G4eBremsstrahlung();
G4SeltzerBergerModel* br1 = new G4SeltzerBergerModel();
@@ -331,6 +334,7 @@ void G4EmStandardPhysics_option3::ConstructProcess()
G4hMultipleScattering* pmsc = new G4hMultipleScattering();
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
hIoni->SetFluctModel(new G4UniversalFluctuation2017());
ph->RegisterProcess(pmsc, particle);
ph->RegisterProcess(hIoni, particle);
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysics_option4.cc
+7 -10
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4EmStandardPhysics_option4.cc 99938 2016-10-12 08:06:52Z gcosmo $
// $Id: G4EmStandardPhysics_option4.cc 104020 2017-05-08 07:34:58Z gcosmo $
//
//---------------------------------------------------------------------------
//
@@ -275,7 +275,7 @@ void G4EmStandardPhysics_option4::ConstructProcess()
// ionisation
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
eIoni->SetStepFunction(0.2, 10*um);
G4PenelopeIonisationModel* pen = new G4PenelopeIonisationModel();
pen->SetHighEnergyLimit(penEnergyLimit);
eIoni->AddEmModel(0, pen, new G4UniversalFluctuation());
@@ -317,7 +317,7 @@ void G4EmStandardPhysics_option4::ConstructProcess()
// ionisation
G4eIonisation* eIoni = new G4eIonisation();
eIoni->SetStepFunction(0.2, 100*um);
eIoni->SetStepFunction(0.2, 10*um);
G4PenelopeIonisationModel* pen = new G4PenelopeIonisationModel();
pen->SetHighEnergyLimit(penEnergyLimit);
eIoni->AddEmModel(0, pen, new G4UniversalFluctuation());
@@ -344,7 +344,7 @@ void G4EmStandardPhysics_option4::ConstructProcess()
particleName == "mu-" ) {
G4MuIonisation* muIoni = new G4MuIonisation();
muIoni->SetStepFunction(0.2, 50*um);
muIoni->SetStepFunction(0.2, 10*um);
ph->RegisterProcess(mumsc, particle);
ph->RegisterProcess(muIoni, particle);
@@ -376,9 +376,8 @@ void G4EmStandardPhysics_option4::ConstructProcess()
} else if (particleName == "pi+" ||
particleName == "pi-" ) {
//G4hMultipleScattering* pimsc = new G4hMultipleScattering();
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
hIoni->SetStepFunction(0.2, 10*um);
ph->RegisterProcess(pimsc, particle);
ph->RegisterProcess(hIoni, particle);
@@ -389,9 +388,8 @@ void G4EmStandardPhysics_option4::ConstructProcess()
} else if (particleName == "kaon+" ||
particleName == "kaon-" ) {
//G4hMultipleScattering* kmsc = new G4hMultipleScattering();
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.2, 50*um);
hIoni->SetStepFunction(0.2, 10*um);
ph->RegisterProcess(kmsc, particle);
ph->RegisterProcess(hIoni, particle);
@@ -402,9 +400,8 @@ void G4EmStandardPhysics_option4::ConstructProcess()
} else if (particleName == "proton" ||
particleName == "anti_proton") {
//G4hMultipleScattering* pmsc = new G4hMultipleScattering();
G4hIonisation* hIoni = new G4hIonisation();
hIoni->SetStepFunction(0.1, 20*um);
hIoni->SetStepFunction(0.1, 10*um);
ph->RegisterProcess(pmsc, particle);
ph->RegisterProcess(hIoni, particle);
source/physics_lists/constructors/factory/History
+3
View File
@@ -14,6 +14,9 @@ introduced in the code and keeptrack of all tags.
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
01-May-2017, Sebastien Incerti (phys-ctor-fact-V10-03-00)
- added Geant4-DNA stationary constructors
17-Oct-2016, Michel Maire (phys-ctor-fact-V10-02-04)
- add README
source/physics_lists/constructors/factory/src/G4PhysicsConstructorRegistry.cc
+5
View File
@@ -178,7 +178,12 @@ G4_REFERENCE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_option2);
G4_REFERENCE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_option3);
G4_REFERENCE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_option4);
G4_REFERENCE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_option5);
G4_REFERENCE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_option6);
G4_REFERENCE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_option7);
G4_REFERENCE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_stationary);
G4_REFERENCE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_stationary_option2);
G4_REFERENCE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_stationary_option4);
G4_REFERENCE_PHYSCONSTR_FACTORY(G4EmDNAPhysics_stationary_option6);
G4_REFERENCE_PHYSCONSTR_FACTORY(G4EmExtraPhysics);
G4_REFERENCE_PHYSCONSTR_FACTORY(G4EmLivermorePhysics);
G4_REFERENCE_PHYSCONSTR_FACTORY(G4EmLivermorePolarizedPhysics);
source/physics_lists/constructors/gamma_lepto_nuclear/History
+11 -2
View File
@@ -1,4 +1,4 @@
$Id: History 101023 2016-11-04 08:29:28Z gcosmo $
$Id: History 104601 2017-06-07 09:01:37Z gcosmo $
-------------------------------------------------------------------
=========================================================
@@ -14,7 +14,16 @@ introduced in the code and keeptrack of all tags.
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
12-November-2015, V.Ivanchenko (phys-ctor-glnuclear-V10-02-04)
06-June-2017, V.Ivanchenko (phys-ctor-glnuclear-V10-03-01)
- G4EmExtraPhysics, G4EmMessenger - added extra UI commands to define
cross section factors for rare processes (requirement of ShiP
experiment for dark matter search)
04-May-2017, V.Ivanchenko (phys-ctor-glnuclear-V10-03-00)
- G4EmExtraPhysics, G4EmMessenger, G4BertiniElectroNuclearBuilder
added option and UI command to enable/disable e+- nuclear process
12-Nov-2016, V.Ivanchenko (phys-ctor-glnuclear-V10-02-04)
- G4EmExtraPhysics, G4EmMessenger - added rare high energy EM processes,
disabled by default
source/physics_lists/constructors/gamma_lepto_nuclear/include/G4BertiniElectroNuclearBuilder.hh
+2 -2
View File
@@ -38,7 +38,6 @@
#include "G4CascadeInterface.hh"
#include "G4ElectroVDNuclearModel.hh"
//#include "G4ElectroNuclearReaction.hh"
#include "G4PhotoNuclearProcess.hh"
#include "G4ElectronNuclearProcess.hh"
#include "G4PositronNuclearProcess.hh"
@@ -49,7 +48,7 @@
class G4BertiniElectroNuclearBuilder
{
public:
G4BertiniElectroNuclearBuilder();
G4BertiniElectroNuclearBuilder(G4bool eNucl);
virtual ~G4BertiniElectroNuclearBuilder();
public:
@@ -68,6 +67,7 @@ class G4BertiniElectroNuclearBuilder
G4QGSMFragmentation * theFragmentation;
G4ExcitedStringDecay * theStringDecay;
G4bool wasActivated;
G4bool eActivated;
};
// 2002 by J.P. Wellisch
source/physics_lists/constructors/gamma_lepto_nuclear/include/G4EmExtraPhysics.hh
+8
View File
@@ -70,20 +70,28 @@ public:
void Synch(G4bool val);
void SynchAll(G4bool val);
void GammaNuclear(G4bool val);
void ElectroNuclear(G4bool val);
void MuonNuclear(G4bool val);
void GammaToMuMu(G4bool val);
void PositronToMuMu(G4bool val);
void PositronToHadrons(G4bool val);
void GammaToMuMuFactor(G4double val);
void PositronToMuMuFactor(G4double val);
void PositronToHadronsFactor(G4double val);
private:
static G4bool gnActivated;
static G4bool eActivated;
static G4bool munActivated;
static G4bool synActivated;
static G4bool synActivatedForAll;
static G4bool gmumuActivated;
static G4bool pmumuActivated;
static G4bool phadActivated;
static G4double gmumuFactor;
static G4double pmumuFactor;
static G4double phadFactor;
static G4ThreadLocal G4BertiniElectroNuclearBuilder* theGNPhysics;
static G4ThreadLocal G4SynchrotronRadiation* theSynchRad;
source/physics_lists/constructors/gamma_lepto_nuclear/include/G4EmMessenger.hh
+5
View File
@@ -46,6 +46,7 @@ class G4EmExtraPhysics;
#include "G4UImessenger.hh"
#include "G4UIdirectory.hh"
#include "G4UIcmdWithABool.hh"
#include "G4UIcmdWithADouble.hh"
class G4EmMessenger: public G4UImessenger
{
@@ -60,10 +61,14 @@ private:
G4UIcmdWithABool* theSynch;
G4UIcmdWithABool* theSynchAll;
G4UIcmdWithABool* theGN;
G4UIcmdWithABool* theEN;
G4UIcmdWithABool* theMUN;
G4UIcmdWithABool* theGMM;
G4UIcmdWithABool* thePMM;
G4UIcmdWithABool* thePH;
G4UIcmdWithADouble* theGMM1;
G4UIcmdWithADouble* thePMM1;
G4UIcmdWithADouble* thePH1;
G4UIdirectory* aDir1;
G4UIdirectory* aDir2;
};
source/physics_lists/constructors/gamma_lepto_nuclear/src/G4BertiniElectroNuclearBuilder.cc
+22 -27
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4BertiniElectroNuclearBuilder.cc 81364 2014-05-27 12:55:46Z gcosmo $
// $Id: G4BertiniElectroNuclearBuilder.cc 104018 2017-05-08 07:32:45Z gcosmo $
//
//---------------------------------------------------------------------------
//
@@ -51,12 +51,12 @@
#include "G4ProcessManager.hh"
G4BertiniElectroNuclearBuilder::G4BertiniElectroNuclearBuilder() :
thePhotoNuclearProcess(0), theElectronNuclearProcess(0),
thePositronNuclearProcess(0), theElectroReaction(0),
theGammaReaction(0), theModel(0), theCascade(0),
theStringModel(0), theFragmentation(0), theStringDecay(0),
wasActivated(false)
G4BertiniElectroNuclearBuilder::G4BertiniElectroNuclearBuilder(G4bool eNucl) :
thePhotoNuclearProcess(nullptr), theElectronNuclearProcess(nullptr),
thePositronNuclearProcess(nullptr), theElectroReaction(nullptr),
theGammaReaction(nullptr), theModel(nullptr), theCascade(nullptr),
theStringModel(nullptr), theFragmentation(nullptr), theStringDecay(nullptr),
wasActivated(false), eActivated(eNucl)
{
}
@@ -65,14 +65,6 @@ G4BertiniElectroNuclearBuilder::~G4BertiniElectroNuclearBuilder()
if(wasActivated) {
delete theFragmentation;
delete theStringDecay;
//delete theStringModel;
//delete thePhotoNuclearProcess;
//delete theElectronNuclearProcess;
//delete thePositronNuclearProcess;
//delete theElectroReaction;
//delete theGammaReaction;
//delete theModel;
//delete theCascade;
}
}
@@ -82,10 +74,11 @@ void G4BertiniElectroNuclearBuilder::Build()
wasActivated=true;
thePhotoNuclearProcess = new G4PhotoNuclearProcess;
theElectronNuclearProcess = new G4ElectronNuclearProcess;
thePositronNuclearProcess = new G4PositronNuclearProcess;
// theElectroReaction = new G4ElectroNuclearReaction;
theElectroReaction = new G4ElectroVDNuclearModel;
if(eActivated) {
theElectronNuclearProcess = new G4ElectronNuclearProcess;
thePositronNuclearProcess = new G4PositronNuclearProcess;
theElectroReaction = new G4ElectroVDNuclearModel;
}
theGammaReaction = new G4CascadeInterface;
theModel = new G4TheoFSGenerator;
@@ -99,7 +92,7 @@ void G4BertiniElectroNuclearBuilder::Build()
theModel->SetTransport(theCascade);
theModel->SetHighEnergyGenerator(theStringModel);
G4ProcessManager * aProcMan = 0;
G4ProcessManager * aProcMan = nullptr;
aProcMan = G4Gamma::Gamma()->GetProcessManager();
theGammaReaction->SetMaxEnergy(3.5*GeV);
@@ -108,13 +101,15 @@ void G4BertiniElectroNuclearBuilder::Build()
theModel->SetMaxEnergy(100*TeV);
thePhotoNuclearProcess->RegisterMe(theModel);
aProcMan->AddDiscreteProcess(thePhotoNuclearProcess);
if(eActivated) {
aProcMan = G4Electron::Electron()->GetProcessManager();
theElectronNuclearProcess->RegisterMe(theElectroReaction);
aProcMan->AddDiscreteProcess(theElectronNuclearProcess);
aProcMan = G4Electron::Electron()->GetProcessManager();
theElectronNuclearProcess->RegisterMe(theElectroReaction);
aProcMan->AddDiscreteProcess(theElectronNuclearProcess);
aProcMan = G4Positron::Positron()->GetProcessManager();
thePositronNuclearProcess->RegisterMe(theElectroReaction);
aProcMan->AddDiscreteProcess(thePositronNuclearProcess);
aProcMan = G4Positron::Positron()->GetProcessManager();
thePositronNuclearProcess->RegisterMe(theElectroReaction);
aProcMan->AddDiscreteProcess(thePositronNuclearProcess);
}
}
source/physics_lists/constructors/gamma_lepto_nuclear/src/G4EmExtraPhysics.cc
+29 -4
View File
@@ -72,12 +72,16 @@
G4_DECLARE_PHYSCONSTR_FACTORY(G4EmExtraPhysics);
G4bool G4EmExtraPhysics::gnActivated = true;
G4bool G4EmExtraPhysics::eActivated = true;
G4bool G4EmExtraPhysics::munActivated = true;
G4bool G4EmExtraPhysics::synActivated = false;
G4bool G4EmExtraPhysics::synActivatedForAll = false;
G4bool G4EmExtraPhysics::gmumuActivated = false;
G4bool G4EmExtraPhysics::pmumuActivated = false;
G4bool G4EmExtraPhysics::phadActivated = false;
G4bool G4EmExtraPhysics::phadActivated = false;
G4double G4EmExtraPhysics::gmumuFactor = 1.0;
G4double G4EmExtraPhysics::pmumuFactor = 1.0;
G4double G4EmExtraPhysics::phadFactor = 1.0;
G4ThreadLocal G4BertiniElectroNuclearBuilder* G4EmExtraPhysics::theGNPhysics = nullptr;
G4ThreadLocal G4SynchrotronRadiation* G4EmExtraPhysics::theSynchRad = nullptr;
@@ -120,6 +124,11 @@ void G4EmExtraPhysics::GammaNuclear(G4bool val)
gnActivated = val;
}
void G4EmExtraPhysics::ElectroNuclear(G4bool val)
{
eActivated = val;
}
void G4EmExtraPhysics::MuonNuclear(G4bool val)
{
munActivated = val;
@@ -140,6 +149,21 @@ void G4EmExtraPhysics::PositronToHadrons(G4bool val)
phadActivated = val;
}
void G4EmExtraPhysics::GammaToMuMuFactor(G4double val)
{
if(val > 0.0) gmumuFactor = val;
}
void G4EmExtraPhysics::PositronToMuMuFactor(G4double val)
{
if(val > 0.0) pmumuFactor = val;
}
void G4EmExtraPhysics::PositronToHadronsFactor(G4double val)
{
if(val > 0.0) phadFactor = val;
}
void G4EmExtraPhysics::ConstructParticle()
{
G4Gamma::Gamma();
@@ -159,9 +183,8 @@ void G4EmExtraPhysics::ConstructProcess()
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
if(gnActivated) {
theGNPhysics = new G4BertiniElectroNuclearBuilder();
theGNPhysics = new G4BertiniElectroNuclearBuilder(eActivated);
theGNPhysics->Build();
//G4AutoDelete::Register(theGNPhysics);
}
if(munActivated) {
G4MuonNuclearProcess* muNucProcess = new G4MuonNuclearProcess();
@@ -172,21 +195,23 @@ void G4EmExtraPhysics::ConstructProcess()
}
if(gmumuActivated) {
theGammaToMuMu = new G4GammaConversionToMuons();
theGammaToMuMu->SetCrossSecFactor(gmumuFactor);
ph->RegisterProcess(theGammaToMuMu, gamma);
}
if(pmumuActivated) {
thePosiToMuMu = new G4AnnihiToMuPair();
thePosiToMuMu->SetCrossSecFactor(pmumuFactor);
ph->RegisterProcess(thePosiToMuMu, positron);
}
if(phadActivated) {
thePosiToHadrons = new G4eeToHadrons();
thePosiToHadrons->SetCrossSecFactor(phadFactor);
ph->RegisterProcess(thePosiToHadrons, positron);
}
if(synActivated) {
theSynchRad = new G4SynchrotronRadiation();
ph->RegisterProcess( theSynchRad, electron);
ph->RegisterProcess( theSynchRad, positron);
//G4AutoDelete::Register(theSynchRad);
if(synActivatedForAll) {
auto myParticleIterator=GetParticleIterator();
myParticleIterator->reset();
source/physics_lists/constructors/gamma_lepto_nuclear/src/G4EmMessenger.cc
+24
View File
@@ -74,6 +74,10 @@ G4EmMessenger::G4EmMessenger(G4EmExtraPhysics* ab)
theGN->SetGuidance("Switching on gamma nuclear physics.");
theGN->AvailableForStates(G4State_PreInit);
theEN = new G4UIcmdWithABool("/physics_lists/em/ElectroNuclear",this);
theEN->SetGuidance("Switching on e+- nuclear physics.");
theEN->AvailableForStates(G4State_PreInit);
// command for muon nuclear physics.
theMUN = new G4UIcmdWithABool("/physics_lists/em/MuonNuclear",this);
theMUN->SetGuidance("Switching on muon nuclear physics.");
@@ -90,6 +94,18 @@ G4EmMessenger::G4EmMessenger(G4EmExtraPhysics* ab)
thePH = new G4UIcmdWithABool("/physics_lists/em/PositronToHadrons",this);
thePH->SetGuidance("Switching on positron conversion to hadrons.");
thePH->AvailableForStates(G4State_PreInit);
theGMM1 = new G4UIcmdWithADouble("/physics_lists/em/GammaToMuonsFactor",this);
theGMM1->SetGuidance("Factor for gamma conversion to muon pair.");
theGMM1->AvailableForStates(G4State_PreInit);
thePMM1 = new G4UIcmdWithADouble("/physics_lists/em/PositronToMuonsFactor",this);
thePMM1->SetGuidance("Factor for positron conversion to muon pair.");
thePMM1->AvailableForStates(G4State_PreInit);
thePH1 = new G4UIcmdWithADouble("/physics_lists/em/PositronToHadronsFactor",this);
thePH1->SetGuidance("Factor for positron conversion to hadrons.");
thePH1->AvailableForStates(G4State_PreInit);
}
G4EmMessenger::~G4EmMessenger()
@@ -97,10 +113,14 @@ G4EmMessenger::~G4EmMessenger()
delete theSynch;
delete theSynchAll;
delete theGN;
delete theEN;
delete theMUN;
delete theGMM;
delete thePMM;
delete thePH;
delete theGMM1;
delete thePMM1;
delete thePH1;
delete aDir1;
delete aDir2;
}
@@ -110,8 +130,12 @@ void G4EmMessenger::SetNewValue(G4UIcommand* aComm, G4String aS)
if(aComm==theSynch) theB->Synch(theSynch->GetNewBoolValue(aS));
if(aComm==theSynchAll) theB->SynchAll(theSynchAll->GetNewBoolValue(aS));
if(aComm==theGN) theB->GammaNuclear(theGN->GetNewBoolValue(aS));
if(aComm==theEN) theB->ElectroNuclear(theEN->GetNewBoolValue(aS));
if(aComm==theMUN) theB->MuonNuclear(theMUN->GetNewBoolValue(aS));
if(aComm==theGMM) theB->GammaToMuMu(theGMM->GetNewBoolValue(aS));
if(aComm==thePMM) theB->PositronToMuMu(thePMM->GetNewBoolValue(aS));
if(aComm==thePH) theB->PositronToHadrons(thePH->GetNewBoolValue(aS));
if(aComm==theGMM1) theB->GammaToMuMuFactor(theGMM1->GetNewDoubleValue(aS));
if(aComm==thePMM1) theB->PositronToMuMuFactor(thePMM1->GetNewDoubleValue(aS));
if(aComm==thePH1) theB->PositronToHadronsFactor(thePH1->GetNewDoubleValue(aS));
}
source/physics_lists/constructors/hadron_elastic/GNUmakefile
+2 -1
View File
@@ -1,4 +1,4 @@
# $Id: GNUmakefile 94088 2015-11-05 15:11:00Z gcosmo $
# $Id: GNUmakefile 104019 2017-05-08 07:34:08Z gcosmo $
# ---------------------------------------------------------------------------
# GNUmakefile for physics_lists/constructors/electromagnetic library.
# Gunter Folger 10-Jan-2012.
@@ -41,6 +41,7 @@ CPPFLAGS += -I$(G4BASE)/global/management/include \
-I$(G4BASE)/physics_lists/builders/include \
-I$(G4BASE)/physics_lists/util/include \
-I$(G4BASE)/physics_lists/constructors/factory/include \
-I$(G4BASE)/physics_lists/constructors/hadron_inelastic/include \
-I$(G4BASE)/processes/management/include \
-I$(G4BASE)/processes/transportation/include \
-I$(G4BASE)/processes/cuts/include \
source/physics_lists/constructors/hadron_elastic/History
+5 -1
View File
@@ -1,4 +1,4 @@
$Id: History 101061 2016-11-04 13:07:09Z gcosmo $
$Id: History 104019 2017-05-08 07:34:08Z gcosmo $
-------------------------------------------------------------------
=========================================================
@@ -14,6 +14,10 @@ introduced in the code and keeptrack of all tags.
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
04-May-2017, V.Ivanchenko (phys-ctor-helastic-V10-03-00)
- G4ThermalNeutrons - new class for addition of thermal neutron
scattering below 4 eV (backported from CMS simulation)
04-Nov-2016, Alberto Ribon (phys-ctor-helastic-V10-02-04)
- Written first draft of the README
source/physics_lists/constructors/hadron_elastic/include/G4ThermalNeutrons.hh
+64
View File
@@ -0,0 +1,64 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4ThermalNeutrons.hh 70995 2013-06-09 00:56:34Z adotti $
//
//---------------------------------------------------------------------------
//
// ClassName: G4ThermalNeutrons
//
// Author: 4 May 2017 V. Ivanchenko
//
// Modified:
//
//----------------------------------------------------------------------------
//
// Addition of neutron thermal scattering on top of any PhysicsList
#ifndef G4ThermalNeutrons_h
#define G4ThermalNeutrons_h
#include "G4VHadronPhysics.hh"
#include "globals.hh"
class G4ThermalNeutrons : public G4VHadronPhysics {
public:
G4ThermalNeutrons(G4int ver);
virtual ~G4ThermalNeutrons();
virtual void ConstructProcess();
private:
G4int verbose;
};
#endif
source/physics_lists/constructors/hadron_elastic/sources.cmake
+5 -1
View File
@@ -11,7 +11,7 @@
#
# Generated on : 10/01/2013
#
# $Id: sources.cmake 94088 2015-11-05 15:11:00Z gcosmo $
# $Id: sources.cmake 104019 2017-05-08 07:34:08Z gcosmo $
#
#------------------------------------------------------------------------------
@@ -39,6 +39,7 @@ include_directories(${CMAKE_SOURCE_DIR}/source/run/include)
include_directories(${CMAKE_SOURCE_DIR}/source/physics_lists/builders/include)
include_directories(${CMAKE_SOURCE_DIR}/source/physics_lists/util/include)
include_directories(${CMAKE_SOURCE_DIR}/source/physics_lists/constructors/factory/include)
include_directories(${CMAKE_SOURCE_DIR}/source/physics_lists/constructors/hadron_inelastic/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/transportation/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/cuts/include)
@@ -70,6 +71,7 @@ GEANT4_DEFINE_MODULE(NAME G4phys_ctor_helastic
G4HadronHElasticPhysics.hh
G4IonElasticPhysics.hh
G4HadronElasticPhysicsPHP.hh
G4ThermalNeutrons.hh
SOURCES
G4ChargeExchangePhysics.cc
G4HadronDElasticPhysics.cc
@@ -80,6 +82,7 @@ GEANT4_DEFINE_MODULE(NAME G4phys_ctor_helastic
G4HadronHElasticPhysics.cc
G4IonElasticPhysics.cc
G4HadronElasticPhysicsPHP.cc
G4ThermalNeutrons.cc
GRANULAR_DEPENDENCIES
G4baryons
G4bosons
@@ -141,6 +144,7 @@ GEANT4_DEFINE_MODULE(NAME G4phys_ctor_helastic
G4partman
G4phys_builders
G4phys_ctor_factory
G4phys_ctor_hinelastic
G4procman
G4run
G4shortlived
source/physics_lists/constructors/hadron_elastic/src/G4ThermalNeutrons.cc
+83
View File
@@ -0,0 +1,83 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4ThermalNeutrons.cc 70995 2013-06-09 00:56:34Z adotti $
//
//---------------------------------------------------------------------------
//
// ClassName: G4ThermalNeutrons
//
// Author: 4 May 2017 V. Ivanchenko
//
// Modified:
//
//----------------------------------------------------------------------------
//
#include "G4ThermalNeutrons.hh"
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
#include "G4HadronicProcess.hh"
#include "G4ParticleHPThermalScattering.hh"
#include "G4ParticleHPThermalScatteringData.hh"
#include "G4BuilderType.hh"
#include "G4SystemOfUnits.hh"
G4ThermalNeutrons::G4ThermalNeutrons(G4int ver) :
G4VHadronPhysics("G4ThermalNeutrons"), verbose(ver) {
}
G4ThermalNeutrons::~G4ThermalNeutrons() {}
void G4ThermalNeutrons::ConstructProcess() {
if(verbose > 0) {
G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;
}
G4Neutron* part = G4Neutron::Neutron();
G4HadronicProcess* hpel = FindElasticProcess(part);
if(!hpel) {
G4cout << "### " << GetPhysicsName()
<< " WARNING: Fail to add thermal neutron scattering" << G4endl;
return;
}
G4int ni = (hpel->GetHadronicInteractionList()).size();
if(ni < 1) {
G4cout << "### " << GetPhysicsName()
<< " WARNING: Fail to add thermal neutron scattering - Nint= "
<< ni << G4endl;
return;
}
(hpel->GetHadronicInteractionList())[ni-1]->SetMinEnergy(4*CLHEP::eV);
hpel->RegisterMe(new G4ParticleHPThermalScattering());
hpel->AddDataSet(new G4ParticleHPThermalScatteringData());
}
source/physics_lists/constructors/hadron_inelastic/History
+2 -2
View File
@@ -1,4 +1,4 @@
$Id: History 102624 2017-02-10 08:22:14Z gcosmo $
$Id: History 102618 2017-02-10 07:59:27Z gcosmo $
-------------------------------------------------------------------
=========================================================
@@ -14,7 +14,7 @@ introduced in the code and keeptrack of all tags.
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
09-Feb-2017, Makoto Asai (phys-ctor-hinelastic-V10-02-11)
09-Feb-2017, Makoto Asai (phys-ctor-hinelastic-V10-03-00)
- Print-out of the transition energy region between FTFP and BERT
in the physics lists FTFP_BERT_HP and G4HadronPhysicsFTFP_BERT_HP
is made only for the master thread.
source/physics_lists/constructors/hadron_inelastic/src/G4HadronPhysicsFTFP_BERT.cc
+1 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4HadronPhysicsFTFP_BERT.cc 102624 2017-02-10 08:22:14Z gcosmo $
// $Id: G4HadronPhysicsFTFP_BERT.cc 102618 2017-02-10 07:59:27Z gcosmo $
//
//---------------------------------------------------------------------------
//
source/physics_lists/constructors/limiters/History
+2 -2
View File
@@ -1,4 +1,4 @@
$Id: History 102622 2017-02-10 08:17:47Z gcosmo $
$Id: History 102617 2017-02-10 07:58:33Z gcosmo $
-------------------------------------------------------------------
=========================================================
@@ -14,7 +14,7 @@ introduced in the code and keeptrack of all tags.
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
09-Feb-2017, M. Asai (phys-ctor-limiters-V10-02-09)
09-Feb-2017, M. Asai (phys-ctor-limiters-V10-03-00)
- Print-out of G4NeutronTrackingCut is made only for the master thread.
07-Nov-2016, M. Verderi (phys-ctor-limiters-V10-02-08)
source/physics_lists/constructors/limiters/src/G4NeutronTrackingCut.cc
+1 -1
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4NeutronTrackingCut.cc 102622 2017-02-10 08:17:47Z gcosmo $
// $Id: G4NeutronTrackingCut.cc 102617 2017-02-10 07:58:33Z gcosmo $
//
//---------------------------------------------------------------------------
//