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

Import Geant4 9.4.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-09 16:25:56 +02:00
parent 74cad5e589
commit 89a9605df1
4440 changed files with 379508 additions and 189225 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/electromagnetic/CMakeLists.txt
+23
View File
@@ -0,0 +1,23 @@
#------------------------------------------------------------------------------
# CMakeLists.txt
# Module : G4electromagnetic
# Package: Geant4.src.G4processes.G4electromagnetic
#
# Intermediate level CMakeLists.txt - just process subdirectories
#
# Generated on : 24/9/2010
#
# $Id: CMakeLists.txt,v 1.2 2010/11/19 08:39:52 gcosmo Exp $
#
#------------------------------------------------------------------------------
add_subdirectory(adjoint)
add_subdirectory(highenergy)
add_subdirectory(lowenergy)
add_subdirectory(muons)
add_subdirectory(pii)
add_subdirectory(polarisation)
add_subdirectory(standard)
add_subdirectory(utils)
add_subdirectory(xrays)
source/processes/electromagnetic/GNUmakefile
+3 -3
View File
@@ -1,4 +1,4 @@
# $Id: GNUmakefile,v 1.7 2008/11/14 19:54:40 gcosmo Exp $
# $Id: GNUmakefile,v 1.9 2010/11/19 08:44:20 gcosmo Exp $
# ------------------------------------------------------------------
# GNUmakefile for electromagnetic library. Gabriele Cosmo, 18/9/96.
# ------------------------------------------------------------------
@@ -7,8 +7,8 @@ MAKEFLAGS= --no-print-directory
name := G4electromagnetic
SUBDIRS = muons standard utils xrays lowenergy highenergy adjoint polarisation
SUBLIBS = G4muons G4emstandard G4emutils G4xrays G4emlowenergy G4emhighenergy G4emadjoint G4polar
SUBDIRS = muons standard utils xrays lowenergy highenergy adjoint polarisation pii
SUBLIBS = G4muons G4emstandard G4emutils G4xrays G4emlowenergy G4emhighenergy G4emadjoint G4empolar G4empii
ifndef G4INSTALL
G4INSTALL = ../../..
source/processes/electromagnetic/adjoint/CMakeLists.txt
+18
View File
@@ -0,0 +1,18 @@
#------------------------------------------------------------------------------
# CMakeLists.txt
# Module : G4emadjoint
# Package: Geant4.src.G4processes.G4electromagnetic.G4emadjoint
#
# CMakeLists.txt for building a single granular library.
#
# Generated on : 24/9/2010
#
# $Id: CMakeLists.txt,v 1.1 2010/09/29 18:52:32 bmorgan Exp $
#
#------------------------------------------------------------------------------
if(GEANT4_BUILD_GRANULAR_LIBS)
include(Geant4MacroLibraryTargets)
GEANT4_GRANULAR_LIBRARY_TARGET(COMPONENT sources.cmake)
endif()
source/processes/electromagnetic/adjoint/History
+18 -1
View File
@@ -1,4 +1,4 @@
$Id: History,v 1.5 2009/11/23 09:02:35 gcosmo Exp $
$Id: History,v 1.8 2010/11/11 11:51:56 ldesorgh Exp $
-------------------------------------------------------------------
=========================================================
@@ -17,6 +17,23 @@ committal in the CVS repository !
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
11 Nov 2010: L. Desorgher (emadjoint-V09-03-02)
-G4AdjointBremsstrahlungModel: add a G4EmModelManager to initialise properly,
the G4eBremsstrahlungModel used as forward model. This allows to fix the
floating point exception detected when compiling with G4FPE_DEBUG=1.
-G4AdjointhIonisation:
Remove a negative term in the expression of the adjoint
cross section (AdjointCrossSection method) and adapt the RapidSampleSecondaries method.
-G4VEmAdjointModel:
Add a check on null cross section to avoid FPE.
3 Sep 2010: G.Cosmo (emadjoint-V09-03-01)
- G4AdjointAlongStepWeightCorrection: get rid of call to non-Standard isnan(),
replaced by explicit validity test.
12 Apr 2010: V.Ivanchenko (emadjoint-V09-03-00)
- G4AdjointhMultipleScattering: removed obsolete unused header.
23 Nov 2009: G.Cosmo (emadjoint-V09-02-02)
- Corrected compilation error on Windows for G4AdjointAlongStepWeightCorrection.
source/processes/electromagnetic/adjoint/include/G4AdjointBremsstrahlungModel.hh
+10 -5
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4AdjointBremsstrahlungModel.hh,v 1.4 2009/11/20 10:31:20 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4AdjointBremsstrahlungModel.hh,v 1.5 2010/11/11 11:51:56 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
/////////////////////////////////////////////////////////////////////////////////
// Class: G4AdjointBremsstrahlungModel
@@ -59,7 +59,7 @@
#include "G4eBremsstrahlungModel.hh"
//#include "G4PenelopeBremsstrahlungModel.hh"
#include "G4PhysicsTable.hh"
//#include "G4EmModelManager.hh"
#include "G4EmModelManager.hh"
class G4Timer;
class G4AdjointBremsstrahlungModel: public G4VEmAdjointModel
@@ -91,14 +91,19 @@ public:
);
virtual G4double AdjointCrossSection(const G4MaterialCutsCouple* aCouple,
G4double primEnergy,
G4bool IsScatProjToProjCase);
G4bool IsScatProjToProjCase);
virtual G4double GetAdjointCrossSection(const G4MaterialCutsCouple* aCouple,
G4double primEnergy,
G4bool IsScatProjToProjCase);
// private void InitialiseFwdModels();
private:
private:
G4eBremsstrahlungModel* theDirectStdBremModel;
G4EmModelManager* theEmModelManagerForFwdModels;
G4bool isDirectModelInitialised ;
//G4PenelopeBremsstrahlungModel* theDirectPenelopeBremModel;
source/processes/electromagnetic/adjoint/include/G4AdjointCSManager.hh
+11 -3
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4AdjointCSManager.hh,v 1.4 2009/11/20 10:31:20 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4AdjointCSManager.hh,v 1.5 2010/11/11 11:51:56 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
/////////////////////////////////////////////////////////////////////////////////
// Class: G4AdjointCSManager
@@ -79,7 +79,7 @@ class G4AdjointCSManager
//Registration of the different models and processes
void RegisterEmAdjointModel(G4VEmAdjointModel*);
size_t RegisterEmAdjointModel(G4VEmAdjointModel*);
void RegisterEmProcess(G4VEmProcess* aProcess, G4ParticleDefinition* aPartDef);
@@ -101,6 +101,8 @@ class G4AdjointCSManager
G4double GetTotalForwardCS(G4ParticleDefinition* aPartDef, G4double Ekin,
const G4MaterialCutsCouple* aCouple);
G4double GetAdjointSigma(G4double Ekin_nuc, size_t index_model,G4bool is_scat_proj_to_proj,
const G4MaterialCutsCouple* aCouple);
void GetEminForTotalCS(G4ParticleDefinition* aPartDef,
const G4MaterialCutsCouple* aCouple, G4double& emin_adj, G4double& emin_fwd);
@@ -205,8 +207,13 @@ class G4AdjointCSManager
std::vector< std::vector<G4double> > EminForAdjSigmaTables;
std::vector< std::vector<G4double> > EkinofFwdSigmaMax;
std::vector< std::vector<G4double> > EkinofAdjSigmaMax;
G4bool TotalSigmaTableAreBuilt;
//Sigma tavle for each G4VAdjointEMModel
std::vector<G4PhysicsTable*> listSigmaTableForAdjointModelScatProjToProj;
std::vector<G4PhysicsTable*> listSigmaTableForAdjointModelProdToProj;
//list of forward G4VEMLossProcess and of G4VEMProcess for the different adjoint particle
@@ -265,6 +272,7 @@ class G4AdjointCSManager
void DefineCurrentMaterial(const G4MaterialCutsCouple* couple);
void DefineCurrentParticle(const G4ParticleDefinition* aPartDef);
G4double ComputeAdjointCS(G4double aPrimEnergy, G4AdjointCSMatrix* anAdjointCSMatrix, G4double Tcut);
size_t eindex;
};
#endif
source/processes/electromagnetic/adjoint/include/G4AdjointComptonModel.hh
+6 -2
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4AdjointComptonModel.hh,v 1.5 2009/11/20 10:31:20 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4AdjointComptonModel.hh,v 1.6 2010/11/11 11:51:56 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
/////////////////////////////////////////////////////////////////////////////////
// Class: G4AdjointComptonModel
@@ -86,6 +86,10 @@ public:
virtual G4double AdjointCrossSection(const G4MaterialCutsCouple* aCouple,
G4double primEnergy,
G4bool IsScatProjToProjCase);
virtual G4double GetAdjointCrossSection(const G4MaterialCutsCouple* aCouple,
G4double primEnergy,
G4bool IsScatProjToProjCase);
source/processes/electromagnetic/adjoint/include/G4AdjointPhotoElectricModel.hh
+5 -2
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4AdjointPhotoElectricModel.hh,v 1.4 2009/11/20 10:31:20 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4AdjointPhotoElectricModel.hh,v 1.5 2010/11/11 11:51:56 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
/////////////////////////////////////////////////////////////////////////////////
// Module: G4AdjointPhotoElectricModel
@@ -76,6 +76,9 @@ public:
virtual G4double AdjointCrossSection(const G4MaterialCutsCouple* aCouple,
G4double primEnergy,
G4bool IsScatProjToProjCase);
virtual G4double GetAdjointCrossSection(const G4MaterialCutsCouple* aCouple,
G4double primEnergy,
G4bool IsScatProjToProjCase);
G4double AdjointCrossSectionPerAtom(const G4Element* anElement,G4double electronEnergy);
source/processes/electromagnetic/adjoint/include/G4ContinuousGainOfEnergy.hh
+3 -2
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4ContinuousGainOfEnergy.hh,v 1.4 2009/11/20 10:31:20 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4ContinuousGainOfEnergy.hh,v 1.5 2010/11/11 11:51:56 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
/////////////////////////////////////////////////////////////////////////////////
// Class: G4ContinuousGainOfEnergy
@@ -161,6 +161,7 @@ private:
G4VEmModel* currentModel;
G4double preStepChargeSqRatio;
G4double preStepScaledKinEnergy;
G4double preStepRange;
source/processes/electromagnetic/adjoint/include/G4VEmAdjointModel.hh
+12 -4
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4VEmAdjointModel.hh,v 1.4 2009/11/20 10:31:20 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4VEmAdjointModel.hh,v 1.5 2010/11/11 11:51:56 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
/////////////////////////////////////////////////////////////////////////////////
// Module: G4VEMAdjointModel
@@ -98,6 +98,10 @@ public: // public methods
virtual G4double AdjointCrossSection(const G4MaterialCutsCouple* aCouple,
G4double primEnergy,
G4bool IsScatProjToProjCase);
virtual G4double GetAdjointCrossSection(const G4MaterialCutsCouple* aCouple,
G4double primEnergy,
G4bool IsScatProjToProjCase);
virtual G4double DiffCrossSectionPerAtomPrimToSecond(
G4double kinEnergyProj, // kinetic energy of the primary particle before the interaction
@@ -313,8 +317,10 @@ protected: //attributes
//For ions
//---------
G4double mass_ratio_product;
G4double mass_ratio_projectile;
//Energy limits
@@ -341,6 +347,8 @@ protected: //attributes
//------------
size_t indexOfUsedCrossSectionMatrix;
size_t model_index;
source/processes/electromagnetic/adjoint/sources.cmake
+125
View File
@@ -0,0 +1,125 @@
#------------------------------------------------------------------------------
# sources.cmake
# Module : G4emadjoint
# Package: Geant4.src.G4processes.G4electromagnetic.G4emadjoint
#
# Sources description for a library.
# Lists the sources and headers of the code explicitely.
# Lists include paths needed.
# Lists the internal granular and global dependencies of the library.
# Source specific properties should be added at the end.
#
# Generated on : 24/9/2010
#
# $Id: sources.cmake,v 1.1 2010/09/29 18:52:40 bmorgan Exp $
#
#------------------------------------------------------------------------------
# List external includes needed.
include_directories(${CLHEP_INCLUDE_DIRS})
# List internal includes needed.
include_directories(${CMAKE_SOURCE_DIR}/source/geometry/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/geometry/navigation/include)
include_directories(${CMAKE_SOURCE_DIR}/source/geometry/volumes/include)
include_directories(${CMAKE_SOURCE_DIR}/source/global/HEPGeometry/include)
include_directories(${CMAKE_SOURCE_DIR}/source/global/HEPNumerics/include)
include_directories(${CMAKE_SOURCE_DIR}/source/global/HEPRandom/include)
include_directories(${CMAKE_SOURCE_DIR}/source/global/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/intercoms/include)
include_directories(${CMAKE_SOURCE_DIR}/source/materials/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/adjoint/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/bosons/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/hadrons/barions/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/hadrons/ions/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/hadrons/mesons/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/leptons/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/cuts/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/electromagnetic/standard/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/electromagnetic/utils/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/track/include)
#
# Define the Geant4 Module.
#
include(Geant4MacroDefineModule)
GEANT4_DEFINE_MODULE(NAME G4emadjoint
HEADERS
G4AdjointAlongStepWeightCorrection.hh
G4AdjointBremsstrahlungModel.hh
G4AdjointCSManager.hh
G4AdjointCSMatrix.hh
G4AdjointComptonModel.hh
G4AdjointInterpolator.hh
G4AdjointIonIonisationModel.hh
G4AdjointPhotoElectricModel.hh
G4AdjointProcessEquivalentToDirectProcess.hh
G4AdjointeIonisationModel.hh
G4AdjointhIonisationModel.hh
G4AdjointhMultipleScattering.hh
G4ContinuousGainOfEnergy.hh
G4InversePEEffect.hh
G4IonInverseIonisation.hh
G4VAdjointReverseReaction.hh
G4VEmAdjointModel.hh
G4eInverseBremsstrahlung.hh
G4eInverseCompton.hh
G4eInverseIonisation.hh
G4hInverseIonisation.hh
SOURCES
G4AdjointAlongStepWeightCorrection.cc
G4AdjointBremsstrahlungModel.cc
G4AdjointCSManager.cc
G4AdjointCSMatrix.cc
G4AdjointComptonModel.cc
G4AdjointInterpolator.cc
G4AdjointIonIonisationModel.cc
G4AdjointPhotoElectricModel.cc
G4AdjointProcessEquivalentToDirectProcess.cc
G4AdjointeIonisationModel.cc
G4AdjointhIonisationModel.cc
G4AdjointhMultipleScattering.cc
G4ContinuousGainOfEnergy.cc
G4InversePEEffect.cc
G4IonInverseIonisation.cc
G4VAdjointReverseReaction.cc
G4VEmAdjointModel.cc
G4eInverseBremsstrahlung.cc
G4eInverseCompton.cc
G4eInverseIonisation.cc
G4hInverseIonisation.cc
GRANULAR_DEPENDENCIES
G4baryons
G4bosons
G4cuts
G4emstandard
G4emutils
G4geometrymng
G4globman
G4hepnumerics
G4intercoms
G4ions
G4leptons
G4materials
G4mesons
G4navigation
G4partadj
G4partman
G4procman
G4track
G4volumes
GLOBAL_DEPENDENCIES
G4geometry
G4global
G4intercoms
G4materials
G4particles
G4track
LINK_LIBRARIES
)
# List any source specific properties here
source/processes/electromagnetic/adjoint/src/G4AdjointAlongStepWeightCorrection.cc
+3 -7
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4AdjointAlongStepWeightCorrection.cc,v 1.5 2009/11/23 09:02:35 gcosmo Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4AdjointAlongStepWeightCorrection.cc,v 1.6 2010/09/03 14:33:21 gcosmo Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
#include "G4AdjointAlongStepWeightCorrection.hh"
#include "G4Step.hh"
@@ -89,11 +89,7 @@ G4VParticleChange* G4AdjointAlongStepWeightCorrection::AlongStepDoIt(const G4Tra
//When the new weight is 0 it will be later on consider as nan by G4.
//Therefore we do put a lower limit of 1.e-300. for new_weight
//Correction by L.Desorgher on 15 July 2009
#ifdef WIN32
if (!!_isnan(new_weight) || new_weight==0){
#else
if (std::isnan(new_weight) || new_weight==0){
#endif
if (new_weight==0 || (new_weight<=0 && new_weight>0)){
//G4cout<<new_weight<<'\t'<<weight_correction<<'\t'<<track.GetWeight()<<G4endl;
new_weight=1.e-300;
}
source/processes/electromagnetic/adjoint/src/G4AdjointBremsstrahlungModel.cc
+25 -13
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4AdjointBremsstrahlungModel.cc,v 1.5 2009/12/16 17:50:01 gunter Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4AdjointBremsstrahlungModel.cc,v 1.6 2010/11/11 11:51:56 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
#include "G4AdjointBremsstrahlungModel.hh"
#include "G4AdjointCSManager.hh"
@@ -50,6 +50,11 @@ G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel():
theDirectStdBremModel = new G4eBremsstrahlungModel(G4Electron::Electron(),"TheDirecteBremModel");
theDirectEMModel=theDirectStdBremModel;
theEmModelManagerForFwdModels = new G4EmModelManager();
isDirectModelInitialised = false;
G4VEmFluctuationModel* f=0;
G4Region* r=0;
theEmModelManagerForFwdModels->AddEmModel(1, theDirectStdBremModel, f, r);
// theDirectPenelopeBremModel =0;
SetApplyCutInRange(true);
@@ -277,11 +282,11 @@ G4double G4AdjointBremsstrahlungModel::DiffCrossSectionPerVolumePrimToSecond(con
G4double kinEnergyProj, // kinetic energy of the primary particle before the interaction
G4double kinEnergyProd // kinetic energy of the secondary particle
)
{/*if (UsePenelopeModel && !isPenelopeModelInitialised) {
theEmModelManagerForFwdModels->Initialise(G4Electron::Electron(),G4Gamma::Gamma(),1.,0);
isPenelopeModelInitialised =true;
}
*/
{if (!isDirectModelInitialised) {
theEmModelManagerForFwdModels->Initialise(G4Electron::Electron(),G4Gamma::Gamma(),1.,0);
isDirectModelInitialised =true;
}
return DiffCrossSectionPerVolumePrimToSecondApproximated2(aMaterial,
kinEnergyProj,
kinEnergyProd);
@@ -304,8 +309,8 @@ G4double G4AdjointBremsstrahlungModel::DiffCrossSectionPerVolumePrimToSecondAppr
//In this approximation we consider that the secondary gammas are sampled with 1/Egamma energy distribution
//This is what is applied in the discrete standard model before the rejection test that make a cooerction
//The application of the same rejection function is not possble here.
//This is what is applied in the discrete standard model before the rejection test that make a correction
//The application of the same rejection function is not possible here.
//The differentiation of the CS over Ecut does not produce neither a good differential CS. That is due to the
// fact that in the discrete model the differential CS and the integrated CS are both fitted but separatly and
// therefore do not allow a correct numerical differentiation of the integrated CS to get the differential one.
@@ -364,11 +369,10 @@ G4double G4AdjointBremsstrahlungModel::DiffCrossSectionPerVolumePrimToSecondAppr
G4double G4AdjointBremsstrahlungModel::AdjointCrossSection(const G4MaterialCutsCouple* aCouple,
G4double primEnergy,
G4bool IsScatProjToProjCase)
{/* if (UsePenelopeModel && !isPenelopeModelInitialised) {
{ if (!isDirectModelInitialised) {
theEmModelManagerForFwdModels->Initialise(G4Electron::Electron(),G4Gamma::Gamma(),1.,0);
isPenelopeModelInitialised =true;
isDirectModelInitialised =true;
}
*/
if (UseMatrix) return G4VEmAdjointModel::AdjointCrossSection(aCouple,primEnergy,IsScatProjToProjCase);
DefineCurrentMaterial(aCouple);
G4double Cross=0.;
@@ -388,7 +392,15 @@ G4double G4AdjointBremsstrahlungModel::AdjointCrossSection(const G4MaterialCutsC
return Cross;
}
G4double G4AdjointBremsstrahlungModel::GetAdjointCrossSection(const G4MaterialCutsCouple* aCouple,
G4double primEnergy,
G4bool IsScatProjToProjCase)
{
return AdjointCrossSection(aCouple, primEnergy,IsScatProjToProjCase);
lastCZ=theDirectEMModel->CrossSectionPerVolume(aCouple->GetMaterial(),theDirectPrimaryPartDef,100.*MeV,100.*MeV/std::exp(1.));//this give the constant above
return G4VEmAdjointModel::GetAdjointCrossSection(aCouple, primEnergy,IsScatProjToProjCase);
}
source/processes/electromagnetic/adjoint/src/G4AdjointCSManager.cc
+54 -13
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4AdjointCSManager.cc,v 1.5 2009/11/20 10:31:20 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4AdjointCSManager.cc,v 1.6 2010/11/11 11:51:56 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
#include "G4AdjointCSManager.hh"
#include "G4AdjointCSMatrix.hh"
@@ -67,6 +67,7 @@ G4AdjointCSManager* G4AdjointCSManager::GetAdjointCSManager()
//
G4AdjointCSManager::G4AdjointCSManager()
{ CrossSectionMatrixesAreBuilt=false;
TotalSigmaTableAreBuilt=false;
theTotalForwardSigmaTableVector.clear();
theTotalAdjointSigmaTableVector.clear();
listOfForwardEmProcess.clear();
@@ -76,9 +77,11 @@ G4AdjointCSManager::G4AdjointCSManager()
EminForAdjSigmaTables.clear();
EkinofFwdSigmaMax.clear();
EkinofAdjSigmaMax.clear();
listSigmaTableForAdjointModelScatProjToProj.clear();
listSigmaTableForAdjointModelProdToProj.clear();
Tmin=0.1*keV;
Tmax=100.*TeV;
nbins=360; //probably this should be decrease, that was choosen to avoid error in the CS value closed to CS jump.(For example at Tcut)
nbins=320; //probably this should be decrease, that was choosen to avoid error in the CS value closed to CS jump.(For example at Tcut)
RegisterAdjointParticle(G4AdjointElectron::AdjointElectron());
RegisterAdjointParticle(G4AdjointGamma::AdjointGamma());
@@ -106,8 +109,12 @@ G4AdjointCSManager::~G4AdjointCSManager()
}
///////////////////////////////////////////////////////
//
void G4AdjointCSManager::RegisterEmAdjointModel(G4VEmAdjointModel* aModel)
size_t G4AdjointCSManager::RegisterEmAdjointModel(G4VEmAdjointModel* aModel)
{listOfAdjointEMModel.push_back(aModel);
listSigmaTableForAdjointModelScatProjToProj.push_back(new G4PhysicsTable);
listSigmaTableForAdjointModelProdToProj.push_back(new G4PhysicsTable);
return listOfAdjointEMModel.size() -1;
}
///////////////////////////////////////////////////////
//
@@ -249,8 +256,24 @@ void G4AdjointCSManager::BuildCrossSectionMatrices()
///////////////////////////////////////////////////////
//
void G4AdjointCSManager::BuildTotalSigmaTables()
{
{ if (TotalSigmaTableAreBuilt) return;
const G4ProductionCutsTable* theCoupleTable= G4ProductionCutsTable::GetProductionCutsTable();
//Prepare the Sigma table for all AdjointEMModel, will be filled later on
for (size_t i=0; i<listOfAdjointEMModel.size();i++){
listSigmaTableForAdjointModelScatProjToProj[i]->clearAndDestroy();
listSigmaTableForAdjointModelProdToProj[i]->clearAndDestroy();
for (size_t j=0;j<theCoupleTable->GetTableSize();j++){
listSigmaTableForAdjointModelScatProjToProj[i]->push_back(new G4PhysicsLogVector(Tmin, Tmax, nbins));
listSigmaTableForAdjointModelProdToProj[i]->push_back(new G4PhysicsLogVector(Tmin, Tmax, nbins));
}
}
for (size_t i=0;i<theListOfAdjointParticlesInAction.size();i++){
G4ParticleDefinition* thePartDef = theListOfAdjointParticlesInAction[i];
DefineCurrentParticle(thePartDef);
@@ -333,10 +356,10 @@ void G4AdjointCSManager::BuildTotalSigmaTables()
e_sigma_max =0.;
ind=0;
G4PhysicsVector* aVector1 = new G4PhysicsLogVector(Tmin, Tmax, nbins);
for(size_t l=0; l<aVector->GetVectorLength(); l++) {
G4double e=aVector->GetLowEdgeEnergy(l);
for(eindex=0; eindex<aVector->GetVectorLength(); eindex++) {
G4double e=aVector->GetLowEdgeEnergy(eindex);
G4double totCS =ComputeTotalAdjointCS(couple,thePartDef,e*0.9999999/massRatio); //massRatio needed for ions
aVector1->PutValue(l,totCS);
aVector1->PutValue(eindex,totCS);
if (totCS>sigma_max){
sigma_max=totCS;
e_sigma_max = e;
@@ -357,6 +380,7 @@ void G4AdjointCSManager::BuildTotalSigmaTables()
}
}
TotalSigmaTableAreBuilt =true;
}
///////////////////////////////////////////////////////
@@ -382,7 +406,15 @@ G4double G4AdjointCSManager::GetTotalForwardCS(G4ParticleDefinition* aPartDef, G
}
///////////////////////////////////////////////////////
//
G4double G4AdjointCSManager::GetAdjointSigma(G4double Ekin_nuc, size_t index_model,G4bool is_scat_proj_to_proj,
const G4MaterialCutsCouple* aCouple)
{ DefineCurrentMaterial(aCouple);
G4bool b;
if (is_scat_proj_to_proj) return (((*listSigmaTableForAdjointModelScatProjToProj[index_model])[currentMatIndex])->GetValue(Ekin_nuc, b));
else return (((*listSigmaTableForAdjointModelProdToProj[index_model])[currentMatIndex])->GetValue(Ekin_nuc, b));
}
///////////////////////////////////////////////////////
//
void G4AdjointCSManager::GetEminForTotalCS(G4ParticleDefinition* aPartDef,
@@ -655,6 +687,7 @@ G4double G4AdjointCSManager::ComputeTotalAdjointCS(const G4MaterialCutsCouple* a
std::vector<G4double> CS_Vs_Element;
G4double CS;
for (size_t i=0; i<listOfAdjointEMModel.size();i++){
G4double Tlow=0;
@@ -673,20 +706,28 @@ G4double G4AdjointCSManager::ComputeTotalAdjointCS(const G4MaterialCutsCouple* a
}
if ( Ekin<=listOfAdjointEMModel[i]->GetHighEnergyLimit() && Ekin>=listOfAdjointEMModel[i]->GetLowEnergyLimit()){
if (aPartDef == listOfAdjointEMModel[i]->GetAdjointEquivalentOfDirectPrimaryParticleDefinition()){
TotalCS += ComputeAdjointCS(currentMaterial,
CS=ComputeAdjointCS(currentMaterial,
listOfAdjointEMModel[i],
Ekin, Tlow,true,CS_Vs_Element);
Ekin, Tlow,true,CS_Vs_Element);
TotalCS += CS;
(*listSigmaTableForAdjointModelScatProjToProj[i])[currentMatIndex]->PutValue(eindex,CS);
}
if (aPartDef == listOfAdjointEMModel[i]->GetAdjointEquivalentOfDirectSecondaryParticleDefinition()){
TotalCS += ComputeAdjointCS(currentMaterial,
CS = ComputeAdjointCS(currentMaterial,
listOfAdjointEMModel[i],
Ekin, Tlow,false, CS_Vs_Element);
TotalCS += CS;
(*listSigmaTableForAdjointModelProdToProj[i])[currentMatIndex]->PutValue(eindex,CS);
}
}
else {
(*listSigmaTableForAdjointModelScatProjToProj[i])[currentMatIndex]->PutValue(eindex,0.);
(*listSigmaTableForAdjointModelProdToProj[i])[currentMatIndex]->PutValue(eindex,0.);
}
}
return TotalCS;
source/processes/electromagnetic/adjoint/src/G4AdjointComptonModel.cc
+18 -9
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4AdjointComptonModel.cc,v 1.6 2009/12/16 17:50:03 gunter Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4AdjointComptonModel.cc,v 1.7 2010/11/11 11:51:56 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
#include "G4AdjointComptonModel.hh"
#include "G4AdjointCSManager.hh"
@@ -45,7 +45,7 @@ G4AdjointComptonModel::G4AdjointComptonModel():
G4VEmAdjointModel("AdjointCompton")
{ SetApplyCutInRange(false);
SetUseMatrix(true);
SetUseMatrix(false);
SetUseMatrixPerElement(true);
SetUseOnlyOneMatrixForAllElements(true);
theAdjEquivOfDirectPrimPartDef =G4AdjointGamma::AdjointGamma();
@@ -170,6 +170,7 @@ void G4AdjointComptonModel::RapidSampleSecondaries(const G4Track& aTrack,
}
G4double diffCSUsed=currentMaterial->GetElectronDensity()*twopi_mc2_rcl2;
G4double gammaE1=0.;
G4double gammaE2=0.;
@@ -380,15 +381,15 @@ G4double G4AdjointComptonModel::AdjointCrossSection(const G4MaterialCutsCouple*
DefineCurrentMaterial(aCouple);
G4double Cross=0.;
G4double Emax_proj =0.;
G4double Emin_proj =0.;
float Cross=0.;
float Emax_proj =0.;
float Emin_proj =0.;
if (!IsScatProjToProjCase ){
Emax_proj = GetSecondAdjEnergyMaxForProdToProjCase(primEnergy);
Emin_proj = GetSecondAdjEnergyMinForProdToProjCase(primEnergy);
if (Emax_proj>Emin_proj ){
Cross= std::log((Emax_proj-primEnergy)*Emin_proj/Emax_proj/(Emin_proj-primEnergy))
*(1.+2.*std::log(1.+electron_mass_c2/primEnergy));
Cross= std::log((Emax_proj-float (primEnergy))*Emin_proj/Emax_proj/(Emin_proj-primEnergy))
*(1.+2.*std::log(float(1.+electron_mass_c2/primEnergy)));
}
}
else {
@@ -404,5 +405,13 @@ G4double G4AdjointComptonModel::AdjointCrossSection(const G4MaterialCutsCouple*
Cross*=currentMaterial->GetElectronDensity()*twopi_mc2_rcl2;
lastCS=Cross;
return Cross;
return double(Cross);
}
////////////////////////////////////////////////////////////////////////////////
//
G4double G4AdjointComptonModel::GetAdjointCrossSection(const G4MaterialCutsCouple* aCouple,
G4double primEnergy,
G4bool IsScatProjToProjCase)
{ return AdjointCrossSection(aCouple, primEnergy,IsScatProjToProjCase);
//return G4VEmAdjointModel::GetAdjointCrossSection(aCouple, primEnergy,IsScatProjToProjCase);
}
source/processes/electromagnetic/adjoint/src/G4AdjointIonIonisationModel.cc
+3 -2
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4AdjointIonIonisationModel.cc,v 1.2 2009/11/20 10:31:20 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4AdjointIonIonisationModel.cc,v 1.3 2010/11/11 11:51:56 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
#include "G4AdjointIonIonisationModel.hh"
#include "G4AdjointCSManager.hh"
@@ -314,6 +314,7 @@ void G4AdjointIonIonisationModel::DefineProjectileProperty()
mass = theDirectPrimaryPartDef->GetPDGMass();
massRatio= G4GenericIon::GenericIon()->GetPDGMass()/mass;
mass_ratio_projectile = massRatio;
spin = theDirectPrimaryPartDef->GetPDGSpin();
G4double q = theDirectPrimaryPartDef->GetPDGCharge()/eplus;
chargeSquare = q*q;
source/processes/electromagnetic/adjoint/src/G4AdjointPhotoElectricModel.cc
+10 -2
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4AdjointPhotoElectricModel.cc,v 1.5 2009/12/16 17:50:05 gunter Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4AdjointPhotoElectricModel.cc,v 1.6 2010/11/11 11:51:56 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
#include "G4AdjointPhotoElectricModel.hh"
#include "G4AdjointCSManager.hh"
@@ -214,6 +214,14 @@ G4double G4AdjointPhotoElectricModel::AdjointCrossSection(const G4MaterialCutsCo
////////////////////////////////////////////////////////////////////////////////
//
G4double G4AdjointPhotoElectricModel::GetAdjointCrossSection(const G4MaterialCutsCouple* aCouple,
G4double electronEnergy,
G4bool IsScatProjToProjCase)
{ return AdjointCrossSection(aCouple,electronEnergy,IsScatProjToProjCase);
}
////////////////////////////////////////////////////////////////////////////////
//
G4double G4AdjointPhotoElectricModel::AdjointCrossSectionPerAtom(const G4Element* anElement,G4double electronEnergy)
{
G4int nShells = anElement->GetNbOfAtomicShells();
source/processes/electromagnetic/adjoint/src/G4AdjointhIonisationModel.cc
+9 -7
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4AdjointhIonisationModel.cc,v 1.3 2009/12/16 17:50:07 gunter Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4AdjointhIonisationModel.cc,v 1.4 2010/11/11 11:51:56 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
#include "G4AdjointhIonisationModel.hh"
#include "G4AdjointCSManager.hh"
@@ -203,9 +203,9 @@ void G4AdjointhIonisationModel::RapidSampleSecondaries(const G4Track& aTrack,
G4double t1=adjointPrimKinEnergy*(1./diff1-1./diff2);
G4double t2=adjointPrimKinEnergy*(1./Emin-1./Emax);
G4double f31=diff1/Emin;
G4double f32=diff2/Emax/f31;
G4double t3=2.*std::log(f32);
/*G4double f31=diff1/Emin;
G4double f32=diff2/Emax/f31;*/
G4double t3=2.*std::log(Emax/Emin);
G4double sum_t=t1+t2+t3;
newCS=newCS*sum_t/adjointPrimKinEnergy/adjointPrimKinEnergy;
G4double t=G4UniformRand()*sum_t;
@@ -219,7 +219,7 @@ void G4AdjointhIonisationModel::RapidSampleSecondaries(const G4Track& aTrack,
projectileKinEnergy =1./(1./Emin-q);
}
else {
projectileKinEnergy=adjointPrimKinEnergy/(1.-f31*std::pow(f32,G4UniformRand()));
projectileKinEnergy=Emin*std::pow(Emax/Emin,G4UniformRand());
}
eEnergy=projectileKinEnergy-adjointPrimKinEnergy;
@@ -414,6 +414,7 @@ void G4AdjointhIonisationModel::DefineProjectileProperty()
}
mass = theDirectPrimaryPartDef->GetPDGMass();
mass_ratio_projectile = proton_mass_c2/theDirectPrimaryPartDef->GetPDGMass();;
spin = theDirectPrimaryPartDef->GetPDGSpin();
G4double q = theDirectPrimaryPartDef->GetPDGCharge()/eplus;
chargeSquare = q*q;
@@ -469,7 +470,8 @@ G4double G4AdjointhIonisationModel::AdjointCrossSection(const G4MaterialCutsCoup
G4double diff1=Emin_proj-primEnergy;
G4double diff2=Emax_proj-primEnergy;
G4double t1=(1./diff1+1./Emin_proj-1./diff2-1./Emax_proj)/primEnergy;
G4double t2=2.*std::log(diff2*Emin_proj/Emax_proj/diff1)/primEnergy/primEnergy;
//G4double t2=2.*std::log(diff2*Emin_proj/Emax_proj/diff1)/primEnergy/primEnergy;
G4double t2=2.*std::log(Emax_proj/Emin_proj)/primEnergy/primEnergy;
Cross*=(t1+t2);
source/processes/electromagnetic/adjoint/src/G4AdjointhMultipleScattering.cc
+2 -3
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4AdjointhMultipleScattering.cc,v 1.2 2009/11/20 10:31:20 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4AdjointhMultipleScattering.cc,v 1.3 2010/04/12 18:57:15 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
//
@@ -42,7 +42,6 @@
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "G4AdjointhMultipleScattering.hh"
#include "G4UrbanMscModel.hh"
#include "G4UrbanMscModel90.hh"
#include "G4MscStepLimitType.hh"
source/processes/electromagnetic/adjoint/src/G4ContinuousGainOfEnergy.cc
+9 -15
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4ContinuousGainOfEnergy.cc,v 1.4 2009/11/20 10:31:20 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4ContinuousGainOfEnergy.cc,v 1.5 2010/11/11 11:51:56 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
#include "G4ContinuousGainOfEnergy.hh"
#include "G4Step.hh"
@@ -136,15 +136,14 @@ G4VParticleChange* G4ContinuousGainOfEnergy::AlongStepDoIt(const G4Track& track,
*dynParticle = *(track.GetDynamicParticle());
dynParticle->SetDefinition(theDirectPartDef);
G4double Tkin = dynParticle->GetKineticEnergy();
G4double Tkin1=Tkin*0.001;
size_t n=1;
if (is_integral ) n=10;
n=1;
G4double dlength= length/n;
for (size_t i=0;i<n;i++) {
G4double factor_dE=1.;
if (Tkin != preStepKinEnergy && IsIon) {
if (Tkin != preStepKinEnergy && IsIon) {
chargeSqRatio = currentModel->GetChargeSquareRatio(theDirectPartDef,currentMaterial,Tkin);
theDirectEnergyLossProcess->SetDynamicMassCharge(massRatio,chargeSqRatio);
@@ -152,9 +151,7 @@ G4VParticleChange* G4ContinuousGainOfEnergy::AlongStepDoIt(const G4Track& track,
G4double r = theDirectEnergyLossProcess->GetRange(Tkin, currentCouple);
if( dlength <= linLossLimit * r ) {
degain = DEDX_before*dlength;
G4double degain1 = dlength*theDirectEnergyLossProcess->GetDEDX(Tkin1, currentCouple);
factor_dE=1.+(degain1-degain)/(Tkin1-Tkin);
degain = DEDX_before*dlength;
}
else {
G4double x = r + dlength;
@@ -172,10 +169,7 @@ G4VParticleChange* G4ContinuousGainOfEnergy::AlongStepDoIt(const G4Track& track,
}
}
G4double r1 = theDirectEnergyLossProcess->GetRange(Tkin1, currentCouple);
G4double x1 = r1 + dlength;
G4double E1 = theDirectEnergyLossProcess->GetKineticEnergy(x1,currentCouple);
factor_dE=(E1-E)/(Tkin1-Tkin);
degain=E-Tkin;
@@ -279,7 +273,7 @@ G4double G4ContinuousGainOfEnergy::GetContinuousStepLimit(const G4Track& track,
maxE=std::min(emax_model*1.001,maxE);
G4double r = theDirectEnergyLossProcess->GetRange(preStepKinEnergy, currentCouple);
preStepRange = theDirectEnergyLossProcess->GetRange(preStepKinEnergy, currentCouple);
if (IsIon) {
G4double chargeSqRatioAtEmax = currentModel->GetChargeSquareRatio(theDirectPartDef,currentMaterial,maxE);
@@ -292,8 +286,8 @@ G4double G4ContinuousGainOfEnergy::GetContinuousStepLimit(const G4Track& track,
x=r1-r;
x=std::max(r1-r,0.001*mm);
x=r1-preStepRange;
x=std::max(r1-preStepRange,0.001*mm);
return x;
source/processes/electromagnetic/adjoint/src/G4VAdjointReverseReaction.cc
+6 -5
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4VAdjointReverseReaction.cc,v 1.2 2009/11/20 10:31:20 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4VAdjointReverseReaction.cc,v 1.3 2010/11/11 11:51:56 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
#include "G4VAdjointReverseReaction.hh"
#include "G4AdjointCSManager.hh"
@@ -108,9 +108,11 @@ G4double G4VAdjointReverseReaction::GetMeanFreePath(const G4Track& track,
{ *condition = NotForced;
G4double preStepKinEnergy = track.GetKineticEnergy();
G4double Sigma =
theAdjointEMModel->AdjointCrossSection(track.GetMaterialCutsCouple(),preStepKinEnergy,IsScatProjToProjCase);
/*G4double Sigma =
theAdjointEMModel->AdjointCrossSection(track.GetMaterialCutsCouple(),preStepKinEnergy,IsScatProjToProjCase);*/
G4double Sigma =
theAdjointEMModel->GetAdjointCrossSection(track.GetMaterialCutsCouple(),preStepKinEnergy,IsScatProjToProjCase);
G4double fwd_TotCS;
Sigma *= theAdjointCSManager->GetCrossSectionCorrection(track.GetDefinition(),preStepKinEnergy,track.GetMaterialCutsCouple(),IsFwdCSUsed, fwd_TotCS);
//G4cout<<fwd_TotCS<<G4endl;
@@ -135,4 +137,3 @@ G4double G4VAdjointReverseReaction::GetMeanFreePath(const G4Track& track,
return mean_free_path;
}
source/processes/electromagnetic/adjoint/src/G4VEmAdjointModel.cc
+59 -31
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4VEmAdjointModel.cc,v 1.5 2009/12/16 17:50:09 gunter Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4VEmAdjointModel.cc,v 1.6 2010/11/11 11:51:56 ldesorgh Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
#include "G4VEmAdjointModel.hh"
#include "G4AdjointCSManager.hh"
@@ -32,6 +32,8 @@
#include "G4TrackStatus.hh"
#include "G4ParticleChange.hh"
#include "G4AdjointElectron.hh"
#include "G4AdjointGamma.hh"
#include "G4AdjointPositron.hh"
#include "G4AdjointInterpolator.hh"
#include "G4PhysicsTable.hh"
@@ -41,9 +43,11 @@ G4VEmAdjointModel::G4VEmAdjointModel(const G4String& nam):
name(nam)
// lowLimit(0.1*keV), highLimit(100.0*TeV), fluc(0), name(nam), pParticleChange(0)
{
G4AdjointCSManager::GetAdjointCSManager()->RegisterEmAdjointModel(this);
model_index = G4AdjointCSManager::GetAdjointCSManager()->RegisterEmAdjointModel(this);
second_part_of_same_type =false;
theDirectEMModel=0;
mass_ratio_product=1.;
mass_ratio_projectile=1.;
}
////////////////////////////////////////////////////////////////////////////////
//
@@ -73,7 +77,49 @@ G4double G4VEmAdjointModel::AdjointCrossSection(const G4MaterialCutsCouple* aCou
return lastCS;
}
}
////////////////////////////////////////////////////////////////////////////////
//
G4double G4VEmAdjointModel::GetAdjointCrossSection(const G4MaterialCutsCouple* aCouple,
G4double primEnergy,
G4bool IsScatProjToProjCase)
{
return AdjointCrossSection(aCouple, primEnergy,
IsScatProjToProjCase);
//To continue
DefineCurrentMaterial(aCouple);
preStepEnergy=primEnergy;
if (IsScatProjToProjCase){
G4double ekin=primEnergy*mass_ratio_projectile;
lastCS = G4AdjointCSManager::GetAdjointCSManager()->GetAdjointSigma(ekin, model_index,true, aCouple);
lastAdjointCSForScatProjToProjCase = lastCS;
//G4cout<<ekin<<std::endl;
}
else {
G4double ekin=primEnergy*mass_ratio_product;
lastCS = G4AdjointCSManager::GetAdjointCSManager()->GetAdjointSigma(ekin, model_index,false, aCouple);
lastAdjointCSForProdToProjCase = lastCS;
//G4cout<<ekin<<std::endl;
}
/* G4double ratio=lastCS;
G4cout<<"Model name"<<name;
G4cout<<" LastCS Get "<<lastCS;
G4cout<<" Energy "<<primEnergy;*/
/*G4double lastCS1 = AdjointCrossSection(aCouple,
primEnergy,
IsScatProjToProjCase);
if (lastCS1 >0) {
G4double ratio=lastCS/lastCS1;
G4double diff = std::abs(1-ratio)*100.;
if (diff >1) G4cout<<primEnergy <<" diff"<<diff<<'\t'<<lastCS<<'\t'<<lastCS1<<'\t'<<name<<'\t'<<IsScatProjToProjCase<<std::endl;
}
//G4cout<<" LastCS Compute "<<lastCS1<<std::endl;
*/
return lastCS;
}
////////////////////////////////////////////////////////////////////////////////
//
//General implementation correct for energy loss process, for the photoelectric and compton scattering the method should be redefine
@@ -601,10 +647,10 @@ void G4VEmAdjointModel::CorrectPostStepWeight(G4ParticleChange* fParticleChange,
lastCS=lastAdjointCSForScatProjToProjCase;
if ( !IsScatProjToProjCase) lastCS=lastAdjointCSForProdToProjCase;
if (adjointPrimKinEnergy !=preStepEnergy){ //Is that in all cases needed???
if ((adjointPrimKinEnergy-preStepEnergy)/preStepEnergy>0.001){ //Is that in all cases needed???
G4double post_stepCS=AdjointCrossSection(currentCouple, adjointPrimKinEnergy
,IsScatProjToProjCase );
w_corr*=post_stepCS/lastCS;
if (post_stepCS>0 && lastCS>0) w_corr*=post_stepCS/lastCS;
}
new_weight*=w_corr;
@@ -654,36 +700,18 @@ void G4VEmAdjointModel::DefineCurrentMaterial(const G4MaterialCutsCouple* coupl
currentCoupleIndex = couple->GetIndex();
currentMaterialIndex = currentMaterial->GetIndex();
size_t idx=56;
currentTcutForDirectPrim =0.00000000001;
if (theAdjEquivOfDirectPrimPartDef) {
if (theAdjEquivOfDirectPrimPartDef->GetParticleName() == "adj_gamma") idx = 0;
else if (theAdjEquivOfDirectPrimPartDef->GetParticleName() == "adj_e-") idx = 1;
else if (theAdjEquivOfDirectPrimPartDef->GetParticleName() == "adj_e+") idx = 2;
currentTcutForDirectSecond =0.00000000001;
if (theAdjEquivOfDirectSecondPartDef) {
if (theAdjEquivOfDirectSecondPartDef == G4AdjointGamma::AdjointGamma()) idx = 0;
else if (theAdjEquivOfDirectSecondPartDef == G4AdjointElectron::AdjointElectron()) idx = 1;
else if (theAdjEquivOfDirectSecondPartDef == G4AdjointPositron::AdjointPositron()) idx = 2;
if (idx <56){
const std::vector<G4double>* aVec = G4ProductionCutsTable::GetProductionCutsTable()->GetEnergyCutsVector(idx);
currentTcutForDirectPrim=(*aVec)[currentCoupleIndex];
currentTcutForDirectSecond=(*aVec)[currentCoupleIndex];
}
}
currentTcutForDirectSecond =0.00000000001;
if (theAdjEquivOfDirectPrimPartDef == theAdjEquivOfDirectSecondPartDef) {
currentTcutForDirectSecond = currentTcutForDirectPrim;
}
else {
if (theAdjEquivOfDirectSecondPartDef){
if (theAdjEquivOfDirectSecondPartDef->GetParticleName() == "adj_gamma") idx = 0;
else if (theAdjEquivOfDirectSecondPartDef->GetParticleName() == "adj_e-") idx = 1;
else if (theAdjEquivOfDirectSecondPartDef->GetParticleName() == "adj_e+") idx = 2;
const std::vector<G4double>* aVec = G4ProductionCutsTable::GetProductionCutsTable()->GetEnergyCutsVector(idx);
currentTcutForDirectSecond=(*aVec)[currentCoupleIndex];
if (idx <56){
const std::vector<G4double>* aVec = G4ProductionCutsTable::GetProductionCutsTable()->GetEnergyCutsVector(idx);
currentTcutForDirectPrim=(*aVec)[currentCoupleIndex];
}
}
}
}
}
////////////////////////////////////////////////////////////////////////////////////////////
source/processes/electromagnetic/highenergy/CMakeLists.txt
+18
View File
@@ -0,0 +1,18 @@
#------------------------------------------------------------------------------
# CMakeLists.txt
# Module : G4emhighenergy
# Package: Geant4.src.G4processes.G4electromagnetic.G4emhighenergy
#
# CMakeLists.txt for building a single granular library.
#
# Generated on : 24/9/2010
#
# $Id: CMakeLists.txt,v 1.1 2010/09/29 18:52:52 bmorgan Exp $
#
#------------------------------------------------------------------------------
if(GEANT4_BUILD_GRANULAR_LIBS)
include(Geant4MacroLibraryTargets)
GEANT4_GRANULAR_LIBRARY_TARGET(COMPONENT sources.cmake)
endif()
source/processes/electromagnetic/highenergy/History
+16 -1
View File
@@ -1,4 +1,4 @@
$Id: History,v 1.34 2009/11/11 17:13:47 vnivanch Exp $
$Id: History,v 1.37 2010/10/26 15:40:03 vnivanch Exp $
-------------------------------------------------------------------
=========================================================
@@ -17,6 +17,21 @@ committal in the CVS repository !
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
26 October 10: V.Ivanchenko (emhighenergy-V09-03-02)
- Fixed problem reported by the Coverity tools (mainly pedantic
initialisation)
- Added G4mplIonisationWithDeltaModel which is substituted
G4mplIonisationModel by default - delat-ray production is required
both by ATLAS and CMS
04 March 10: V.Ivanchenko (emhighenergy-V09-03-01)
- G4ICRU73NoDeltaModel - new model derived from G4ICRU73QOModel
28 March 10: V.Ivanchenko (emhighenergy-V09-03-00)
- G4mplIonisation - fixed IsApplicable method - always "true"
(CMS report crash in the case when several types
of monopoles are instantiated)
11 November 09: V.Ivanchenko (emhighenergy-V09-02-03)
- G4eeTo3PiModel - fixed vector product in matrix element
source/processes/electromagnetic/highenergy/include/G4GammaConversionToMuons.hh
+2 -4
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4GammaConversionToMuons.hh,v 1.2 2006/06/29 19:32:18 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4GammaConversionToMuons.hh,v 1.3 2010/10/26 14:15:40 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// ------------ G4GammaConversionToMuons physics process ------
// by H.Burkhardt, S. Kelner and R. Kokoulin, April 2002
@@ -131,8 +131,6 @@ class G4GammaConversionToMuons : public G4VDiscreteProcess
G4double LowestEnergyLimit ; // low energy limit of the tables
G4double HighestEnergyLimit ; // high energy limit of the tables
G4double fminimalEnergy; // minimalEnergy of produced particles
G4double MeanFreePath; // actual MeanFreePath (current medium)
G4double CrossSecFactor; // factor to artificially increase
// the cross section
source/processes/electromagnetic/highenergy/include/G4ICRU73NoDeltaModel.hh
+85
View File
@@ -0,0 +1,85 @@
//
// ********************************************************************
// * 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: G4ICRU73NoDeltaModel.hh,v 1.1 2010/06/04 10:23:31 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
// -------------------------------------------------------------------
//
// GEANT4 Class header file
//
//
// File name: G4ICRU73NoDeltaModel
//
// Author: Vladimir Ivanchenko
//
// Creation date: 04.10.2010
//
// Modifications:
//
//
// Class Description:
//
// Implementation of G4ICRU73QOModel without delta-ray
// -------------------------------------------------------------------
//
#ifndef G4ICRU73NoDeltaModel_h
#define G4ICRU73NoDeltaModel_h 1
#include "G4ICRU73QOModel.hh"
class G4ICRU73NoDeltaModel : public G4ICRU73QOModel
{
public:
G4ICRU73NoDeltaModel(const G4ParticleDefinition* p = 0,
const G4String& nam = "ICRU73QONoD");
virtual ~G4ICRU73NoDeltaModel();
virtual G4double ComputeDEDXPerVolume(const G4Material*,
const G4ParticleDefinition*,
G4double kineticEnergy,
G4double cutEnergy);
virtual G4double CrossSectionPerVolume(const G4Material*,
const G4ParticleDefinition*,
G4double kineticEnergy,
G4double cutEnergy,
G4double maxEnergy);
private:
// hide assignment operator
G4ICRU73NoDeltaModel & operator=(const G4ICRU73NoDeltaModel &right);
G4ICRU73NoDeltaModel(const G4ICRU73NoDeltaModel&);
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#endif
source/processes/electromagnetic/highenergy/include/G4hhIonisation.hh
+2 -7
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4hhIonisation.hh,v 1.6 2009/02/20 16:38:33 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4hhIonisation.hh,v 1.7 2010/10/26 14:15:40 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// -------------------------------------------------------------------
//
@@ -89,17 +89,12 @@ private:
G4double mass;
G4double ratio;
G4double minKinEnergy;
G4double maxKinEnergy;
const G4ParticleDefinition* theParticle;
const G4ParticleDefinition* theBaseParticle;
G4VEmFluctuationModel* flucModel;
G4bool isInitialised;
G4double eth;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
source/processes/electromagnetic/highenergy/include/G4mplIonisationModel.hh
+2 -4
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4mplIonisationModel.hh,v 1.7 2009/02/20 16:38:33 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4mplIonisationModel.hh,v 1.8 2010/10/26 15:40:03 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// -------------------------------------------------------------------
//
@@ -108,12 +108,10 @@ private:
G4double betalim;
G4double beta2lim;
G4double bg2lim;
G4double factlow;
G4double chargeSquare;
G4double dedxlim;
G4int nmpl;
G4double pi_hbarc2_over_mc2;
G4double approxConst;
};
#endif
source/processes/electromagnetic/highenergy/include/G4mplIonisationWithDeltaModel.hh
+139
View File
@@ -0,0 +1,139 @@
//
// ********************************************************************
// * 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: G4mplIonisationWithDeltaModel.hh,v 1.1 2010/10/26 15:40:03 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// -------------------------------------------------------------------
//
// GEANT4 Class header file
//
//
// File name: G4mplIonisationWithDeltaModel
//
// Author: Vladimir Ivanchenko
//
// Creation date: 06.09.2005
//
// Modifications:
// 12.08.2007 ComputeDEDXAhlen function added (M. Vladymyrov)
//
// Class Description:
//
// Implementation of model of energy loss of the magnetic monopole
// -------------------------------------------------------------------
//
#ifndef G4mplIonisationWithDeltaModel_h
#define G4mplIonisationWithDeltaModel_h 1
#include "G4VEmModel.hh"
#include "G4VEmFluctuationModel.hh"
class G4ParticleChangeForLoss;
class G4mplIonisationWithDeltaModel : public G4VEmModel, public G4VEmFluctuationModel
{
public:
G4mplIonisationWithDeltaModel(G4double mCharge, const G4String& nam = "mplIonisationWithDelta");
virtual ~G4mplIonisationWithDeltaModel();
virtual void Initialise(const G4ParticleDefinition*, const G4DataVector&);
virtual G4double ComputeDEDXPerVolume(const G4Material*,
const G4ParticleDefinition*,
G4double kineticEnergy,
G4double cutEnergy);
virtual G4double ComputeCrossSectionPerElectron(
const G4ParticleDefinition*,
G4double kineticEnergy,
G4double cutEnergy,
G4double maxEnergy);
virtual G4double ComputeCrossSectionPerAtom(
const G4ParticleDefinition*,
G4double kineticEnergy,
G4double Z, G4double A,
G4double cutEnergy,
G4double maxEnergy);
virtual void SampleSecondaries(std::vector<G4DynamicParticle*>*,
const G4MaterialCutsCouple*,
const G4DynamicParticle*,
G4double tmin,
G4double maxEnergy);
virtual G4double SampleFluctuations(const G4Material*,
const G4DynamicParticle*,
G4double& tmax,
G4double& length,
G4double& meanLoss);
virtual G4double Dispersion(const G4Material*,
const G4DynamicParticle*,
G4double& tmax,
G4double& length);
protected:
virtual G4double MaxSecondaryEnergy(const G4ParticleDefinition*,
G4double kinEnergy);
private:
void SetParticle(const G4ParticleDefinition* p);
G4double ComputeDEDXAhlen(const G4Material* material, G4double bg2, G4double cut);
// hide assignment operator
G4mplIonisationWithDeltaModel & operator=(const G4mplIonisationWithDeltaModel &right);
G4mplIonisationWithDeltaModel(const G4mplIonisationWithDeltaModel&);
const G4ParticleDefinition* monopole;
G4ParticleDefinition* theElectron;
G4ParticleChangeForLoss* fParticleChange;
G4double mass;
G4double magCharge;
G4double twoln10;
G4double betalow;
G4double betalim;
G4double beta2lim;
G4double bg2lim;
G4double chargeSquare;
G4double dedxlim;
G4int nmpl;
G4double pi_hbarc2_over_mc2;
};
#endif
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
source/processes/electromagnetic/highenergy/sources.cmake
+125
View File
@@ -0,0 +1,125 @@
#------------------------------------------------------------------------------
# sources.cmake
# Module : G4emhighenergy
# Package: Geant4.src.G4processes.G4electromagnetic.G4emhighenergy
#
# Sources description for a library.
# Lists the sources and headers of the code explicitely.
# Lists include paths needed.
# Lists the internal granular and global dependencies of the library.
# Source specific properties should be added at the end.
#
# Generated on : 24/9/2010
#
# $Id: sources.cmake,v 1.2 2010/10/26 16:42:12 gcosmo Exp $
#
#------------------------------------------------------------------------------
# List external includes needed.
include_directories(${CLHEP_INCLUDE_DIRS})
# List internal includes needed.
include_directories(${CMAKE_SOURCE_DIR}/source/geometry/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/geometry/volumes/include)
include_directories(${CMAKE_SOURCE_DIR}/source/global/HEPGeometry/include)
include_directories(${CMAKE_SOURCE_DIR}/source/global/HEPNumerics/include)
include_directories(${CMAKE_SOURCE_DIR}/source/global/HEPRandom/include)
include_directories(${CMAKE_SOURCE_DIR}/source/global/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/intercoms/include)
include_directories(${CMAKE_SOURCE_DIR}/source/materials/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/bosons/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/hadrons/barions/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/hadrons/ions/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/hadrons/mesons/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/leptons/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/cuts/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/electromagnetic/muons/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/electromagnetic/standard/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/electromagnetic/utils/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/track/include)
#
# Define the Geant4 Module.
#
include(Geant4MacroDefineModule)
GEANT4_DEFINE_MODULE(NAME G4emhighenergy
HEADERS
G4AnnihiToMuPair.hh
G4BetheBlochNoDeltaModel.hh
G4BraggNoDeltaModel.hh
G4GammaConversionToMuons.hh
G4ICRU73NoDeltaModel.hh
G4Vee2hadrons.hh
G4ee2KChargedModel.hh
G4ee2KNeutralModel.hh
G4eeCrossSections.hh
G4eeTo3PiModel.hh
G4eeToHadrons.hh
G4eeToHadronsModel.hh
G4eeToHadronsMultiModel.hh
G4eeToPGammaModel.hh
G4eeToTwoPiModel.hh
G4hBremsstrahlung.hh
G4hBremsstrahlungModel.hh
G4hPairProduction.hh
G4hPairProductionModel.hh
G4hhIonisation.hh
G4mplIonisation.hh
G4mplIonisationModel.hh
G4mplIonisationWithDeltaModel.hh
SOURCES
G4AnnihiToMuPair.cc
G4BetheBlochNoDeltaModel.cc
G4BraggNoDeltaModel.cc
G4GammaConversionToMuons.cc
G4ICRU73NoDeltaModel.cc
G4ee2KChargedModel.cc
G4ee2KNeutralModel.cc
G4eeCrossSections.cc
G4eeTo3PiModel.cc
G4eeToHadrons.cc
G4eeToHadronsModel.cc
G4eeToHadronsMultiModel.cc
G4eeToPGammaModel.cc
G4eeToTwoPiModel.cc
G4hBremsstrahlung.cc
G4hBremsstrahlungModel.cc
G4hPairProduction.cc
G4hPairProductionModel.cc
G4hhIonisation.cc
G4mplIonisation.cc
G4mplIonisationModel.cc
G4mplIonisationWithDeltaModel.cc
GRANULAR_DEPENDENCIES
G4baryons
G4bosons
G4cuts
G4emstandard
G4emutils
G4geometrymng
G4globman
G4hepnumerics
G4intercoms
G4ions
G4leptons
G4materials
G4mesons
G4muons
G4partman
G4procman
G4track
G4volumes
GLOBAL_DEPENDENCIES
G4geometry
G4global
G4intercoms
G4materials
G4particles
G4track
LINK_LIBRARIES
)
# List any source specific properties here
source/processes/electromagnetic/highenergy/src/G4GammaConversionToMuons.cc
+3 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4GammaConversionToMuons.cc,v 1.7 2008/10/16 14:29:48 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4GammaConversionToMuons.cc,v 1.8 2010/10/26 14:15:40 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// ------------ G4GammaConversionToMuons physics process ------
// by H.Burkhardt, S. Kelner and R. Kokoulin, April 2002
@@ -52,6 +52,7 @@ G4GammaConversionToMuons::G4GammaConversionToMuons(const G4String& processName,
CrossSecFactor(1.)
{
SetProcessSubType(15);
MeanFreePath = DBL_MAX;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
source/processes/electromagnetic/highenergy/src/G4ICRU73NoDeltaModel.cc
+88
View File
@@ -0,0 +1,88 @@
//
// ********************************************************************
// * 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: G4ICRU73NoDeltaModel.cc,v 1.1 2010/06/04 10:23:31 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
// -------------------------------------------------------------------
//
// GEANT4 Class file
//
//
// File name: G4ICRU73NoDeltaModel
//
// Author: Vladimir Ivanchenko
//
// Creation date: 04.06.2010
//
// Modifications:
//
//
// Class Description:
//
// Ionisation of heavy negatively charged particles
// -------------------------------------------------------------------
//
#include "G4ICRU73NoDeltaModel.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4ICRU73NoDeltaModel::G4ICRU73NoDeltaModel(const G4ParticleDefinition*p,
const G4String& nam) :
G4ICRU73QOModel(p, nam)
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4ICRU73NoDeltaModel::~G4ICRU73NoDeltaModel()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4ICRU73NoDeltaModel::ComputeDEDXPerVolume(
const G4Material* material,
const G4ParticleDefinition* pd,
G4double kinEnergy, G4double)
{
return
G4ICRU73QOModel::ComputeDEDXPerVolume(material, pd, kinEnergy, DBL_MAX);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4ICRU73NoDeltaModel::CrossSectionPerVolume(
const G4Material*,
const G4ParticleDefinition*,
G4double, G4double, G4double)
{
return 0.0;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
source/processes/electromagnetic/highenergy/src/G4eeToHadronsModel.cc
+9 -3
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4eeToHadronsModel.cc,v 1.9 2008/07/10 18:06:39 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4eeToHadronsModel.cc,v 1.10 2010/10/26 14:15:40 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// -------------------------------------------------------------------
//
@@ -75,6 +75,12 @@ G4eeToHadronsModel::G4eeToHadronsModel(G4Vee2hadrons* m, G4int ver,
verbose(ver)
{
theGamma = G4Gamma::Gamma();
highKinEnergy = HighEnergyLimit();
lowKinEnergy = LowEnergyLimit();
emin = lowKinEnergy;
emax = highKinEnergy;
peakKinEnergy = highKinEnergy;
epeak = emax;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
@@ -91,7 +97,7 @@ G4eeToHadronsModel::~G4eeToHadronsModel()
void G4eeToHadronsModel::Initialise(const G4ParticleDefinition*,
const G4DataVector&)
{
if(isInitialised) return;
if(isInitialised) { return; }
isInitialised = true;
// Lab system
source/processes/electromagnetic/highenergy/src/G4eeToHadronsMultiModel.cc
+6 -6
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4eeToHadronsMultiModel.cc,v 1.8 2009/04/12 17:48:21 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4eeToHadronsMultiModel.cc,v 1.9 2010/10/26 14:15:40 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// -------------------------------------------------------------------
//
@@ -67,7 +67,10 @@ G4eeToHadronsMultiModel::G4eeToHadronsMultiModel(G4int ver, const G4String& name
nModels(0),
verbose(ver),
isInitialised(false)
{}
{
thKineticEnergy = DBL_MAX;
maxKineticEnergy = 1.2*GeV;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
@@ -90,9 +93,6 @@ void G4eeToHadronsMultiModel::Initialise(const G4ParticleDefinition*,
if(!isInitialised) {
isInitialised = true;
thKineticEnergy = DBL_MAX;
maxKineticEnergy = 1.2*GeV;
cross = new G4eeCrossSections();
G4eeToTwoPiModel* m2pi = new G4eeToTwoPiModel(cross);
source/processes/electromagnetic/highenergy/src/G4hhIonisation.cc
+17 -11
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4hhIonisation.cc,v 1.9 2009/02/20 16:38:33 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4hhIonisation.cc,v 1.11 2010/10/26 14:15:40 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// -------------------------------------------------------------------
//
@@ -50,6 +50,7 @@
#include "G4hhIonisation.hh"
#include "G4BraggNoDeltaModel.hh"
#include "G4BetheBlochNoDeltaModel.hh"
#include "G4ICRU73NoDeltaModel.hh"
#include "G4UniversalFluctuation.hh"
#include "G4BohrFluctuations.hh"
#include "G4UnitsTable.hh"
@@ -100,30 +101,35 @@ G4double G4hhIonisation::MinPrimaryEnergy(const G4ParticleDefinition*,
void G4hhIonisation::InitialiseEnergyLossProcess(const G4ParticleDefinition* part,
const G4ParticleDefinition* bpart)
{
if(isInitialised) return;
if(isInitialised) { return; }
theParticle = part;
if(bpart) G4cout << "G4hhIonisation::InitialiseEnergyLossProcess WARNING: no "
<< "base particle should be defined for the process "
<< GetProcessName() << G4endl;
if(bpart) {
G4cout << "G4hhIonisation::InitialiseEnergyLossProcess WARNING: no "
<< "base particle should be defined for the process "
<< GetProcessName() << G4endl;
}
SetBaseParticle(0);
SetSecondaryParticle(G4Electron::Electron());
//G4double q = theParticle->GetPDGCharge();
mass = theParticle->GetPDGMass();
ratio = electron_mass_c2/mass;
eth = 2.0*MeV*mass/proton_mass_c2;
G4double eth = 2*MeV*mass/proton_mass_c2;
flucModel = new G4BohrFluctuations();
G4int nm = 1;
minKinEnergy = MinKinEnergy();
G4double minKinEnergy = MinKinEnergy();
if(eth > minKinEnergy) {
G4VEmModel* em = new G4BraggNoDeltaModel();
G4VEmModel* em;
em = new G4BraggNoDeltaModel();
//if(q > 0.0) { em = new G4BraggNoDeltaModel(); }
//else { em = new G4ICRU73NoDeltaModel(); }
em->SetLowEnergyLimit(minKinEnergy);
em->SetHighEnergyLimit(eth);
AddEmModel(nm, em, flucModel);
nm++;
++nm;
}
if(eth < MaxKinEnergy()) {
source/processes/electromagnetic/highenergy/src/G4mplIonisation.cc
+8 -6
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4mplIonisation.cc,v 1.8 2009/02/20 16:38:33 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4mplIonisation.cc,v 1.11 2010/10/26 15:40:03 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// -------------------------------------------------------------------
//
@@ -48,6 +48,7 @@
#include "G4mplIonisation.hh"
#include "G4Electron.hh"
#include "G4mplIonisationModel.hh"
#include "G4mplIonisationWithDeltaModel.hh"
#include "G4BohrFluctuations.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
@@ -74,9 +75,9 @@ G4mplIonisation::~G4mplIonisation()
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4bool G4mplIonisation::IsApplicable(const G4ParticleDefinition& p)
G4bool G4mplIonisation::IsApplicable(const G4ParticleDefinition&)
{
return (p.GetParticleName() == "monopole");
return true;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
@@ -84,12 +85,13 @@ G4bool G4mplIonisation::IsApplicable(const G4ParticleDefinition& p)
void G4mplIonisation::InitialiseEnergyLossProcess(const G4ParticleDefinition*,
const G4ParticleDefinition*)
{
if(isInitialised) return;
if(isInitialised) { return; }
SetBaseParticle(0);
SetSecondaryParticle(G4Electron::Electron());
G4mplIonisationModel* ion = new G4mplIonisationModel(magneticCharge,"PAI");
G4mplIonisationWithDeltaModel* ion =
new G4mplIonisationWithDeltaModel(magneticCharge,"PAI");
ion->SetLowEnergyLimit(MinKinEnergy());
ion->SetHighEnergyLimit(MaxKinEnergy());
AddEmModel(0,ion,ion);
source/processes/electromagnetic/highenergy/src/G4mplIonisationModel.cc
+6 -5
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4mplIonisationModel.cc,v 1.7 2009/04/12 17:35:41 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4mplIonisationModel.cc,v 1.8 2010/10/26 15:40:03 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// -------------------------------------------------------------------
//
@@ -73,12 +73,13 @@ G4mplIonisationModel::G4mplIonisationModel(G4double mCharge, const G4String& nam
bg2lim(beta2lim*(1.0 + beta2lim))
{
nmpl = G4int(abs(magCharge) * 2 * fine_structure_const + 0.5);
if(nmpl > 6) nmpl = 6;
else if(nmpl < 1) nmpl = 1;
if(nmpl > 6) { nmpl = 6; }
else if(nmpl < 1) { nmpl = 1; }
pi_hbarc2_over_mc2 = pi * hbarc * hbarc / electron_mass_c2;
chargeSquare = magCharge * magCharge;
dedxlim = 45.*nmpl*nmpl*GeV*cm2/g;
fParticleChange = 0;
mass = 0.0;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
@@ -93,7 +94,7 @@ void G4mplIonisationModel::Initialise(const G4ParticleDefinition* p,
{
monopole = p;
mass = monopole->GetPDGMass();
if(!fParticleChange) fParticleChange = GetParticleChangeForLoss();
if(!fParticleChange) { fParticleChange = GetParticleChangeForLoss(); }
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
source/processes/electromagnetic/highenergy/src/G4mplIonisationWithDeltaModel.cc
+330
View File
@@ -0,0 +1,330 @@
//
// ********************************************************************
// * 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: G4mplIonisationWithDeltaModel.cc,v 1.1 2010/10/26 15:40:03 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// -------------------------------------------------------------------
//
// GEANT4 Class header file
//
//
// File name: G4mplIonisationWithDeltaModel
//
// Author: Vladimir Ivanchenko
//
// Creation date: 06.09.2005
//
// Modifications:
// 12.08.2007 Changing low energy approximation and extrapolation.
// Small bug fixing and refactoring (M. Vladymyrov)
// 13.11.2007 Use low-energy asymptotic from [3] (V.Ivanchenko)
//
//
// -------------------------------------------------------------------
// References
// [1] Steven P. Ahlen: Energy loss of relativistic heavy ionizing particles,
// S.P. Ahlen, Rev. Mod. Phys 52(1980), p121
// [2] K.A. Milton arXiv:hep-ex/0602040
// [3] S.P. Ahlen and K. Kinoshita, Phys. Rev. D26 (1982) 2347
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#include "G4mplIonisationWithDeltaModel.hh"
#include "Randomize.hh"
#include "G4LossTableManager.hh"
#include "G4ParticleChangeForLoss.hh"
#include "G4Electron.hh"
#include "G4DynamicParticle.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
using namespace std;
G4mplIonisationWithDeltaModel::G4mplIonisationWithDeltaModel(G4double mCharge, const G4String& nam)
: G4VEmModel(nam),G4VEmFluctuationModel(nam),
magCharge(mCharge),
twoln10(log(100.0)),
betalow(0.01),
betalim(0.1),
beta2lim(betalim*betalim),
bg2lim(beta2lim*(1.0 + beta2lim))
{
nmpl = G4int(abs(magCharge) * 2 * fine_structure_const + 0.5);
if(nmpl > 6) { nmpl = 6; }
else if(nmpl < 1) { nmpl = 1; }
pi_hbarc2_over_mc2 = pi * hbarc * hbarc / electron_mass_c2;
chargeSquare = magCharge * magCharge;
dedxlim = 45.*nmpl*nmpl*GeV*cm2/g;
fParticleChange = 0;
theElectron = G4Electron::Electron();
G4cout << "### Monopole ionisation model with d-electron production, Gmag= "
<< magCharge/eplus << G4endl;
mass = 0.0;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4mplIonisationWithDeltaModel::~G4mplIonisationWithDeltaModel()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void
G4mplIonisationWithDeltaModel::Initialise(const G4ParticleDefinition* p,
const G4DataVector&)
{
monopole = p;
mass = monopole->GetPDGMass();
if(!fParticleChange) { fParticleChange = GetParticleChangeForLoss(); }
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double
G4mplIonisationWithDeltaModel::ComputeDEDXPerVolume(const G4Material* material,
const G4ParticleDefinition* p,
G4double kineticEnergy,
G4double maxEnergy)
{
G4double tmax = MaxSecondaryEnergy(p,kineticEnergy);
G4double cutEnergy = std::min(tmax, maxEnergy);
G4double tau = kineticEnergy / mass;
G4double gam = tau + 1.0;
G4double bg2 = tau * (tau + 2.0);
G4double beta2 = bg2 / (gam * gam);
G4double beta = sqrt(beta2);
// low-energy asymptotic formula
G4double dedx = dedxlim*beta*material->GetDensity();
// above asymptotic
if(beta > betalow) {
// high energy
if(beta >= betalim) {
dedx = ComputeDEDXAhlen(material, bg2, cutEnergy);
} else {
G4double dedx1 = dedxlim*betalow*material->GetDensity();
G4double dedx2 = ComputeDEDXAhlen(material, bg2lim, cutEnergy);
// extrapolation between two formula
G4double kapa2 = beta - betalow;
G4double kapa1 = betalim - beta;
dedx = (kapa1*dedx1 + kapa2*dedx2)/(kapa1 + kapa2);
}
}
return dedx;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double
G4mplIonisationWithDeltaModel::ComputeDEDXAhlen(const G4Material* material,
G4double bg2,
G4double cutEnergy)
{
G4double eDensity = material->GetElectronDensity();
G4double eexc = material->GetIonisation()->GetMeanExcitationEnergy();
// Ahlen's formula for nonconductors, [1]p157, f(5.7)
G4double dedx =
0.5*(log(2.0 * electron_mass_c2 * bg2*cutEnergy / (eexc*eexc)) - 1.0);
// Kazama et al. cross-section correction
G4double k = 0.406;
if(nmpl > 1) { k = 0.346; }
// Bloch correction
const G4double B[7] = { 0.0, 0.248, 0.672, 1.022, 1.243, 1.464, 1.685};
dedx += 0.5 * k - B[nmpl];
// density effect correction
G4double x = log(bg2)/twoln10;
dedx -= material->GetIonisation()->DensityCorrection(x);
// now compute the total ionization loss
dedx *= pi_hbarc2_over_mc2 * eDensity * nmpl * nmpl;
if (dedx < 0.0) { dedx = 0; }
return dedx;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4double
G4mplIonisationWithDeltaModel::ComputeCrossSectionPerElectron(
const G4ParticleDefinition* p,
G4double kineticEnergy,
G4double cutEnergy,
G4double maxKinEnergy)
{
G4double cross = 0.0;
G4double tmax = MaxSecondaryEnergy(p, kineticEnergy);
G4double maxEnergy = min(tmax,maxKinEnergy);
if(cutEnergy < maxEnergy) {
cross = (1.0/cutEnergy - 1.0/maxEnergy)*twopi_mc2_rcl2*chargeSquare;
}
return cross;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4double
G4mplIonisationWithDeltaModel::ComputeCrossSectionPerAtom(
const G4ParticleDefinition* p,
G4double kineticEnergy,
G4double Z, G4double,
G4double cutEnergy,
G4double maxEnergy)
{
G4double cross =
Z*ComputeCrossSectionPerElectron(p,kineticEnergy,cutEnergy,maxEnergy);
return cross;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void
G4mplIonisationWithDeltaModel::SampleSecondaries(vector<G4DynamicParticle*>* vdp,
const G4MaterialCutsCouple*,
const G4DynamicParticle* dp,
G4double minKinEnergy,
G4double maxEnergy)
{
G4double kineticEnergy = dp->GetKineticEnergy();
G4double tmax = MaxSecondaryEnergy(dp->GetDefinition(),kineticEnergy);
G4double maxKinEnergy = std::min(maxEnergy,tmax);
if(minKinEnergy >= maxKinEnergy) { return; }
//G4cout << "G4mplIonisationWithDeltaModel::SampleSecondaries: E(GeV)= "
// << kineticEnergy/GeV << " M(GeV)= " << mass/GeV
// << " tmin(MeV)= " << minKinEnergy/MeV << G4endl;
G4double totEnergy = kineticEnergy + mass;
G4double etot2 = totEnergy*totEnergy;
G4double beta2 = kineticEnergy*(kineticEnergy + 2.0*mass)/etot2;
// sampling without nuclear size effect
G4double q = G4UniformRand();
G4double deltaKinEnergy = minKinEnergy*maxKinEnergy
/(minKinEnergy*(1.0 - q) + maxKinEnergy*q);
// delta-electron is produced
G4double totMomentum = totEnergy*sqrt(beta2);
G4double deltaMomentum =
sqrt(deltaKinEnergy * (deltaKinEnergy + 2.0*electron_mass_c2));
G4double cost = deltaKinEnergy * (totEnergy + electron_mass_c2) /
(deltaMomentum * totMomentum);
if(cost > 1.0) { cost = 1.0; }
G4double sint = sqrt((1.0 - cost)*(1.0 + cost));
G4double phi = twopi * G4UniformRand() ;
G4ThreeVector deltaDirection(sint*cos(phi),sint*sin(phi), cost);
G4ThreeVector direction = dp->GetMomentumDirection();
deltaDirection.rotateUz(direction);
// create G4DynamicParticle object for delta ray
G4DynamicParticle* delta =
new G4DynamicParticle(theElectron,deltaDirection,deltaKinEnergy);
vdp->push_back(delta);
// Change kinematics of primary particle
kineticEnergy -= deltaKinEnergy;
G4ThreeVector finalP = direction*totMomentum - deltaDirection*deltaMomentum;
finalP = finalP.unit();
fParticleChange->SetProposedKineticEnergy(kineticEnergy);
fParticleChange->SetProposedMomentumDirection(finalP);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4mplIonisationWithDeltaModel::SampleFluctuations(
const G4Material* material,
const G4DynamicParticle* dp,
G4double& tmax,
G4double& length,
G4double& meanLoss)
{
G4double siga = Dispersion(material,dp,tmax,length);
G4double loss = meanLoss;
siga = sqrt(siga);
G4double twomeanLoss = meanLoss + meanLoss;
if(twomeanLoss < siga) {
G4double x;
do {
loss = twomeanLoss*G4UniformRand();
x = (loss - meanLoss)/siga;
} while (1.0 - 0.5*x*x < G4UniformRand());
} else {
do {
loss = G4RandGauss::shoot(meanLoss,siga);
} while (0.0 > loss || loss > twomeanLoss);
}
return loss;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double
G4mplIonisationWithDeltaModel::Dispersion(const G4Material* material,
const G4DynamicParticle* dp,
G4double& tmax,
G4double& length)
{
G4double siga = 0.0;
G4double tau = dp->GetKineticEnergy()/mass;
if(tau > 0.0) {
G4double electronDensity = material->GetElectronDensity();
G4double gam = tau + 1.0;
G4double invbeta2 = (gam*gam)/(tau * (tau+2.0));
siga = (invbeta2 - 0.5) * twopi_mc2_rcl2 * tmax * length
* electronDensity * chargeSquare;
}
return siga;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double
G4mplIonisationWithDeltaModel::MaxSecondaryEnergy(const G4ParticleDefinition*,
G4double kinEnergy)
{
G4double tau = kinEnergy/mass;
return 2.0*electron_mass_c2*tau*(tau + 2.);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
source/processes/electromagnetic/lowenergy/CMakeLists.txt
+18
View File
@@ -0,0 +1,18 @@
#------------------------------------------------------------------------------
# CMakeLists.txt
# Module : G4emlowenergy
# Package: Geant4.src.G4processes.G4electromagnetic.G4emlowenergy
#
# CMakeLists.txt for building a single granular library.
#
# Generated on : 24/9/2010
#
# $Id: CMakeLists.txt,v 1.1 2010/09/29 18:53:09 bmorgan Exp $
#
#------------------------------------------------------------------------------
if(GEANT4_BUILD_GRANULAR_LIBS)
include(Geant4MacroLibraryTargets)
GEANT4_GRANULAR_LIBRARY_TARGET(COMPONENT sources.cmake)
endif()
source/processes/electromagnetic/lowenergy/History
+278 -1
View File
@@ -1,4 +1,4 @@
$Id: History,v 1.407 2009/12/10 12:26:05 sincerti Exp $
$Id: History,v 1.477 2010/12/02 18:02:33 vnivanch Exp $
-------------------------------------------------------------------
=========================================================
@@ -17,6 +17,283 @@ committal in the CVS repository !
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
02.12.2010 V.Ivanchenko, tag emlowen-V09-03-69
fixed minor memory leaks in G4VCrossSectinDataSet, G4EMDataSet,
G4LivermoreBremsstrahlungModel, G4LivermoreIonisationModel
01.12.2010, L.Pandola, tag emlowen-V09-03-68
Address Coverity reports for a few Penelope/Livermore
models.
26.11.2010, L.Pandola, tag emlowen-V09-03-67
Address Coverity reports for a few Penelope/Livermore
25.11.2010 tag emlowen-V09-03-66
V.Ivanchenko fixed initialisation in
G4UAtomicDeexcitation: delete objects, use consistent names
25.11.2010, L.Pandola, tag emlowen-V09-03-65
Address Coverity reports for a few Penelope/Livermore
classes
22.11.2010, A.Mantero, tag emlowen-V09-03-64
changed default for PIXE model
22.11.2010, A.Mantero, tag emlowen-V09-03-63
minor fixes
22.11.2010, A.Mantero, tag emlowen-V09-03-62
units management in PIXE fixed
calculation bug in G4UAtomicDeexcitation fixed
19.11.2010, A.Mantero, tag emlowen-V09-03-61
bug removal from G4LivermoreIonisation
bug removal from G4LivermorePolarizedPhotoElectricModel
12.11.2010, A.Mantero, tag emlowen-V09-03-60
minor fixes and added a test for G4UAtomicDeexcitation
in test subdir
12.11.2010, A.Mantero, tag emlowen-V09-03-59
Creation of G4UAtomicDeexcitation class,
derived from G4VAtomicDeexcitation in Utils.
It will replace G4AtomicDeexcitation class.
Updated G4hLowEnergyIonisation to use G4UAtomicDeexcitation
instead of G4AtomicDeexcitation.
12.11.2010, V. Ivanchenko, tag emlowen-V09-03-58
G4BoldyshevTripletModel - F.Longo substitute asinh,
because it is abcent at Windows
12.11.2010, S. Incerti, tag emlowen-V09-03-57
Renamed inline function in Sanche excitation model
11.11.2010, S. Incerti, tag emlowen-V09-03-56
Added new control of low energy limit of G4DNA e- models
Energy ranges adapted accordingly.
10.11.2010, V. Ivanchenko, tag emlowen-V09-03-55
F.Longo and G.Depaiola provided new models:
G4BoldyshevTripletModel, G4LivermoreGammaConversionModelRC,
G4LivermoreNuclearGammaConversionModel;
G4LivermorePolarizedGammaConversionModel - fixed element
selection and initialisation
04.11.2010, S. Incerti, tag emlowen-V09-03-54
- removed warnings in Rudd ionization classes (SI)
- G4IonParametrisedLossModel - (VI) moved few virtual methods from
inline to source, minor cleanup of initialisation
03.11.2010, S. Incerti, tag emlowen-V09-03-53
restricted momentum conservation to electrons
in G4DNA ionisation
03.11.2010, S. Incerti, tag emlowen-V09-03-52
new preliminary Geant4-DNA ionisation class for ions by Z. Francis
to be used with G4LEDATA 6.18
17.10.2010, S. Incerti, tag emlowen-V09-03-51
extended low energy coverage of G4DNA electron models
to be used with G4LEDATA 6.17
14.10.2010, V. Ivanchenko, tag emlowen-V09-03-50
G4GeneratorBS - optimise computations to speedup, fixed comments
G4GeneratorBN - fixed comments
G4VBremAngularDistribution - moved to utils
G4ModifiedTsai - moved to standard
13.10.2010, L. Pandola, tag emlowen-V09-03-49
Update G4LivermoreIonisationModel to produce fluorescence AlongStep
only if above the production cuts. Stricter check for energy
conservation
08.10.2010, S. Incerti, tag emlowen-V09-03-48
Added new excitation model for H
15.09.2010, S. Incerti, tag emlowen-V09-03-47
Added protection in xs file opening for G4DNA Sanche excitation
15.09.2010, S. Incerti, tag emlowen-V09-03-46
Corrected data file names in G4DNA Melton and Sanche
08.09.2010, S. Incerti, tag emlowen-V09-03-45
Updated high energy limits of G4DNAExcitation and G4DNAIonisation
08.09.2010, S. Incerti, tag emlowen-V09-03-44
Set high energy limit of G4DNAScreenedRutherfordModel to 1 MeV
08.09.2010, S. Incerti, tag emlowen-V09-03-43
Added new G4DNA processes and models for vib. exc & attachment
Provided by Z. Francis et al. - Appl. Rad. Isot. (2010)
http://dx.doi.org/10.1016/j.apradiso.2010.08.011
to be used with G4LEDATA 6.16
08.09.2010, S. Incerti, tag emlowen-V09-03-42
Decreased low energy limit of G4DNAScreenedRutherfordModel
05.09.2010, S. Incerti, tag emlowen-V09-03-41
Bugzilla 1120
Modified G4PhotoElectricAngularGeneratorSauterGavrila.cc
as proposed by J. Goldberg
25.08.2010, S. Incerti, tag emlowen-V09-03-40
- updated & extended Rudd and Miller & Green models
- to be used with G4LEDATA 6.15
25.08.2010, S. Incerti, tag emlowen-V09-03-39
-Adapted all high energy limits of G4DNA electron models
24.08.2010, S. Incerti, tag emlowen-V09-03-38
-Changed low energy limit of G4DNA elastic scattering models for e-
-Switched default excitation model for e- to Born
-to be used with G4LEDATA 6.14
28.07.2010, L. Pandola, tag emlowen-V09-03-37
First full version of G4Penelope08IonisationModel, model for e+/e-
ionisation according to Penelope v2008. Still beta version.
26.07.2010, L. Pandola, tag emlowen-V09-03-36
Added class G4PenelopeCrossSection to store/handle cross sections
(and higher momenta, like stopping powers) for the updated
Penelope08 e+/e- models (ionisation and bremsstrahlung).
15.06.2010, G. Cosmo, tag emlowen-V09-03-35
Corrected return value case in method GetPhotoElectronDirection()
in G4PhotoElectricAngularGeneratorSauterGavrila; addressing problem
report #1120.
Added missing virtual destructor to G4VecpssrKModel and
G4VecpssrLiModel base classes.
14.06.2010, A. Lechner, tag emlowen-V09-03-34
Made desctructor of base class G4VIonDEDXScalingAlgorithm virtual
(avoids also compiler warnings).
10.06.2010, A. Mantero, tag emlowen-V09-03-33
Fix in G4AugerTransition to cure crash on Windows.
09.06.2010, A. Mantero, tag emlowen-V09-03-32
Fixed compilation warning in G4AnalyticalEcpssrKCrossSection.
08.06.2010, S. Incerti, tag emlowen-V09-03-31
modified initialisation of e- Emfietzoglou excitation
model in G4DNAEmfietzoglouExcitationModel.cc and
in G4DNAMillerGreenExcitationModel.cc
07.06.2010, A. Mantero, tag emlowen-V09-03-30
added analytical (ecpssr) and empirical (Paul and Orlic)
models for the calculation of hadronc shell ionisation CS
29.04.2010, L. Pandola, tag emlowen-V09-03-29
Removed the compiler warning in G4PenelopeIonisationModel.cc which
caused the rejection of emlowen-V09-03-28
23.04.2010, L. Pandola, tag emlowen-V09-03-28
Removed useless call in G4PenelopeIonisationModel which triggered fake
warning messages
15.04.2010, L. Pandola, tag emlowen-V09-03-27
Added MinEnergyCut() method to G4PenelopeIonisationModel. Small (minor)
changes to other G4Penelope models (mainly clean-up)
08.04.2010, S. Incerti, tag emlowen-V09-03-26
Changed computation of scattering angle in G4DNAChampionElasticModel.cc
G4EMLOW 6.12 version needed
07.04.2010, S. Incerti, tag emlowen-V09-03-25
Fixed memory leak in G4DNARuddIonisationModel.cc
06.04.2010, S. Incerti, tag emlowen-V09-03-24
Replaced hard coded masses in G4DNADingfelderCharge*.cc
31.03.2010, L. Pandola, tag emlowen-V09-03-23
Removed G4cout's used for debugging in G4Penelope08ComptonModel and
G4Penelope08PhotoElectricModel
27.03.2010, S. Incerti, tag emlowen-V09-03-22
Modified G4DNABornIonisationModel.hh
27.03.2010, S. Incerti, tag emlowen-V09-03-21
Modified method declaration in G4DNABornExcitation.hh
27.03.2010, S. Incerti, tag emlowen-V09-03-20
Added new excitation model for electrons in G4DNABornExcitationModel
26.03.2010, S. Incerti, tag emlowen-V09-03-19
Modified electron correction in G4DNAMillerGreenExcitation.cc
26.03.2010, S. Incerti, tag emlowen-V09-03-18
Extended range of search for maximum of DCS in G4DNARuddIonisationModel.cc
26.03.2010, S. Incerti, tag emlowen-V09-03-17
Changed default parameters of G4DNAEmfietzoglouExcitationModel.hh
26.03.2010, tag emlowen-V09-03-16
- S. Incerti : corrected G4DNABornIonisationModel.cc class
for maximum kinetic energy transfer
- A. Mantero: fixed bugs in G4AtomicDeexcitation.cc, G4AugerTransition.cc
26.03.2010, L. Pandola, tag emlowen-V09-03-15
Changed order in some models' constructor to get rid of a valgrind
warning (conditional jump or move depends on unitialized value(s)).
25.03.2010, S. Incerti, tag emlowen-V09-03-14
Modified hydrogen correction in G4DNARuddIonisation.cc
25.03.2010, S. Incerti, tag emlowen-V09-03-13
Dummy tag
18.03.2010, S. Incerti, tag emlowen-V09-03-12
- Re-added vapor water shell constants to G4DNARuddIonisationModel.cc
as suggested by Ziad.
18.03.2010, S. Incerti, tag emlowen-V09-03-11
Extended low energy cover of G4DNA charge change processes
17.03.2010, L. Pandola, tag emlowen-V09-03-10
Added four new models (gamma ray models Compton, GammaConversion,
PhotoElectric, Rayleigh), upgrades of G4Penelope from version2001 to
version 2008. For now, 2008 models named as G4Penelope08xxxxModel
** to be used with G4LEDATA version 6.10 **
16.03.2010, L. Pandola, tag emlowen-V09-03-09
Modified public interface of G4PenelopeOscillatorManager (info to be used for
PenelopeIonisation)
15.03.2010, S. Incerti, tag emlowen-V09-03-08
Modified electron correction in G4DNARuddIonisationModel.cc
15.03.2010, L. Pandola tag emlowen-V09-03-07
Updated public interface of G4LivermorePhotoElectricModel. Removed
possibility to use custom cuts for fluorescence/Auger. Main cuts from
G4ProductionCutsTable are always used - for consistency.
15.03.2010, L. Pandola tag emlowen-V09-03-06
Clean-up in Penelope models (explicitely set Auger flag to false in
constructor)
19.02.2010, L. Pandola tag emlowen-V09-03-05
Modification in calculations made by G4PenelopeOscillatorManager (Hartree
factors for Penelope Compton Scattering)
17.02.2010, L. Pandola tag emlowen-V09-03-04
Updated interface for G4PenelopeOscillatorManager. Still *beta*
05.02.2010, S. Incerti, tag emlowen-V09-03-03
Added initialisation to atomTotalCrossSection in G4hShellCrossSectionDoubleExp.cc.
07.01.2010, S. Incerti, tag emlowen-V09-03-02
Improved way of testing material in Geant4-DNA models.
21.12.2009, L. Pandola, tag emlowen-V09-03-01
Added classes G4PenelopeOscillator* to manage multi-element atomic oscillators used
in Penelope Compton and Ionisation models. Already compliant with Penelope2008.
**Beta version at the moment**
21.12.2009, L. Pandola, tag emlowen-V09-03-00
Added a dummy ComputeCrossSectionPerAtom() method in G4PenelopeRayleighModel.
Never inkoved by tracking, issues a warning if users access it via G4EmCalculator.
10.12.2009, S. Incerti, tag emlowen-V09-02-68
- Added vapor water shell constants to G4DNARuddIonisationModel.cc
as suggested by Ziad.
source/processes/electromagnetic/lowenergy/include/G4AnalyticalEcpssrKCrossSection.hh
Executable
+92
View File
@@ -0,0 +1,92 @@
//
// ********************************************************************
// * 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: G4AnalyticalEcpssrKCrossSection.hh,v 1.1 2010/06/06 23:40:35 mantero Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
#ifndef G4ANALYTICALECPSSRKCROSSSECTION_HH
#define G4ANALYTICALECPSSRKCROSSSECTION_HH 1
#include "G4VecpssrKModel.hh"
#include "globals.hh"
#include <map>
#include <vector>
#include "G4DNACrossSectionDataSet.hh"
class G4AnalyticalEcpssrKCrossSection : public G4VecpssrKModel
{
public:
G4AnalyticalEcpssrKCrossSection();
~G4AnalyticalEcpssrKCrossSection();
G4double CalculateCrossSection(G4int, G4double, G4double);//according to W.Brandt and G.Lapicki, Phys.Rev.A23(1981)
G4double ExpIntFunction(G4int n,G4double x);//Exponential Integral Function
private:
G4AnalyticalEcpssrKCrossSection(const G4AnalyticalEcpssrKCrossSection&);
G4AnalyticalEcpssrKCrossSection & operator = (const G4AnalyticalEcpssrKCrossSection &right);
G4double FunctionFK(G4double k, G4double theta);
G4double LogLogInterpolate(G4double e1, G4double e2, G4double e, G4double xs1, G4double xs2);
G4double LinLogInterpolate(G4double e1, G4double e2, G4double e, G4double xs1, G4double xs2);
G4double QuadInterpolator(G4double e11,
G4double e12,
G4double e21,
G4double e22,
G4double x11,
G4double x12,
G4double x21,
G4double x22,
G4double t1,
G4double t2,
G4double t,
G4double e);
typedef std::map<double, std::map<double, double> > TriDimensionMap;
TriDimensionMap FKData;
std::vector<double> dummyVec;
typedef std::map<double, std::vector<double> > VecMap;
VecMap aVecMap;
G4int verboseLevel;
G4DNACrossSectionDataSet* tableC1;
G4DNACrossSectionDataSet* tableC2;
G4DNACrossSectionDataSet* tableC3;
};
#endif
source/processes/electromagnetic/lowenergy/include/G4AnalyticalEcpssrLiCrossSection.hh
Executable
+125
View File
@@ -0,0 +1,125 @@
//
// ********************************************************************
// * 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: G4AnalyticalEcpssrLiCrossSection.hh,v 1.2 2010/06/25 09:41:09 gunter Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
// Author: Haifa Ben Abdelouahed
//
//
// History:
// -----------
// 23 Apr 2008 H. Ben Abdelouahed 1st implementation
// 28 Apr 2008 MGP Major revision according to a design iteration
// 29 Apr 2009 ALF Updated Desing for Integration
// 01 Sep 2009 ALF Updated to G4AnalyticalEcpssrLiCrossSection
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics, Cross section, p and alpha ionisation, L shell
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4ANALYTICALECPSSRLICROSSSECTION_HH
#define G4ANALYTICALECPSSRLICROSSSECTION_HH 1
#include "G4VecpssrLiModel.hh"
#include "globals.hh"
#include <map>
#include <vector>
class G4AnalyticalEcpssrLiCrossSection : public G4VecpssrLiModel
{
public:
G4AnalyticalEcpssrLiCrossSection();
~G4AnalyticalEcpssrLiCrossSection();
G4double CalculateL1CrossSection(G4int zTarget,G4double massIncident, G4double energyIncident);//according to W.Brandt and G.Lapicki, Phys.Rev.A23(1981)
G4double CalculateL2CrossSection(G4int zTarget,G4double massIncident, G4double energyIncident);//according to W.Brandt and G.Lapicki, Phys.Rev.A23(1981)
G4double CalculateL3CrossSection(G4int zTarget,G4double massIncident, G4double energyIncident);//according to W.Brandt and G.Lapicki, Phys.Rev.A23(1981)
G4double CalculateVelocity(G4int subShell, G4int zTarget,G4double massIncident, G4double energyIncident);
G4double ExpIntFunction(G4int n,G4double x);//Exponential Integral Function
private:
G4AnalyticalEcpssrLiCrossSection(const G4AnalyticalEcpssrLiCrossSection&);
G4AnalyticalEcpssrLiCrossSection & operator = (const G4AnalyticalEcpssrLiCrossSection &right);
G4double FunctionFL1(G4double k, G4double theta);
G4double FunctionFL2(G4double k, G4double theta);
G4double LogLogInterpolate(G4double e1, G4double e2, G4double e, G4double xs1, G4double xs2);
G4double LinLogInterpolate(G4double e1, G4double e2, G4double e, G4double xs1, G4double xs2);
G4double LinLinInterpolate(G4double e1, G4double e2, G4double e, G4double xs1, G4double xs2);
G4double QuadInterpolator(G4double e11,
G4double e12,
G4double e21,
G4double e22,
G4double x11,
G4double x12,
G4double x21,
G4double x22,
G4double t1,
G4double t2,
G4double t,
G4double e);
typedef std::map<double, std::map<double, double> > TriDimensionMap;
TriDimensionMap FL1Data;
TriDimensionMap FL2Data;
std::vector<double> dummyVec1;
std::vector<double> dummyVec2;
typedef std::map<double, std::vector<double> > VecMap;
VecMap aVecMap1;
VecMap aVecMap2;
G4int verboseLevel;
};
#endif
source/processes/electromagnetic/lowenergy/include/G4BoldyshevTripletModel.hh
+95
View File
@@ -0,0 +1,95 @@
//
// ********************************************************************
// * 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: G4BoldyshevTripletModel.hh,v 1.1 2010/11/10 17:09:16 flongo Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
#ifndef G4BoldyshevTripletModel_h
#define G4BoldyshevTripletModel_h 1
#include "G4VEmModel.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4ParticleChangeForGamma.hh"
#include "G4CrossSectionHandler.hh"
#include "G4ForceCondition.hh"
#include "G4CompositeEMDataSet.hh"
#include "G4Gamma.hh"
class G4BoldyshevTripletModel : public G4VEmModel
{
public:
G4BoldyshevTripletModel(const G4ParticleDefinition* p = 0,
const G4String& nam = "BoldyshevTriplet");
virtual ~G4BoldyshevTripletModel();
virtual void Initialise(const G4ParticleDefinition*, const G4DataVector&);
virtual G4double ComputeCrossSectionPerAtom(
const G4ParticleDefinition*,
G4double kinEnergy,
G4double Z,
G4double A=0,
G4double cut=0,
G4double emax=DBL_MAX);
virtual void SampleSecondaries(std::vector<G4DynamicParticle*>*,
const G4MaterialCutsCouple*,
const G4DynamicParticle*,
G4double tmin,
G4double maxEnergy);
protected:
G4ParticleChangeForGamma* fParticleChange;
G4double GetMeanFreePath(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition);
private:
const G4double smallEnergy;
G4double lowEnergyLimit;
G4double highEnergyLimit;
G4int verboseLevel;
G4bool isInitialised;
G4VCrossSectionHandler* crossSectionHandler;
G4VEMDataSet* meanFreePathTable;
G4BoldyshevTripletModel & operator=(const G4BoldyshevTripletModel &right);
G4BoldyshevTripletModel(const G4BoldyshevTripletModel&);
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#endif
source/processes/electromagnetic/lowenergy/include/G4DNAAttachment.hh
+68
View File
@@ -0,0 +1,68 @@
//
// ********************************************************************
// * 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: G4DNAAttachment.hh,v 1.1 2010/09/08 13:46:45 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04 $
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
// Created by Z. Francis
#ifndef G4DNAAttachment_h
#define G4DNAAttachment_h 1
#include "G4VEmProcess.hh"
// Available models
#include "G4DNAMeltonAttachmentModel.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class G4DNAAttachment : public G4VEmProcess
{
public:
G4DNAAttachment(const G4String& processName ="DNAAttachment",
G4ProcessType type = fElectromagnetic);
virtual ~G4DNAAttachment();
virtual G4bool IsApplicable(const G4ParticleDefinition&);
virtual void PrintInfo();
protected:
virtual void InitialiseProcess(const G4ParticleDefinition*);
private:
G4bool isInitialised;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
source/processes/electromagnetic/lowenergy/include/G4DNABornExcitationModel.hh
+14 -13
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DNABornExcitationModel.hh,v 1.1 2009/01/12 14:26:02 sincerti Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4DNABornExcitationModel.hh,v 1.4 2010/03/27 12:46:51 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
#ifndef G4DNABornExcitationModel_h
@@ -36,6 +36,7 @@
#include "G4DNACrossSectionDataSet.hh"
#include "G4LogLogInterpolation.hh"
#include "G4Electron.hh"
#include "G4Proton.hh"
#include "G4WaterExcitationStructure.hh"
@@ -49,7 +50,7 @@ public:
virtual ~G4DNABornExcitationModel();
virtual void Initialise(const G4ParticleDefinition*, const G4DataVector&);
virtual void Initialise(const G4ParticleDefinition*, const G4DataVector& = *(new G4DataVector()) );
virtual G4double CrossSectionPerVolume(const G4Material* material,
const G4ParticleDefinition* p,
@@ -69,30 +70,30 @@ protected:
private:
G4double lowEnergyLimit;
G4double highEnergyLimit;
std::map<G4String,G4double,std::less<G4String> > lowEnergyLimit;
std::map<G4String,G4double,std::less<G4String> > highEnergyLimit;
G4bool isInitialised;
G4int verboseLevel;
// Cross section
G4DNACrossSectionDataSet* table;
typedef std::map<G4String,G4String,std::less<G4String> > MapFile;
MapFile tableFile;
typedef std::map<G4String,G4DNACrossSectionDataSet*,std::less<G4String> > MapData;
MapData tableData;
// Partial cross section
G4int RandomSelect(G4double energy);
G4int RandomSelect(G4double energy,const G4String& particle );
// Final state
G4WaterExcitationStructure waterStructure;
// Test water material
G4bool flagMaterialIsWater;
G4double densityWater;
//
G4DNABornExcitationModel & operator=(const G4DNABornExcitationModel &right);
G4DNABornExcitationModel(const G4DNABornExcitationModel&);
source/processes/electromagnetic/lowenergy/include/G4DNABornIonisationModel.hh
+5 -10
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DNABornIonisationModel.hh,v 1.3 2009/06/26 10:15:19 mantero Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4DNABornIonisationModel.hh,v 1.5 2010/03/28 18:33:19 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
#ifndef G4DNABornIonisationModel_h
@@ -54,7 +54,7 @@ public:
virtual ~G4DNABornIonisationModel();
virtual void Initialise(const G4ParticleDefinition*, const G4DataVector&);
virtual void Initialise(const G4ParticleDefinition*, const G4DataVector& = *(new G4DataVector()));
virtual G4double CrossSectionPerVolume( const G4Material* material,
const G4ParticleDefinition* p,
@@ -67,6 +67,8 @@ public:
const G4DynamicParticle*,
G4double tmin,
G4double maxEnergy);
double DifferentialCrossSection(G4ParticleDefinition * aParticleDefinition, G4double k, G4double energyTransfer, G4int shell);
protected:
@@ -97,8 +99,6 @@ private:
void RandomizeEjectedElectronDirection(G4ParticleDefinition * aParticleDefinition, G4double incomingParticleEnergy, G4double
outgoingParticleEnergy, G4double & cosTheta, G4double & phi );
double DifferentialCrossSection(G4ParticleDefinition * aParticleDefinition, G4double k, G4double energyTransfer, G4int shell);
G4double LogLogInterpolate(G4double e1, G4double e2, G4double e, G4double xs1, G4double xs2);
G4double QuadInterpolator( G4double e11,
@@ -128,11 +128,6 @@ private:
G4int RandomSelect(G4double energy,const G4String& particle );
// Test water material
G4bool flagMaterialIsWater;
G4double densityWater;
//
G4DNABornIonisationModel & operator=(const G4DNABornIonisationModel &right);
source/processes/electromagnetic/lowenergy/include/G4DNAChampionElasticModel.hh
+29 -16
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DNAChampionElasticModel.hh,v 1.1 2009/01/12 14:26:02 sincerti Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4DNAChampionElasticModel.hh,v 1.4 2010/11/11 22:32:22 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
#ifndef G4DNAChampionElasticModel_h
@@ -44,23 +44,26 @@ class G4DNAChampionElasticModel : public G4VEmModel
public:
G4DNAChampionElasticModel(const G4ParticleDefinition* p = 0,
const G4String& nam = "DNAChampionElasticModel");
const G4String& nam = "DNAChampionElasticModel");
virtual ~G4DNAChampionElasticModel();
virtual void Initialise(const G4ParticleDefinition*, const G4DataVector&);
virtual G4double CrossSectionPerVolume(const G4Material* material,
const G4ParticleDefinition* p,
G4double ekin,
G4double emin,
G4double emax);
const G4ParticleDefinition* p,
G4double ekin,
G4double emin,
G4double emax);
virtual void SampleSecondaries(std::vector<G4DynamicParticle*>*,
const G4MaterialCutsCouple*,
const G4DynamicParticle*,
G4double tmin,
G4double maxEnergy);
inline void SetKillBelowThreshold (G4double threshold);
G4double GetKillBelowThreshold () { return killBelowEnergy; }
protected:
@@ -70,7 +73,6 @@ private:
G4double killBelowEnergy;
G4double lowEnergyLimit;
G4double lowEnergyLimitOfModel;
G4double highEnergyLimit;
G4bool isInitialised;
G4int verboseLevel;
@@ -85,12 +87,16 @@ private:
// Final state
G4double DifferentialCrossSection(G4ParticleDefinition * aParticleDefinition, G4double k, G4double theta);
//G4double DifferentialCrossSection(G4ParticleDefinition * aParticleDefinition, G4double k, G4double theta);
G4double Theta(G4ParticleDefinition * aParticleDefinition, G4double k, G4double integrDiff);
G4double LinLinInterpolate(G4double e1, G4double e2, G4double e, G4double xs1, G4double xs2);
G4double LogLogInterpolate(G4double e1, G4double e2, G4double e, G4double xs1, G4double xs2);
G4double LinLogInterpolate(G4double e1, G4double e2, G4double e, G4double xs1, G4double xs2);
G4double LogLogInterpolate(G4double e1, G4double e2, G4double e, G4double xs1, G4double xs2);
G4double QuadInterpolator(G4double e11,
G4double e12,
G4double e21,
@@ -114,11 +120,6 @@ private:
G4double RandomizeCosTheta(G4double k);
// Test water material
G4bool flagMaterialIsWater;
G4double densityWater;
//
G4DNAChampionElasticModel & operator=(const G4DNAChampionElasticModel &right);
@@ -126,6 +127,18 @@ private:
};
inline void G4DNAChampionElasticModel::SetKillBelowThreshold (G4double threshold)
{
killBelowEnergy = threshold;
if (threshold < 1*eV)
G4Exception ("*** WARNING : the G4DNAChampionElasticModel class is not validated below 1 eV !","",JustWarning,"") ;
if (threshold < 0.025*eV) threshold = 0.025*eV;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#endif
source/processes/electromagnetic/lowenergy/include/G4DNADingfelderChargeDecreaseModel.hh
+2 -7
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DNADingfelderChargeDecreaseModel.hh,v 1.1 2009/01/12 14:26:02 sincerti Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4DNADingfelderChargeDecreaseModel.hh,v 1.2 2010/01/07 18:10:19 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
#ifndef G4DNADingfelderChargeDecreaseModel_h
@@ -103,11 +103,6 @@ private:
G4double OutgoingParticleBindingEnergyConstant(G4ParticleDefinition* particleDefinition, G4int finalStateIndex);
// Test water material
G4bool flagMaterialIsWater;
G4double densityWater;
//
G4DNADingfelderChargeDecreaseModel & operator=(const G4DNADingfelderChargeDecreaseModel &right);
source/processes/electromagnetic/lowenergy/include/G4DNADingfelderChargeIncreaseModel.hh
+2 -7
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DNADingfelderChargeIncreaseModel.hh,v 1.1 2009/01/12 14:26:02 sincerti Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4DNADingfelderChargeIncreaseModel.hh,v 1.2 2010/01/07 18:10:19 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
#ifndef G4DNADingfelderChargeIncreaseModel_h
@@ -106,11 +106,6 @@ private:
G4double IncomingParticleBindingEnergyConstant(G4ParticleDefinition* particleDefinition, G4int finalStateIndex);
// Test water material
G4bool flagMaterialIsWater;
G4double densityWater;
//
G4DNADingfelderChargeIncreaseModel & operator=(const G4DNADingfelderChargeIncreaseModel &right);
source/processes/electromagnetic/lowenergy/include/G4DNAEmfietzoglouExcitationModel.hh
+3 -8
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DNAEmfietzoglouExcitationModel.hh,v 1.1 2009/01/12 14:26:02 sincerti Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4DNAEmfietzoglouExcitationModel.hh,v 1.3 2010/03/26 19:52:44 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
#ifndef G4DNAEmfietzoglouExcitationModel_h
@@ -49,7 +49,7 @@ public:
virtual ~G4DNAEmfietzoglouExcitationModel();
virtual void Initialise(const G4ParticleDefinition*, const G4DataVector&);
virtual void Initialise(const G4ParticleDefinition*, const G4DataVector& = *(new G4DataVector()) );
virtual G4double CrossSectionPerVolume(const G4Material* material,
const G4ParticleDefinition* p,
@@ -88,11 +88,6 @@ private:
G4WaterExcitationStructure waterExcitation;
// Test water material
G4bool flagMaterialIsWater;
G4double densityWater;
//
G4DNAEmfietzoglouExcitationModel & operator=(const G4DNAEmfietzoglouExcitationModel &right);
source/processes/electromagnetic/lowenergy/include/G4DNAMeltonAttachmentModel.hh
+97
View File
@@ -0,0 +1,97 @@
//
// ********************************************************************
// * 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: G4DNAMeltonAttachmentModel.hh,v 1.1 2010/09/08 13:46:45 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
// Created by Z. Francis
#ifndef G4DNAMeltonAttachmentModel_h
#define G4DNAMeltonAttachmentModel_h 1
#include "G4VEmModel.hh"
#include "G4ParticleChangeForGamma.hh"
#include "G4DNAGenericIonsManager.hh"
#include "G4DNACrossSectionDataSet.hh"
#include "G4Electron.hh"
#include "G4LogLogInterpolation.hh"
class G4DNAMeltonAttachmentModel : public G4VEmModel
{
public:
G4DNAMeltonAttachmentModel(const G4ParticleDefinition* p = 0,
const G4String& nam = "DNAMeltonAttachmentModel");
virtual ~G4DNAMeltonAttachmentModel();
virtual void Initialise(const G4ParticleDefinition*, const G4DataVector&);
virtual G4double CrossSectionPerVolume(const G4Material* material,
const G4ParticleDefinition* p,
G4double ekin,
G4double emin,
G4double emax);
virtual void SampleSecondaries(std::vector<G4DynamicParticle*>*,
const G4MaterialCutsCouple*,
const G4DynamicParticle*,
G4double tmin,
G4double maxEnergy);
protected:
G4ParticleChangeForGamma* fParticleChangeForGamma;
private:
G4double lowEnergyLimit;
G4double highEnergyLimit;
G4double lowEnergyLimitOfModel;
G4bool isInitialised;
G4int verboseLevel;
// Cross section
typedef std::map<G4String,G4String,std::less<G4String> > MapFile;
MapFile tableFile;
typedef std::map<G4String,G4DNACrossSectionDataSet*,std::less<G4String> > MapData;
MapData tableData;
//
G4DNAMeltonAttachmentModel & operator=(const G4DNAMeltonAttachmentModel &right);
G4DNAMeltonAttachmentModel(const G4DNAMeltonAttachmentModel&);
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#endif
source/processes/electromagnetic/lowenergy/include/G4DNAMillerGreenExcitationModel.hh
+2 -9
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DNAMillerGreenExcitationModel.hh,v 1.1 2009/01/12 14:26:03 sincerti Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4DNAMillerGreenExcitationModel.hh,v 1.2 2010/01/07 18:10:19 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
#ifndef G4DNAMillerGreenExcitationModel_h
@@ -114,13 +114,6 @@ private:
G4double slaterEffectiveCharge[3][4];
G4double sCoefficient[3][4];
// Final state
// Test water material
G4bool flagMaterialIsWater;
G4double densityWater;
//
G4DNAMillerGreenExcitationModel & operator=(const G4DNAMillerGreenExcitationModel &right);
source/processes/electromagnetic/lowenergy/include/G4DNARuddIonisationExtendedModel.hh
+162
View File
@@ -0,0 +1,162 @@
//
// ********************************************************************
// * 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: G4DNARuddIonisationExtendedModel.hh,v 1.1 2010/11/03 10:44:26 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
#ifndef G4DNARuddIonisationExtendedModel_h
#define G4DNARuddIonisationExtendedModel_h 1
#include "G4VEmModel.hh"
#include "G4ParticleChangeForGamma.hh"
#include "G4ProductionCutsTable.hh"
#include "G4DNAGenericIonsManager.hh"
#include "G4DNACrossSectionDataSet.hh"
#include "G4Electron.hh"
#include "G4Proton.hh"
#include "G4LogLogInterpolation.hh"
#include "G4WaterIonisationStructure.hh"
class G4DNARuddIonisationExtendedModel : public G4VEmModel
{
public:
G4DNARuddIonisationExtendedModel(const G4ParticleDefinition* p = 0,
const G4String& nam = "DNARuddIonisationExtendedModel");
virtual ~G4DNARuddIonisationExtendedModel();
virtual void Initialise(const G4ParticleDefinition*, const G4DataVector&);
virtual G4double CrossSectionPerVolume( const G4Material* material,
const G4ParticleDefinition* p,
G4double ekin,
G4double emin,
G4double emax);
virtual void SampleSecondaries(std::vector<G4DynamicParticle*>*,
const G4MaterialCutsCouple*,
const G4DynamicParticle*,
G4double tmin,
G4double maxEnergy);
protected:
G4ParticleChangeForGamma* fParticleChangeForGamma;
private:
std::map<G4String,G4double,std::less<G4String> > lowEnergyLimit;
std::map<G4String,G4double,std::less<G4String> > highEnergyLimit;
// ZF 26-10-2010
std::map<G4double,G4double> lowEnergyLimitForA, lowEnergyLimitOfModelForA, killBelowEnergyForA;
G4bool isInitialised;
G4int verboseLevel;
// Cross section
typedef std::map<G4String,G4String,std::less<G4String> > MapFile;
MapFile tableFile;
typedef std::map<G4String,G4DNACrossSectionDataSet*,std::less<G4String> > MapData;
MapData tableData;
// Final state
G4WaterIonisationStructure waterStructure;
G4double RandomizeEjectedElectronEnergy(G4ParticleDefinition* particleDefinition,
G4double incomingParticleEnergy,
G4int shell);
void RandomizeEjectedElectronDirection(G4ParticleDefinition* particleDefinition,
G4double incomingParticleEnergy,
G4double outgoingParticleEnergy,
G4double & cosTheta,
G4double & phi, G4int shell);
G4double RejectionFunction(G4ParticleDefinition* particle,
G4double k,
G4double proposed_ws,
G4int ionizationLevelIndex);
G4double ProposedSampledEnergy(G4ParticleDefinition* particle,
G4double k,
G4int ionizationLevelIndex);
G4double CorrectionFactor(G4ParticleDefinition* particleDefinition, G4double k, G4int shell);
G4double S_1s(G4double t,
G4double energyTransferred,
G4double slaterEffectiveChg,
G4double shellNumber);
G4double S_2s(G4double t,
G4double energyTransferred,
G4double slaterEffectiveChg,
G4double shellNumber);
G4double S_2p(G4double t,
G4double energyTransferred,
G4double slaterEffectiveChg,
G4double shellNumber);
G4double R(G4double t,
G4double energyTransferred,
G4double slaterEffectiveChg,
G4double shellNumber) ;
G4double slaterEffectiveCharge[3];
G4double sCoefficient[3];
// Partial cross section
G4double PartialCrossSection(const G4Track& track);
G4double Sum(G4double energy, const G4String& particle);
G4int RandomSelect(G4double energy,const G4String& particle );
// Test water material
G4bool flagMaterialIsWater;
G4double densityWater;
//
G4DNARuddIonisationExtendedModel & operator=(const G4DNARuddIonisationExtendedModel &right);
G4DNARuddIonisationExtendedModel(const G4DNARuddIonisationExtendedModel&);
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#endif
source/processes/electromagnetic/lowenergy/include/G4DNARuddIonisationModel.hh
+2 -7
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DNARuddIonisationModel.hh,v 1.3 2009/06/26 09:42:32 mantero Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4DNARuddIonisationModel.hh,v 1.4 2010/01/07 18:10:19 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
#ifndef G4DNARuddIonisationModel_h
@@ -147,11 +147,6 @@ private:
G4int RandomSelect(G4double energy,const G4String& particle );
// Test water material
G4bool flagMaterialIsWater;
G4double densityWater;
//
G4DNARuddIonisationModel & operator=(const G4DNARuddIonisationModel &right);
source/processes/electromagnetic/lowenergy/include/G4DNASancheExcitationModel.hh
+116
View File
@@ -0,0 +1,116 @@
//
// ********************************************************************
// * 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: G4DNASancheExcitationModel.hh,v 1.3 2010/11/11 23:43:35 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
// Created by Z. Francis
#ifndef G4DNASancheExcitationModel_h
#define G4DNASancheExcitationModel_h 1
#include "G4VEmModel.hh"
#include "G4ParticleChangeForGamma.hh"
#include <deque>
#include "G4Electron.hh"
class G4DNASancheExcitationModel : public G4VEmModel
{
public:
G4DNASancheExcitationModel(const G4ParticleDefinition* p = 0,
const G4String& nam = "DNASancheExcitationModel");
virtual ~G4DNASancheExcitationModel();
virtual void Initialise(const G4ParticleDefinition*, const G4DataVector&);
virtual G4double CrossSectionPerVolume(const G4Material* material,
const G4ParticleDefinition* p,
G4double ekin,
G4double emin,
G4double emax);
virtual void SampleSecondaries(std::vector<G4DynamicParticle*>*,
const G4MaterialCutsCouple*,
const G4DynamicParticle*,
G4double tmin,
G4double maxEnergy);
// Cross section
G4double PartialCrossSection(G4double energy,G4int level);
inline void ExtendLowEnergyLimit (G4double /*threshold*/);
protected:
G4ParticleChangeForGamma* fParticleChangeForGamma;
private:
G4double killBelowEnergy;
G4double lowEnergyLimit;
G4double highEnergyLimit;
G4bool isInitialised;
G4int verboseLevel;
// Cross section
G4int RandomSelect(G4double energy);
G4int nLevels;
G4double VibrationEnergy(G4int level);
G4double Sum(G4double k);
G4double LinInterpolate(G4double e1,
G4double e2,
G4double e,
G4double xs1,
G4double xs2);
//
typedef std::map<double, std::map<double, double> > TriDimensionMap;
TriDimensionMap map1;
std::vector<double> tdummyVec;
//
G4DNASancheExcitationModel & operator=(const G4DNASancheExcitationModel &right);
G4DNASancheExcitationModel(const G4DNASancheExcitationModel&);
};
inline void G4DNASancheExcitationModel::ExtendLowEnergyLimit (G4double threshold)
{
lowEnergyLimit = threshold;
if (lowEnergyLimit < 2*eV)
G4Exception ("*** WARNING : the G4DNASancheExcitationModel class is not validated below 2 eV !","",JustWarning,"") ;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#endif
source/processes/electromagnetic/lowenergy/include/G4DNAScreenedRutherfordElasticModel.hh
+13 -9
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DNAScreenedRutherfordElasticModel.hh,v 1.1 2009/01/12 14:26:03 sincerti Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4DNAScreenedRutherfordElasticModel.hh,v 1.4 2010/11/11 22:32:22 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
#ifndef G4DNAScreenedRutherfordElasticModel_h
@@ -58,6 +58,9 @@ public:
G4double tmin,
G4double maxEnergy);
inline void SetKillBelowThreshold (G4double threshold);
G4double GetKillBelowThreshold () { return killBelowEnergy; }
protected:
G4ParticleChangeForGamma* fParticleChangeForGamma;
@@ -66,8 +69,7 @@ private:
G4double killBelowEnergy;
G4double lowEnergyLimit;
G4double lowEnergyLimitOfModel;
G4double intermediateEnergyLimit;
G4double intermediateEnergyLimit;
G4double highEnergyLimit;
G4bool isInitialised;
G4int verboseLevel;
@@ -92,11 +94,6 @@ private:
G4double ScreenedRutherfordRandomizeCosTheta(G4double k, G4double z);
// Test water material
G4bool flagMaterialIsWater;
G4double densityWater;
//
G4DNAScreenedRutherfordElasticModel & operator=(const G4DNAScreenedRutherfordElasticModel &right);
@@ -104,6 +101,13 @@ private:
};
inline void G4DNAScreenedRutherfordElasticModel::SetKillBelowThreshold (G4double threshold)
{
killBelowEnergy = threshold;
if (threshold < 9*eV)
G4Exception ("*** WARNING : the G4DNAScreenedRutherfordElasticModel class is not validated below 9 eV !","",JustWarning,"") ;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#endif
source/processes/electromagnetic/lowenergy/include/G4DNAVibExcitation.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: G4DNAVibExcitation.hh,v 1.1 2010/09/08 13:46:45 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04 $
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
// Created by Z. Francis
#ifndef G4DNAVibExcitation_h
#define G4DNAVibExcitation_h 1
#include "G4VEmProcess.hh"
// Available models
#include "G4DNASancheExcitationModel.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
class G4DNAVibExcitation : public G4VEmProcess
{
public:
G4DNAVibExcitation(const G4String& processName ="DNAVibrationalExcitation",
G4ProcessType type = fElectromagnetic);
virtual ~G4DNAVibExcitation();
virtual G4bool IsApplicable(const G4ParticleDefinition&);
virtual void PrintInfo();
protected:
virtual void InitialiseProcess(const G4ParticleDefinition*);
private:
G4bool isInitialised;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#endif
source/processes/electromagnetic/lowenergy/include/G4Generator2BN.hh
+4 -2
View File
@@ -23,6 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4Generator2BN.hh,v 1.4 2010/10/14 14:00:29 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// -------------------------------------------------------------------
//
@@ -62,9 +64,9 @@ class G4Generator2BN : public G4VBremAngularDistribution
public:
G4Generator2BN(const G4String& name);
G4Generator2BN(const G4String& name = "");
~G4Generator2BN();
virtual ~G4Generator2BN();
G4double PolarAngle(const G4double initial_energy,
const G4double final_energy,
source/processes/electromagnetic/lowenergy/include/G4Generator2BS.hh
+24 -8
View File
@@ -23,6 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4Generator2BS.hh,v 1.5 2010/10/14 14:00:29 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// -------------------------------------------------------------------
//
@@ -38,13 +40,15 @@
// Creation date: 2 June 2003
//
// Modifications:
// 02 Jun 2003 First implementation acording with new design
// 02 Jun 2003 First implementation acording with new design
// 12 Oct 2010 V.Ivanchenko moved RejectionFunction inline
//
//
// Class Description:
//
// Concrete class for Bremsstrahlung Angular Distribution Generation - 2BS Distribution
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// Concrete class for Bremsstrahlung Angular Distribution Generation
// 2BS Distribution
//
// -------------------------------------------------------------------
//
@@ -56,14 +60,16 @@
#include "globals.hh"
#include "G4VBremAngularDistribution.hh"
class G4Pow;
class G4Generator2BS : public G4VBremAngularDistribution
{
public:
G4Generator2BS(const G4String& name);
G4Generator2BS(const G4String& name="");
~G4Generator2BS();
virtual ~G4Generator2BS();
G4double PolarAngle(const G4double initial_energy,
const G4double final_energy,
@@ -73,18 +79,28 @@ public:
protected:
G4double RejectionFunction(G4double value) const;
inline G4double RejectionFunction(G4double value) const;
private:
G4double z;
G4double rejection_argument1, rejection_argument2, rejection_argument3;
G4double EnergyRatio;
G4Pow* g4pow;
// hide assignment operator
G4Generator2BS & operator=(const G4Generator2BS &right);
G4Generator2BS(const G4Generator2BS&);
G4Generator2BS & operator=(const G4Generator2BS &right);
G4Generator2BS(const G4Generator2BS&);
};
inline G4double G4Generator2BS::RejectionFunction(G4double value) const
{
G4double argument = (1+value)*(1+value);
return (4+std::log(rejection_argument3+(z/argument)))*
((4*EnergyRatio*value/argument)-rejection_argument1)+rejection_argument2;
}
#endif
source/processes/electromagnetic/lowenergy/include/G4IonParametrisedLossModel.hh
+10 -10
View File
@@ -23,7 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4IonParametrisedLossModel.hh,v 1.8 2010/11/04 12:21:47 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// ===========================================================================
// GEANT4 class header file
@@ -135,7 +136,7 @@ class G4IonParametrisedLossModel : public G4VEmModel {
G4double); // Length of current step
// Function, which computes the mean energy transfer rate to delta rays
G4double DeltaRayMeanEnergyTransferRate(
inline G4double DeltaRayMeanEnergyTransferRate(
const G4Material*, // Target Material
const G4ParticleDefinition*, // Projectile
G4double, // Kinetic energy of projectile
@@ -182,7 +183,7 @@ class G4IonParametrisedLossModel : public G4VEmModel {
// Function checking the applicability of physics tables to ion-material
// combinations (Note: the energy range of tables is not checked)
LossTableList::iterator IsApplicable(
inline LossTableList::iterator IsApplicable(
const G4ParticleDefinition*, // Projectile (ion)
const G4Material*); // Target material
@@ -207,9 +208,11 @@ class G4IonParametrisedLossModel : public G4VEmModel {
G4bool); // Logarithmic scaling of energy
// Function for setting energy loss limit for stopping power integration
void SetEnergyLossLimit(G4double ionEnergyLossLimit);
inline void SetEnergyLossLimit(G4double ionEnergyLossLimit);
protected:
virtual
G4double MaxSecondaryEnergy(const G4ParticleDefinition*,
G4double); // Kinetic energy of projectile
@@ -230,7 +233,7 @@ class G4IonParametrisedLossModel : public G4VEmModel {
const G4MaterialCutsCouple*); // Target material
// Function, which updates parameters concering particle properties
void UpdateCache(
inline void UpdateCache(
const G4ParticleDefinition*); // Projectile (ion)
// Function, which builds range vs energy (and energy vs range) vectors
@@ -286,13 +289,10 @@ class G4IonParametrisedLossModel : public G4VEmModel {
// ######################################################################
// Pointer to particle change object, which is used to set e.g. the
// energy loss due to nuclear stopping
// energy loss and secondary delta-electron
// used indicating if model is initialized
G4ParticleChangeForLoss* particleChangeLoss;
// Flag indicating if model is initialized (i.e. if
// G4ParticleChangeForLoss was created)
G4bool modelIsInitialised;
// ######################################################################
// # Corrections and energy loss limit
// #
source/processes/electromagnetic/lowenergy/include/G4IonParametrisedLossModel.icc
+3 -60
View File
@@ -23,7 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// $Id: G4IonParametrisedLossModel.icc,v 1.7 2010/11/04 12:21:47 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// ===========================================================================
// GEANT4 class
@@ -42,6 +43,7 @@
// (tables are now built in initialisation phase),
// Minor bug fix in ComputeDEDXPerVolume (AL)
// 20. 11. 2009 - Added set-method for energy loss limit (AL)
// 04. 11. 2010 - Moved virtual methods to the source (VI)
//
// Class description:
// Model for computing the energy loss of ions by employing a
@@ -54,7 +56,6 @@
//
// ===========================================================================
inline G4double G4IonParametrisedLossModel::DeltaRayMeanEnergyTransferRate(
const G4Material* material,
const G4ParticleDefinition* particle,
@@ -115,35 +116,6 @@ inline G4double G4IonParametrisedLossModel::DeltaRayMeanEnergyTransferRate(
return meanRate;
}
inline
G4double G4IonParametrisedLossModel::MaxSecondaryEnergy(
const G4ParticleDefinition* particle,
G4double kineticEnergy) {
// ############## Maximum energy of secondaries ##########################
// Function computes maximum energy of secondary electrons which are
// released by an ion
//
// See Geant4 physics reference manual (version 9.1), section 9.1.1
//
// Ref.: W.M. Yao et al, Jour. of Phys. G 33 (2006) 1.
// C.Caso et al. (Part. Data Group), Europ. Phys. Jour. C 3 1 (1998).
// B. Rossi, High energy particles, New York, NY: Prentice-Hall (1952).
//
// (Implementation adapted from G4BraggIonModel)
if(particle != cacheParticle) UpdateCache(particle);
G4double tau = kineticEnergy/cacheMass;
G4double tmax = 2.0 * electron_mass_c2 * tau * (tau + 2.) /
(1. + 2.0 * (tau + 1.) * cacheElecMassRatio +
cacheElecMassRatio * cacheElecMassRatio);
return tmax;
}
inline
void G4IonParametrisedLossModel::UpdateCache(
const G4ParticleDefinition* particle) {
@@ -155,35 +127,6 @@ void G4IonParametrisedLossModel::UpdateCache(
cacheChargeSquare = q * q;
}
inline
G4double G4IonParametrisedLossModel::GetChargeSquareRatio(
const G4ParticleDefinition* particle,
const G4Material* material,
G4double kineticEnergy) { // Kinetic energy
G4double chargeSquareRatio = corrections ->
EffectiveChargeSquareRatio(particle,
material,
kineticEnergy);
corrFactor = chargeSquareRatio *
corrections -> EffectiveChargeCorrection(particle,
material,
kineticEnergy);
return corrFactor;
}
inline
G4double G4IonParametrisedLossModel::GetParticleCharge(
const G4ParticleDefinition* particle,
const G4Material* material,
G4double kineticEnergy) { // Kinetic energy
return corrections -> GetParticleCharge(particle, material, kineticEnergy);
}
inline
LossTableList::iterator G4IonParametrisedLossModel::IsApplicable(
const G4ParticleDefinition* particle, // Projectile (ion)
source/processes/electromagnetic/lowenergy/include/G4LivermoreGammaConversionModelRC.hh
+97
View File
@@ -0,0 +1,97 @@
//
// ********************************************************************
// * 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: G4LivermoreGammaConversionModelRC.hh,v 1.1 2010/11/10 17:12:21 flongo Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
#ifndef G4LivermoreGammaConversionModelRC_h
#define G4LivermoreGammaConversionModelRC_h 1
#include "G4VEmModel.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4ParticleChangeForGamma.hh"
#include "G4CrossSectionHandler.hh"
#include "G4ForceCondition.hh"
#include "G4CompositeEMDataSet.hh"
#include "G4Gamma.hh"
class G4LivermoreGammaConversionModelRC : public G4VEmModel
{
public:
G4LivermoreGammaConversionModelRC(const G4ParticleDefinition* p = 0,
const G4String& nam = "LivermoreConversion");
virtual ~G4LivermoreGammaConversionModelRC();
virtual void Initialise(const G4ParticleDefinition*, const G4DataVector&);
virtual G4double ComputeCrossSectionPerAtom(
const G4ParticleDefinition*,
G4double kinEnergy,
G4double Z,
G4double A=0,
G4double cut=0,
G4double emax=DBL_MAX);
virtual void SampleSecondaries(std::vector<G4DynamicParticle*>*,
const G4MaterialCutsCouple*,
const G4DynamicParticle*,
G4double tmin,
G4double maxEnergy);
protected:
G4ParticleChangeForGamma* fParticleChange;
G4double GetMeanFreePath(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition);
private:
const G4double smallEnergy;
G4double lowEnergyLimit;
G4double highEnergyLimit;
G4int verboseLevel;
G4bool isInitialised;
G4double ScreenFunction1(G4double screenVariable);
G4double ScreenFunction2(G4double screenVariable);
G4VCrossSectionHandler* crossSectionHandler;
G4VEMDataSet* meanFreePathTable;
G4LivermoreGammaConversionModelRC & operator=(const G4LivermoreGammaConversionModelRC &right);
G4LivermoreGammaConversionModelRC(const G4LivermoreGammaConversionModelRC&);
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#endif
source/processes/electromagnetic/lowenergy/include/G4LivermoreNuclearGammaConversionModel.hh
+97
View File
@@ -0,0 +1,97 @@
//
// ********************************************************************
// * 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: G4LivermoreNuclearGammaConversionModel.hh,v 1.1 2010/11/10 17:09:16 flongo Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
#ifndef G4LivermoreNuclearGammaConversionModel_h
#define G4LivermoreNuclearGammaConversionModel_h 1
#include "G4VEmModel.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4ParticleChangeForGamma.hh"
#include "G4CrossSectionHandler.hh"
#include "G4ForceCondition.hh"
#include "G4CompositeEMDataSet.hh"
#include "G4Gamma.hh"
class G4LivermoreNuclearGammaConversionModel : public G4VEmModel
{
public:
G4LivermoreNuclearGammaConversionModel(const G4ParticleDefinition* p = 0,
const G4String& nam = "LivermoreNuclearGammaConversion");
virtual ~G4LivermoreNuclearGammaConversionModel();
virtual void Initialise(const G4ParticleDefinition*, const G4DataVector&);
virtual G4double ComputeCrossSectionPerAtom(
const G4ParticleDefinition*,
G4double kinEnergy,
G4double Z,
G4double A=0,
G4double cut=0,
G4double emax=DBL_MAX);
virtual void SampleSecondaries(std::vector<G4DynamicParticle*>*,
const G4MaterialCutsCouple*,
const G4DynamicParticle*,
G4double tmin,
G4double maxEnergy);
protected:
G4ParticleChangeForGamma* fParticleChange;
G4double GetMeanFreePath(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition);
private:
const G4double smallEnergy;
G4double lowEnergyLimit;
G4double highEnergyLimit;
G4int verboseLevel;
G4bool isInitialised;
G4double ScreenFunction1(G4double screenVariable);
G4double ScreenFunction2(G4double screenVariable);
G4VCrossSectionHandler* crossSectionHandler;
G4VEMDataSet* meanFreePathTable;
G4LivermoreNuclearGammaConversionModel & operator=(const G4LivermoreNuclearGammaConversionModel &right);
G4LivermoreNuclearGammaConversionModel(const G4LivermoreNuclearGammaConversionModel&);
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#endif
source/processes/electromagnetic/lowenergy/include/G4LivermorePhotoElectricModel.hh
+8 -14
View File
@@ -23,9 +23,13 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LivermorePhotoElectricModel.hh,v 1.3 2009/04/17 10:29:20 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4LivermorePhotoElectricModel.hh,v 1.4 2010/03/15 09:02:29 pandola Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
// 15-Mar-2010 L. Pandola, removed methods to set explicitely fluorescence cuts.
// Main cuts from G4ProductionCutsTable are always used
//
#ifndef G4LivermorePhotoElectricModel_h
#define G4LivermorePhotoElectricModel_h 1
@@ -75,10 +79,6 @@ public:
G4double tmin,
G4double maxEnergy);
void SetCutForLowEnSecPhotons(G4double);
void SetCutForLowEnSecElectrons(G4double);
void ActivateAuger(G4bool);
void SetAngularGenerator(G4VPhotoElectricAngularDistribution* distribution);
@@ -88,11 +88,8 @@ public:
protected:
G4ParticleChangeForGamma* fParticleChange;
/*
G4double GetMeanFreePath(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition);
*/
private:
G4double lowEnergyLimit;
@@ -106,9 +103,6 @@ private:
G4VCrossSectionHandler* crossSectionHandler;
G4VCrossSectionHandler* shellCrossSectionHandler;
G4double cutForLowEnergySecondaryPhotons;
G4double cutForLowEnergySecondaryElectrons;
G4AtomicDeexcitation deexcitationManager;
G4VPhotoElectricAngularDistribution* ElectronAngularGenerator;
source/processes/electromagnetic/lowenergy/include/G4LivermorePolarizedPhotoElectricModel.hh
+10 -10
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4LivermorePolarizedPhotoElectricModel.hh,v 1.1 2009/10/30 14:52:05 flongo Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4LivermorePolarizedPhotoElectricModel.hh,v 1.2 2010/11/23 16:42:15 flongo Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
#ifndef G4LivermorePolarizedPhotoElectricModel_h
@@ -43,7 +43,7 @@
#include "G4AtomicShell.hh"
#include "G4ProductionCutsTable.hh"
#include "G4ForceCondition.hh"
#include "G4Gamma.hh"
class G4LivermorePolarizedPhotoElectricModel : public G4VEmModel
{
@@ -72,10 +72,9 @@ public:
G4double maxEnergy);
void SetCutForLowEnSecPhotons(G4double);
void SetCutForLowEnSecElectrons(G4double);
// void SetCutForLowEnSecPhotons(G4double);
// void SetCutForLowEnSecElectrons(G4double);
void ActivateAuger(G4bool);
@@ -84,9 +83,10 @@ protected:
G4ParticleChangeForGamma* fParticleChange;
G4double GetMeanFreePath(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition);
//G4double GetMeanFreePath(const G4Track& aTrack,
//G4double previousStepSize,
// G4ForceCondition* condition);
private:
G4double lowEnergyLimit;
source/processes/electromagnetic/lowenergy/include/G4OrlicLCrossSection.hh → source/processes/electromagnetic/lowenergy/include/G4OrlicLiCrossSection.hh
+14 -10
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4OrlicLCrossSection.hh,v 1.3 2008/06/03 07:29:15 gcosmo Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4OrlicLiCrossSection.hh,v 1.2 2009/06/11 15:46:18 mantero Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
// Author: Haifa Ben Abdelouahed
//
@@ -33,6 +33,8 @@
// -----------
// 23 Apr 2008 H. Ben Abdelouahed 1st implementation
// 28 Apr 2008 MGP Major revision according to a design iteration
// 21 Apr 2009 ALF Some correction for compatibility to G4VShellCrossSection
// and changed name to G4OrlicLiCrossSection
//
// -------------------------------------------------------------------
@@ -43,20 +45,20 @@
// -------------------------------------------------------------------
#ifndef G4ORLICLCROSSSECTION_HH
#define G4ORLICLCROSSSECTION_HH 1
#ifndef G4ORLICLICROSSSECTION_HH
#define G4ORLICLICROSSSECTION_HH 1
#include "globals.hh"
#include "G4AtomicTransitionManager.hh"
class G4OrlicLCrossSection
class G4OrlicLiCrossSection
{
public:
G4OrlicLCrossSection();
G4OrlicLiCrossSection();
virtual ~G4OrlicLCrossSection();
virtual ~G4OrlicLiCrossSection();
//according to I.ORLIC, C.H.SOW and S.M.TANG,International Journal of PIXE.Vol.4(1997) 217-230
@@ -70,8 +72,10 @@ public:
private:
G4OrlicLCrossSection(const G4OrlicLCrossSection&);
G4OrlicLCrossSection & operator = (const G4OrlicLCrossSection &right);
G4OrlicLiCrossSection(const G4OrlicLiCrossSection&);
G4OrlicLiCrossSection & operator = (const G4OrlicLiCrossSection &right);
G4AtomicTransitionManager* transitionManager;
};
source/processes/electromagnetic/lowenergy/include/G4PaulKCrossSection.hh
+24 -4
View File
@@ -24,13 +24,29 @@
// ********************************************************************
//
//
// History:
// -----------
// 21 Apr 2008 H. Abdelohauwed - 1st implementation
// 29 Apr 2009 ALF Major Design Revision
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics, Cross section, p ionisation, K shell
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4PAULKCROSSSECTION_HH
#define G4PAULKCROSSSECTION_HH 1
//#include "G4VDataSetAlgorithm.hh"
#include "globals.hh"
#include <map>
class G4VDataSetAlgorithm;
class G4VEMDataSet;
class G4PaulKCrossSection
@@ -41,18 +57,22 @@ public:
virtual ~G4PaulKCrossSection();
G4double CalculateKCrossSection(G4int zTarget,G4int zIncident, G4double energyIncident);
G4double CalculateKCrossSection(G4int zTarget,G4double massIncident, G4double energyIncident);
private:
G4PaulKCrossSection(const G4PaulKCrossSection&);
G4PaulKCrossSection & operator = (const G4PaulKCrossSection &right);
G4VDataSetAlgorithm* interpolation;
std::map< G4int , G4VEMDataSet* > protonDataSetMap;
std::map< G4int , G4VEMDataSet* > alphaDataSetMap;
};
#endif
source/processes/electromagnetic/lowenergy/include/G4Penelope08ComptonModel.hh
+132
View File
@@ -0,0 +1,132 @@
//
// ********************************************************************
// * 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: G4Penelope08ComptonModel.hh,v 1.2 2010/03/19 11:33:24 pandola Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
// Author: Luciano Pandola
//
// History:
// -----------
// 15 Feb 2010 L. Pandola 1st implementation.
// 18 Mar 2010 L. Pandola Removed GetAtomsPerMolecule(), now demanded
// to G4PenelopeOscillatorManager
//
// -------------------------------------------------------------------
//*
// Class description:
// Low Energy Electromagnetic Physics, Compton Scattering
// with Penelope Model, version 2008
// -------------------------------------------------------------------
#ifndef G4PENELOPE08COMPTONMODEL_HH
#define G4PENELOPE08COMPTONMODEL_HH 1
#include "globals.hh"
#include "G4VEmModel.hh"
#include "G4DataVector.hh"
#include "G4ParticleChangeForGamma.hh"
#include "G4AtomicDeexcitation.hh"
class G4ParticleDefinition;
class G4DynamicParticle;
class G4MaterialCutsCouple;
class G4Material;
class G4PenelopeOscillatorManager;
class G4PenelopeOscillator;
class G4Penelope08ComptonModel : public G4VEmModel
{
public:
G4Penelope08ComptonModel(const G4ParticleDefinition* p=0,
const G4String& processName ="PenCompton");
virtual ~G4Penelope08ComptonModel();
virtual void Initialise(const G4ParticleDefinition*, const G4DataVector&);
virtual G4double CrossSectionPerVolume(const G4Material*,
const G4ParticleDefinition*,
G4double kineticEnergy,
G4double cutEnergy = 0.0,
G4double maxEnergy = DBL_MAX);
//This is a dummy method. Never inkoved by the tracking, it just issues
//a warning if one tries to get Cross Sections per Atom via the
//G4EmCalculator.
virtual G4double ComputeCrossSectionPerAtom(const G4ParticleDefinition*,
G4double,
G4double,
G4double,
G4double,
G4double);
virtual void SampleSecondaries(std::vector<G4DynamicParticle*>*,
const G4MaterialCutsCouple*,
const G4DynamicParticle*,
G4double tmin,
G4double maxEnergy);
void SetVerbosityLevel(G4int lev){verboseLevel = lev;};
G4int GetVerbosityLevel(){return verboseLevel;};
void ActivateAuger(G4bool);
protected:
G4ParticleChangeForGamma* fParticleChange;
private:
//Differential cross section which is numerically integrated
G4double DifferentialCrossSection (G4double cdt,G4double energy,
G4PenelopeOscillator* osc);
G4double OscillatorTotalCrossSection(G4double energy,
G4PenelopeOscillator* osc);
G4double KleinNishinaCrossSection(G4double energy,const G4Material*);
G4Penelope08ComptonModel & operator=(const G4Penelope08ComptonModel &right);
G4Penelope08ComptonModel(const G4Penelope08ComptonModel&);
//Intrinsic energy limits of the model:
//cannot be extended by the parent process
G4double fIntrinsicLowEnergyLimit;
G4double fIntrinsicHighEnergyLimit;
G4int verboseLevel;
G4bool isInitialised;
G4AtomicDeexcitation deexcitationManager;
G4PenelopeOscillatorManager* oscManager;
};
#endif
source/processes/electromagnetic/lowenergy/include/G4Penelope08GammaConversionModel.hh
+124
View File
@@ -0,0 +1,124 @@
//
// ********************************************************************
// * 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: G4Penelope08GammaConversionModel.hh,v 1.1 2010/03/17 14:19:04 pandola Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
// Author: Luciano Pandola
//
// History:
// -----------
// 13 Jan 2010 L. Pandola First implementation
//
// -------------------------------------------------------------------
//
// Class description:
// Low Energy Electromagnetic Physics, Gamma Conversion
// with Penelope Model, version 2008
// -------------------------------------------------------------------
#ifndef G4PENELOPE08GAMMACONVERSIONMODEL_HH
#define G4PENELOPE08GAMMACONVERSIONMODEL_HH 1
#include "globals.hh"
#include "G4VEmModel.hh"
#include "G4DataVector.hh"
#include "G4ParticleChangeForGamma.hh"
class G4ParticleDefinition;
class G4DynamicParticle;
class G4MaterialCutsCouple;
class G4Material;
class G4PhysicsFreeVector;
class G4Penelope08GammaConversionModel : public G4VEmModel
{
public:
G4Penelope08GammaConversionModel(const G4ParticleDefinition* p=0,
const G4String& processName ="PenConversion");
virtual ~G4Penelope08GammaConversionModel();
virtual void Initialise(const G4ParticleDefinition*, const G4DataVector&);
virtual G4double ComputeCrossSectionPerAtom(
const G4ParticleDefinition*,
G4double kinEnergy,
G4double Z,
G4double A=0,
G4double cut=0,
G4double emax=DBL_MAX);
virtual void SampleSecondaries(std::vector<G4DynamicParticle*>*,
const G4MaterialCutsCouple*,
const G4DynamicParticle*,
G4double tmin,
G4double maxEnergy);
void SetVerbosityLevel(G4int lev){verboseLevel = lev;};
G4int GetVerbosityLevel(){return verboseLevel;};
protected:
G4ParticleChangeForGamma* fParticleChange;
private:
G4Penelope08GammaConversionModel & operator=(const
G4Penelope08GammaConversionModel &right);
G4Penelope08GammaConversionModel(const G4Penelope08GammaConversionModel&);
//Intrinsic energy limits of the model: cannot be extended by the parent process
G4double fIntrinsicLowEnergyLimit;
G4double fIntrinsicHighEnergyLimit;
//Use a quicker sampling algorithm if E < smallEnergy
G4double fSmallEnergy;
std::map<const G4int,G4PhysicsFreeVector*> *logAtomicCrossSection;
void ReadDataFile(const G4int Z);
void InitializeScreeningRadii();
G4double fAtomicScreeningRadius[99];
void InitializeScreeningFunctions(const G4Material*);
//Effective (scalar) properties attached to materials:
// effective charge
std::map<const G4Material*,G4double> *fEffectiveCharge;
// 2/Rs (Rs = screening radius), BCB array in Penelope
std::map<const G4Material*,G4double> *fMaterialInvScreeningRadius;
// Parameters of screening functions
std::map<const G4Material*,std::pair<G4double,G4double> > *fScreeningFunction;
std::pair<G4double,G4double> GetScreeningFunctions(G4double);
G4int verboseLevel;
G4bool isInitialised;
};
#endif
source/processes/electromagnetic/lowenergy/include/G4Penelope08IonisationModel.hh
+172
View File
@@ -0,0 +1,172 @@
//
// ********************************************************************
// * 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: G4Penelope08IonisationModel.hh,v 1.1 2010/07/28 07:12:13 pandola Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// Author: Luciano Pandola
//
// History:
// -----------
// 30 Mar 2010 L. Pandola 1st implementation.
//
// -------------------------------------------------------------------
//
// Class description:
// Low Energy Electromagnetic Physics, e+ and e- ionisation
// with Penelope Model, version 2008
// -------------------------------------------------------------------
#ifndef G4PENELOPE08IONISATIONMODEL_HH
#define G4PENELOPE08IONISATIONMODEL_HH 1
#include "globals.hh"
#include "G4VEmModel.hh"
#include "G4DataVector.hh"
#include "G4ParticleChangeForLoss.hh"
#include "G4AtomicDeexcitation.hh"
class G4PhysicsFreeVector;
class G4PhysicsLogVector;
class G4ParticleDefinition;
class G4DynamicParticle;
class G4MaterialCutsCouple;
class G4Material;
class G4PenelopeOscillatorManager;
class G4PenelopeOscillator;
class G4PenelopeCrossSection;
class G4Penelope08IonisationModel : public G4VEmModel
{
public:
G4Penelope08IonisationModel(const G4ParticleDefinition* p=0,
const G4String& processName ="PenIoni");
virtual ~G4Penelope08IonisationModel();
virtual void Initialise(const G4ParticleDefinition*, const G4DataVector&);
//*This is a dummy method. Never inkoved by the tracking, it just issues
//*a warning if one tries to get Cross Sections per Atom via the
//*G4EmCalculator.
virtual G4double ComputeCrossSectionPerAtom(const G4ParticleDefinition*,
G4double,
G4double,
G4double,
G4double,
G4double);
virtual G4double CrossSectionPerVolume(const G4Material* material,
const G4ParticleDefinition* theParticle,
G4double kineticEnergy,
G4double cutEnergy,
G4double maxEnergy = DBL_MAX);
virtual void SampleSecondaries(std::vector<G4DynamicParticle*>*,
const G4MaterialCutsCouple*,
const G4DynamicParticle*,
G4double tmin,
G4double maxEnergy);
virtual G4double ComputeDEDXPerVolume(const G4Material*,
const G4ParticleDefinition*,
G4double kineticEnergy,
G4double cutEnergy);
// Min cut in kinetic energy allowed by the model
virtual G4double MinEnergyCut(const G4ParticleDefinition*,
const G4MaterialCutsCouple*);
void SetVerbosityLevel(G4int lev){verboseLevel = lev;};
G4int GetVerbosityLevel(){return verboseLevel;};
void ActivateAuger(G4bool);
G4double GetDensityCorrection(const G4Material*,G4double energy);
protected:
G4ParticleChangeForLoss* fParticleChange;
private:
void ClearTables();
G4Penelope08IonisationModel & operator=(const G4Penelope08IonisationModel &right);
G4Penelope08IonisationModel(const G4Penelope08IonisationModel&);
G4PenelopeCrossSection* GetCrossSectionTableForCouple(const G4ParticleDefinition*,
const G4Material*,G4double cut);
void BuildXSTable(const G4Material*,G4double cut,
const G4ParticleDefinition*);
void BuildDeltaTable(const G4Material*);
G4DataVector* ComputeShellCrossSectionsElectron(G4PenelopeOscillator* ,
G4double energy,G4double cut,
G4double delta);
G4DataVector* ComputeShellCrossSectionsPositron(G4PenelopeOscillator* ,
G4double energy,G4double cut,
G4double delta);
void SampleFinalStateElectron(const G4Material*,G4double cutEnergy,G4double kineticEnergy);
void SampleFinalStatePositron(const G4Material*,G4double cutEnergy,G4double kineticEnergy);
//Intrinsic energy limits of the model: cannot be extended by the parent process
G4double fIntrinsicLowEnergyLimit;
G4double fIntrinsicHighEnergyLimit;
G4int verboseLevel;
G4bool isInitialised;
G4AtomicDeexcitation deexcitationManager;
G4double kineticEnergy1;
G4double cosThetaPrimary;
G4double energySecondary;
G4double cosThetaSecondary;
G4int targetOscillator;
G4PenelopeOscillatorManager* oscManager;
//G4PenelopeCrossSection takes care of the logs
std::map< std::pair<const G4Material*,G4double>, G4PenelopeCrossSection*> *XSTableElectron;
std::map< std::pair<const G4Material*,G4double>, G4PenelopeCrossSection*> *XSTablePositron;
//delta vs. log(energy)
std::map<const G4Material*,G4PhysicsFreeVector*> *theDeltaTable;
G4PhysicsLogVector* energyGrid;
size_t nBins;
};
#endif
source/processes/electromagnetic/lowenergy/include/G4Penelope08PhotoElectricModel.hh
+125
View File
@@ -0,0 +1,125 @@
//
// ********************************************************************
// * 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: G4Penelope08PhotoElectricModel.hh,v 1.1 2010/03/17 14:19:04 pandola Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
// Author: Luciano Pandola
//
// History:
// -----------
// 08 Jan 2010 L. Pandola 1st implementation.
//
// -------------------------------------------------------------------
//
// Class description:
// Low Energy Electromagnetic Physics, Photo-electric effect
// with Penelope Model, version 2008
// -------------------------------------------------------------------
#ifndef G4PENELOPE08PHOTOELECTRICMODEL_HH
#define G4PENELOPE08PHOTOELECTRICMODEL_HH 1
#include "globals.hh"
#include "G4VEmModel.hh"
#include "G4DataVector.hh"
#include "G4ParticleChangeForGamma.hh"
#include "G4AtomicDeexcitation.hh"
class G4ParticleDefinition;
class G4DynamicParticle;
class G4MaterialCutsCouple;
class G4Material;
class G4Penelope08PhotoElectricModel : public G4VEmModel
{
public:
G4Penelope08PhotoElectricModel(const G4ParticleDefinition* p=0,
const G4String& processName ="PenPhotoElec");
virtual ~G4Penelope08PhotoElectricModel();
virtual void Initialise(const G4ParticleDefinition*, const G4DataVector&);
virtual G4double ComputeCrossSectionPerAtom(
const G4ParticleDefinition*,
G4double kinEnergy,
G4double Z,
G4double A=0,
G4double cut=0,
G4double emax=DBL_MAX);
virtual void SampleSecondaries(std::vector<G4DynamicParticle*>*,
const G4MaterialCutsCouple*,
const G4DynamicParticle*,
G4double tmin,
G4double maxEnergy);
void SetVerbosityLevel(G4int lev){verboseLevel = lev;};
G4int GetVerbosityLevel(){return verboseLevel;};
void ActivateAuger(G4bool);
//testing purposes
size_t GetNumberOfShellXS(G4int);
G4double GetShellCrossSection(G4int Z,size_t shellID,G4double energy);
protected:
G4ParticleChangeForGamma* fParticleChange;
private:
G4Penelope08PhotoElectricModel & operator=(const G4Penelope08PhotoElectricModel &right);
G4Penelope08PhotoElectricModel(const G4Penelope08PhotoElectricModel&);
G4double SampleElectronDirection(G4double energy);
//Intrinsic energy limits of the model: cannot be extended by the parent process
G4double fIntrinsicLowEnergyLimit;
G4double fIntrinsicHighEnergyLimit;
G4int verboseLevel;
G4bool isInitialised;
G4AtomicDeexcitation deexcitationManager;
void ReadDataFile(G4int Z);
//For each Z, the PhysicsTable contains nShell+1 physics vectors
//with log(E) vs. log(XS)
//Element [0] of the table is the total XS, element [iS] is the
//partial cross section for shell iS-1
std::map<const G4int,G4PhysicsTable*> *logAtomicShellXS;
size_t SelectRandomShell(G4int Z,G4double energy);
G4String WriteTargetShell(size_t shellID);
};
#endif
source/processes/electromagnetic/lowenergy/include/G4Penelope08RayleighModel.hh
+127
View File
@@ -0,0 +1,127 @@
//
// ********************************************************************
// * 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: G4Penelope08RayleighModel.hh,v 1.1 2010/03/17 14:19:04 pandola Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
// Author: Luciano Pandola
//
// History:
// -----------
// 03 Dec 2009 L. Pandola 1st implementation.
//
// -------------------------------------------------------------------
//
// Class description:
// Low Energy Electromagnetic Physics, Rayleigh Scattering
// with the model from Penelope, version 2008
// -------------------------------------------------------------------
#ifndef G4PENELOPE08RAYLEIGHMODEL_HH
#define G4PENELOPE08RAYLEIGHMODEL_HH 1
#include "globals.hh"
#include "G4VEmModel.hh"
#include "G4DataVector.hh"
#include "G4ParticleChangeForGamma.hh"
class G4ParticleDefinition;
class G4DynamicParticle;
class G4MaterialCutsCouple;
class G4Material;
class G4PhysicsFreeVector;
class G4PenelopeSamplingData;
class G4Penelope08RayleighModel : public G4VEmModel
{
public:
G4Penelope08RayleighModel(const G4ParticleDefinition* p=0,
const G4String& processName ="PenRayleigh");
virtual ~G4Penelope08RayleighModel();
virtual void Initialise(const G4ParticleDefinition*, const G4DataVector&);
virtual G4double ComputeCrossSectionPerAtom(const G4ParticleDefinition*,
G4double kinEnergy,
G4double Z,
G4double A=0,
G4double cut=0,
G4double emax=DBL_MAX);
virtual void SampleSecondaries(std::vector<G4DynamicParticle*>*,
const G4MaterialCutsCouple*,
const G4DynamicParticle*,
G4double tmin,
G4double maxEnergy);
void SetVerbosityLevel(G4int lev){verboseLevel = lev;};
G4int GetVerbosityLevel(){return verboseLevel;};
//Testing purposes
void DumpFormFactorTable(const G4Material*);
protected:
G4ParticleChangeForGamma* fParticleChange;
private:
G4Penelope08RayleighModel& operator=(const G4Penelope08RayleighModel &right);
G4Penelope08RayleighModel(const G4Penelope08RayleighModel&);
//Intrinsic energy limits of the model: cannot be extended by
//the parent process
G4double fIntrinsicLowEnergyLimit;
G4double fIntrinsicHighEnergyLimit;
G4int verboseLevel;
G4bool isInitialised;
//Internal tables and manager methods
std::map<const G4int,G4PhysicsFreeVector*> *logAtomicCrossSection;
std::map<const G4int,G4PhysicsFreeVector*> *atomicFormFactor;
G4DataVector logQSquareGrid; //log(Q^2) grid for interpolation
std::map<const G4Material*,G4PhysicsFreeVector*> *logFormFactorTable; //log(Q^2) vs. log(F^2)
G4DataVector logEnergyGridPMax; //energy grid for PMac (and originally for the x-section)
std::map<const G4Material*,G4PhysicsFreeVector*> *pMaxTable; //E vs. Pmax
std::map<const G4Material*,G4PenelopeSamplingData*> *samplingTable;
//Helper methods
void ReadDataFile(G4int);
void ClearTables();
void BuildFormFactorTable(const G4Material*);
void GetPMaxTable(const G4Material*);
G4double GetFSquared(const G4Material*,const G4double);
void InitializeSamplingAlgorithm(const G4Material*);
};
#endif
source/processes/electromagnetic/lowenergy/include/G4PenelopeCrossSection.hh
+124
View File
@@ -0,0 +1,124 @@
//
// ********************************************************************
// * 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: G4PenelopeCrossSection.hh,v 1.1 2010/07/26 09:56:42 pandola Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// Author: Luciano Pandola
//
// History:
// -----------
// 18 Mar 2010 L. Pandola 1st implementation.
//
// -------------------------------------------------------------------
//
// Class description:
// This class is a container for cross sections and transport momenta
// calculated by Penelope models (ionisation, bremsstrahlung). It stores
// PhysicsTables/PhysicsVectors of
// a) the "hard quantities" (above the threshold), 0-th order (cross section)
// 1-st order (= stopping XS), 2-nd order (= straggling XS)
// b) the "soft quantities" (below threshold), 0-th order (cross section)
// 1-st order (= stopping XS), 2-nd order (= straggling XS)
// c) total hard cross sections for individual oscillators
// vs. energy.
//
// The interface *always* uses energy and cross sections, while internally
// log(energy) and log(XS) are used.
//
// One instance per each cut-material couple should be created by the
// calling class.
//
// Public method to retrieve hard cross section, soft stopping power,
// total cross section and hard shell cross sections.
//
// The method NormalizeShellCrossSections() normalizes the
// shell cross sections by retrieving the total hard cross section.
// Used for sampling.
//
// Notice: all quantities stored here are *per molecule*
//
// -------------------------------------------------------------------
#ifndef G4PENELOPECROSSSECTION_HH
#define G4PENELOPECROSSSECTION_HH 1
#include "globals.hh"
class G4PhysicsTable;
class G4DataVector;
class G4PenelopeCrossSection
{
public:
//constructor: one has to give the number of points in each PhysicsVector
//(= dimension of the energy grid) and the number of shells (0 is the
//default).
G4PenelopeCrossSection(size_t nOfEnergyPoints,size_t nOfShells=0);
//
~G4PenelopeCrossSection();
G4double GetTotalCrossSection(G4double energy);
G4double GetHardCrossSection(G4double energy);
G4double GetSoftStoppingPower(G4double energy);
G4double GetShellCrossSection(size_t shellID,G4double energy);
size_t GetNumberOfShells(){return numberOfShells;};
void AddCrossSectionPoint(size_t binNumber,
G4double energy,G4double XH0, G4double XH1,
G4double XH2,
G4double XS0, G4double XS1, G4double XS2);
void AddShellCrossSectionPoint(size_t binNumber,
size_t shellID,G4double energy,G4double xs);
void NormalizeShellCrossSections();
private:
G4PenelopeCrossSection & operator=(const G4PenelopeCrossSection &right);
G4PenelopeCrossSection(const G4PenelopeCrossSection&);
G4bool isNormalized;
size_t numberOfEnergyPoints;
size_t numberOfShells;
//all tables are log. XS vs. log E
//XS0, XS1, XS2 in Penelope nomenclature
G4PhysicsTable* softCrossSections;
//XH0, XH1, XH2 in Penelope nomenclature
G4PhysicsTable* hardCrossSections;
//XS for individual shells
G4PhysicsTable* shellCrossSections;
};
#endif
source/processes/electromagnetic/lowenergy/include/G4PenelopeIonisationModel.hh
+20 -2
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4PenelopeIonisationModel.hh,v 1.3 2009/10/21 14:56:47 pandola Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4PenelopeIonisationModel.hh,v 1.5 2010/04/15 10:02:10 pandola Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
// Author: Luciano Pandola
//
@@ -35,6 +35,10 @@
// 21 Oct 2009 L. Pandola Remove un-necessary methods and variables to handle
// AtomicDeexcitationFlag - now demanded to G4VEmModel
// Add ActivateAuger() method
// 29 Mar 2010 L. Pandola Added a dummy ComputeCrossSectioPerAtom() method issueing a
// warning if users try to access atomic cross sections via
// G4EmCalculator
// 15 Apr 2010 L. Pandola Implemented model's own version of MinEnergyCut()
//
// -------------------------------------------------------------------
//
@@ -72,6 +76,16 @@ public:
virtual void Initialise(const G4ParticleDefinition*, const G4DataVector&);
//*This is a dummy method. Never inkoved by the tracking, it just issues
//*a warning if one tries to get Cross Sections per Atom via the
//*G4EmCalculator.
virtual G4double ComputeCrossSectionPerAtom(const G4ParticleDefinition*,
G4double,
G4double,
G4double,
G4double,
G4double);
virtual G4double CrossSectionPerVolume(const G4Material* material,
const G4ParticleDefinition* theParticle,
G4double kineticEnergy,
@@ -89,6 +103,10 @@ public:
G4double kineticEnergy,
G4double cutEnergy);
// Min cut in kinetic energy allowed by the model
virtual G4double MinEnergyCut(const G4ParticleDefinition*,
const G4MaterialCutsCouple*);
void SetVerbosityLevel(G4int lev){verboseLevel = lev;};
G4int GetVerbosityLevel(){return verboseLevel;};
source/processes/electromagnetic/lowenergy/include/G4PenelopeOscillator.hh
+107
View File
@@ -0,0 +1,107 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
// Author: Luciano Pandola
//
// History:
// -----------
// 18 Dec 2008 L. Pandola First implementation
//
//
// -------------------------------------------------------------------
//
// Class description:
// Class designed to contain data of atomic oscillators that are used by
// several Penelope models. Objects of G4PenelopeOscillators are managed
// by a dedicated G4PenelopeOscillatorManager.
// -------------------------------------------------------------------
#ifndef G4PENELOPEOSCILLATOR_HH
#define G4PENELOPEOSCILLATOR_HH 1
#include "globals.hh"
class G4PenelopeOscillator
{
public:
G4PenelopeOscillator();
G4PenelopeOscillator(const G4PenelopeOscillator&);
~G4PenelopeOscillator(){;};
//I need to overload the following operators: > < == =
const G4PenelopeOscillator& operator=(const G4PenelopeOscillator&);
int operator==(const G4PenelopeOscillator&) const;
int operator>(const G4PenelopeOscillator&) const;
int operator<(const G4PenelopeOscillator&) const;
//Setters and getters
G4double GetHartreeFactor() {return hartreeFactor;};
void SetHartreeFactor(G4double hf) {hartreeFactor = hf;};
//
G4double GetIonisationEnergy() {return ionisationEnergy;};
void SetIonisationEnergy(G4double ie) {ionisationEnergy = ie;};
//
G4double GetResonanceEnergy() const {return resonanceEnergy;};
void SetResonanceEnergy(G4double re) {resonanceEnergy = re;};
//
G4double GetOscillatorStrength() {return oscillatorStrength;};
void SetOscillatorStrength(G4double ostr) {oscillatorStrength=ostr;};
//
G4int GetShellFlag() {return shellFlag;};
void SetShellFlag(G4int theflag) {shellFlag=theflag;};
//
G4double GetParentZ() {return parentZ;};
void SetParentZ(G4double parZ) {parentZ = parZ;};
//
G4int GetParentShellID() {return parentShellID;};
void SetParentShellID(G4int psID) {parentShellID = psID;};
//
G4double GetCutoffRecoilResonantEnergy(){return cutoffRecoilResonantEnergy;};
void SetCutoffRecoilResonantEnergy(G4double ene){cutoffRecoilResonantEnergy = ene;};
private:
G4double hartreeFactor;
G4double ionisationEnergy;
G4double resonanceEnergy;
G4double oscillatorStrength;
G4int shellFlag;
G4double parentZ;
G4int parentShellID; //necessary for interface to AtomicDeexcitationManager
G4double cutoffRecoilResonantEnergy;
};
struct G4PenelopeOscillatorResEnergyComparator
{
public:
int operator()(const G4PenelopeOscillator& left,
const G4PenelopeOscillator& right)
{return ((left.GetResonanceEnergy() < right.GetResonanceEnergy()) ? 1 : 0);};
};
#endif
source/processes/electromagnetic/lowenergy/include/G4PenelopeOscillatorManager.hh
+137
View File
@@ -0,0 +1,137 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
//
// Authors: Luciano Pandola (luciano.pandola at lngs.infn.it)
//
// History:
// -----------
//
// 03 Dec 2009 First implementation, Luciano Pandola
// 16 Feb 2010 Added methods to calculate and store also A and Z
// for molecules. Luciano Pandola
// 16 Mar 2010 Added methods to calculate and store mean exc energy
// and plasma energy (used for Ionisation). L Pandola
// 18 Mar 2010 Added method to retrieve number of atoms per
// molecule. L. Pandola
//
// -------------------------------------------------------------------
//
//! Class description:
//! Fills and manages G4PenelopeOscillator objects and takes care of
//! building and managing the G4PenelopeOscillatorTables for the materials
//! in the geometry. G4PenelopeOscillatorManager is a singleton.
//! This is compliant with Penelope2008, so different tables (with different
//! grouping factors) are created for Ionisation and Compton processes.
//
// -------------------------------------------------------------------
#ifndef G4PenelopeOscillatorManager_h
#define G4PenelopeOscillatorManager_h 1
#include "globals.hh"
#include "G4PenelopeOscillator.hh"
#include <vector>
#include <map>
class G4Material;
typedef std::vector<G4PenelopeOscillator*> G4PenelopeOscillatorTable ;
// This class is a singleton
class G4PenelopeOscillatorManager {
public:
// The only way to get an instance of this class is to call the
// function GetOscillatorManager()
static G4PenelopeOscillatorManager* GetOscillatorManager();
//Clear() is invoked by Initialise() of the processes, if required
void Clear();
void Dump(const G4Material*);
//For ionisation
G4PenelopeOscillatorTable* GetOscillatorTableIonisation(const G4Material*);
G4PenelopeOscillator* GetOscillatorIonisation(const G4Material*,G4int);
//For Compton
G4PenelopeOscillatorTable* GetOscillatorTableCompton(const G4Material*);
G4PenelopeOscillator* GetOscillatorCompton(const G4Material*,G4int);
void SetVerbosityLevel(G4int vl){verbosityLevel = vl;};
G4int GetVerbosityLevel(){return verbosityLevel;};
//These are cumulative for the molecule
G4double GetTotalZ(const G4Material*);
G4double GetTotalA(const G4Material*);
G4double GetMeanExcitationEnergy(const G4Material*);
G4double GetPlasmaEnergySquared(const G4Material*);
G4double GetAtomsPerMolecule(const G4Material*);
protected:
G4PenelopeOscillatorManager();
~G4PenelopeOscillatorManager();
private:
// Hide copy constructor and assignment operator
G4PenelopeOscillatorManager& operator=(const
G4PenelopeOscillatorManager& right);
G4PenelopeOscillatorManager(const G4PenelopeOscillatorManager&);
static G4PenelopeOscillatorManager* instance;
//In Penelope2008, the Ionisation and Compton oscillator tables are
//slightly different!
std::map<const G4Material*,G4PenelopeOscillatorTable*>
*oscillatorStoreIonisation;
std::map<const G4Material*,G4PenelopeOscillatorTable*>
*oscillatorStoreCompton;
std::map<const G4Material*,G4double> *atomicNumber;
std::map<const G4Material*,G4double> *atomicMass;
std::map<const G4Material*,G4double> *excitationEnergy;
std::map<const G4Material*,G4double> *plasmaSquared;
std::map<const G4Material*,G4double> *atomsPerMolecule;
//create both tables simultaneously
void CheckForTablesCreated();
void ReadElementData();
G4double elementData[5][2000];
G4bool fReadElementData;
void BuildOscillatorTable(const G4Material*);
G4int verbosityLevel;
};
#endif
source/processes/electromagnetic/lowenergy/include/G4PenelopeRayleighModel.hh
+16 -3
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4PenelopeRayleighModel.hh,v 1.1 2008/10/28 08:50:21 pandola Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4PenelopeRayleighModel.hh,v 1.3 2010/04/15 10:02:25 pandola Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
// Author: Luciano Pandola
//
@@ -32,12 +32,15 @@
// -----------
// 13 Oct 2008 L. Pandola 1st implementation. Migration from EM process
// to EM model
// 18 Dec 2009 L. Pandola Added a dummy ComputeCrossSectioPerAtom() method issueing a
// warning if users try to access atomic cross sections via
// G4EmCalculator
//
// -------------------------------------------------------------------
//
// Class description:
// Low Energy Electromagnetic Physics, Rayleigh Scattering
// with Penelope Model
// with Penelope v2001 Model
// -------------------------------------------------------------------
#ifndef G4PENELOPERAYLEIGHMODEL_HH
@@ -70,6 +73,16 @@ public:
G4double cutEnergy = 0.0,
G4double maxEnergy = DBL_MAX);
//*This is a dummy method. Never inkoved by the tracking, it just issues
//*a warning if one tries to get Cross Sections per Atom via the
//*G4EmCalculator.
virtual G4double ComputeCrossSectionPerAtom(const G4ParticleDefinition*,
G4double,
G4double,
G4double,
G4double,
G4double);
virtual void SampleSecondaries(std::vector<G4DynamicParticle*>*,
const G4MaterialCutsCouple*,
const G4DynamicParticle*,
source/processes/electromagnetic/lowenergy/include/G4PenelopeSamplingData.hh
+92
View File
@@ -0,0 +1,92 @@
//
// ********************************************************************
// * 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: G4PenelopeSamplingData.hh,v 1.1 2010/03/17 14:19:04 pandola Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
// Author: Luciano Pandola
//
// History:
// -----------
// 09 Dec 2009 L. Pandola 1st implementation.
//
// -------------------------------------------------------------------
//
// Class description:
// This is a container of data that are used for sampling algorithm
// of Penelope08 Rayleigh scattering
// -------------------------------------------------------------------
#ifndef G4PENELOPESAMPLINGDATA_HH
#define G4PENELOPESAMPLINGDATA_HH 1
#include "globals.hh"
#include "G4DataVector.hh"
//
//This is a container of data that are used for sampling algoritm
//
class G4PenelopeSamplingData
{
public:
G4PenelopeSamplingData(G4int npoints=150);
~G4PenelopeSamplingData();
void AddPoint(G4double x0,G4double pac0,G4double a0,G4double b0,size_t ITTL0,
size_t ITTU0);
size_t GetNumberOfStoredPoints();
void Clear();
void DumpTable();
G4double GetX(size_t index);
G4double GetPAC(size_t index);
G4double GetA(size_t index);
G4double GetB(size_t index);
G4double SampleValue(G4double rndm);
private:
G4PenelopeSamplingData & operator=(const G4PenelopeSamplingData &right);
G4PenelopeSamplingData(const G4PenelopeSamplingData&);
//G4double xlow;
//G4double xhigh;
G4DataVector* x; //grid points, in increasing order
G4DataVector* pac; //value of the cumulative pdf at x_i
G4DataVector* a; // rational inverse cumulative inverse distribution parameters
G4DataVector* b;
std::vector<size_t> *ITTL; //largest j for which pac(j) < (i-1)/(np-1)
std::vector<size_t> *ITTU; //smallest k for which pac(k) > i/(np-1)
G4int np; //number of grid points
};
#endif
source/processes/electromagnetic/lowenergy/include/G4UAtomicDeexcitation.hh
+159
View File
@@ -0,0 +1,159 @@
//
// ********************************************************************
// * 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: G4AtomicTransitionManager.hh,v 1.2 ????
// GEANT4 tag $Name: geant4-09-04 $
//
// -------------------------------------------------------------------
//
// Geant4 Header G4UAtomicDeexcitation
//
// Authors: Alfonso Mantero (Alfonso.Mantero@ge.infn.it)
//
// Created 22 April 2010 from old G4AtomicDeexcitation class
//
// Modified:
// ---------
//
//
// -------------------------------------------------------------------
//
// Class description:
// Implementation of atomic deexcitation
//
// -------------------------------------------------------------------
#ifndef G4UAtomicDeexcitation_h
#define G4UAtomicDeexcitation_h 1
#include "G4VAtomDeexcitation.hh"
#include "G4AtomicShell.hh"
#include "globals.hh"
#include <vector>
#include "G4DynamicParticle.hh"
//#include "G4VhShellCrossSection.hh"
#include "G4teoCrossSection.hh"
#include "G4empCrossSection.hh"
class G4AtomicTransitionManager;
class G4VhShellCrossSection;
//class G4teoCrossSection;
//class G4empCrossSection;
class G4UAtomicDeexcitation : public G4VAtomDeexcitation
{
public:
G4UAtomicDeexcitation();
virtual ~G4UAtomicDeexcitation();
//=================================================================
// methods that are requested to be implemented by the interface
//=================================================================
// initialisation methods
virtual void InitialiseForNewRun();
virtual void InitialiseForExtraAtom(G4int Z);
// Set threshold energy for fluorescence
void SetCutForSecondaryPhotons(G4double cut);
// Set threshold energy for Auger electron production
void SetCutForAugerElectrons(G4double cut);
// Get atomic shell by shell index, used by discrete processes
// (for example, photoelectric), when shell vacancy sampled by the model
virtual
const G4AtomicShell* GetAtomicShell(G4int Z,
G4AtomicShellEnumerator shell);
// generation of deexcitation for given atom, shell vacancy and cuts
virtual void GenerateParticles(std::vector<G4DynamicParticle*>* secVect,
const G4AtomicShell*,
G4int Z,
G4double gammaCut,
G4double eCut);
// access or compute PIXE cross section
virtual
G4double GetShellIonisationCrossSectionPerAtom(const G4ParticleDefinition*,
G4int Z,
G4AtomicShellEnumerator shell,
G4double kinE);
// access or compute PIXE cross section
virtual
G4double ComputeShellIonisationCrossSectionPerAtom(const G4ParticleDefinition*,
G4int Z,
G4AtomicShellEnumerator shell,
G4double kinE);
//=================================================================
// concrete methods of the deextation class
//=================================================================
private:
// Decides wether a radiative transition is possible and, if it is,
// returns the identity of the starting shell for the transition
G4int SelectTypeOfTransition(G4int Z, G4int shellId);
// Generates a particle from a radiative transition and returns it
G4DynamicParticle* GenerateFluorescence(G4int Z, G4int shellId,
G4int provShellId);
// Generates a particle from a non-radiative transition and returns it
G4DynamicParticle* GenerateAuger(G4int Z, G4int shellId);
// copy constructor and hide assignment operator
G4UAtomicDeexcitation(G4UAtomicDeexcitation &);
G4UAtomicDeexcitation & operator=(const G4UAtomicDeexcitation &right);
const G4AtomicTransitionManager* transitionManager;
// Data member which stores the shells to be filled by
// the radiative transition
G4int newShellId;
G4double minGammaEnergy;
G4double minElectronEnergy;
// G4bool fAuger;
// Data member wich stores the id of the shell where is the vacancy
// left from the Auger electron
G4int augerVacancyId;
// Data member for the calculation of the proton and alpha ionisation XS
G4VhShellCrossSection* PIXEshellCS;
};
#endif
source/processes/electromagnetic/lowenergy/include/G4VIonDEDXScalingAlgorithm.hh
+1 -1
View File
@@ -58,7 +58,7 @@ class G4VIonDEDXScalingAlgorithm {
public:
G4VIonDEDXScalingAlgorithm();
~G4VIonDEDXScalingAlgorithm();
virtual ~G4VIonDEDXScalingAlgorithm();
// Function for scaling the kinetic energy (no scaling by default).
// Returns scaling factor for a given ion.
source/processes/electromagnetic/lowenergy/include/G4ecpssrCrossSection.hh → source/processes/electromagnetic/lowenergy/include/G4VecpssrKModel.hh
Regular → Executable
+11 -20
View File
@@ -23,54 +23,45 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4ecpssrCrossSection.hh,v 1.3 2008/06/03 07:29:15 gcosmo Exp $
// GEANT4 tag $Name: geant4-09-02 $
//
// Author: Haifa Ben Abdelouahed
// Author: Alfonso Mantero
//
//
// History:
// -----------
// 21 Apr 2008 H. Ben Abdelouahed 1st implementation
// 21 Apr 2008 MGP Major revision according to a design iteration
// 01 Sep 2009 Alf Created
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics, Cross section, p ionisation, K shell
// Low Energy Electromagnetic Physics, Cross section, p and alpha ionisation, L shell
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4ECPSSRCROSSSECTION_HH
#define G4ECPSSRCROSSSECTION_HH 1
#ifndef G4VECPSSRKMODEL_HH
#define G4VECPSSRKMODEL_HH 1
#include "globals.hh"
class G4ecpssrCrossSection
class G4VecpssrKModel
{
public:
G4ecpssrCrossSection();
G4VecpssrKModel();
virtual ~G4ecpssrCrossSection();
virtual ~G4VecpssrKModel();
G4double CalculateCrossSection(G4int zTarget,G4int zIncident, G4double energyIncident);//according to W.Brandt and G.Lapicki, Phys.Rev.A23(1981)
G4double CalculateVelocity(G4int zTarget,G4int zIncident, G4double energyIncident);
G4double ExpIntFunction(G4int n,G4double x);//Exponential Integral Function
virtual G4double CalculateCrossSection(G4int zTarget,G4double massIncident, G4double energyIncident) = 0;
private:
G4ecpssrCrossSection(const G4ecpssrCrossSection&);
G4ecpssrCrossSection & operator = (const G4ecpssrCrossSection &right);
G4VecpssrKModel(const G4VecpssrKModel&);
G4VecpssrKModel & operator = (const G4VecpssrKModel &right);
};
source/processes/electromagnetic/lowenergy/include/G4VecpssrLiModel.hh
Executable
+78
View File
@@ -0,0 +1,78 @@
//
// ********************************************************************
// * 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: G4VecpssrLiModel.hh,v 1.4 2010/06/25 09:41:13 gunter Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
// Author: Haifa Ben Abdelouahed
//
//
// History:
// -----------
// 23 Apr 2008 H. Ben Abdelouahed 1st implementation
// 28 Apr 2008 MGP Major revision according to a design iteration
// 29 Apr 2009 ALF Updated Desing for Integration
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics, Cross section, p and alpha ionisation, L shell
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4VECPSSRLIMODEL_HH
#define G4VECPSSRLIMODEL_HH 1
#include "globals.hh"
class G4VecpssrLiModel
{
public:
G4VecpssrLiModel();
virtual ~G4VecpssrLiModel();
virtual G4double CalculateL1CrossSection(G4int zTarget,G4double massIncident, G4double energyIncident) = 0;//according to W.Brandt and G.Lapicki, Phys.Rev.A23(1981)
virtual G4double CalculateL2CrossSection(G4int zTarget,G4double massIncident, G4double energyIncident) = 0;//according to W.Brandt and G.Lapicki, Phys.Rev.A23(1981)
virtual G4double CalculateL3CrossSection(G4int zTarget,G4double massIncident, G4double energyIncident) = 0;//according to W.Brandt and G.Lapicki, Phys.Rev.A23(1981)
private:
G4VecpssrLiModel(const G4VecpssrLiModel&);
G4VecpssrLiModel & operator = (const G4VecpssrLiModel &right);
};
#endif
source/processes/electromagnetic/lowenergy/include/G4empCrossSection.hh
Executable
+90
View File
@@ -0,0 +1,90 @@
//
// ********************************************************************
// * 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: G4empCrossSection.hh,v 1.1 2009/06/17 16:39:55 mantero Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
//
//
// History:
// -----------
// 21 Apr 2009 ALF 1st implementation
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics, Cross section, p ionisation, K shell
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4EMPCROSSSECTION_HH
#define G4EMPCROSSSECTION_HH 1
#include "globals.hh"
#include "G4VhShellCrossSection.hh"
#include "G4PaulKCrossSection.hh"
#include "G4OrlicLiCrossSection.hh"
class G4empCrossSection : public G4VhShellCrossSection
{
public:
G4empCrossSection();
~G4empCrossSection();
std::vector<G4double> GetCrossSection(G4int Z,
G4double incidentEnergy,
G4double mass,
G4double deltaEnergy,
G4bool testFlag = false) const;
std::vector<G4double> Probabilities(G4int Z,
G4double incidentEnergy,
G4double mass,
G4double deltaEnergy) const;
void SetTotalCS(G4double);
private:
G4double totalCS;
G4PaulKCrossSection* paulShellK;
G4OrlicLiCrossSection* orlicShellLi;
G4empCrossSection(const G4empCrossSection&);
G4empCrossSection & operator = (const G4empCrossSection &right);
};
#endif
source/processes/electromagnetic/lowenergy/include/G4hLowEnergyIonisation.hh
+7 -3
View File
@@ -49,6 +49,7 @@
// 07 Dec 2001 V.Ivanchenko Add SetFluorescence method
// 26 Feb 2002 V.Ivanchenko Add initialMass for GenericIons
// 21 Jan 2003 V.Ivanchenko Cut per region
// 03 Oct 2009 ALF added SelectShellIonisationCS
// ------------------------------------------------------------
// Class Description:
@@ -86,7 +87,7 @@
#include "G4hIonEffChargeSquare.hh"
#include "G4IonChuFluctuationModel.hh"
#include "G4IonYangFluctuationModel.hh"
#include "G4AtomicDeexcitation.hh"
#include "G4UAtomicDeexcitation.hh"
#include "G4MaterialCutsCouple.hh"
#include <map>
@@ -174,6 +175,9 @@ public: // With description
void SetFluorescence(const G4bool val) {theFluo = val;};
// This method switch on/off simulation of the fluorescence of the media.
void SelectShellIonisationCS(G4String);
G4VParticleChange* AlongStepDoIt(const G4Track& trackData ,
const G4Step& stepData ) ;
// Function to determine total energy deposition on the step
@@ -260,6 +264,7 @@ private:
G4double hMass,
G4double eLoss);
G4int SelectRandomAtom(const G4MaterialCutsCouple* couple,
G4double kineticEnergy) const;
@@ -308,12 +313,11 @@ private:
G4double initialMass; // mass to calculate Lambda tables
G4double fBarkas;
G4AtomicDeexcitation deexcitationManager;
G4UAtomicDeexcitation deexcitationManager;
G4ShellVacancy* shellVacancy;
G4VhShellCrossSection* shellCS;
std::vector<G4VEMDataSet*> zFluoDataVector;
G4bool theFluo;
G4bool expFlag;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
source/processes/electromagnetic/lowenergy/include/G4teoCrossSection.hh
+92
View File
@@ -0,0 +1,92 @@
//
// ********************************************************************
// * 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: G4teoCrossSection.hh,v 1.6 2010/11/12 18:09:44 mantero Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
//
//
// History:
// -----------
// 21 Apr 2008 ALF 1st implementation
// 29 Apr 2009 ALF Updated Desing for Integration
//
// -------------------------------------------------------------------
// Class description:
// Low Energy Electromagnetic Physics, Cross section, p ionisation, K shell
// Further documentation available from http://www.ge.infn.it/geant4/lowE
// -------------------------------------------------------------------
#ifndef G4TEOCROSSSECTION_HH
#define G4TEOCROSSSECTION_HH 1
#include "globals.hh"
#include "G4VhShellCrossSection.hh"
#include "G4AnalyticalEcpssrKCrossSection.hh"
#include "G4AnalyticalEcpssrLiCrossSection.hh"
class G4teoCrossSection : public G4VhShellCrossSection
{
public:
G4teoCrossSection(G4String);
~G4teoCrossSection();
std::vector<G4double> GetCrossSection(G4int Z,
G4double incidentEnergy,
G4double mass,
G4double deltaEnergy = 0,
G4bool testFlag = false) const;
std::vector<G4double> Probabilities(G4int Z,
G4double incidentEnergy,
G4double mass,
G4double deltaEnergy = 0) const;
void SetTotalCS(G4double);
private:
G4double totalCS;
G4VecpssrKModel* ecpssrShellK;
G4VecpssrLiModel* ecpssrShellLi;
G4teoCrossSection(const G4teoCrossSection&);
G4teoCrossSection & operator = (const G4teoCrossSection &right);
};
#endif
source/processes/electromagnetic/lowenergy/sources.cmake
+472
View File
@@ -0,0 +1,472 @@
#------------------------------------------------------------------------------
# sources.cmake
# Module : G4emlowenergy
# Package: Geant4.src.G4processes.G4electromagnetic.G4emlowenergy
#
# Sources description for a library.
# Lists the sources and headers of the code explicitely.
# Lists include paths needed.
# Lists the internal granular and global dependencies of the library.
# Source specific properties should be added at the end.
#
# Generated on : 24/9/2010
#
# $Id: sources.cmake,v 1.4 2010/11/15 08:24:43 gcosmo Exp $
#
#------------------------------------------------------------------------------
# List external includes needed.
include_directories(${CLHEP_INCLUDE_DIRS})
# List internal includes needed.
include_directories(${CMAKE_SOURCE_DIR}/source/geometry/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/global/HEPGeometry/include)
include_directories(${CMAKE_SOURCE_DIR}/source/global/HEPNumerics/include)
include_directories(${CMAKE_SOURCE_DIR}/source/global/HEPRandom/include)
include_directories(${CMAKE_SOURCE_DIR}/source/global/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/intercoms/include)
include_directories(${CMAKE_SOURCE_DIR}/source/materials/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/bosons/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/hadrons/barions/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/hadrons/ions/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/hadrons/mesons/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/leptons/include)
include_directories(${CMAKE_SOURCE_DIR}/source/particles/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/cuts/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/electromagnetic/standard/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/electromagnetic/utils/include)
include_directories(${CMAKE_SOURCE_DIR}/source/processes/management/include)
include_directories(${CMAKE_SOURCE_DIR}/source/track/include)
#
# Define the Geant4 Module.
#
include(Geant4MacroDefineModule)
GEANT4_DEFINE_MODULE(NAME G4emlowenergy
HEADERS
G4AnalyticalEcpssrKCrossSection.hh
G4AnalyticalEcpssrLiCrossSection.hh
G4AtomicDeexcitation.hh
G4AtomicTransitionManager.hh
G4AugerData.hh
G4AugerTransition.hh
G4BoldyshevTripletModel.hh
G4BremsstrahlungCrossSectionHandler.hh
G4BremsstrahlungParameters.hh
G4CompositeEMDataSet.hh
G4CrossSectionChargeDecrease.hh
G4CrossSectionChargeDecreasePartial.hh
G4CrossSectionChargeIncrease.hh
G4CrossSectionChargeIncreasePartial.hh
G4CrossSectionChargeTransferCH.hh
G4CrossSectionChargeTransferExp.hh
G4CrossSectionElasticChampion.hh
G4CrossSectionElasticScreenedRutherfordHE.hh
G4CrossSectionElasticScreenedRutherford.hh
G4CrossSectionElasticScreenedRutherfordLE.hh
G4CrossSectionExcitationBorn.hh
G4CrossSectionExcitationBornPartial.hh
G4CrossSectionExcitationEmfietzoglou.hh
G4CrossSectionExcitationEmfietzoglouPartial.hh
G4CrossSectionExcitationMillerGreen.hh
G4CrossSectionExcitationMillerGreenPartial.hh
G4CrossSectionHandler.hh
G4CrossSectionIonisationBornElectron.hh
G4CrossSectionIonisationBorn.hh
G4CrossSectionIonisationBornPartialElectron.hh
G4CrossSectionIonisationBornPartial.hh
G4CrossSectionIonisationRudd.hh
G4CrossSectionIonisationRuddPartial.hh
G4CrossSectionKill.hh
G4CrossSectionPsCreationChampion.hh
G4CrossSectionPsCreationChampionPartial.hh
G4DNAAttachment.hh
G4DNABornExcitationModel.hh
G4DNABornIonisationModel.hh
G4DNAChampionElasticModel.hh
G4DNAChargeDecrease.hh
G4DNAChargeIncrease.hh
G4DNACrossSectionDataSet.hh
G4DNADingfelderChargeDecreaseModel.hh
G4DNADingfelderChargeIncreaseModel.hh
G4DNAElastic.hh
G4DNAEmfietzoglouExcitationModel.hh
G4DNAExcitation.hh
G4DNAGenericIonsManager.hh
G4DNAIonisation.hh
G4DNAMeltonAttachmentModel.hh
G4DNAMillerGreenExcitationModel.hh
G4DNAMoleculeManager.hh
G4DNAProcess.hh
G4DNAProcess.icc
G4DNARuddIonisationExtendedModel.hh
G4DNARuddIonisationModel.hh
G4DNASancheExcitationModel.hh
G4DNAScreenedRutherfordElasticModel.hh
G4DNAVibExcitation.hh
G4DopplerProfile.hh
G4DummyFinalState.hh
G4eBremsstrahlungSpectrum.hh
G4eCrossSectionExcitationEmfietzoglou.hh
G4eCrossSectionScreenedRutherford.hh
G4eIonisationCrossSectionHandler.hh
G4eIonisationParameters.hh
G4eIonisationSpectrum.hh
G4eLowEnergyLoss.hh
G4eLowEnergyLoss.icc
G4EMDataSet.hh
G4empCrossSection.hh
G4FinalStateChargeDecrease.hh
G4FinalStateChargeIncrease.hh
G4FinalStateChargeTransferProton.hh
G4FinalStateElasticBrennerZaider.hh
G4FinalStateElasticChampion.hh
G4FinalStateElasticScreenedRutherford.hh
G4FinalStateExcitationBorn.hh
G4FinalStateExcitationEmfietzoglou.hh
G4FinalStateExcitationMillerGreen.hh
G4FinalStateIonisationBorn.hh
G4FinalStateIonisationRudd.hh
G4FinalStateKill.hh
G4FinalStateProduct.hh
G4FinalStatePsCreationChampion.hh
G4FluoData.hh
G4FluoTransition.hh
G4Generator2BN.hh
G4Generator2BS.hh
G4hBetheBlochModel.hh
G4hICRU49He.hh
G4hICRU49Nuclear.hh
G4hICRU49p.hh
G4hIonEffChargeSquare.hh
G4hLowEnergyIonisation.hh
G4hLowEnergyLoss.hh
G4hLowEnergyLoss.icc
G4hNuclearStoppingModel.hh
G4hParametrisedLossModel.hh
G4hQAOModel.hh
G4hShellCrossSectionDoubleExpData.hh
G4hShellCrossSectionDoubleExp.hh
G4hShellCrossSectionExpData.hh
G4hShellCrossSectionExp.hh
G4hShellCrossSection.hh
G4hSRIM2000p.hh
G4hZiegler1977He.hh
G4hZiegler1977Nuclear.hh
G4hZiegler1977p.hh
G4hZiegler1985Nuclear.hh
G4hZiegler1985p.hh
G4IonChuFluctuationModel.hh
G4IonDEDXHandler.hh
G4IonDEDXScalingICRU73.hh
G4ionLowEnergyIonisation.hh
G4IonParametrisedLossModel.hh
G4IonParametrisedLossModel.icc
G4IonYangFluctuationModel.hh
G4LinInterpolation.hh
G4LinLogInterpolation.hh
G4LinLogLogInterpolation.hh
G4LivermoreBremsstrahlungModel.hh
G4LivermoreComptonModel.hh
G4LivermoreGammaConversionModel.hh
G4LivermoreGammaConversionModelRC.hh
G4LivermoreIonisationModel.hh
G4LivermoreNuclearGammaConversionModel.hh
G4LivermorePhotoElectricModel.hh
G4LivermorePolarizedComptonModel.hh
G4LivermorePolarizedGammaConversionModel.hh
G4LivermorePolarizedPhotoElectricModel.hh
G4LivermorePolarizedRayleighModel.hh
G4LivermoreRayleighModel.hh
G4LogLogInterpolation.hh
G4LowEnergyBremsstrahlung.hh
G4LowEnergyCompton.hh
G4LowEnergyGammaConversion.hh
G4LowEnergyIonisation.hh
G4LowEnergyPhotoElectric.hh
G4LowEnergyPolarizedCompton.hh
G4LowEnergyPolarizedRayleigh.hh
G4LowEnergyRayleigh.hh
G4OrlicLiCrossSection.hh
G4PaulKCrossSection.hh
G4Penelope08ComptonModel.hh
G4Penelope08GammaConversionModel.hh
G4Penelope08IonisationModel.hh
G4Penelope08PhotoElectricModel.hh
G4Penelope08RayleighModel.hh
G4PenelopeAnnihilation.hh
G4PenelopeAnnihilationModel.hh
G4PenelopeBremsstrahlungAngular.hh
G4PenelopeBremsstrahlungContinuous.hh
G4PenelopeBremsstrahlung.hh
G4PenelopeBremsstrahlungModel.hh
G4PenelopeCompton.hh
G4PenelopeComptonModel.hh
G4PenelopeCrossSectionHandler.hh
G4PenelopeCrossSection.hh
G4PenelopeGammaConversion.hh
G4PenelopeGammaConversionModel.hh
G4PenelopeIntegrator.hh
G4PenelopeIntegrator.icc
G4PenelopeInterpolator.hh
G4PenelopeIonisation.hh
G4PenelopeIonisationModel.hh
G4PenelopeOscillator.hh
G4PenelopeOscillatorManager.hh
G4PenelopePhotoElectric.hh
G4PenelopePhotoElectricModel.hh
G4PenelopeRayleigh.hh
G4PenelopeRayleighModel.hh
G4PenelopeSamplingData.hh
G4PhotoElectricAngularGeneratorPolarized.hh
G4PhotoElectricAngularGeneratorSauterGavrila.hh
G4PhotoElectricAngularGeneratorSimple.hh
G4QAOLowEnergyLoss.hh
G4RangeNoTest.hh
G4RangeTest.hh
G4RayleighScattering.hh
G4SemiLogInterpolation.hh
G4ShellData.hh
G4ShellEMDataSet.hh
G4ShellVacancy.hh
G4teoCrossSection.hh
G4UAtomicDeexcitation.hh
G4VCrossSectionHandler.hh
G4VDataSetAlgorithm.hh
G4VecpssrKModel.hh
G4VecpssrLiModel.hh
G4VeLowEnergyLoss.hh
G4VEMDataSet.hh
G4VEnergySpectrum.hh
G4VhElectronicStoppingPower.hh
G4VhEnergyLossModel.hh
G4VhNuclearStoppingPower.hh
G4VhShellCrossSection.hh
G4VIonDEDXScalingAlgorithm.hh
G4VLowEnergyDiscretePhotonProcess.hh
G4VLowEnergyModel.hh
G4VLowEnergyTestableDiscreteProcess.hh
G4VPhotoElectricAngularDistribution.hh
G4VRangeTest.hh
G4WaterExcitationStructure.hh
G4WaterIonisationStructure.hh
SOURCES
G4AnalyticalEcpssrKCrossSection.cc
G4AnalyticalEcpssrLiCrossSection.cc
G4AtomicDeexcitation.cc
G4AtomicTransitionManager.cc
G4AugerData.cc
G4AugerTransition.cc
G4BoldyshevTripletModel.cc
G4BremsstrahlungCrossSectionHandler.cc
G4BremsstrahlungParameters.cc
G4CompositeEMDataSet.cc
G4CrossSectionChargeDecrease.cc
G4CrossSectionChargeDecreasePartial.cc
G4CrossSectionChargeIncrease.cc
G4CrossSectionChargeIncreasePartial.cc
G4CrossSectionChargeTransferCH.cc
G4CrossSectionChargeTransferExp.cc
G4CrossSectionElasticChampion.cc
G4CrossSectionElasticScreenedRutherford.cc
G4CrossSectionElasticScreenedRutherfordHE.cc
G4CrossSectionElasticScreenedRutherfordLE.cc
G4CrossSectionExcitationBorn.cc
G4CrossSectionExcitationBornPartial.cc
G4CrossSectionExcitationEmfietzoglou.cc
G4CrossSectionExcitationEmfietzoglouPartial.cc
G4CrossSectionExcitationMillerGreen.cc
G4CrossSectionExcitationMillerGreenPartial.cc
G4CrossSectionHandler.cc
G4CrossSectionIonisationBorn.cc
G4CrossSectionIonisationBornElectron.cc
G4CrossSectionIonisationBornPartial.cc
G4CrossSectionIonisationBornPartialElectron.cc
G4CrossSectionIonisationRudd.cc
G4CrossSectionIonisationRuddPartial.cc
G4CrossSectionKill.cc
G4CrossSectionPsCreationChampion.cc
G4CrossSectionPsCreationChampionPartial.cc
G4DNAAttachment.cc
G4DNABornExcitationModel.cc
G4DNABornIonisationModel.cc
G4DNAChampionElasticModel.cc
G4DNAChargeDecrease.cc
G4DNAChargeIncrease.cc
G4DNACrossSectionDataSet.cc
G4DNADingfelderChargeDecreaseModel.cc
G4DNADingfelderChargeIncreaseModel.cc
G4DNAElastic.cc
G4DNAEmfietzoglouExcitationModel.cc
G4DNAExcitation.cc
G4DNAGenericIonsManager.cc
G4DNAIonisation.cc
G4DNAMeltonAttachmentModel.cc
G4DNAMillerGreenExcitationModel.cc
G4DNARuddIonisationExtendedModel.cc
G4DNARuddIonisationModel.cc
G4DNASancheExcitationModel.cc
G4DNAScreenedRutherfordElasticModel.cc
G4DNAVibExcitation.cc
G4DopplerProfile.cc
G4DummyFinalState.cc
G4eBremsstrahlungSpectrum.cc
G4eCrossSectionExcitationEmfietzoglou.cc
G4eCrossSectionScreenedRutherford.cc
G4eIonisationCrossSectionHandler.cc
G4eIonisationParameters.cc
G4eIonisationSpectrum.cc
G4eLowEnergyLoss.cc
G4EMDataSet.cc
G4empCrossSection.cc
G4FinalStateChargeDecrease.cc
G4FinalStateChargeIncrease.cc
G4FinalStateChargeTransferProton.cc
G4FinalStateElasticBrennerZaider.cc
G4FinalStateElasticChampion.cc
G4FinalStateElasticScreenedRutherford.cc
G4FinalStateExcitationBorn.cc
G4FinalStateExcitationEmfietzoglou.cc
G4FinalStateExcitationMillerGreen.cc
G4FinalStateIonisationBorn.cc
G4FinalStateIonisationRudd.cc
G4FinalStateKill.cc
G4FinalStateProduct.cc
G4FinalStatePsCreationChampion.cc
G4FluoData.cc
G4FluoTransition.cc
G4Generator2BN.cc
G4Generator2BS.cc
G4hBetheBlochModel.cc
G4hICRU49He.cc
G4hICRU49Nuclear.cc
G4hICRU49p.cc
G4hIonEffChargeSquare.cc
G4hLowEnergyIonisation.cc
G4hLowEnergyLoss.cc
G4hNuclearStoppingModel.cc
G4hParametrisedLossModel.cc
G4hQAOModel.cc
G4hShellCrossSection.cc
G4hShellCrossSectionDoubleExp.cc
G4hShellCrossSectionDoubleExpData.cc
G4hShellCrossSectionExp.cc
G4hShellCrossSectionExpData.cc
G4hSRIM2000p.cc
G4hZiegler1977He.cc
G4hZiegler1977Nuclear.cc
G4hZiegler1977p.cc
G4hZiegler1985Nuclear.cc
G4hZiegler1985p.cc
G4IonChuFluctuationModel.cc
G4IonDEDXHandler.cc
G4IonDEDXScalingICRU73.cc
G4IonParametrisedLossModel.cc
G4IonYangFluctuationModel.cc
G4LinInterpolation.cc
G4LinLogInterpolation.cc
G4LinLogLogInterpolation.cc
G4LivermoreBremsstrahlungModel.cc
G4LivermoreComptonModel.cc
G4LivermoreGammaConversionModel.cc
G4LivermoreGammaConversionModelRC.cc
G4LivermoreIonisationModel.cc
G4LivermoreNuclearGammaConversionModel.cc
G4LivermorePhotoElectricModel.cc
G4LivermorePolarizedComptonModel.cc
G4LivermorePolarizedGammaConversionModel.cc
G4LivermorePolarizedPhotoElectricModel.cc
G4LivermorePolarizedRayleighModel.cc
G4LivermoreRayleighModel.cc
G4LogLogInterpolation.cc
G4LowEnergyBremsstrahlung.cc
G4LowEnergyCompton.cc
G4LowEnergyGammaConversion.cc
G4LowEnergyIonisation.cc
G4LowEnergyPhotoElectric.cc
G4LowEnergyPolarizedCompton.cc
G4LowEnergyPolarizedRayleigh.cc
G4LowEnergyRayleigh.cc
G4OrlicLiCrossSection.cc
G4PaulKCrossSection.cc
G4Penelope08ComptonModel.cc
G4Penelope08GammaConversionModel.cc
G4Penelope08IonisationModel.cc
G4Penelope08PhotoElectricModel.cc
G4Penelope08RayleighModel.cc
G4PenelopeAnnihilation.cc
G4PenelopeAnnihilationModel.cc
G4PenelopeBremsstrahlungAngular.cc
G4PenelopeBremsstrahlung.cc
G4PenelopeBremsstrahlungContinuous.cc
G4PenelopeBremsstrahlungModel.cc
G4PenelopeCompton.cc
G4PenelopeComptonModel.cc
G4PenelopeCrossSection.cc
G4PenelopeCrossSectionHandler.cc
G4PenelopeGammaConversion.cc
G4PenelopeGammaConversionModel.cc
G4PenelopeInterpolator.cc
G4PenelopeIonisation.cc
G4PenelopeIonisationModel.cc
G4PenelopeOscillator.cc
G4PenelopeOscillatorManager.cc
G4PenelopePhotoElectric.cc
G4PenelopePhotoElectricModel.cc
G4PenelopeRayleigh.cc
G4PenelopeRayleighModel.cc
G4PenelopeSamplingData.cc
G4PhotoElectricAngularGeneratorPolarized.cc
G4PhotoElectricAngularGeneratorSauterGavrila.cc
G4PhotoElectricAngularGeneratorSimple.cc
G4QAOLowEnergyLoss.cc
G4RangeTest.cc
G4RayleighScattering.cc
G4SemiLogInterpolation.cc
G4ShellData.cc
G4ShellEMDataSet.cc
G4ShellVacancy.cc
G4teoCrossSection.cc
G4UAtomicDeexcitation.cc
G4VCrossSectionHandler.cc
G4VecpssrKModel.cc
G4VecpssrLiModel.cc
G4VeLowEnergyLoss.cc
G4VhElectronicStoppingPower.cc
G4VhNuclearStoppingPower.cc
G4VhShellCrossSection.cc
G4VIonDEDXScalingAlgorithm.cc
G4VLowEnergyDiscretePhotonProcess.cc
G4VLowEnergyModel.cc
G4VPhotoElectricAngularDistribution.cc
G4WaterExcitationStructure.cc
G4WaterIonisationStructure.cc
GRANULAR_DEPENDENCIES
G4baryons
G4bosons
G4cuts
G4emstandard
G4emutils
G4geometrymng
G4globman
G4hepnumerics
G4intercoms
G4ions
G4leptons
G4materials
G4mesons
G4partman
G4procman
G4track
GLOBAL_DEPENDENCIES
G4geometry
G4global
G4intercoms
G4materials
G4particles
G4track
LINK_LIBRARIES
)
# List any source specific properties here
source/processes/electromagnetic/lowenergy/src/G4AnalyticalEcpssrKCrossSection.cc
Executable
+644
View File
@@ -0,0 +1,644 @@
//
// ********************************************************************
// * 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: G4AnalyticalEcpssrKCrossSection.cc,v 1.5 2010/12/15 07:39:10 gunter Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#include "globals.hh"
#include "G4AnalyticalEcpssrKCrossSection.hh"
#include "G4AtomicTransitionManager.hh"
#include "G4NistManager.hh"
#include "G4Proton.hh"
#include "G4Alpha.hh"
#include <math.h>
#include <iostream>
#include "G4SemiLogInterpolation.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4AnalyticalEcpssrKCrossSection::G4AnalyticalEcpssrKCrossSection()
{
// Storing FK data needed for medium velocities region
char *path = getenv("G4LEDATA");
if (!path)
G4Exception("G4AnalyticalEcpssrKCrossSection::G4AnalyticalEcpssrKCrossSection() G4LEDATA environment variable not set");
std::ostringstream fileName;
fileName << path << "/pixe/uf/FK.dat";
std::ifstream FK(fileName.str().c_str());
if (!FK) G4Exception("G4AnalyticalEcpssrKCrossSection::G4AnalyticalEcpssrKCrossSection() error opening FK data file");
dummyVec.push_back(0.);
while(!FK.eof())
{
double x;
double y;
FK>>x>>y;
// Mandatory vector initialization
if (x != dummyVec.back())
{
dummyVec.push_back(x);
aVecMap[x].push_back(-1.);
}
FK>>FKData[x][y];
if (y != aVecMap[x].back()) aVecMap[x].push_back(y);
}
// Storing C coefficients for high velocity formula
G4String fileC1("pixe/uf/c1");
tableC1 = new G4DNACrossSectionDataSet(new G4SemiLogInterpolation, 1.,1.);
tableC1->LoadData(fileC1);
G4String fileC2("pixe/uf/c2");
tableC2 = new G4DNACrossSectionDataSet(new G4SemiLogInterpolation, 1.,1.);
tableC2->LoadData(fileC2);
G4String fileC3("pixe/uf/c3");
tableC3 = new G4DNACrossSectionDataSet(new G4SemiLogInterpolation, 1.,1.);
tableC3->LoadData(fileC3);
//
verboseLevel=0;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void print (G4double elem)
{
G4cout << elem << " ";
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4AnalyticalEcpssrKCrossSection::~G4AnalyticalEcpssrKCrossSection()
{
delete tableC1;
delete tableC2;
delete tableC3;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4AnalyticalEcpssrKCrossSection::ExpIntFunction(G4int n,G4double x)
{
// this "ExpIntFunction" function allows fast evaluation of the n order exponential integral function En(x)
G4int i;
G4int ii;
G4int nm1;
G4double a;
G4double b;
G4double c;
G4double d;
G4double del;
G4double fact;
G4double h;
G4double psi;
G4double ans = 0;
const G4double euler= 0.5772156649;
const G4int maxit= 100;
const G4double fpmin = 1.0e-30;
const G4double eps = 1.0e-7;
nm1=n-1;
if (n<0 || x<0.0 || (x==0.0 && (n==0 || n==1))) {
G4cout << "G4AnalyticalEcpssrKCrossSection::ExpIntFunction: VERY Bad arguments in ExpIntFunction" << G4endl;
G4cout << n << ", " << x << G4endl;
}
else {
if (n==0) ans=std::exp(-x)/x;
else {
if (x==0.0) ans=1.0/nm1;
else {
if (x > 1.0) {
b=x+n;
c=1.0/fpmin;
d=1.0/b;
h=d;
for (i=1;i<=maxit;i++) {
a=-i*(nm1+i);
b +=2.0;
d=1.0/(a*d+b);
c=b+a/c;
del=c*d;
h *=del;
if (std::fabs(del-1.0) < eps) {
ans=h*std::exp(-x);
return ans;
}
}
} else {
ans = (nm1!=0 ? 1.0/nm1 : -std::log(x)-euler);
fact=1.0;
for (i=1;i<=maxit;i++) {
fact *=-x/i;
if (i !=nm1) del = -fact/(i-nm1);
else {
psi = -euler;
for (ii=1;ii<=nm1;ii++) psi +=1.0/ii;
del=fact*(-std::log(x)+psi);
}
ans += del;
if (std::fabs(del) < std::fabs(ans)*eps) return ans;
}
}
}
}
}
return ans;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4AnalyticalEcpssrKCrossSection::CalculateCrossSection(G4int zTarget,G4double massIncident, G4double energyIncident)
{
// this K-CrossSection calculation method is done according to W.Brandt and G.Lapicki, Phys.Rev.A23(1981)//
G4NistManager* massManager = G4NistManager::Instance();
G4AtomicTransitionManager* transitionManager = G4AtomicTransitionManager::Instance();
G4double zIncident = 0;
G4Proton* aProtone = G4Proton::Proton();
G4Alpha* aAlpha = G4Alpha::Alpha();
if (massIncident == aProtone->GetPDGMass() )
{
zIncident = (aProtone->GetPDGCharge())/eplus;
}
else
{
if (massIncident == aAlpha->GetPDGMass())
{
zIncident = (aAlpha->GetPDGCharge())/eplus;
}
else
{
G4cout << "*** WARNING in G4AnalyticalEcpssrKCrossSection::CalculateCrossSection : we can treat only Proton or Alpha incident particles " << G4endl;
return 0;
}
}
if (verboseLevel>0) G4cout << " massIncident=" << massIncident<< G4endl;
G4double kBindingEnergy = transitionManager->Shell(zTarget,0)->BindingEnergy();
if (verboseLevel>0) G4cout << " kBindingEnergy=" << kBindingEnergy/eV<< G4endl;
G4double massTarget = (massManager->GetAtomicMassAmu(zTarget))*amu_c2;
if (verboseLevel>0) G4cout << " massTarget=" << massTarget<< G4endl;
G4double systemMass =((massIncident*massTarget)/(massIncident+massTarget))/electron_mass_c2; //the mass of the system (projectile, target)
if (verboseLevel>0) G4cout << " systemMass=" << systemMass<< G4endl;
const G4double zkshell= 0.3;
G4double screenedzTarget = zTarget-zkshell; // screenedzTarget is the screened nuclear charge of the target
const G4double rydbergMeV= 13.6056923e-6;
G4double tetaK = kBindingEnergy/((screenedzTarget*screenedzTarget)*rydbergMeV); //tetaK denotes the reduced binding energy of the electron
if (verboseLevel>0) G4cout << " tetaK=" << tetaK<< G4endl;
G4double velocity =(2./(tetaK*screenedzTarget))*std::pow(((energyIncident*electron_mass_c2)/(massIncident*rydbergMeV)),0.5);
if (verboseLevel>0) G4cout << " velocity=" << velocity<< G4endl;
const G4double bohrPow2Barn=(Bohr_radius*Bohr_radius)/barn ;
if (verboseLevel>0) G4cout << " bohrPow2Barn=" << bohrPow2Barn<< G4endl;
G4double sigma0 = 8.*pi*(zIncident*zIncident)*bohrPow2Barn*std::pow(screenedzTarget,-4.); //sigma0 is the initial cross section of K shell at stable state
if (verboseLevel>0) G4cout << " sigma0=" << sigma0<< G4endl;
const G4double kAnalyticalApproximation= 1.5;
G4double x = kAnalyticalApproximation/velocity;
if (verboseLevel>0) G4cout << " x=" << x<< G4endl;
G4double electrIonizationEnergy;
if ((0.< x) && (x <= 0.035))
{
electrIonizationEnergy= 0.75*pi*(std::log(1./(x*x))-1.);
}
else
{
if ( (0.035 < x) && (x <=3.))
{
electrIonizationEnergy =std::exp(-2.*x)/(0.031+(0.213*std::pow(x,0.5))+(0.005*x)-(0.069*std::pow(x,3./2.))+(0.324*x*x));
}
else
{
if ( (3.< x) && (x<=11.))
{
electrIonizationEnergy =2.*std::exp(-2.*x)/std::pow(x,1.6);
}
else electrIonizationEnergy =0.;
}
}
if (verboseLevel>0) G4cout << " electrIonizationEnergy=" << electrIonizationEnergy<< G4endl;
G4double hFunction =(electrIonizationEnergy*2.)/(tetaK*std::pow(velocity,3)); //hFunction represents the correction for polarization effet
if (verboseLevel>0) G4cout << " hFunction=" << hFunction<< G4endl;
G4double gFunction = (1.+(9.*velocity)+(31.*velocity*velocity)+(98.*std::pow(velocity,3.))+(12.*std::pow(velocity,4.))+(25.*std::pow(velocity,5.))
+(4.2*std::pow(velocity,6.))+(0.515*std::pow(velocity,7.)))/std::pow(1.+velocity,9.); //gFunction represents the correction for binding effet
if (verboseLevel>0) G4cout << " gFunction=" << gFunction<< G4endl;
//-----------------------------------------------------------------------------------------------------------------------------
G4double sigmaPSS = 1.+(((2.*zIncident)/(screenedzTarget*tetaK))*(gFunction-hFunction)); //describes the perturbed stationnairy state of the affected atomic electon
if (verboseLevel>0) G4cout << " sigmaPSS=" << sigmaPSS<< G4endl;
if (verboseLevel>0) G4cout << " sigmaPSS*tetaK=" << sigmaPSS*tetaK<< G4endl;
//----------------------------------------------------------------------------------------------------------------------------
const G4double cNaturalUnit= 1/fine_structure_const; // it's the speed of light according to Atomic-Unit-System
if (verboseLevel>0) G4cout << " cNaturalUnit=" << cNaturalUnit<< G4endl;
G4double ykFormula=0.4*(screenedzTarget/cNaturalUnit)*(screenedzTarget/cNaturalUnit)/(velocity/sigmaPSS);
if (verboseLevel>0) G4cout << " ykFormula=" << ykFormula<< G4endl;
G4double relativityCorrection = std::pow((1.+(1.1*ykFormula*ykFormula)),0.5)+ykFormula;// the relativistic correction parameter
if (verboseLevel>0) G4cout << " relativityCorrection=" << relativityCorrection<< G4endl;
G4double reducedVelocity = velocity*std::pow(relativityCorrection,0.5); // presents the reduced collision velocity parameter
if (verboseLevel>0) G4cout << " reducedVelocity=" << reducedVelocity<< G4endl;
G4double etaOverTheta2 = (energyIncident*electron_mass_c2)/(massIncident*rydbergMeV*screenedzTarget*screenedzTarget)
/(sigmaPSS*tetaK)/(sigmaPSS*tetaK);
if (verboseLevel>0) G4cout << " etaOverTheta2=" << etaOverTheta2<< G4endl;
G4double universalFunction = 0;
// low velocity formula
if ( velocity < 1. )
{
if (verboseLevel>0) G4cout << " Notice : FK is computed from low velocity formula" << G4endl;
universalFunction = (std::pow(2.,9.)/45.)*std::pow(reducedVelocity/sigmaPSS,8.)*std::pow((1.+(1.72*(reducedVelocity/sigmaPSS)*(reducedVelocity/sigmaPSS))),-4.);// is the reduced universal cross section
if (verboseLevel>0) G4cout << " universalFunction by Brandt 1981 =" << universalFunction<< G4endl;
}
else
{
if ( etaOverTheta2 > 86.6 && (sigmaPSS*tetaK) > 0.4 && (sigmaPSS*tetaK) < 2.9996 )
{
// High and medium energies. Method from Rice 1977 on tabvles from Benka 1978
if (verboseLevel>0) G4cout << " Notice : FK is computed from high velocity formula" << G4endl;
if (verboseLevel>0) G4cout << " sigmaPSS*tetaK=" << sigmaPSS*tetaK << G4endl;
G4double C1= tableC1->FindValue(sigmaPSS*tetaK);
G4double C2= tableC2->FindValue(sigmaPSS*tetaK);
G4double C3= tableC3->FindValue(sigmaPSS*tetaK);
if (verboseLevel>0) G4cout << " C1=" << C1 << G4endl;
if (verboseLevel>0) G4cout << " C2=" << C2 << G4endl;
if (verboseLevel>0) G4cout << " C3=" << C3 << G4endl;
G4double etaK = (energyIncident*electron_mass_c2)/(massIncident*rydbergMeV*screenedzTarget*screenedzTarget);
if (verboseLevel>0) G4cout << " etaK=" << etaK << G4endl;
G4double etaT = (sigmaPSS*tetaK)*(sigmaPSS*tetaK)*(86.6); // at any theta, the largest tabulated etaOverTheta2 is 86.6
if (verboseLevel>0) G4cout << " etaT=" << etaT << G4endl;
G4double fKT = FunctionFK((sigmaPSS*tetaK),86.6)*(etaT/(sigmaPSS*tetaK));
if (FunctionFK((sigmaPSS*tetaK),86.6)<=0.)
{
G4cout <<
"*** WARNING in G4AnalyticalEcpssrKCrossSection::CalculateCrossSection : unable to interpolate FK function in high velocity region ! ***" << G4endl;
return 0;
}
if (verboseLevel>0) G4cout << " FunctionFK=" << FunctionFK((sigmaPSS*tetaK),86.6) << G4endl;
if (verboseLevel>0) G4cout << " fKT=" << fKT << G4endl;
G4double GK = C2/(4*etaK) + C3/(32*etaK*etaK);
if (verboseLevel>0) G4cout << " GK=" << GK << G4endl;
G4double GT = C2/(4*etaT) + C3/(32*etaT*etaT);
if (verboseLevel>0) G4cout << " GT=" << GT << G4endl;
G4double DT = fKT - C1*std::log(etaT) + GT;
if (verboseLevel>0) G4cout << " DT=" << DT << G4endl;
G4double fKK = C1*std::log(etaK) + DT - GK;
if (verboseLevel>0) G4cout << " fKK=" << fKK << G4endl;
G4double universalFunction3= fKK/(etaK/tetaK);
if (verboseLevel>0) G4cout << " universalFunction3=" << universalFunction3 << G4endl;
universalFunction=universalFunction3;
}
else if ( etaOverTheta2 >= 1.e-3 && etaOverTheta2 <= 86.6 && (sigmaPSS*tetaK) >= 0.4 && (sigmaPSS*tetaK) <= 2.9996 )
{
// From Benka 1978
if (verboseLevel>0) G4cout << " Notice : FK is computed from INTERPOLATED data" << G4endl;
G4double universalFunction2 = FunctionFK((sigmaPSS*tetaK),etaOverTheta2);
if (universalFunction2<=0)
{
G4cout <<
"*** WARNING : G4AnalyticalEcpssrKCrossSection::CalculateCrossSection is unable to interpolate FK function in medium velocity region ! ***" << G4endl;
return 0;
}
if (verboseLevel>0) G4cout << " universalFunction2=" << universalFunction2 << " for theta=" << sigmaPSS*tetaK << " and etaOverTheta2=" << etaOverTheta2 << G4endl;
universalFunction=universalFunction2;
}
}
//----------------------------------------------------------------------------------------------------------------------
G4double sigmaPSSR = (sigma0/(sigmaPSS*tetaK))*universalFunction; //sigmaPSSR is the straight-line K-shell ionization cross section
if (verboseLevel>0) G4cout << " sigmaPSSR=" << sigmaPSSR<< G4endl;
//-----------------------------------------------------------------------------------------------------------------------
G4double pssDeltaK = (4./(systemMass*sigmaPSS*tetaK))*(sigmaPSS/velocity)*(sigmaPSS/velocity);
if (verboseLevel>0) G4cout << " pssDeltaK=" << pssDeltaK<< G4endl;
G4double energyLoss = std::pow(1-pssDeltaK,0.5); //energyLoss incorporates the straight-line energy-loss
if (verboseLevel>0) G4cout << " energyLoss=" << energyLoss<< G4endl;
G4double energyLossFunction = (std::pow(2.,-9)/8.)*((((9.*energyLoss)-1.)*std::pow(1.+energyLoss,9.))+(((9.*energyLoss)+1.)*std::pow(1.-energyLoss,9.)));//energy loss function
if (verboseLevel>0) G4cout << " energyLossFunction=" << energyLossFunction<< G4endl;
//----------------------------------------------------------------------------------------------------------------------------------------------
G4double coulombDeflection = (4.*pi*zIncident/systemMass)*std::pow(tetaK*sigmaPSS,-2.)*std::pow(velocity/sigmaPSS,-3.)*(zTarget/screenedzTarget); //incorporates Coulomb deflection parameter
if (verboseLevel>0) G4cout << " cParameter-short=" << coulombDeflection<< G4endl;
G4double cParameter = 2.*coulombDeflection/(energyLoss*(energyLoss+1.));
if (verboseLevel>0) G4cout << " cParameter-full=" << cParameter<< G4endl;
G4double coulombDeflectionFunction = 9.*ExpIntFunction(10,cParameter); //this function describes Coulomb-deflection effect
if (verboseLevel>0) G4cout << " ExpIntFunction(10,cParameter) =" << ExpIntFunction(10,cParameter) << G4endl;
if (verboseLevel>0) G4cout << " coulombDeflectionFunction =" << coulombDeflectionFunction << G4endl;
//--------------------------------------------------------------------------------------------------------------------------------------------------
G4double crossSection = 0;
crossSection = energyLossFunction* coulombDeflectionFunction*sigmaPSSR; //this ECPSSR cross section is estimated at perturbed-stationnairy-state(PSS)
//and it's reduced by the energy-loss(E),the Coulomb deflection(C),
//and the relativity(R) effects
//--------------------------------------------------------------------------------------------------------------------------------------------------
if (crossSection >= 0) {
return crossSection * barn;
}
else {return 0;}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4AnalyticalEcpssrKCrossSection::FunctionFK(G4double k, G4double theta)
{
G4double sigma = 0.;
G4double valueT1 = 0;
G4double valueT2 = 0;
G4double valueE21 = 0;
G4double valueE22 = 0;
G4double valueE12 = 0;
G4double valueE11 = 0;
G4double xs11 = 0;
G4double xs12 = 0;
G4double xs21 = 0;
G4double xs22 = 0;
// PROTECTION TO ALLOW INTERPOLATION AT MINIMUM AND MAXIMUM EtaK/Theta2 values
// (in particular for FK computation at 8.66EXX for high velocity formula)
if (
theta==8.66e-3 ||
theta==8.66e-2 ||
theta==8.66e-1 ||
theta==8.66e+0 ||
theta==8.66e+1
) theta=theta-1e-12;
if (
theta==1.e-3 ||
theta==1.e-2 ||
theta==1.e-1 ||
theta==1.e+00 ||
theta==1.e+01
) theta=theta+1e-12;
// END PROTECTION
std::vector<double>::iterator t2 = std::upper_bound(dummyVec.begin(),dummyVec.end(), k);
std::vector<double>::iterator t1 = t2-1;
std::vector<double>::iterator e12 = std::upper_bound(aVecMap[(*t1)].begin(),aVecMap[(*t1)].end(), theta);
std::vector<double>::iterator e11 = e12-1;
std::vector<double>::iterator e22 = std::upper_bound(aVecMap[(*t2)].begin(),aVecMap[(*t2)].end(), theta);
std::vector<double>::iterator e21 = e22-1;
valueT1 =*t1;
valueT2 =*t2;
valueE21 =*e21;
valueE22 =*e22;
valueE12 =*e12;
valueE11 =*e11;
xs11 = FKData[valueT1][valueE11];
xs12 = FKData[valueT1][valueE12];
xs21 = FKData[valueT2][valueE21];
xs22 = FKData[valueT2][valueE22];
/*
if (verboseLevel>0)
{
G4cout << "x1= " << valueT1 << G4endl;
G4cout << " vector of y for x1" << G4endl;
std::for_each (aVecMap[(*t1)].begin(),aVecMap[(*t1)].end(), print);
G4cout << G4endl;
G4cout << "x2= " << valueT2 << G4endl;
G4cout << " vector of y for x2" << G4endl;
std::for_each (aVecMap[(*t2)].begin(),aVecMap[(*t2)].end(), print);
G4cout << G4endl;
G4cout
<< " "
<< valueT1 << " "
<< valueT2 << " "
<< valueE11 << " "
<< valueE12 << " "
<< valueE21<< " "
<< valueE22 << " "
<< xs11 << " "
<< xs12 << " "
<< xs21 << " "
<< xs22 << " "
<< G4endl;
}
*/
G4double xsProduct = xs11 * xs12 * xs21 * xs22;
if (xs11==0 || xs12==0 ||xs21==0 ||xs22==0) return (0.);
if (xsProduct != 0.)
{
sigma = QuadInterpolator( valueE11, valueE12,
valueE21, valueE22,
xs11, xs12,
xs21, xs22,
valueT1, valueT2,
k, theta );
}
return sigma;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4AnalyticalEcpssrKCrossSection::LinLogInterpolate(G4double e1,
G4double e2,
G4double e,
G4double xs1,
G4double xs2)
{
G4double d1 = std::log(xs1);
G4double d2 = std::log(xs2);
G4double value = std::exp(d1 + (d2 - d1)*(e - e1)/ (e2 - e1));
return value;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4AnalyticalEcpssrKCrossSection::LogLogInterpolate(G4double e1,
G4double e2,
G4double e,
G4double xs1,
G4double xs2)
{
G4double a = (std::log10(xs2)-std::log10(xs1)) / (std::log10(e2)-std::log10(e1));
G4double b = std::log10(xs2) - a*std::log10(e2);
G4double sigma = a*std::log10(e) + b;
G4double value = (std::pow(10.,sigma));
return value;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4AnalyticalEcpssrKCrossSection::QuadInterpolator(G4double e11, G4double e12,
G4double e21, G4double e22,
G4double xs11, G4double xs12,
G4double xs21, G4double xs22,
G4double t1, G4double t2,
G4double t, G4double e)
{
// Log-Log
G4double interpolatedvalue1 = LogLogInterpolate(e11, e12, e, xs11, xs12);
G4double interpolatedvalue2 = LogLogInterpolate(e21, e22, e, xs21, xs22);
G4double value = LogLogInterpolate(t1, t2, t, interpolatedvalue1, interpolatedvalue2);
/*
// Lin-Log
G4double interpolatedvalue1 = LinLogInterpolate(e11, e12, e, xs11, xs12);
G4double interpolatedvalue2 = LinLogInterpolate(e21, e22, e, xs21, xs22);
G4double value = LinLogInterpolate(t1, t2, t, interpolatedvalue1, interpolatedvalue2);
*/
return value;
}
source/processes/electromagnetic/lowenergy/src/G4AnalyticalEcpssrLiCrossSection.cc
Executable
+983
View File
@@ -0,0 +1,983 @@
//
// ********************************************************************
// * 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: G4AnalyticalEcpssrLiCrossSection.cc,v 1.4 2010/11/22 17:25:45 mantero Exp $
// GEANT4 tag $Name: geant4-09-04 $
#include "globals.hh"
#include "G4AnalyticalEcpssrLiCrossSection.hh"
#include "G4AtomicTransitionManager.hh"
#include "G4NistManager.hh"
#include "G4Proton.hh"
#include "G4Alpha.hh"
#include <math.h>
#include <iostream>
#include "G4LinLogInterpolation.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4AnalyticalEcpssrLiCrossSection::G4AnalyticalEcpssrLiCrossSection()
{
// Storing FLi data needed for 0.2 to 3.0 velocities region
char *path = getenv("G4LEDATA");
if (!path)
G4Exception("G4ecpssrLCrossSection::G4AnalyticalEcpssrLiCrossSection() G4LEDDATA environment variable not set");
std::ostringstream fileName1;
std::ostringstream fileName2;
fileName1 << path << "/pixe/uf/FL1.dat";
fileName2 << path << "/pixe/uf/FL2.dat";
// Reading of FL1.dat
std::ifstream FL1(fileName1.str().c_str());
if (!FL1) G4Exception("G4ecpssrLCrossSection::G4AnalyticalEcpssrLiCrossSection() error opening FL1 data file");
dummyVec1.push_back(0.);
while(!FL1.eof())
{
double x1;
double y1;
FL1>>x1>>y1;
// Mandatory vector initialization
if (x1 != dummyVec1.back())
{
dummyVec1.push_back(x1);
aVecMap1[x1].push_back(-1.);
}
FL1>>FL1Data[x1][y1];
if (y1 != aVecMap1[x1].back()) aVecMap1[x1].push_back(y1);
}
// Reading of FL2.dat
std::ifstream FL2(fileName2.str().c_str());
if (!FL2) G4Exception("G4ecpssrLCrossSection::G4AnalyticalEcpssrLiCrossSection() error opening FL2 data file");
dummyVec2.push_back(0.);
while(!FL2.eof())
{
double x2;
double y2;
FL2>>x2>>y2;
// Mandatory vector initialization
if (x2 != dummyVec2.back())
{
dummyVec2.push_back(x2);
aVecMap2[x2].push_back(-1.);
}
FL2>>FL2Data[x2][y2];
if (y2 != aVecMap2[x2].back()) aVecMap2[x2].push_back(y2);
}
// Verbose level
verboseLevel=0;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4AnalyticalEcpssrLiCrossSection::~G4AnalyticalEcpssrLiCrossSection()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4AnalyticalEcpssrLiCrossSection::ExpIntFunction(G4int n,G4double x)
{
// this function allows fast evaluation of the n order exponential integral function En(x)
G4int i;
G4int ii;
G4int nm1;
G4double a;
G4double b;
G4double c;
G4double d;
G4double del;
G4double fact;
G4double h;
G4double psi;
G4double ans = 0;
const G4double euler= 0.5772156649;
const G4int maxit= 100;
const G4double fpmin = 1.0e-30;
const G4double eps = 1.0e-7;
nm1=n-1;
if (n<0 || x<0.0 || (x==0.0 && (n==0 || n==1)))
G4cout << "bad arguments in ExpIntFunction" << G4endl;
else {
if (n==0) ans=std::exp(-x)/x;
else {
if (x==0.0) ans=1.0/nm1;
else {
if (x > 1.0) {
b=x+n;
c=1.0/fpmin;
d=1.0/b;
h=d;
for (i=1;i<=maxit;i++) {
a=-i*(nm1+i);
b +=2.0;
d=1.0/(a*d+b);
c=b+a/c;
del=c*d;
h *=del;
if (std::fabs(del-1.0) < eps) {
ans=h*std::exp(-x);
return ans;
}
}
} else {
ans = (nm1!=0 ? 1.0/nm1 : -std::log(x)-euler);
fact=1.0;
for (i=1;i<=maxit;i++) {
fact *=-x/i;
if (i !=nm1) del = -fact/(i-nm1);
else {
psi = -euler;
for (ii=1;ii<=nm1;ii++) psi +=1.0/ii;
del=fact*(-std::log(x)+psi);
}
ans += del;
if (std::fabs(del) < std::fabs(ans)*eps) return ans;
}
}
}
}
}
return ans;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4AnalyticalEcpssrLiCrossSection::CalculateL1CrossSection(G4int zTarget,G4double massIncident, G4double energyIncident)
{
//this L1-CrossSection calculation method is done according to Werner Brandt and Grzegorz Lapicki, Phys.Rev.A20 N2 (1979),
//and using data tables of O. Benka et al. At.Data Nucl.Data Tables Vol.22 No.3 (1978).
G4NistManager* massManager = G4NistManager::Instance();
G4AtomicTransitionManager* transitionManager = G4AtomicTransitionManager::Instance();
G4double zIncident = 0;
G4Proton* aProtone = G4Proton::Proton();
G4Alpha* aAlpha = G4Alpha::Alpha();
if (massIncident == aProtone->GetPDGMass() )
zIncident = (aProtone->GetPDGCharge())/eplus;
else
{
if (massIncident == aAlpha->GetPDGMass())
zIncident = (aAlpha->GetPDGCharge())/eplus;
else
{
G4cout << "*** WARNING in G4AnalyticalEcpssrLiCrossSection::CalculateL1CrossSection : Proton or Alpha incident particles only. " << G4endl;
G4cout << massIncident << ", " << aAlpha->GetPDGMass() << " (alpha)" << aProtone->GetPDGMass() << " (proton)" << G4endl;
return 0;
}
}
G4double l1BindingEnergy = transitionManager->Shell(zTarget,1)->BindingEnergy(); //Observed binding energy of L1-subshell
G4double massTarget = (massManager->GetAtomicMassAmu(zTarget))*amu_c2;
G4double systemMass =((massIncident*massTarget)/(massIncident+massTarget))/electron_mass_c2; //Mass of the system (projectile, target)
const G4double zlshell= 4.15;
G4double screenedzTarget = zTarget-zlshell; //Effective nuclear charge as seen by electrons in L1-sub shell
const G4double rydbergMeV= 13.6056923e-6;
const G4double nl= 2.;
G4double tetal1 = (l1BindingEnergy*nl*nl)/((screenedzTarget*screenedzTarget)*rydbergMeV); //Screening parameter
if (verboseLevel>0) G4cout << " tetal1=" << tetal1<< G4endl;
G4double reducedEnergy = (energyIncident*electron_mass_c2)/(massIncident*rydbergMeV*screenedzTarget*screenedzTarget);
const G4double bohrPow2Barn=(Bohr_radius*Bohr_radius)/barn ; //Bohr radius of hydrogen
G4double sigma0 = 8.*pi*(zIncident*zIncident)*bohrPow2Barn*std::pow(screenedzTarget,-4.);
G4double velocityl1 = CalculateVelocity(1, zTarget, massIncident, energyIncident); // Scaled velocity
if (verboseLevel>0) G4cout << " velocityl1=" << velocityl1<< G4endl;
const G4double l1AnalyticalApproximation= 1.5;
G4double x1 =(nl*l1AnalyticalApproximation)/velocityl1;
if (verboseLevel>0) G4cout << " x1=" << x1<< G4endl;
G4double electrIonizationEnergyl1=0.;
if ( x1<=0.035) electrIonizationEnergyl1= 0.75*pi*(std::log(1./(x1*x1))-1.);
else
{
if ( x1<=3.)
electrIonizationEnergyl1 =std::exp(-2.*x1)/(0.031+(0.213*std::pow(x1,0.5))+(0.005*x1)-(0.069*std::pow(x1,3./2.))+(0.324*x1*x1));
else
{if ( x1<=11.) electrIonizationEnergyl1 =2.*std::exp(-2.*x1)/std::pow(x1,1.6);}
}
G4double hFunctionl1 =(electrIonizationEnergyl1*2.*nl)/(tetal1*std::pow(velocityl1,3)); //takes into account the polarization effect
if (verboseLevel>0) G4cout << " hFunctionl1=" << hFunctionl1<< G4endl;
G4double gFunctionl1 = (1.+(9.*velocityl1)+(31.*velocityl1*velocityl1)+(49.*std::pow(velocityl1,3.))+(162.*std::pow(velocityl1,4.))+(63.*std::pow(velocityl1,5.))+(18.*std::pow(velocityl1,6.))+(1.97*std::pow(velocityl1,7.)))/std::pow(1.+velocityl1,9.);//takes into account the reduced binding effect
if (verboseLevel>0) G4cout << " gFunctionl1=" << gFunctionl1<< G4endl;
G4double sigmaPSS_l1 = 1.+(((2.*zIncident)/(screenedzTarget*tetal1))*(gFunctionl1-hFunctionl1)); //Binding-polarization factor
if (verboseLevel>0) G4cout << "sigmaPSS_l1 =" << sigmaPSS_l1<< G4endl;
const G4double cNaturalUnit= 137.;
G4double yl1Formula=0.4*(screenedzTarget/cNaturalUnit)*(screenedzTarget/cNaturalUnit)/(nl*velocityl1/sigmaPSS_l1);
G4double l1relativityCorrection = std::pow((1.+(1.1*yl1Formula*yl1Formula)),0.5)+yl1Formula; // Relativistic correction parameter
//G4double reducedVelocity_l1 = velocityl1*std::pow(l1relativityCorrection,0.5); //Reduced velocity parameter
G4double L1etaOverTheta2;
G4double universalFunction_l1 = 0.;
G4double sigmaPSSR_l1;
if ( velocityl1 <5. )
{
L1etaOverTheta2 =(reducedEnergy* l1relativityCorrection)/((tetal1*sigmaPSS_l1)*(tetal1*sigmaPSS_l1));
if ( ((tetal1*sigmaPSS_l1) >=0.2) && ((tetal1*sigmaPSS_l1) <=2.6670) && (L1etaOverTheta2>=0.1e-3) && (L1etaOverTheta2<=0.866e2) )
universalFunction_l1 = FunctionFL1((tetal1*sigmaPSS_l1),L1etaOverTheta2);
if (verboseLevel>0) G4cout << "at low velocity range, universalFunction_l1 =" << universalFunction_l1 << G4endl;
sigmaPSSR_l1 = (sigma0/(tetal1*sigmaPSS_l1))*universalFunction_l1;// Plane-wave Born -Aproximation L1-subshell ionisation Cross Section
if (verboseLevel>0) G4cout << " at low velocity range, sigma PWBA L1 CS = " << sigmaPSSR_l1<< G4endl;
}
else
{
L1etaOverTheta2 = reducedEnergy/(tetal1*tetal1);
if ( (tetal1 >=0.2) && (tetal1 <=2.6670) && (L1etaOverTheta2>=0.1e-3) && (L1etaOverTheta2<=0.866e2) )
universalFunction_l1 = FunctionFL1(tetal1,L1etaOverTheta2);
if (verboseLevel>0) G4cout << "at medium and high velocity range, universalFunction_l1 =" << universalFunction_l1 << G4endl;
sigmaPSSR_l1 = (sigma0/tetal1)*universalFunction_l1;// Plane-wave Born -Aproximation L1-subshell ionisation Cross Section
if (verboseLevel>0) G4cout << " sigma PWBA L1 CS at medium and high velocity range = " << sigmaPSSR_l1<< G4endl;
}
G4double pssDeltal1 = (4./(systemMass *sigmaPSS_l1*tetal1))*(sigmaPSS_l1/velocityl1)*(sigmaPSS_l1/velocityl1);
if (verboseLevel>0) G4cout << " pssDeltal1=" << pssDeltal1<< G4endl;
G4double energyLossl1 = std::pow(1-pssDeltal1,0.5);
if (verboseLevel>0) G4cout << " energyLossl1=" << energyLossl1<< G4endl;
G4double coulombDeflectionl1 =
(8.*pi*zIncident/systemMass)*std::pow(tetal1*sigmaPSS_l1,-2.)*std::pow(velocityl1/sigmaPSS_l1,-3.)*(zTarget/screenedzTarget);
G4double cParameterl1 =2.* coulombDeflectionl1/(energyLossl1*(energyLossl1+1.));
G4double coulombDeflectionFunction_l1 = 9.*ExpIntFunction(10,cParameterl1); //Coulomb-deflection effect correction
if (verboseLevel>0) G4cout << " coulombDeflectionFunction_l1 =" << coulombDeflectionFunction_l1 << G4endl;
G4double crossSection_L1 = coulombDeflectionFunction_l1 * sigmaPSSR_l1;
//ECPSSR L1 -subshell cross section is estimated at perturbed-stationnairy-state(PSS)
//and reduced by the energy-loss(E),the Coulomb deflection(C),and the relativity(R) effects
if (verboseLevel>0) G4cout << " crossSection_L1 =" << crossSection_L1 << G4endl;
if (crossSection_L1 >= 0) {
return crossSection_L1 * barn;
}
else {return 0;}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4AnalyticalEcpssrLiCrossSection::CalculateL2CrossSection(G4int zTarget,G4double massIncident, G4double energyIncident)
{
// this L2-CrossSection calculation method is done according to Werner Brandt and Grzegorz Lapicki, Phys.Rev.A20 N2 (1979),
// and using data tables of O. Benka et al. At.Data Nucl.Data Tables Vol.22 No.3 (1978).
G4NistManager* massManager = G4NistManager::Instance();
G4AtomicTransitionManager* transitionManager = G4AtomicTransitionManager::Instance();
G4double zIncident = 0;
G4Proton* aProtone = G4Proton::Proton();
G4Alpha* aAlpha = G4Alpha::Alpha();
if (massIncident == aProtone->GetPDGMass() )
zIncident = (aProtone->GetPDGCharge())/eplus;
else
{
if (massIncident == aAlpha->GetPDGMass())
zIncident = (aAlpha->GetPDGCharge())/eplus;
else
{
G4cout << "*** WARNING in G4AnalyticalEcpssrLiCrossSection::CalculateL2CrossSection : Proton or Alpha incident particles only. " << G4endl;
G4cout << massIncident << ", " << aAlpha->GetPDGMass() << " (alpha)" << aProtone->GetPDGMass() << " (proton)" << G4endl;
return 0;
}
}
G4double l2BindingEnergy = transitionManager->Shell(zTarget,2)->BindingEnergy(); //Observed binding energy of L2-subshell
G4double massTarget = (massManager->GetAtomicMassAmu(zTarget))*amu_c2;
G4double systemMass =((massIncident*massTarget)/(massIncident+massTarget))/electron_mass_c2; //Mass of the system (projectile, target)
const G4double zlshell= 4.15;
G4double screenedzTarget = zTarget-zlshell; //Effective nuclear charge as seen by electrons in L2-subshell
const G4double rydbergMeV= 13.6056923e-6;
const G4double nl= 2.;
G4double tetal2 = (l2BindingEnergy*nl*nl)/((screenedzTarget*screenedzTarget)*rydbergMeV); //Screening parameter
if (verboseLevel>0) G4cout << " tetal2=" << tetal2<< G4endl;
G4double reducedEnergy = (energyIncident*electron_mass_c2)/(massIncident*rydbergMeV*screenedzTarget*screenedzTarget);
const G4double bohrPow2Barn=(Bohr_radius*Bohr_radius)/barn ; //Bohr radius of hydrogen
G4double sigma0 = 8.*pi*(zIncident*zIncident)*bohrPow2Barn*std::pow(screenedzTarget,-4.);
G4double velocityl2 = CalculateVelocity(2, zTarget, massIncident, energyIncident); // Scaled velocity
if (verboseLevel>0) G4cout << " velocityl2=" << velocityl2<< G4endl;
const G4double l23AnalyticalApproximation= 1.25;
G4double x2 = (nl*l23AnalyticalApproximation)/velocityl2;
if (verboseLevel>0) G4cout << " x2=" << x2<< G4endl;
G4double electrIonizationEnergyl2=0.;
if ( x2<=0.035) electrIonizationEnergyl2= 0.75*pi*(std::log(1./(x2*x2))-1.);
else
{
if ( x2<=3.)
electrIonizationEnergyl2 =std::exp(-2.*x2)/(0.031+(0.210*std::pow(x2,0.5))+(0.005*x2)-(0.069*std::pow(x2,3./2.))+(0.324*x2*x2));
else
{if ( x2<=11.) electrIonizationEnergyl2 =2.*std::exp(-2.*x2)/std::pow(x2,1.6); }
}
G4double hFunctionl2 =(electrIonizationEnergyl2*2.*nl)/(tetal2*std::pow(velocityl2,3)); //takes into account the polarization effect
if (verboseLevel>0) G4cout << " hFunctionl2=" << hFunctionl2<< G4endl;
G4double gFunctionl2 = (1.+(10.*velocityl2)+(45.*velocityl2*velocityl2)+(102.*std::pow(velocityl2,3.))+(331.*std::pow(velocityl2,4.))+(6.7*std::pow(velocityl2,5.))+(58.*std::pow(velocityl2,6.))+(7.8*std::pow(velocityl2,7.))+ (0.888*std::pow(velocityl2,8.)) )/std::pow(1.+velocityl2,10.);
//takes into account the reduced binding effect
if (verboseLevel>0) G4cout << " gFunctionl2=" << gFunctionl2<< G4endl;
G4double sigmaPSS_l2 = 1.+(((2.*zIncident)/(screenedzTarget*tetal2))*(gFunctionl2-hFunctionl2)); //Binding-polarization factor
if (verboseLevel>0) G4cout << " sigmaPSS_l2=" << sigmaPSS_l2<< G4endl;
const G4double cNaturalUnit= 137.;
G4double yl2Formula=0.15*(screenedzTarget/cNaturalUnit)*(screenedzTarget/cNaturalUnit)/(velocityl2/sigmaPSS_l2);
G4double l2relativityCorrection = std::pow((1.+(1.1*yl2Formula*yl2Formula)),0.5)+yl2Formula; // Relativistic correction parameter
G4double L2etaOverTheta2;
G4double universalFunction_l2 = 0.;
G4double sigmaPSSR_l2 ;
if ( velocityl2 < 5. )
{
L2etaOverTheta2 = (reducedEnergy*l2relativityCorrection)/((sigmaPSS_l2*tetal2)*(sigmaPSS_l2*tetal2));
if ( (tetal2*sigmaPSS_l2>=0.2) && (tetal2*sigmaPSS_l2<=2.6670) && (L2etaOverTheta2>=0.1e-3) && (L2etaOverTheta2<=0.866e2) )
universalFunction_l2 = FunctionFL2((tetal2*sigmaPSS_l2),L2etaOverTheta2);
sigmaPSSR_l2 = (sigma0/(tetal2*sigmaPSS_l2))*universalFunction_l2;
if (verboseLevel>0) G4cout << " sigma PWBA L2 CS at low velocity range = " << sigmaPSSR_l2<< G4endl;
}
else
{
L2etaOverTheta2 = reducedEnergy /(tetal2*tetal2);
if ( (tetal2>=0.2) && (tetal2<=2.6670) && (L2etaOverTheta2>=0.1e-3) && (L2etaOverTheta2<=0.866e2) )
universalFunction_l2 = FunctionFL2((tetal2),L2etaOverTheta2);
sigmaPSSR_l2 = (sigma0/tetal2)*universalFunction_l2;
if (verboseLevel>0) G4cout << " sigma PWBA L2 CS at medium and high velocity range = " << sigmaPSSR_l2<< G4endl;
}
G4double pssDeltal2 = (4./(systemMass*sigmaPSS_l2*tetal2))*(sigmaPSS_l2/velocityl2)*(sigmaPSS_l2/velocityl2);
G4double energyLossl2 = std::pow(1-pssDeltal2,0.5);
if (verboseLevel>0) G4cout << " energyLossl2=" << energyLossl2<< G4endl;
G4double coulombDeflectionl2
=(8.*pi*zIncident/systemMass)*std::pow(tetal2*sigmaPSS_l2,-2.)*std::pow(velocityl2/sigmaPSS_l2,-3.)*(zTarget/screenedzTarget);
G4double cParameterl2 = 2.*coulombDeflectionl2/(energyLossl2*(energyLossl2+1.));
G4double coulombDeflectionFunction_l2 = 11.*ExpIntFunction(12,cParameterl2); //Coulomb-deflection effect correction
if (verboseLevel>0) G4cout << " coulombDeflectionFunction_l2 =" << coulombDeflectionFunction_l2 << G4endl;
G4double crossSection_L2 = coulombDeflectionFunction_l2 * sigmaPSSR_l2;
//ECPSSR L2 -subshell cross section is estimated at perturbed-stationnairy-state(PSS)
//and reduced by the energy-loss(E),the Coulomb deflection(C),and the relativity(R) effects
if (verboseLevel>0) G4cout << " crossSection_L2 =" << crossSection_L2 << G4endl;
if (crossSection_L2 >= 0) {
return crossSection_L2 * barn;
}
else {return 0;}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4AnalyticalEcpssrLiCrossSection::CalculateL3CrossSection(G4int zTarget,G4double massIncident, G4double energyIncident)
{
//this L3-CrossSection calculation method is done according to Werner Brandt and Grzegorz Lapicki, Phys.Rev.A20 N2 (1979),
//and using data tables of O. Benka et al. At.Data Nucl.Data Tables Vol.22 No.3 (1978).
G4NistManager* massManager = G4NistManager::Instance();
G4AtomicTransitionManager* transitionManager = G4AtomicTransitionManager::Instance();
G4double zIncident = 0;
G4Proton* aProtone = G4Proton::Proton();
G4Alpha* aAlpha = G4Alpha::Alpha();
if (massIncident == aProtone->GetPDGMass() )
zIncident = (aProtone->GetPDGCharge())/eplus;
else
{
if (massIncident == aAlpha->GetPDGMass())
zIncident = (aAlpha->GetPDGCharge())/eplus;
else
{
G4cout << "*** WARNING in G4AnalyticalEcpssrLiCrossSection::CalculateL3CrossSection : Proton or Alpha incident particles only. " << G4endl;
G4cout << massIncident << ", " << aAlpha->GetPDGMass() << " (alpha)" << aProtone->GetPDGMass() << " (proton)" << G4endl;
return 0;
}
}
G4double l3BindingEnergy = transitionManager->Shell(zTarget,3)->BindingEnergy();
G4double massTarget = (massManager->GetAtomicMassAmu(zTarget))*amu_c2;
G4double systemMass =((massIncident*massTarget)/(massIncident+massTarget))/electron_mass_c2;//Mass of the system (projectile, target)
const G4double zlshell= 4.15;
G4double screenedzTarget = zTarget-zlshell;//Effective nuclear charge as seen by electrons in L3-subshell
const G4double rydbergMeV= 13.6056923e-6;
const G4double nl= 2.;
G4double tetal3 = (l3BindingEnergy*nl*nl)/((screenedzTarget*screenedzTarget)*rydbergMeV);//Screening parameter
if (verboseLevel>0) G4cout << " tetal3=" << tetal3<< G4endl;
G4double reducedEnergy = (energyIncident*electron_mass_c2)/(massIncident*rydbergMeV*screenedzTarget*screenedzTarget);
const G4double bohrPow2Barn=(Bohr_radius*Bohr_radius)/barn ;//Bohr radius of hydrogen
G4double sigma0 = 8.*pi*(zIncident*zIncident)*bohrPow2Barn*std::pow(screenedzTarget,-4.);
G4double velocityl3 = CalculateVelocity(3, zTarget, massIncident, energyIncident);// Scaled velocity
if (verboseLevel>0) G4cout << " velocityl3=" << velocityl3<< G4endl;
const G4double l23AnalyticalApproximation= 1.25;
G4double x3 = (nl*l23AnalyticalApproximation)/velocityl3;
if (verboseLevel>0) G4cout << " x3=" << x3<< G4endl;
G4double electrIonizationEnergyl3=0.;
if ( x3<=0.035) electrIonizationEnergyl3= 0.75*pi*(std::log(1./(x3*x3))-1.);
else
{
if ( x3<=3.) electrIonizationEnergyl3 =std::exp(-2.*x3)/(0.031+(0.210*std::pow(x3,0.5))+(0.005*x3)-(0.069*std::pow(x3,3./2.))+(0.324*x3*x3));
else
{
if ( x3<=11.) electrIonizationEnergyl3 =2.*std::exp(-2.*x3)/std::pow(x3,1.6);}
}
G4double hFunctionl3 =(electrIonizationEnergyl3*2.*nl)/(tetal3*std::pow(velocityl3,3));//takes into account the polarization effect
if (verboseLevel>0) G4cout << " hFunctionl3=" << hFunctionl3<< G4endl;
G4double gFunctionl3 = (1.+(10.*velocityl3)+(45.*velocityl3*velocityl3)+(102.*std::pow(velocityl3,3.))+(331.*std::pow(velocityl3,4.))+(6.7*std::pow(velocityl3,5.))+(58.*std::pow(velocityl3,6.))+(7.8*std::pow(velocityl3,7.))+ (0.888*std::pow(velocityl3,8.)) )/std::pow(1.+velocityl3,10.);
//takes into account the reduced binding effect
if (verboseLevel>0) G4cout << " gFunctionl3=" << gFunctionl3<< G4endl;
G4double sigmaPSS_l3 = 1.+(((2.*zIncident)/(screenedzTarget*tetal3))*(gFunctionl3-hFunctionl3));//Binding-polarization factor
if (verboseLevel>0) G4cout << "sigmaPSS_l3 =" << sigmaPSS_l3<< G4endl;
const G4double cNaturalUnit= 137.;
G4double yl3Formula=0.15*(screenedzTarget/cNaturalUnit)*(screenedzTarget/cNaturalUnit)/(velocityl3/sigmaPSS_l3);
G4double l3relativityCorrection = std::pow((1.+(1.1*yl3Formula*yl3Formula)),0.5)+yl3Formula; // Relativistic correction parameter
G4double L3etaOverTheta2;
G4double universalFunction_l3 = 0.;
G4double sigmaPSSR_l3;
if ( velocityl3 < 5. )
{
L3etaOverTheta2 = (reducedEnergy* l3relativityCorrection)/((sigmaPSS_l3*tetal3)*(sigmaPSS_l3*tetal3));
if ( (tetal3*sigmaPSS_l3>=0.2) && (tetal3*sigmaPSS_l3<=2.6670) && (L3etaOverTheta2>=0.1e-3) && (L3etaOverTheta2<=0.866e2) )
universalFunction_l3 = 2.*FunctionFL2((tetal3*sigmaPSS_l3), L3etaOverTheta2 );
sigmaPSSR_l3 = (sigma0/(tetal3*sigmaPSS_l3))*universalFunction_l3;
if (verboseLevel>0) G4cout << " sigma PWBA L3 CS at low velocity range = " << sigmaPSSR_l3<< G4endl;
}
else
{
L3etaOverTheta2 = reducedEnergy/(tetal3*tetal3);
if ( (tetal3>=0.2) && (tetal3<=2.6670) && (L3etaOverTheta2>=0.1e-3) && (L3etaOverTheta2<=0.866e2) )
universalFunction_l3 = 2.*FunctionFL2(tetal3, L3etaOverTheta2 );
sigmaPSSR_l3 = (sigma0/tetal3)*universalFunction_l3;
if (verboseLevel>0) G4cout << " sigma PWBA L3 CS at medium and high velocity range = " << sigmaPSSR_l3<< G4endl;
}
G4double pssDeltal3 = (4./(systemMass*sigmaPSS_l3*tetal3))*(sigmaPSS_l3/velocityl3)*(sigmaPSS_l3/velocityl3);
if (verboseLevel>0) G4cout << " pssDeltal3=" << pssDeltal3<< G4endl;
G4double energyLossl3 = std::pow(1-pssDeltal3,0.5);
if (verboseLevel>0) G4cout << " energyLossl3=" << energyLossl3<< G4endl;
G4double coulombDeflectionl3 =
(8.*pi*zIncident/systemMass)*std::pow(tetal3*sigmaPSS_l3,-2.)*std::pow(velocityl3/sigmaPSS_l3,-3.)*(zTarget/screenedzTarget);
G4double cParameterl3 = 2.*coulombDeflectionl3/(energyLossl3*(energyLossl3+1.));
G4double coulombDeflectionFunction_l3 = 11.*ExpIntFunction(12,cParameterl3);//Coulomb-deflection effect correction
if (verboseLevel>0) G4cout << " coulombDeflectionFunction_l3 =" << coulombDeflectionFunction_l3 << G4endl;
G4double crossSection_L3 = coulombDeflectionFunction_l3 * sigmaPSSR_l3;
//ECPSSR L3 -subshell cross section is estimated at perturbed-stationnairy-state(PSS)
//and reduced by the energy-loss(E),the Coulomb deflection(C),and the relativity(R) effects
if (verboseLevel>0) G4cout << " crossSection_L3 =" << crossSection_L3 << G4endl;
if (crossSection_L3 >= 0) {
return crossSection_L3 * barn;
}
else {return 0;}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4AnalyticalEcpssrLiCrossSection::CalculateVelocity(G4int subShell, G4int zTarget, G4double massIncident, G4double energyIncident)
{
G4AtomicTransitionManager* transitionManager = G4AtomicTransitionManager::Instance();
G4double liBindingEnergy = transitionManager->Shell(zTarget,subShell)->BindingEnergy();
G4Proton* aProtone = G4Proton::Proton();
G4Alpha* aAlpha = G4Alpha::Alpha();
if (!((massIncident == aProtone->GetPDGMass()) || (massIncident == aAlpha->GetPDGMass())))
{
G4cout << "*** WARNING in G4AnalyticalEcpssrLiCrossSection::CalculateVelocity : Proton or Alpha incident particles only. " << G4endl;
G4cout << massIncident << ", " << aAlpha->GetPDGMass() << " (alpha)" << aProtone->GetPDGMass() << " (proton)" << G4endl;
return 0;
}
const G4double zlshell= 4.15;
G4double screenedzTarget = zTarget- zlshell;
const G4double rydbergMeV= 13.6056923e-6;
const G4double nl= 2.;
G4double tetali = (liBindingEnergy*nl*nl)/(screenedzTarget*screenedzTarget*rydbergMeV);
G4double reducedEnergy = (energyIncident*electron_mass_c2)/(massIncident*rydbergMeV*screenedzTarget*screenedzTarget);
G4double velocity = 2.*nl*std::pow(reducedEnergy,0.5)/tetali;
return velocity;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4AnalyticalEcpssrLiCrossSection::FunctionFL1(G4double k, G4double theta)
{
G4double sigma = 0.;
G4double valueT1 = 0;
G4double valueT2 = 0;
G4double valueE21 = 0;
G4double valueE22 = 0;
G4double valueE12 = 0;
G4double valueE11 = 0;
G4double xs11 = 0;
G4double xs12 = 0;
G4double xs21 = 0;
G4double xs22 = 0;
// PROTECTION TO ALLOW INTERPOLATION AT MINIMUM AND MAXIMUM Eta/Theta2 values
if (
theta==8.66e-4 ||
theta==8.66e-3 ||
theta==8.66e-2 ||
theta==8.66e-1 ||
theta==8.66e+00 ||
theta==8.66e+01
) theta=theta-1e-12;
if (
theta==1.e-4 ||
theta==1.e-3 ||
theta==1.e-2 ||
theta==1.e-1 ||
theta==1.e+00 ||
theta==1.e+01
) theta=theta+1e-12;
// END PROTECTION
std::vector<double>::iterator t2 = std::upper_bound(dummyVec1.begin(),dummyVec1.end(), k);
std::vector<double>::iterator t1 = t2-1;
std::vector<double>::iterator e12 = std::upper_bound(aVecMap1[(*t1)].begin(),aVecMap1[(*t1)].end(), theta);
std::vector<double>::iterator e11 = e12-1;
std::vector<double>::iterator e22 = std::upper_bound(aVecMap1[(*t2)].begin(),aVecMap1[(*t2)].end(), theta);
std::vector<double>::iterator e21 = e22-1;
valueT1 =*t1;
valueT2 =*t2;
valueE21 =*e21;
valueE22 =*e22;
valueE12 =*e12;
valueE11 =*e11;
xs11 = FL1Data[valueT1][valueE11];
xs12 = FL1Data[valueT1][valueE12];
xs21 = FL1Data[valueT2][valueE21];
xs22 = FL1Data[valueT2][valueE22];
if (verboseLevel>0)
G4cout
<< valueT1 << " "
<< valueT2 << " "
<< valueE11 << " "
<< valueE12 << " "
<< valueE21 << " "
<< valueE22 << " "
<< xs11 << " "
<< xs12 << " "
<< xs21 << " "
<< xs22 << " "
<< G4endl;
G4double xsProduct = xs11 * xs12 * xs21 * xs22;
if (xs11==0 || xs12==0 ||xs21==0 ||xs22==0) return (0.);
if (xsProduct != 0.)
{
sigma = QuadInterpolator( valueE11, valueE12,
valueE21, valueE22,
xs11, xs12,
xs21, xs22,
valueT1, valueT2,
k, theta );
}
return sigma;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4AnalyticalEcpssrLiCrossSection::FunctionFL2(G4double k, G4double theta)
{
G4double sigma = 0.;
G4double valueT1 = 0;
G4double valueT2 = 0;
G4double valueE21 = 0;
G4double valueE22 = 0;
G4double valueE12 = 0;
G4double valueE11 = 0;
G4double xs11 = 0;
G4double xs12 = 0;
G4double xs21 = 0;
G4double xs22 = 0;
// PROTECTION TO ALLOW INTERPOLATION AT MINIMUM AND MAXIMUM Eta/Theta2 values
if (
theta==8.66e-4 ||
theta==8.66e-3 ||
theta==8.66e-2 ||
theta==8.66e-1 ||
theta==8.66e+00 ||
theta==8.66e+01
) theta=theta-1e-12;
if (
theta==1.e-4 ||
theta==1.e-3 ||
theta==1.e-2 ||
theta==1.e-1 ||
theta==1.e+00 ||
theta==1.e+01
) theta=theta+1e-12;
// END PROTECTION
std::vector<double>::iterator t2 = std::upper_bound(dummyVec2.begin(),dummyVec2.end(), k);
std::vector<double>::iterator t1 = t2-1;
std::vector<double>::iterator e12 = std::upper_bound(aVecMap2[(*t1)].begin(),aVecMap2[(*t1)].end(), theta);
std::vector<double>::iterator e11 = e12-1;
std::vector<double>::iterator e22 = std::upper_bound(aVecMap2[(*t2)].begin(),aVecMap2[(*t2)].end(), theta);
std::vector<double>::iterator e21 = e22-1;
valueT1 =*t1;
valueT2 =*t2;
valueE21 =*e21;
valueE22 =*e22;
valueE12 =*e12;
valueE11 =*e11;
xs11 = FL2Data[valueT1][valueE11];
xs12 = FL2Data[valueT1][valueE12];
xs21 = FL2Data[valueT2][valueE21];
xs22 = FL2Data[valueT2][valueE22];
if (verboseLevel>0)
G4cout
<< valueT1 << " "
<< valueT2 << " "
<< valueE11 << " "
<< valueE12 << " "
<< valueE21 << " "
<< valueE22 << " "
<< xs11 << " "
<< xs12 << " "
<< xs21 << " "
<< xs22 << " "
<< G4endl;
G4double xsProduct = xs11 * xs12 * xs21 * xs22;
if (xs11==0 || xs12==0 ||xs21==0 ||xs22==0) return (0.);
if (xsProduct != 0.)
{
sigma = QuadInterpolator( valueE11, valueE12,
valueE21, valueE22,
xs11, xs12,
xs21, xs22,
valueT1, valueT2,
k, theta );
}
return sigma;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4AnalyticalEcpssrLiCrossSection::LinLinInterpolate(G4double e1,
G4double e2,
G4double e,
G4double xs1,
G4double xs2)
{
G4double value = xs1 + (xs2 - xs1)*(e - e1)/ (e2 - e1);
return value;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4AnalyticalEcpssrLiCrossSection::LinLogInterpolate(G4double e1,
G4double e2,
G4double e,
G4double xs1,
G4double xs2)
{
G4double d1 = std::log(xs1);
G4double d2 = std::log(xs2);
G4double value = std::exp(d1 + (d2 - d1)*(e - e1)/ (e2 - e1));
return value;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4AnalyticalEcpssrLiCrossSection::LogLogInterpolate(G4double e1,
G4double e2,
G4double e,
G4double xs1,
G4double xs2)
{
G4double a = (std::log10(xs2)-std::log10(xs1)) / (std::log10(e2)-std::log10(e1));
G4double b = std::log10(xs2) - a*std::log10(e2);
G4double sigma = a*std::log10(e) + b;
G4double value = (std::pow(10.,sigma));
return value;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4AnalyticalEcpssrLiCrossSection::QuadInterpolator(G4double e11, G4double e12,
G4double e21, G4double e22,
G4double xs11, G4double xs12,
G4double xs21, G4double xs22,
G4double t1, G4double t2,
G4double t, G4double e)
{
// Log-Log
G4double interpolatedvalue1 = LogLogInterpolate(e11, e12, e, xs11, xs12);
G4double interpolatedvalue2 = LogLogInterpolate(e21, e22, e, xs21, xs22);
G4double value = LogLogInterpolate(t1, t2, t, interpolatedvalue1, interpolatedvalue2);
/*
// Lin-Log
G4double interpolatedvalue1 = LinLogInterpolate(e11, e12, e, xs11, xs12);
G4double interpolatedvalue2 = LinLogInterpolate(e21, e22, e, xs21, xs22);
G4double value = LinLogInterpolate(t1, t2, t, interpolatedvalue1, interpolatedvalue2);
*/
/*
// Lin-Lin
G4double interpolatedvalue1 = LinLinInterpolate(e11, e12, e, xs11, xs12);
G4double interpolatedvalue2 = LinLinInterpolate(e21, e22, e, xs21, xs22);
G4double value = LinLinInterpolate(t1, t2, t, interpolatedvalue1, interpolatedvalue2);
*/
return value;
}
source/processes/electromagnetic/lowenergy/src/G4AtomicDeexcitation.cc
+9 -6
View File
@@ -25,7 +25,7 @@
//
//
// $Id: G4AtomicDeexcitation.cc,v 1.11
// GEANT4 tag $Name: geant4-09-03 $
// GEANT4 tag $Name: geant4-09-04 $
//
// Authors: Elena Guardincerri (Elena.Guardincerri@ge.infn.it)
// Alfonso Mantero (Alfonso.Mantero@ge.infn.it)
@@ -58,8 +58,8 @@ std::vector<G4DynamicParticle*>* G4AtomicDeexcitation::GenerateParticles(G4int Z
{
std::vector<G4DynamicParticle*>* vectorOfParticles;
vectorOfParticles = new std::vector<G4DynamicParticle*>;
G4DynamicParticle* aParticle;
G4int provShellId = 0;
G4int counter = 0;
@@ -112,7 +112,12 @@ std::vector<G4DynamicParticle*>* G4AtomicDeexcitation::GenerateParticles(G4int Z
// Look this in a particular way: only one auger emitted! // ????
while (provShellId > -2);
// debug
// if (vectorOfParticles->size() > 0) {
// G4cout << " DEEXCITATION!" << G4endl;
// }
return vectorOfParticles;
}
@@ -383,9 +388,7 @@ G4DynamicParticle* G4AtomicDeexcitation::GenerateAuger(G4int Z, G4int shellId)
// G4int augerOriginatingShellId = 0;
G4int numberOfPossibleAuger = 0;
numberOfPossibleAuger = anAugerTransition->AugerTransitionProbabilities(transitionRandomShellId)->size();
G4bool foundFlag = false;
while (transitionRandomShellIndex < transitionSize) {
source/processes/electromagnetic/lowenergy/src/G4AtomicTransitionManager.cc
+1 -1
View File
@@ -25,7 +25,7 @@
//
//
// $Id: G4AtomicTransitionManager.cc,v 1.2 ????
// GEANT4 tag $Name: geant4-09-03 $
// GEANT4 tag $Name: geant4-09-04 $
//
// Authors: Elena Guardincerri (Elena.Guardincerri@ge.infn.it)
// Alfonso Mantero (Alfonso.Mantero@ge.infn.it)
source/processes/electromagnetic/lowenergy/src/G4AugerTransition.cc
+19 -1
View File
@@ -96,19 +96,37 @@ const std::vector<G4int>* G4AugerTransition::TransitionOriginatingShellIds() con
const G4DataVector* G4AugerTransition::AugerTransitionEnergies(G4int startShellId) const
{
std::map<G4int,G4DataVector,std::less<G4int> >::const_iterator shellId = augerTransitionEnergiesMap.find(startShellId);
if (shellId == augerTransitionEnergiesMap.end() )
{G4Exception("G4AugerTransition: corresponding map element not found");}
const G4DataVector* dataSet = &(*shellId).second;
return dataSet;
}
// Returns the emission probabilities of the auger electrons, given th shell
// Returns the emission probabilities of the auger electrons, given the shell
// from wich the transition electron cames from.
const G4DataVector* G4AugerTransition::AugerTransitionProbabilities(G4int startShellId) const
{
//debugging
//if (startShellId == 1){G4cout <<"OI!!!"<< G4endl;}
std::map<G4int,G4DataVector,std::less<G4int> >::const_iterator shellId = augerTransitionProbabilitiesMap.find(startShellId);
if (shellId == augerTransitionProbabilitiesMap.end() )
{G4Exception("G4AugerTransition: corresponding map element not found");}
const G4DataVector* dataSet = &(*shellId).second;
// debugging purpose:
/* G4cout << "id: " << shellId->first << G4endl;
G4cout << "size:" << dataSet->size() << G4endl;
for (G4int i = 0; i < dataSet->size(); i++){
G4cout << (dataSet[0])[i] << G4endl;
}*/
return dataSet;
}
source/processes/electromagnetic/lowenergy/src/G4BoldyshevTripletModel.cc
+338
View File
@@ -0,0 +1,338 @@
//
// ********************************************************************
// * 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: G4BoldyshevTripletModel.cc,v 1.2 2010/11/12 16:48:13 flongo Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
//
// Author: Gerardo Depaola & Francesco Longo
//
// History:
// --------
// 23-06-2010 First implementation as model
#include "G4BoldyshevTripletModel.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
using namespace std;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4BoldyshevTripletModel::G4BoldyshevTripletModel(const G4ParticleDefinition*,
const G4String& nam)
:G4VEmModel(nam),smallEnergy(4.*MeV),isInitialised(false),
crossSectionHandler(0),meanFreePathTable(0)
{
lowEnergyLimit = 4.0*electron_mass_c2;
highEnergyLimit = 100 * GeV;
SetHighEnergyLimit(highEnergyLimit);
verboseLevel= 0;
// Verbosity scale:
// 0 = nothing
// 1 = warning for energy non-conservation
// 2 = details of energy budget
// 3 = calculation of cross sections, file openings, sampling of atoms
// 4 = entering in methods
if(verboseLevel > 0) {
G4cout << "Triplet Gamma conversion is constructed " << G4endl
<< "Energy range: "
<< lowEnergyLimit / MeV << " MeV - "
<< highEnergyLimit / GeV << " GeV"
<< G4endl;
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4BoldyshevTripletModel::~G4BoldyshevTripletModel()
{
if (crossSectionHandler) delete crossSectionHandler;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void
G4BoldyshevTripletModel::Initialise(const G4ParticleDefinition*,
const G4DataVector&)
{
if (verboseLevel > 3)
G4cout << "Calling G4BoldyshevTripletModel::Initialise()" << G4endl;
if (crossSectionHandler)
{
crossSectionHandler->Clear();
delete crossSectionHandler;
}
// Read data tables for all materials
crossSectionHandler = new G4CrossSectionHandler();
crossSectionHandler->Initialise(0,lowEnergyLimit,100.*GeV,400);
G4String crossSectionFile = "tripdata/pp-trip-cs-"; // here only pair in electron field cs should be used
crossSectionHandler->LoadData(crossSectionFile);
//
if (verboseLevel > 0) {
G4cout << "Loaded cross section files for Livermore GammaConversion" << G4endl;
G4cout << "To obtain the total cross section this should be used only " << G4endl
<< "in connection with G4NuclearGammaConversion " << G4endl;
}
if (verboseLevel > 0) {
G4cout << "Livermore Electron Gamma Conversion model is initialized " << G4endl
<< "Energy range: "
<< LowEnergyLimit() / MeV << " MeV - "
<< HighEnergyLimit() / GeV << " GeV"
<< G4endl;
}
if(isInitialised) return;
fParticleChange = GetParticleChangeForGamma();
isInitialised = true;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double
G4BoldyshevTripletModel::ComputeCrossSectionPerAtom(const G4ParticleDefinition*,
G4double GammaEnergy,
G4double Z, G4double,
G4double, G4double)
{
if (verboseLevel > 3) {
G4cout << "Calling ComputeCrossSectionPerAtom() of G4BoldyshevTripletModel"
<< G4endl;
}
if (GammaEnergy < lowEnergyLimit || GammaEnergy > highEnergyLimit) return 0;
G4double cs = crossSectionHandler->FindValue(G4int(Z), GammaEnergy);
return cs;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4BoldyshevTripletModel::SampleSecondaries(std::vector<G4DynamicParticle*>* fvect,
const G4MaterialCutsCouple* ,
const G4DynamicParticle* aDynamicGamma,
G4double,
G4double)
{
// The energies of the secondary particles are sampled using
// a modified Wheeler-Lamb model (see PhysRevD 7 (1973), 26)
if (verboseLevel > 3)
G4cout << "Calling SampleSecondaries() of G4BoldyshevTripletModel" << G4endl;
G4double photonEnergy = aDynamicGamma->GetKineticEnergy();
G4ParticleMomentum photonDirection = aDynamicGamma->GetMomentumDirection();
G4double epsilon ;
G4double p0 = electron_mass_c2;
G4double positronTotEnergy, electronTotEnergy, thetaEle, thetaPos;
G4double ener_re=0., theta_re, phi_re, phi;
// Calculo de theta - elecron de recoil
G4double energyThreshold = sqrt(2.)*electron_mass_c2; // -> momentumThreshold_N = 1
energyThreshold = 1.1*electron_mass_c2;
// G4cout << energyThreshold << G4endl;
G4double momentumThreshold_c = sqrt(energyThreshold * energyThreshold - electron_mass_c2*electron_mass_c2); // momentun in MeV/c unit
G4double momentumThreshold_N = momentumThreshold_c/electron_mass_c2; // momentun in mc unit
// Calculation of recoil electron production
G4double SigmaTot = (28./9.) * std::log ( 2.* photonEnergy / electron_mass_c2 ) - 218. / 27. ;
G4double X_0 = 2. * ( sqrt(momentumThreshold_N*momentumThreshold_N + 1) -1 );
G4double SigmaQ = (82./27. - (14./9.) * log (X_0) + 4./15.*X_0 - 0.0348 * X_0 * X_0);
G4double recoilProb = G4UniformRand();
//G4cout << "SIGMA TOT " << SigmaTot << " " << "SigmaQ " << SigmaQ << " " << SigmaQ/SigmaTot << " " << recoilProb << G4endl;
if (recoilProb >= SigmaQ/SigmaTot) // create electron recoil
{
G4double cosThetaMax = ( ( energyThreshold - electron_mass_c2 ) / (momentumThreshold_c) + electron_mass_c2*
( energyThreshold + electron_mass_c2 ) / (photonEnergy*momentumThreshold_c) );
if (cosThetaMax > 1) G4cout << "ERRORE " << G4endl;
G4double r1;
G4double r2;
G4double are, bre, loga, f1_re, greject, cost;
do {
r1 = G4UniformRand();
r2 = G4UniformRand();
// cost = (pow(4./enern,0.5*r1)) ;
cost = pow(cosThetaMax,r1);
theta_re = acos(cost);
are = 1./(14.*cost*cost);
bre = (1.-5.*cost*cost)/(2.*cost);
loga = log((1.+ cost)/(1.- cost));
f1_re = 1. - bre*loga;
if ( theta_re >= 4.47*CLHEP::pi/180.)
{
greject = are*f1_re;
} else {
greject = 1. ;
}
} while(greject < r2);
// Calculo de phi - elecron de recoil
G4double r3, r4, rt;
do {
r3 = G4UniformRand();
r4 = G4UniformRand();
phi_re = twopi*r3 ;
G4double sint2 = 1. - cost*cost ;
G4double fp = 1. - sint2*loga/(2.*cost) ;
rt = (1.-cos(2.*phi_re)*fp/f1_re)/(2.*pi) ;
} while(rt < r4);
// Calculo de la energia - elecron de recoil - relacion momento maximo <-> angulo
G4double S = electron_mass_c2*(2.* photonEnergy + electron_mass_c2);
G4double D2 = 4.*S * electron_mass_c2*electron_mass_c2
+ (S - electron_mass_c2*electron_mass_c2)
*(S - electron_mass_c2*electron_mass_c2)*sin(theta_re)*sin(theta_re);
ener_re = electron_mass_c2 * (S + electron_mass_c2*electron_mass_c2)/sqrt(D2);
// G4cout << "electron de retroceso " << ener_re << " " << theta_re << " " << phi_re << G4endl;
// Recoil electron creation
G4double dxEle_re=sin(theta_re)*std::cos(phi_re),dyEle_re=sin(theta_re)*std::sin(phi_re), dzEle_re=cos(theta_re);
G4double electronRKineEnergy = std::max(0.,ener_re - electron_mass_c2) ;
G4ThreeVector electronRDirection (dxEle_re, dyEle_re, dzEle_re);
electronRDirection.rotateUz(photonDirection);
G4DynamicParticle* particle3 = new G4DynamicParticle (G4Electron::Electron(),
electronRDirection,
electronRKineEnergy);
fvect->push_back(particle3);
}
else
{
// deposito la energia ener_re - electron_mass_c2
// G4cout << "electron de retroceso " << ener_re << G4endl;
fParticleChange->ProposeLocalEnergyDeposit(ener_re - electron_mass_c2);
}
// Depaola (2004) suggested distribution for e+e- energy
// G4double t = 0.5*asinh(momentumThreshold_N);
G4double t = 0.5*log(momentumThreshold_N + sqrt(momentumThreshold_N*momentumThreshold_N+1));
G4double J1 = 0.5*(t*cosh(t)/sinh(t) - log(2.*sinh(t)));
G4double J2 = (-2./3.)*log(2.*sinh(t)) + t*cosh(t)/sinh(t) + (sinh(t)-t*pow(cosh(t),3))/(3.*pow(sinh(t),2));
G4double b = 2.*(J2-J1)/J1;
G4double n = 1 - b/6.;
G4double re=0.;
re = G4UniformRand();
G4double a = 0.;
G4double b1 = 16. - 3.*b - 36.*b*re*n + 36.*b*pow(re,2.)*pow(n,2.) +
6.*pow(b,2.)*re*n;
a = pow((b1/b),0.5);
G4double c1 = (-6. + 12.*re*n + b + 2*a)*pow(b,2.);
epsilon = (pow(c1,1./3.))/(2.*b) + (b-4.)/(2.*pow(c1,1./3.))+0.5;
G4double photonEnergy1 = photonEnergy - ener_re ; // resto al foton la energia del electron de retro.
positronTotEnergy = epsilon*photonEnergy1;
electronTotEnergy = photonEnergy1 - positronTotEnergy; // temporarly
G4double momento_e = sqrt(electronTotEnergy*electronTotEnergy -
electron_mass_c2*electron_mass_c2) ;
G4double momento_p = sqrt(positronTotEnergy*positronTotEnergy -
electron_mass_c2*electron_mass_c2) ;
thetaEle = acos((sqrt(p0*p0/(momento_e*momento_e) +1.)- p0/momento_e)) ;
thetaPos = acos((sqrt(p0*p0/(momento_p*momento_p) +1.)- p0/momento_p)) ;
phi = twopi * G4UniformRand();
G4double dxEle= std::sin(thetaEle)*std::cos(phi),dyEle= std::sin(thetaEle)*std::sin(phi),dzEle=std::cos(thetaEle);
G4double dxPos=-std::sin(thetaPos)*std::cos(phi),dyPos=-std::sin(thetaPos)*std::sin(phi),dzPos=std::cos(thetaPos);
// Kinematics of the created pair:
// the electron and positron are assumed to have a symetric angular
// distribution with respect to the Z axis along the parent photon
G4double electronKineEnergy = std::max(0.,electronTotEnergy - electron_mass_c2) ;
// SI - The range test has been removed wrt original G4LowEnergyGammaconversion class
G4ThreeVector electronDirection (dxEle, dyEle, dzEle);
electronDirection.rotateUz(photonDirection);
G4DynamicParticle* particle1 = new G4DynamicParticle (G4Electron::Electron(),
electronDirection,
electronKineEnergy);
// The e+ is always created (even with kinetic energy = 0) for further annihilation
G4double positronKineEnergy = std::max(0.,positronTotEnergy - electron_mass_c2) ;
// SI - The range test has been removed wrt original G4LowEnergyGammaconversion class
G4ThreeVector positronDirection (dxPos, dyPos, dzPos);
positronDirection.rotateUz(photonDirection);
// Create G4DynamicParticle object for the particle2
G4DynamicParticle* particle2 = new G4DynamicParticle(G4Positron::Positron(),
positronDirection, positronKineEnergy);
// Fill output vector
fvect->push_back(particle1);
fvect->push_back(particle2);
// kill incident photon
fParticleChange->SetProposedKineticEnergy(0.);
fParticleChange->ProposeTrackStatus(fStopAndKill);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
source/processes/electromagnetic/lowenergy/src/G4CompositeEMDataSet.cc
+3 -2
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4CompositeEMDataSet.cc,v 1.15 2009/09/25 07:41:34 sincerti Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4CompositeEMDataSet.cc,v 1.16 2010/11/26 11:51:11 pandola Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// Author: Maria Grazia Pia (Maria.Grazia.Pia@cern.ch)
//
@@ -195,6 +195,7 @@ G4bool G4CompositeEMDataSet::SaveData(const G4String& argFileName) const
std::ostringstream message;
message << "G4CompositeEMDataSet::SaveData - component " << (z-minZ) << " not found";
G4Exception(message.str().c_str());
return false;
}
if (!component->SaveData(argFileName))
source/processes/electromagnetic/lowenergy/src/G4DNAAttachment.cc
+87
View File
@@ -0,0 +1,87 @@
//
// ********************************************************************
// * 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: G4DNAAttachment.cc,v 1.1 2010/09/08 13:46:45 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04 $
#include "G4DNAAttachment.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
using namespace std;
G4DNAAttachment::G4DNAAttachment(const G4String& processName,
G4ProcessType type):G4VEmProcess (processName, type),
isInitialised(false)
{
SetProcessSubType(51);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4DNAAttachment::~G4DNAAttachment()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4bool G4DNAAttachment::IsApplicable(const G4ParticleDefinition& p)
{
G4DNAGenericIonsManager *instance;
instance = G4DNAGenericIonsManager::Instance();
return (&p == G4Electron::Electron());
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4DNAAttachment::InitialiseProcess(const G4ParticleDefinition* p)
{
if(!isInitialised)
{
isInitialised = true;
SetBuildTableFlag(false);
G4String name = p->GetParticleName();
if(name == "e-")
{
if(!Model()) SetModel(new G4DNAMeltonAttachmentModel);
Model()->SetLowEnergyLimit(4.*eV);
Model()->SetHighEnergyLimit(13.*eV);
AddEmModel(1, Model());
}
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void G4DNAAttachment::PrintInfo()
{
G4cout
<< " Total cross sections computed from "
<< Model()->GetName()
<< G4endl;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/processes/electromagnetic/lowenergy/src/G4DNABornExcitationModel.cc
+176 -118
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DNABornExcitationModel.cc,v 1.7 2009/08/31 14:03:29 sincerti Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4DNABornExcitationModel.cc,v 1.10 2010/08/24 13:51:06 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
#include "G4DNABornExcitationModel.hh"
@@ -39,12 +39,6 @@ G4DNABornExcitationModel::G4DNABornExcitationModel(const G4ParticleDefinition*,
const G4String& nam)
:G4VEmModel(nam),isInitialised(false)
{
lowEnergyLimit = 500 * keV;
highEnergyLimit = 100 * MeV;
SetLowEnergyLimit(lowEnergyLimit);
SetHighEnergyLimit(highEnergyLimit);
verboseLevel= 0;
// Verbosity scale:
// 0 = nothing
@@ -53,19 +47,9 @@ G4DNABornExcitationModel::G4DNABornExcitationModel(const G4ParticleDefinition*,
// 3 = calculation of cross sections, file openings, sampling of atoms
// 4 = entering in methods
//
table = 0;
//
if( verboseLevel>0 )
{
G4cout << "Born excitation model is constructed " << G4endl
<< "Energy range: "
<< lowEnergyLimit / keV << " keV - "
<< highEnergyLimit / MeV << " MeV"
<< G4endl;
G4cout << "Born excitation model is constructed " << G4endl;
}
}
@@ -75,50 +59,103 @@ G4DNABornExcitationModel::G4DNABornExcitationModel(const G4ParticleDefinition*,
G4DNABornExcitationModel::~G4DNABornExcitationModel()
{
// Cross section
delete table;
std::map< G4String,G4DNACrossSectionDataSet*,std::less<G4String> >::iterator pos;
for (pos = tableData.begin(); pos != tableData.end(); ++pos)
{
G4DNACrossSectionDataSet* table = pos->second;
delete table;
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4DNABornExcitationModel::Initialise(const G4ParticleDefinition* /*particle*/,
void G4DNABornExcitationModel::Initialise(const G4ParticleDefinition* particle,
const G4DataVector& /*cuts*/)
{
if (verboseLevel > 3)
G4cout << "Calling G4DNABornExcitationModel::Initialise()" << G4endl;
// Energy limits
G4String fileElectron("dna/sigma_excitation_e_born");
G4String fileProton("dna/sigma_excitation_p_born");
G4ParticleDefinition* electronDef = G4Electron::ElectronDefinition();
G4ParticleDefinition* protonDef = G4Proton::ProtonDefinition();
G4String electron;
G4String proton;
if (LowEnergyLimit() < lowEnergyLimit)
G4double scaleFactor = (1.e-22 / 3.343) * m*m;
if (electronDef != 0)
{
G4cout << "G4DNABornExcitationModel: low energy limit increased from " <<
LowEnergyLimit()/keV << " keV to " << lowEnergyLimit/keV << " keV" << G4endl;
SetLowEnergyLimit(lowEnergyLimit);
electron = electronDef->GetParticleName();
tableFile[electron] = fileElectron;
lowEnergyLimit[electron] = 9. * eV;
highEnergyLimit[electron] = 1. * MeV;
// Cross section
G4DNACrossSectionDataSet* tableE = new G4DNACrossSectionDataSet(new G4LogLogInterpolation, eV,scaleFactor );
tableE->LoadData(fileElectron);
tableData[electron] = tableE;
}
else
{
G4Exception("G4DNABornExcitationModel::Initialise(): electron is not defined");
}
if (HighEnergyLimit() > highEnergyLimit)
if (protonDef != 0)
{
G4cout << "G4DNABornExcitationModel: high energy limit decreased from " <<
HighEnergyLimit()/MeV << " MeV to " << highEnergyLimit/MeV << " MeV" << G4endl;
SetHighEnergyLimit(highEnergyLimit);
proton = protonDef->GetParticleName();
tableFile[proton] = fileProton;
lowEnergyLimit[proton] = 500. * keV;
highEnergyLimit[proton] = 100. * MeV;
// Cross section
G4DNACrossSectionDataSet* tableP = new G4DNACrossSectionDataSet(new G4LogLogInterpolation, eV,scaleFactor );
tableP->LoadData(fileProton);
tableData[proton] = tableP;
}
else
{
G4Exception("G4DNABornExcitationModel::Initialise(): proton is not defined");
}
//
if (table == 0)
if (particle==electronDef)
{
table = new G4DNACrossSectionDataSet(new G4LogLogInterpolation, eV,(1e-22/3.343)*m*m );
table->LoadData("dna/sigma_excitation_p_born");
SetLowEnergyLimit(lowEnergyLimit[electron]);
SetHighEnergyLimit(highEnergyLimit[electron]);
}
if (particle==protonDef)
{
SetLowEnergyLimit(lowEnergyLimit[proton]);
SetHighEnergyLimit(highEnergyLimit[proton]);
}
if( verboseLevel>0 )
{
G4cout << "Born excitation model is initialized " << G4endl
<< "Energy range: "
<< LowEnergyLimit() / keV << " keV - "
<< HighEnergyLimit() / MeV << " MeV " << G4endl;
<< LowEnergyLimit() / eV << " eV - "
<< HighEnergyLimit() / keV << " keV for "
<< particle->GetParticleName()
<< G4endl;
}
if(!isInitialised)
{
isInitialised = true;
@@ -130,77 +167,82 @@ void G4DNABornExcitationModel::Initialise(const G4ParticleDefinition* /*particle
}
// InitialiseElementSelectors(particle,cuts);
// Test if water material
flagMaterialIsWater= false;
densityWater = 0;
const G4ProductionCutsTable* theCoupleTable = G4ProductionCutsTable::GetProductionCutsTable();
if(theCoupleTable)
{
G4int numOfCouples = theCoupleTable->GetTableSize();
if(numOfCouples>0)
{
for (G4int i=0; i<numOfCouples; i++)
{
const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(i);
const G4Material* material = couple->GetMaterial();
if (material->GetName() == "G4_WATER")
{
G4double density = material->GetAtomicNumDensityVector()[1];
flagMaterialIsWater = true;
densityWater = density;
if (verboseLevel > 3)
G4cout << "****** Water material is found with density(cm^-3)=" << density/(cm*cm*cm) << G4endl;
}
}
} // if(numOfCouples>0)
} // if (theCoupleTable)
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4DNABornExcitationModel::CrossSectionPerVolume(const G4Material*,
G4double G4DNABornExcitationModel::CrossSectionPerVolume(const G4Material* material,
const G4ParticleDefinition* particleDefinition,
G4double k,
G4double ekin,
G4double,
G4double)
{
if (verboseLevel > 3)
G4cout << "Calling CrossSectionPerVolume() of G4DNABornExcitationModel" << G4endl;
if (
particleDefinition != G4Proton::ProtonDefinition()
&&
particleDefinition != G4Electron::ElectronDefinition()
)
return 0;
// Calculate total cross section for model
G4double crossSection=0;
if (flagMaterialIsWater)
G4double lowLim = 0;
G4double highLim = 0;
G4double sigma=0;
if (material->GetName() == "G4_WATER")
{
if (particleDefinition == G4Proton::ProtonDefinition())
const G4String& particleName = particleDefinition->GetParticleName();
std::map< G4String,G4double,std::less<G4String> >::iterator pos1;
pos1 = lowEnergyLimit.find(particleName);
if (pos1 != lowEnergyLimit.end())
{
if (k >= lowEnergyLimit && k < highEnergyLimit)
{
crossSection = table->FindValue(k);
}
if (verboseLevel > 3)
{
G4cout << "---> Kinetic energy(keV)=" << k/keV << G4endl;
G4cout << " - Cross section per water molecule (cm^2)=" << crossSection/cm/cm << G4endl;
G4cout << " - Cross section per water molecule (cm^-1)=" << crossSection*densityWater/(1./cm) << G4endl;
}
lowLim = pos1->second;
}
std::map< G4String,G4double,std::less<G4String> >::iterator pos2;
pos2 = highEnergyLimit.find(particleName);
if (pos2 != highEnergyLimit.end())
{
highLim = pos2->second;
}
} // if (flagMaterialIsWater)
return crossSection*densityWater;
if (ekin >= lowLim && ekin < highLim)
{
std::map< G4String,G4DNACrossSectionDataSet*,std::less<G4String> >::iterator pos;
pos = tableData.find(particleName);
if (pos != tableData.end())
{
G4DNACrossSectionDataSet* table = pos->second;
if (table != 0)
{
sigma = table->FindValue(ekin);
}
}
else
{
G4Exception("G4DNABornExcitationModel::CrossSectionPerVolume: attempting to calculate cross section for wrong particle");
}
}
if (verboseLevel > 3)
{
G4cout << "---> Kinetic energy(eV)=" << ekin/eV << G4endl;
G4cout << " - Cross section per water molecule (cm^2)=" << sigma/cm/cm << G4endl;
G4cout << " - Cross section per water molecule (cm^-1)=" << sigma*material->GetAtomicNumDensityVector()[1]/(1./cm) << G4endl;
}
} // if (waterMaterial)
return sigma*material->GetAtomicNumDensityVector()[1];
}
@@ -218,7 +260,9 @@ void G4DNABornExcitationModel::SampleSecondaries(std::vector<G4DynamicParticle*>
G4double k = aDynamicParticle->GetKineticEnergy();
G4int level = RandomSelect(k);
const G4String& particleName = aDynamicParticle->GetDefinition()->GetParticleName();
G4int level = RandomSelect(k,particleName);
G4double excitationEnergy = waterStructure.ExcitationEnergy(level);
G4double newEnergy = k - excitationEnergy;
@@ -233,41 +277,55 @@ void G4DNABornExcitationModel::SampleSecondaries(std::vector<G4DynamicParticle*>
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4int G4DNABornExcitationModel::RandomSelect(G4double k)
G4int G4DNABornExcitationModel::RandomSelect(G4double k, const G4String& particle)
{
G4int level = 0;
G4double* valuesBuffer = new G4double[table->NumberOfComponents()];
std::map< G4String,G4DNACrossSectionDataSet*,std::less<G4String> >::iterator pos;
pos = tableData.find(particle);
const size_t n(table->NumberOfComponents());
size_t i(n);
G4double value = 0.;
while (i>0)
{
i--;
valuesBuffer[i] = table->GetComponent(i)->FindValue(k);
value += valuesBuffer[i];
}
value *= G4UniformRand();
i = n;
while (i > 0)
if (pos != tableData.end())
{
i--;
if (valuesBuffer[i] > value)
G4DNACrossSectionDataSet* table = pos->second;
if (table != 0)
{
delete[] valuesBuffer;
return i;
G4double* valuesBuffer = new G4double[table->NumberOfComponents()];
const size_t n(table->NumberOfComponents());
size_t i(n);
G4double value = 0.;
while (i>0)
{
i--;
valuesBuffer[i] = table->GetComponent(i)->FindValue(k);
value += valuesBuffer[i];
}
value *= G4UniformRand();
i = n;
while (i > 0)
{
i--;
if (valuesBuffer[i] > value)
{
delete[] valuesBuffer;
return i;
}
value -= valuesBuffer[i];
}
if (valuesBuffer) delete[] valuesBuffer;
}
value -= valuesBuffer[i];
}
if (valuesBuffer) delete[] valuesBuffer;
else
{
G4Exception("G4DNABornExcitationModel::RandomSelect attempting to calculate cross section for wrong particle");
}
return level;
}
source/processes/electromagnetic/lowenergy/src/G4DNABornIonisationModel.cc
+32 -76
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DNABornIonisationModel.cc,v 1.14 2009/11/12 03:08:58 sincerti Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4DNABornIonisationModel.cc,v 1.18 2010/11/03 12:22:36 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
#include "G4DNABornIonisationModel.hh"
@@ -238,45 +238,11 @@ void G4DNABornIonisationModel::Initialise(const G4ParticleDefinition* particle,
// InitialiseElementSelectors(particle,cuts);
// Test if water material
flagMaterialIsWater= false;
densityWater = 0;
const G4ProductionCutsTable* theCoupleTable = G4ProductionCutsTable::GetProductionCutsTable();
if(theCoupleTable)
{
G4int numOfCouples = theCoupleTable->GetTableSize();
if(numOfCouples>0)
{
for (G4int i=0; i<numOfCouples; i++)
{
const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(i);
const G4Material* material = couple->GetMaterial();
if (material->GetName() == "G4_WATER")
{
G4double density = material->GetAtomicNumDensityVector()[1];
flagMaterialIsWater = true;
densityWater = density;
if (verboseLevel > 3)
G4cout << "****** Water material is found with density(cm^-3)=" << density/(cm*cm*cm) << G4endl;
}
}
} // if(numOfCouples>0)
} // if (theCoupleTable)
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4DNABornIonisationModel::CrossSectionPerVolume(const G4Material*,
G4double G4DNABornIonisationModel::CrossSectionPerVolume(const G4Material* material,
const G4ParticleDefinition* particleDefinition,
G4double ekin,
G4double,
@@ -299,7 +265,7 @@ G4double G4DNABornIonisationModel::CrossSectionPerVolume(const G4Material*,
G4double highLim = 0;
G4double sigma=0;
if (flagMaterialIsWater)
if (material->GetName() == "G4_WATER")
{
const G4String& particleName = particleDefinition->GetParticleName();
@@ -340,12 +306,12 @@ G4double G4DNABornIonisationModel::CrossSectionPerVolume(const G4Material*,
{
G4cout << "---> Kinetic energy(eV)=" << ekin/eV << G4endl;
G4cout << " - Cross section per water molecule (cm^2)=" << sigma/cm/cm << G4endl;
G4cout << " - Cross section per water molecule (cm^-1)=" << sigma*densityWater/(1./cm) << G4endl;
G4cout << " - Cross section per water molecule (cm^-1)=" << sigma*material->GetAtomicNumDensityVector()[1]/(1./cm) << G4endl;
}
} // if (waterMaterial)
return sigma*densityWater;
return sigma*material->GetAtomicNumDensityVector()[1];
}
@@ -409,49 +375,32 @@ void G4DNABornIonisationModel::SampleSecondaries(std::vector<G4DynamicParticle*>
G4ThreeVector deltaDirection(dirX,dirY,dirZ);
deltaDirection.rotateUz(primaryDirection);
G4double deltaTotalMomentum = std::sqrt(secondaryKinetic*(secondaryKinetic + 2.*electron_mass_c2 ));
if (particle->GetDefinition() == G4Electron::ElectronDefinition())
{
G4double deltaTotalMomentum = std::sqrt(secondaryKinetic*(secondaryKinetic + 2.*electron_mass_c2 ));
G4double finalPx = totalMomentum*primaryDirection.x() - deltaTotalMomentum*deltaDirection.x();
G4double finalPy = totalMomentum*primaryDirection.y() - deltaTotalMomentum*deltaDirection.y();
G4double finalPz = totalMomentum*primaryDirection.z() - deltaTotalMomentum*deltaDirection.z();
G4double finalMomentum = std::sqrt(finalPx*finalPx + finalPy*finalPy + finalPz*finalPz);
finalPx /= finalMomentum;
finalPy /= finalMomentum;
finalPz /= finalMomentum;
G4double finalPx = totalMomentum*primaryDirection.x() - deltaTotalMomentum*deltaDirection.x();
G4double finalPy = totalMomentum*primaryDirection.y() - deltaTotalMomentum*deltaDirection.y();
G4double finalPz = totalMomentum*primaryDirection.z() - deltaTotalMomentum*deltaDirection.z();
G4double finalMomentum = std::sqrt(finalPx*finalPx + finalPy*finalPy + finalPz*finalPz);
finalPx /= finalMomentum;
finalPy /= finalMomentum;
finalPz /= finalMomentum;
G4ThreeVector direction;
direction.set(finalPx,finalPy,finalPz);
G4ThreeVector direction;
direction.set(finalPx,finalPy,finalPz);
fParticleChangeForGamma->ProposeMomentumDirection(direction.unit()) ;
}
else fParticleChangeForGamma->ProposeMomentumDirection(primaryDirection) ;
fParticleChangeForGamma->ProposeMomentumDirection(direction.unit()) ;
fParticleChangeForGamma->SetProposedKineticEnergy(k-bindingEnergy-secondaryKinetic);
fParticleChangeForGamma->ProposeLocalEnergyDeposit(bindingEnergy);
G4DynamicParticle* dp = new G4DynamicParticle (G4Electron::Electron(),deltaDirection,secondaryKinetic) ;
fvect->push_back(dp);
/*
// creating neutral water molechule...
G4DNAGenericMoleculeManager *instance;
instance = G4DNAGenericMoleculeManager::Instance();
G4ParticleDefinition* waterDef = NULL;
G4Molecule* water = instance->GetMolecule("H2O");
waterDef = (G4ParticleDefinition*)water;
direction.set(0.,0.,0.);
//G4DynamicParticle* dynamicWater = new G4DynamicParticle(waterDef, direction, bindingEnergy);
G4DynamicMolecule* dynamicWater = new G4DynamicMolecule(water, direction, bindingEnergy);
//dynamicWater->RemoveElectron(ionizationShell, 1);
G4DynamicMolecule* dynamicWater2 = new G4DynamicMolecule(water, direction, bindingEnergy);
G4DynamicMolecule* dynamicWater3 = new G4DynamicMolecule(water, direction, bindingEnergy);
fvect->push_back(dynamicWater);
fvect->push_back(dynamicWater2);
fvect->push_back(dynamicWater3);
*/
}
}
@@ -511,7 +460,7 @@ G4double k, G4int shell)
if (particleDefinition == G4Proton::ProtonDefinition())
{
G4double maximumKineticEnergyTransfer = 4.* (electron_mass_c2 / proton_mass_c2) * k - (waterStructure.IonisationEnergy(shell));
G4double maximumKineticEnergyTransfer = 4.* (electron_mass_c2 / proton_mass_c2) * k;
G4double crossSectionMaximum = 0.;
for (G4double value = waterStructure.IonisationEnergy(shell);
@@ -563,7 +512,14 @@ void G4DNABornIonisationModel::RandomizeEjectedElectronDirection(G4ParticleDefin
{
G4double maxSecKinetic = 4.* (electron_mass_c2 / proton_mass_c2) * k;
phi = twopi * G4UniformRand();
cosTheta = std::sqrt(secKinetic / maxSecKinetic);
// cosTheta = std::sqrt(secKinetic / maxSecKinetic);
// Restriction below 100 eV from Emfietzoglou (2000)
if (secKinetic>100*eV) cosTheta = std::sqrt(secKinetic / maxSecKinetic);
else cosTheta = (2.*G4UniformRand())-1.;
}
}
source/processes/electromagnetic/lowenergy/src/G4DNAChampionElasticModel.cc
+62 -105
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DNAChampionElasticModel.cc,v 1.10 2009/11/03 15:04:25 sincerti Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4DNAChampionElasticModel.cc,v 1.16 2010/11/11 22:32:22 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
#include "G4DNAChampionElasticModel.hh"
@@ -40,10 +40,9 @@ G4DNAChampionElasticModel::G4DNAChampionElasticModel(const G4ParticleDefinition*
:G4VEmModel(nam),isInitialised(false)
{
killBelowEnergy = 8.23*eV; // Minimum e- energy for energy loss by excitation
killBelowEnergy = 4*eV;
lowEnergyLimit = 0 * eV;
lowEnergyLimitOfModel = 7.4 * eV; // The model lower energy is 7.4 eV
highEnergyLimit = 10 * MeV;
highEnergyLimit = 1. * MeV;
SetLowEnergyLimit(lowEnergyLimit);
SetHighEnergyLimit(highEnergyLimit);
@@ -63,6 +62,7 @@ G4DNAChampionElasticModel::G4DNAChampionElasticModel(const G4ParticleDefinition*
<< highEnergyLimit / MeV << " MeV"
<< G4endl;
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
@@ -131,14 +131,14 @@ void G4DNAChampionElasticModel::Initialise(const G4ParticleDefinition* /*particl
tableData[electron] = tableE;
// For final state
char *path = getenv("G4LEDATA");
if (!path)
G4Exception("G4FinalStateElasticChampion::Initialise: G4LEDATA environment variable not set");
std::ostringstream eFullFileName;
eFullFileName << path << "/dna/sigmadiff_elastic_e_champion.dat";
eFullFileName << path << "/dna/sigmadiff_cumulatedshort_elastic_e_champion.dat";
std::ifstream eDiffCrossSection(eFullFileName.str().c_str());
if (!eDiffCrossSection) G4Exception("G4DNAChampionElasticModel::Initialise: error opening electron DATA FILE");
@@ -150,8 +150,9 @@ void G4DNAChampionElasticModel::Initialise(const G4ParticleDefinition* /*particl
double tDummy;
double eDummy;
eDiffCrossSection>>tDummy>>eDummy;
// SI : mandatory eVecm initialization
if (tDummy != eTdummyVec.back())
{
eTdummyVec.push_back(tDummy);
@@ -160,11 +161,8 @@ void G4DNAChampionElasticModel::Initialise(const G4ParticleDefinition* /*particl
eDiffCrossSection>>eDiffCrossSectionData[tDummy][eDummy];
// SI : only if not end of file reached !
if (!eDiffCrossSection.eof()) eDiffCrossSectionData[tDummy][eDummy]*=scaleFactor;
if (eDummy != eVecm[tDummy].back()) eVecm[tDummy].push_back(eDummy);
}
// End final state
@@ -196,45 +194,11 @@ void G4DNAChampionElasticModel::Initialise(const G4ParticleDefinition* /*particl
// InitialiseElementSelectors(particle,cuts);
// Test if water material
flagMaterialIsWater= false;
densityWater = 0;
const G4ProductionCutsTable* theCoupleTable = G4ProductionCutsTable::GetProductionCutsTable();
if(theCoupleTable)
{
G4int numOfCouples = theCoupleTable->GetTableSize();
if(numOfCouples>0)
{
for (G4int i=0; i<numOfCouples; i++)
{
const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(i);
const G4Material* material = couple->GetMaterial();
if (material->GetName() == "G4_WATER")
{
G4double density = material->GetAtomicNumDensityVector()[1];
flagMaterialIsWater = true;
densityWater = density;
if (verboseLevel > 3)
G4cout << "****** Water material is found with density(cm^-3)=" << density/(cm*cm*cm) << G4endl;
}
}
} // if(numOfCouples>0)
} // if (theCoupleTable)
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4DNAChampionElasticModel::CrossSectionPerVolume(const G4Material*,
G4double G4DNAChampionElasticModel::CrossSectionPerVolume(const G4Material* material,
const G4ParticleDefinition* p,
G4double ekin,
G4double,
@@ -247,14 +211,14 @@ G4double G4DNAChampionElasticModel::CrossSectionPerVolume(const G4Material*,
G4double sigma=0;
if (flagMaterialIsWater)
if (material->GetName() == "G4_WATER")
{
const G4String& particleName = p->GetParticleName();
if (ekin < highEnergyLimit)
{
//SI : XS must not be zero otherwise sampling of secondaries method ignored
if (ekin < lowEnergyLimitOfModel) ekin = lowEnergyLimitOfModel;
if (ekin < killBelowEnergy) return DBL_MAX;
//
std::map< G4String,G4DNACrossSectionDataSet*,std::less<G4String> >::iterator pos;
@@ -278,12 +242,12 @@ G4double G4DNAChampionElasticModel::CrossSectionPerVolume(const G4Material*,
{
G4cout << "---> Kinetic energy(eV)=" << ekin/eV << G4endl;
G4cout << " - Cross section per water molecule (cm^2)=" << sigma/cm/cm << G4endl;
G4cout << " - Cross section per water molecule (cm^-1)=" << sigma*densityWater/(1./cm) << G4endl;
G4cout << " - Cross section per water molecule (cm^-1)=" << sigma*material->GetAtomicNumDensityVector()[1]/(1./cm) << G4endl;
}
} // if (flagMaterialIsWater)
}
return sigma*densityWater;
return sigma*material->GetAtomicNumDensityVector()[1];
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
@@ -309,6 +273,7 @@ void G4DNAChampionElasticModel::SampleSecondaries(std::vector<G4DynamicParticle*
if (electronEnergy0>= killBelowEnergy && electronEnergy0 < highEnergyLimit)
{
G4double cosTheta = RandomizeCosTheta(electronEnergy0);
G4double phi = 2. * pi * G4UniformRand();
@@ -333,11 +298,10 @@ void G4DNAChampionElasticModel::SampleSecondaries(std::vector<G4DynamicParticle*
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4DNAChampionElasticModel::DifferentialCrossSection
(G4ParticleDefinition * particleDefinition, G4double k, G4double theta)
G4double G4DNAChampionElasticModel::Theta
(G4ParticleDefinition * particleDefinition, G4double k, G4double integrDiff)
{
G4double sigma = 0.;
G4double theta = 0.;
G4double valueT1 = 0;
G4double valueT2 = 0;
G4double valueE21 = 0;
@@ -349,18 +313,15 @@ G4double G4DNAChampionElasticModel::DifferentialCrossSection
G4double xs21 = 0;
G4double xs22 = 0;
//SI : ensure the correct computation of cross section at the 180*deg limit
if (theta==180.) theta=theta-1e-9;
if (particleDefinition == G4Electron::ElectronDefinition())
{
std::vector<double>::iterator t2 = std::upper_bound(eTdummyVec.begin(),eTdummyVec.end(), k);
std::vector<double>::iterator t1 = t2-1;
std::vector<double>::iterator e12 = std::upper_bound(eVecm[(*t1)].begin(),eVecm[(*t1)].end(), theta);
std::vector<double>::iterator e12 = std::upper_bound(eVecm[(*t1)].begin(),eVecm[(*t1)].end(), integrDiff);
std::vector<double>::iterator e11 = e12-1;
std::vector<double>::iterator e22 = std::upper_bound(eVecm[(*t2)].begin(),eVecm[(*t2)].end(), theta);
std::vector<double>::iterator e22 = std::upper_bound(eVecm[(*t2)].begin(),eVecm[(*t2)].end(), integrDiff);
std::vector<double>::iterator e21 = e22-1;
valueT1 =*t1;
@@ -374,24 +335,18 @@ G4double G4DNAChampionElasticModel::DifferentialCrossSection
xs12 = eDiffCrossSectionData[valueT1][valueE12];
xs21 = eDiffCrossSectionData[valueT2][valueE21];
xs22 = eDiffCrossSectionData[valueT2][valueE22];
}
G4double xsProduct = xs11 * xs12 * xs21 * xs22;
}
if (xs11==0 || xs12==0 ||xs21==0 ||xs22==0) return (0.);
if (xsProduct != 0.)
{
sigma = QuadInterpolator( valueE11, valueE12,
if (xs11==0 && xs12==0 && xs21==0 && xs22==0) return (0.);
theta = QuadInterpolator ( valueE11, valueE12,
valueE21, valueE22,
xs11, xs12,
xs21, xs22,
valueT1, valueT2,
k, theta );
}
return sigma;
k, integrDiff );
return theta;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
@@ -410,6 +365,20 @@ G4double G4DNAChampionElasticModel::LinLogInterpolate(G4double e1,
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4DNAChampionElasticModel::LinLinInterpolate(G4double e1,
G4double e2,
G4double e,
G4double xs1,
G4double xs2)
{
G4double d1 = xs1;
G4double d2 = xs2;
G4double value = (d1 + (d2 - d1)*(e - e1)/ (e2 - e1));
return value;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4DNAChampionElasticModel::LogLogInterpolate(G4double e1,
G4double e2,
G4double e,
@@ -425,6 +394,7 @@ G4double G4DNAChampionElasticModel::LogLogInterpolate(G4double e1,
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4DNAChampionElasticModel::QuadInterpolator(G4double e11, G4double e12,
G4double e21, G4double e22,
G4double xs11, G4double xs12,
@@ -432,17 +402,24 @@ G4double G4DNAChampionElasticModel::QuadInterpolator(G4double e11, G4double e12,
G4double t1, G4double t2,
G4double t, G4double e)
{
// Log-Log
// Log-Log
/*
G4double interpolatedvalue1 = LogLogInterpolate(e11, e12, e, xs11, xs12);
G4double interpolatedvalue2 = LogLogInterpolate(e21, e22, e, xs21, xs22);
G4double value = LogLogInterpolate(t1, t2, t, interpolatedvalue1, interpolatedvalue2);
*/
// Lin-Log
// Lin-Log
G4double interpolatedvalue1 = LinLogInterpolate(e11, e12, e, xs11, xs12);
G4double interpolatedvalue2 = LinLogInterpolate(e21, e22, e, xs21, xs22);
G4double value = LinLogInterpolate(t1, t2, t, interpolatedvalue1, interpolatedvalue2);
*/
// Lin-Lin
G4double interpolatedvalue1 = LinLinInterpolate(e11, e12, e, xs11, xs12);
G4double interpolatedvalue2 = LinLinInterpolate(e21, e22, e, xs21, xs22);
G4double value = LinLinInterpolate(t1, t2, t, interpolatedvalue1, interpolatedvalue2);
return value;
}
@@ -450,36 +427,16 @@ G4double G4DNAChampionElasticModel::QuadInterpolator(G4double e11, G4double e12,
G4double G4DNAChampionElasticModel::RandomizeCosTheta(G4double k)
{
// ***** Similar method as for screened Rutherford scattering
G4int iMax=180;
G4double max=0;
G4double tmp=0;
// Look for maximum :
for (G4int i=0; i<iMax; i++)
{
tmp = DifferentialCrossSection(G4Electron::ElectronDefinition(),k/eV,G4double(i)*180./(iMax-1));
if (tmp>max) max = tmp;
}
G4double integrdiff=0;
G4double uniformRand=G4UniformRand();
integrdiff = uniformRand;
G4double theta=0.;
G4double cosTheta=0.;
theta = Theta(G4Electron::ElectronDefinition(),k/eV,integrdiff);
G4double oneOverMax=0;
if (max!=0) oneOverMax = 1./max;
G4double cosTheta = 0.;
G4double fCosTheta = 0.;
do
{
cosTheta = 2. * G4UniformRand() - 1.;
fCosTheta = oneOverMax * DifferentialCrossSection(G4Electron::ElectronDefinition(),k/eV,std::acos(cosTheta)*180./pi);
}
while (fCosTheta < G4UniformRand());
if (verboseLevel > 3)
{
G4cout << "---> Cos(theta)=" << cosTheta << G4endl;
}
cosTheta= std::cos(theta*pi/180);
return cosTheta;
}
source/processes/electromagnetic/lowenergy/src/G4DNAChargeDecrease.cc
+12 -3
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DNAChargeDecrease.cc,v 1.3 2009/03/04 13:28:49 sincerti Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4DNAChargeDecrease.cc,v 1.4 2010/03/18 16:36:48 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
#include "G4DNAChargeDecrease.hh"
@@ -71,7 +71,16 @@ void G4DNAChargeDecrease::InitialiseProcess(const G4ParticleDefinition* p)
G4String name = p->GetParticleName();
if( name == "proton" || name == "alpha" || name == "alpha+" )
if( name == "proton" )
{
if(!Model()) SetModel(new G4DNADingfelderChargeDecreaseModel);
Model()->SetLowEnergyLimit(100*eV);
Model()->SetHighEnergyLimit(10*MeV);
AddEmModel(1, Model());
}
if( name == "alpha" || name == "alpha+" )
{
if(!Model()) SetModel(new G4DNADingfelderChargeDecreaseModel);
Model()->SetLowEnergyLimit(1*keV);
source/processes/electromagnetic/lowenergy/src/G4DNAChargeIncrease.cc
+13 -3
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DNAChargeIncrease.cc,v 1.3 2009/03/04 13:28:49 sincerti Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4DNAChargeIncrease.cc,v 1.4 2010/03/18 16:36:48 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
#include "G4DNAChargeIncrease.hh"
@@ -71,7 +71,16 @@ void G4DNAChargeIncrease::InitialiseProcess(const G4ParticleDefinition* p)
G4String name = p->GetParticleName();
if( name == "hydrogen" || name =="alpha+" || name =="helium" )
if( name == "hydrogen" )
{
if(!Model()) SetModel(new G4DNADingfelderChargeIncreaseModel);
Model()->SetLowEnergyLimit(100*eV);
Model()->SetHighEnergyLimit(10*MeV);
AddEmModel(1, Model());
}
if( name =="alpha+" || name =="helium" )
{
if(!Model()) SetModel(new G4DNADingfelderChargeIncreaseModel);
Model()->SetLowEnergyLimit(1*keV);
@@ -79,6 +88,7 @@ void G4DNAChargeIncrease::InitialiseProcess(const G4ParticleDefinition* p)
AddEmModel(1, Model());
}
}
}
source/processes/electromagnetic/lowenergy/src/G4DNADingfelderChargeDecreaseModel.cc
+11 -43
View File
@@ -23,8 +23,8 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DNADingfelderChargeDecreaseModel.cc,v 1.6 2009/08/13 11:32:47 sincerti Exp $
// GEANT4 tag $Name: geant4-09-03 $
// $Id: G4DNADingfelderChargeDecreaseModel.cc,v 1.9 2010/04/06 11:00:35 sincerti Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
#include "G4DNADingfelderChargeDecreaseModel.hh"
@@ -83,7 +83,7 @@ void G4DNADingfelderChargeDecreaseModel::Initialise(const G4ParticleDefinition*
if (protonDef != 0)
{
proton = protonDef->GetParticleName();
lowEnergyLimit[proton] = 1. * keV;
lowEnergyLimit[proton] = 100. * eV;
highEnergyLimit[proton] = 10. * MeV;
}
else
@@ -208,45 +208,11 @@ void G4DNADingfelderChargeDecreaseModel::Initialise(const G4ParticleDefinition*
// InitialiseElementSelectors(particle,cuts);
// Test if water material
flagMaterialIsWater= false;
densityWater = 0;
const G4ProductionCutsTable* theCoupleTable = G4ProductionCutsTable::GetProductionCutsTable();
if(theCoupleTable)
{
G4int numOfCouples = theCoupleTable->GetTableSize();
if(numOfCouples>0)
{
for (G4int i=0; i<numOfCouples; i++)
{
const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(i);
const G4Material* material = couple->GetMaterial();
if (material->GetName() == "G4_WATER")
{
G4double density = material->GetAtomicNumDensityVector()[1];
flagMaterialIsWater = true;
densityWater = density;
if (verboseLevel > 3)
G4cout << "****** Water material is found with density(cm^-3)=" << density/(cm*cm*cm) << G4endl;
}
}
} // if(numOfCouples>0)
} // if (theCoupleTable)
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4DNADingfelderChargeDecreaseModel::CrossSectionPerVolume(const G4Material*,
G4double G4DNADingfelderChargeDecreaseModel::CrossSectionPerVolume(const G4Material* material,
const G4ParticleDefinition* particleDefinition,
G4double k,
G4double,
@@ -274,7 +240,7 @@ G4double G4DNADingfelderChargeDecreaseModel::CrossSectionPerVolume(const G4Mater
G4double highLim = 0;
G4double crossSection = 0.;
if (flagMaterialIsWater)
if (material->GetName() == "G4_WATER")
{
const G4String& particleName = particleDefinition->GetParticleName();
@@ -303,12 +269,12 @@ G4double G4DNADingfelderChargeDecreaseModel::CrossSectionPerVolume(const G4Mater
{
G4cout << "---> Kinetic energy(eV)=" << k/eV << G4endl;
G4cout << " - Cross section per water molecule (cm^2)=" << crossSection/cm/cm << G4endl;
G4cout << " - Cross section per water molecule (cm^-1)=" << crossSection*densityWater/(1./cm) << G4endl;
G4cout << " - Cross section per water molecule (cm^-1)=" << crossSection*material->GetAtomicNumDensityVector()[1]/(1./cm) << G4endl;
}
} // if (flagMaterialIsWater)
}
return crossSection*densityWater;
return crossSection*material->GetAtomicNumDensityVector()[1];
}
@@ -326,6 +292,8 @@ void G4DNADingfelderChargeDecreaseModel::SampleSecondaries(std::vector<G4Dynamic
G4double inK = aDynamicParticle->GetKineticEnergy();
G4ParticleDefinition* definition = aDynamicParticle->GetDefinition();
G4double particleMass = definition->GetPDGMass();
G4int finalStateIndex = RandomSelect(inK,definition);
@@ -337,7 +305,7 @@ void G4DNADingfelderChargeDecreaseModel::SampleSecondaries(std::vector<G4Dynamic
if (definition==G4Proton::Proton())
outK = inK - n*(inK*electron_mass_c2/proton_mass_c2) - waterBindingEnergy + outgoingParticleBindingEnergy;
else
outK = inK - n*(inK*electron_mass_c2/(3728*MeV)) - waterBindingEnergy + outgoingParticleBindingEnergy;
outK = inK - n*(inK*electron_mass_c2/particleMass) - waterBindingEnergy + outgoingParticleBindingEnergy;
if (outK<0)
{

Some files were not shown because too many files have changed in this diff Show More