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

Import Geant4 4.0.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-08 16:18:25 +02:00
parent 36c080dca6
commit 921d3b1cda
3990 changed files with 185376 additions and 82884 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/hadronic/models/cascade/evaporation/src/G4BEChargedChannel.cc
+202
View File
@@ -0,0 +1,202 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * authors in the GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// Implementation of the HETC88 code into Geant4.
// Evaporation and De-excitation parts
// T. Lampen, Helsinki Institute of Physics, May-2000
#include "G4BEChargedChannel.hh"
G4BEChargedChannel::G4BEChargedChannel()
{
verboseLevel = 0;
}
G4BEChargedChannel::~G4BEChargedChannel()
{
}
void G4BEChargedChannel::calculateProbability()
{
G4int residualZ = nucleusZ - particleZ;
G4int residualA = nucleusA - particleA;
// Check if nucleus is too small, if this evaporation channel
// leads to an impossible residual nucleus or if there is no enough
// energy.
if ( nucleusA < 2.0 * particleA ||
nucleusZ < 2.0 * particleZ ||
residualA <= residualZ ||
excitationEnergy - getThresh() - correction < 0 )
{
if ( verboseLevel >= 6 )
G4cout << "G4BEChargedChannel : calculateProbability for " << getName() << " = 0 " << G4endl;
emissionProbability = 0;
return;
}
// In HETC88 s-s0 was used in exp( s ), in which s0 was either 50 or
// max(s_i), where i goes over all channels.
G4double levelParam = getLevelDensityParameter();
G4double s = 2 * sqrt( levelParam * ( excitationEnergy - getThresh() - correction ) );
G4double constant = A / 2 * ( 2 * spin + 1 ) * ( 1 + coulombFactor() );
G4double eye1 = ( pow( s, 2 ) - 3 * s + 3 ) / ( 4 * pow( levelParam, 2 ) ) * exp( s );
emissionProbability = constant * pow( residualA, 0.6666666 ) * eye1;
if ( verboseLevel >= 6 )
G4cout << "G4BEChargedChannel : calculateProbability for " << getName() << G4endl
<< " res A = " << residualA << G4endl
<< " res Z = " << residualZ << G4endl
<< " c*(c_i+1) = "<< constant << G4endl
<< " qmfactor = "<< qmFactor() << G4endl
<< " coulombfactor = "<< coulombFactor() << G4endl
<< " E = " << excitationEnergy << G4endl
<< " correction = " << correction << G4endl
<< " eye1 = " << eye1 << G4endl
<< " levelParam = " << levelParam << G4endl
<< " thresh = " << getThresh() << G4endl
<< " s = " << s << G4endl
<< " probability = " << emissionProbability << G4endl;
return;
}
G4double G4BEChargedChannel::sampleKineticEnergy()
{
// G4double randExp1;
// G4double randExp2;
// G4double s;
// G4double levelParam;
// G4double kineticEnergyAv;
// G4double kineticEnergy;
// randExp1 = RandExponential::shoot( 1 );
// randExp2 = RandExponential::shoot( 1 );
// levelParam = getLevelDensityParameter();
// s = 2 * sqrt( levelParam * ( excitationEnergy - getThresh() - correction ) );
// kineticEnergyAv = 2 * ( pow( s, 3 ) - 6.0 * pow( s, 2 ) + 15.0 * s - 15.0 ) /
// ( ( 2.0 * pow( s, 2 ) - 6.0 * s + 6.0 ) * levelParam );
// kineticEnergy = 0.5 * ( randExp1 + randExp2 ) * kineticEnergyAv + getThresh() - getQ();
// if ( verboseLevel >= 10 )
// G4cout << " G4BEChargedChannel : sampleKineticEnergy() " << G4endl
// << " kinetic e = " << kineticEnergy << G4endl
// << " average = " << kineticEnergyAv << G4endl
// << " s = " << s << G4endl
// << " levelParam = " << levelParam << G4endl
// << " randExp1 = " << randExp1 << G4endl
// << " randExp2 = " << randExp2 << G4endl;
G4double levelParam;
levelParam = getLevelDensityParameter();
const G4double xMax = excitationEnergy - getThresh() - correction; // maximum number
const G4double xProb = ( - 1 + sqrt ( 1 + 4 * levelParam * xMax ) ) / ( 2 * levelParam ); // most probable value
const G4double m = xProb * exp ( 2 * sqrt ( levelParam * ( xMax - xProb ) ) ); // maximum value of P(x)
// Sample x according to density function P(x) with rejection method
G4double r1;
G4double r2;
G4int koe=0;
do
{
r1 = G4UniformRand() * xMax;
r2 = G4UniformRand() * m;
koe++;
}
while ( r1 * exp ( 2 * sqrt ( levelParam * ( xMax - r1 ) ) ) < r2 );
// G4cout << "Q ch " << koe << G4endl;
G4double kineticEnergy = r1 + getCoulomb(); // add coulomb potential;
if ( verboseLevel >= 10 )
G4cout << " G4BENeutronChannel : sampleKineticEnergy() " << G4endl
<< " kinetic n e = " << kineticEnergy << G4endl
<< " levelParam = " << levelParam << G4endl
<< " thresh= " << getThresh() << G4endl;
return kineticEnergy;
}
G4double G4BEChargedChannel::coulombFactorForProton()
{
// Coefficient c_p:s for empirical cross section formula are
// defined with the proton constant. See Dostrovsky, Phys. Rev.,
// vol. 116, 1959.
G4double t[7] = { 0.08 , 0 , -0.06 , -0.1 , -0.1 , -0.1 , -0.1 };
G4int Z = nucleusZ - particleZ;
if ( Z >= 70.0 ) return t[6];
if ( Z <= 10.0 ) return t[0];
// Linear interpolation
G4int n = G4int( 0.1 * Z + 1.0 );
G4float x = ( 10 * n - Z ) * 0.1;
G4double ret_val = x * t[n - 2] + ( 1.0 - x ) * t[n-1];
return ret_val;
}
G4double G4BEChargedChannel::qmFactorForProton()
{
// Coefficient k_p for empirical cross section formula are defined
// with the proton constant. See Dostrovsky, Phys. Rev., vol. 116,
// 1959
G4double t[7] = { 0.36, 0.51, 0.60, 0.66, 0.68, 0.69, 0.69 };
G4int Z = nucleusZ - particleZ;
if ( Z >= 70.0 ) return t[6];
if ( Z <= 10.0 ) return t[0];
// Linear interpolation
G4int n = G4int( 0.1 * Z + 1.0 );
G4float x = ( 10 * n - Z ) * 0.1;
return x * t[n - 2] + ( 1.0 - x ) * t[n-1];
}
G4double G4BEChargedChannel::qmFactorForAlpha()
{
// Coefficient k_alpha for empirical cross section formula presented
// in Dostrovsky, Phys. Rev., vol. 116, 1959
G4double t[7] = { 0.77, 0.81, 0.85, 0.89, 0.93, 0.97, 1.00 };
G4int Z = nucleusZ - particleZ;
if ( Z >= 70.0 ) return t[6];
if ( Z <= 10.0 ) return t[0];
// Linear interpolation
G4int n = G4int( 0.1 * Z + 1.0 );
G4float x = ( 10 * n - Z ) * 0.1;
return x * t[n - 2] + ( 1.0 - x ) * t[n-1];
}
source/processes/hadronic/models/cascade/evaporation/src/G4BEDeuteronChannel.cc
+76
View File
@@ -0,0 +1,76 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * authors in the GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// Implementation of the HETC88 code into Geant4.
// Evaporation and De-excitation parts
// T. Lampen, Helsinki Institute of Physics, May-2000
#include "G4BEDeuteronChannel.hh"
#include "G4Deuteron.hh"
G4BEDeuteronChannel::G4BEDeuteronChannel()
{
name = "deuteron";
verboseLevel = 0;
particleA = 2;
particleZ = 1;
rho = 0.70588;
exmass = G4NucleiProperties::GetMassExcess( particleA, particleZ );
A=2;
spin = 1;
}
G4BEDeuteronChannel::~G4BEDeuteronChannel()
{
}
G4DynamicParticle* G4BEDeuteronChannel::emit()
{
G4double u, v, w;
G4DynamicParticle * pParticle = new G4DynamicParticle;
pParticle -> SetDefinition( G4Deuteron::Deuteron() );
pParticle -> SetKineticEnergy( sampleKineticEnergy() );
isotropicCosines( u, v, w );
pParticle -> SetMomentumDirection( u, v, w );
return pParticle;
}
G4double G4BEDeuteronChannel::coulombFactor()
{
// Coefficient c_i representing the variation of charged-particle
// capture cross sections with Z for each particle. See Dostrovsky,
// Phys. Rev. 116, 1959.
return 0.5 * coulombFactorForProton();
}
G4double G4BEDeuteronChannel::qmFactor()
{
// Coefficient k_i representing the quantum mechanical barrier
// penetration, see Dostrovsky, Phys. Rev. 116, 1959.
return qmFactorForProton() + 0.06;
}
source/processes/hadronic/models/cascade/evaporation/src/G4BEGammaDeexcitation.cc
+107
View File
@@ -0,0 +1,107 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * authors in the GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// Implementation of the HETC88 code into Geant4.
// Evaporation and De-excitation parts
// T. Lampen, Helsinki Institute of Physics, May-2000
#include "globals.hh"
#include "G4ios.hh"
#include "Randomize.hh"
#include "G4Neutron.hh"
#include "G4Proton.hh"
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4Alpha.hh"
#include "G4Nucleus.hh"
#include "G4BEGammaDeexcitation.hh"
G4BEGammaDeexcitation::G4BEGammaDeexcitation()
{
}
G4BEGammaDeexcitation::~G4BEGammaDeexcitation()
{
}
void G4BEGammaDeexcitation::setVerboseLevel( G4int level )
{
verboseLevel = level ;
}
void G4BEGammaDeexcitation::setNucleusA( G4int a )
{
nucleusA = a;
}
void G4BEGammaDeexcitation::setNucleusZ( G4int z )
{
nucleusZ = z;
}
void G4BEGammaDeexcitation::setExcitationEnergy( G4double energy )
{
excitationEnergy = energy;
}
G4double G4BEGammaDeexcitation::sampleKineticEnergy()
{
return excitationEnergy * G4UniformRand();
}
G4DynamicParticle * G4BEGammaDeexcitation::emit()
{
// Isotropic distribution assumed to gammas
G4double u, v, w;
G4DynamicParticle * pParticle = new G4DynamicParticle;
pParticle -> SetDefinition( G4Gamma::Gamma() );
pParticle -> SetKineticEnergy( sampleKineticEnergy() );
isotropicCosines( u, v, w );
pParticle -> SetMomentumDirection( u, v, w );
return pParticle;
}
void G4BEGammaDeexcitation::isotropicCosines( G4double & u,
G4double & v,
G4double & w )
{
// Samples isotropic random direction cosines.
G4double CosTheta = 1.0 - 2.0 * G4UniformRand();
G4double SinTheta = sqrt( 1.0 - CosTheta * CosTheta );
G4double Phi = twopi * G4UniformRand();
u = cos( Phi ) * SinTheta;
v = cos( Phi ) * CosTheta,
w = sin( Phi );
return;
}
source/processes/hadronic/models/cascade/evaporation/src/G4BEHe3Channel.cc
+71
View File
@@ -0,0 +1,71 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * authors in the GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// Implementation of the HETC88 code into Geant4.
// Evaporation and De-excitation parts
// T. Lampen, Helsinki Institute of Physics, May-2000
#include "G4BEHe3Channel.hh"
#include "G4He3.hh"
G4BEHe3Channel::G4BEHe3Channel()
{
name = "He3";
verboseLevel = 0;
particleA = 3;
particleZ = 2;
rho = 0.70588;
A=3;
spin = 0.5;
}
G4BEHe3Channel::~G4BEHe3Channel()
{
}
G4DynamicParticle* G4BEHe3Channel::emit()
{
G4double u , v , w;
G4DynamicParticle * pParticle = new G4DynamicParticle;
pParticle -> SetDefinition( G4He3::He3() );
pParticle -> SetKineticEnergy( sampleKineticEnergy() );
isotropicCosines( u, v, w);
pParticle -> SetMomentumDirection( u, v, w);
return pParticle;
}
G4double G4BEHe3Channel::coulombFactor()
{
return 0;
}
G4double G4BEHe3Channel::qmFactor()
{
// Coefficient representing the quantum mechanical barrier
// penetration, see Dostrovsky, Phys. Rev. 116, 1959.
return qmFactorForAlpha() - 0.06;
}
source/processes/hadronic/models/cascade/evaporation/src/G4BEHe4Channel.cc
+71
View File
@@ -0,0 +1,71 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * authors in the GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// Implementation of the HETC88 code into Geant4.
// Evaporation and De-excitation parts
// T. Lampen, Helsinki Institute of Physics, May-2000
#include "G4BEHe4Channel.hh"
#include "G4Alpha.hh"
G4BEHe4Channel::G4BEHe4Channel()
{
name = "He4";
verboseLevel = 0;
particleA = 4;
particleZ = 2;
rho = 0.70588;
A=4;
spin = 0;
}
G4BEHe4Channel::~G4BEHe4Channel()
{
}
G4DynamicParticle * G4BEHe4Channel::emit()
{
G4double u , v , w;
G4DynamicParticle * pParticle = new G4DynamicParticle;
pParticle -> SetDefinition( G4Alpha::Alpha() );
pParticle -> SetKineticEnergy( sampleKineticEnergy() );
isotropicCosines( u , v , w );
pParticle -> SetMomentumDirection( u , v , w );
return pParticle;
}
G4double G4BEHe4Channel::coulombFactor()
{
return 0;
}
G4double G4BEHe4Channel::qmFactor()
{
// Coefficient representing the quantum mechanical barrier
// penetration, see Dostrovsky, Phys. Rev. 116, 1959.
return qmFactorForAlpha();
}
source/processes/hadronic/models/cascade/evaporation/src/G4BENeutronChannel.cc
+201
View File
@@ -0,0 +1,201 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * authors in the GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// Implementation of the HETC88 code into Geant4.
// Evaporation and De-excitation parts
// T. Lampen, Helsinki Institute of Physics, May-2000
#include "globals.hh"
#include "G4ios.hh"
#include "Randomize.hh"
#include "G4Neutron.hh"
#include "G4Proton.hh"
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4Alpha.hh"
#include "G4ParticleTable.hh"
#include "G4Nucleus.hh"
#include "G4BENeutronChannel.hh"
G4BENeutronChannel::G4BENeutronChannel()
{
name = "neutron";
particleA = 1;
particleZ = 0;
verboseLevel = 0;
rho = 0;
}
G4BENeutronChannel::~G4BENeutronChannel()
{
}
void G4BENeutronChannel::calculateProbability()
{
const G4int residualZ = nucleusZ - particleZ;
const G4int residualA = nucleusA - particleA;
if ( nucleusA < 2.0 * particleA ||
nucleusZ < 2.0 * particleZ ||
residualA <= residualZ ||
excitationEnergy - getThresh() - correction < 0 )
{
if ( verboseLevel >= 6 )
G4cout << "G4BENeutronChannel : calculateProbability = 0 " << G4endl;
emissionProbability = 0;
return;
}
// In HETC88 s-s0 was used in exp( s ), in which s0 was either 50 or
// max(s_i), where i goes over all channels.
const G4double levelParam = getLevelDensityParameter();
const G4double s = 2 * sqrt( levelParam * ( excitationEnergy - getThresh() - correction ) );
const G4double temp = ( pow( s, 2 ) - 3 * s + 3 ) / ( 4 * pow( levelParam, 2 ) )
+ beta() * ( s - 1 ) / ( 2 * levelParam );
const G4double eye0 = exp( s ) * ( s - 1 ) / ( 2 * levelParam );
const G4double eye1 = ( pow( s, 2 ) - 3*s +3 ) * exp( s ) / ( 4 * pow( levelParam, 2 ) ) ;
emissionProbability = pow( residualA, 0.666666 ) * alpha() * ( eye1 + beta() * eye0 );
if ( verboseLevel >= 6 )
G4cout << "G4BENeutronChannel : calculateProbability " << G4endl
<< " res A = " << residualA << G4endl
<< " res Z = " << residualZ << G4endl
<< " alpha = " << alpha() << G4endl
<< " beta = " << beta() << G4endl
<< " E = " << excitationEnergy << G4endl
<< " correction = " << correction << G4endl
<< " eye1 = " << eye1 << G4endl
<< " eye0 = " << eye0 << G4endl
<< " levelParam = " << levelParam << G4endl
<< " thresh = " << getThresh() << G4endl
<< " s = " << s << G4endl
<< " probability = " << emissionProbability << G4endl;
return;
}
G4double G4BENeutronChannel::sampleKineticEnergy()
{
// Samples the kinetic energy of the particle in CMS
//
// Algorithm used in HETC98
//
// G4double e1;
// G4double e2;
// G4double s;
// G4double levelParam;
// G4double eye0;
// G4double eye1;
// G4double kineticEnergyAv;
// G4double kineticEnergy;
// e1 = RandExponential::shoot( 1 );
// e2 = RandExponential::shoot( 1 );
// levelParam = getLevelDensityParameter();
// s = 2 * sqrt( levelParam * ( excitationEnergy - getThresh() - correction ) );
// eye0 = 0.5 * ( s - 1 ) * exp( s ) / levelParam;
// eye1 = ( pow( s, 2 ) - 3*s + 3 ) * exp( s ) / ( 4 * pow( levelParam, 2 ) );
// kineticEnergyAv = 2 * ( pow( s, 3 ) - 6.0 * pow( s, 2 ) + 15.0 * s - 15.0 ) /
// ( ( 2.0 * pow( s, 2 ) - 6.0 * s + 6.0 ) * levelParam );
// kineticEnergyAv = ( kineticEnergyAv + beta() ) / ( 1.0 + beta() * eye0
// / eye1 );
// kineticEnergy = 0.5 * ( e1 + e2 ) * kineticEnergyAv + getThresh() - getQ();
////////////////
// A random number is sampled from the density function
// P(x) = x * exp ( 2 sqrt ( a ( xMax - x ) ) ) [not normalized],
// x belongs to [ 0, xMax ]
// with the 'Hit or Miss' -method
// Kinetic energy is this energy scaled properly
G4double levelParam;
levelParam = getLevelDensityParameter();
const G4double xMax = excitationEnergy - getThresh() - correction + beta(); // maximum number
const G4double xProb = ( - 1 + sqrt ( 1 + 4 * levelParam * xMax ) ) / ( 2 * levelParam ); // most probable value
const G4double m = xProb * exp ( 2 * sqrt ( levelParam * ( xMax - xProb ) ) ); // maximum value of P(x)
// Sample x according to density function P(x) with rejection method
G4double r1;
G4double r2;
G4int koe=0;
do
{
r1 = beta() + G4UniformRand() * ( xMax - beta() );
r2 = G4UniformRand() * m;
koe++;
}
while ( r1 * exp ( 2 * sqrt ( levelParam * ( xMax - r1 ) ) ) < r2 );
// G4cout << koe << G4endl;
G4double kineticEnergy = r1 - beta();
if ( verboseLevel >= 10 )
G4cout << " G4BENeutronChannel : sampleKineticEnergy() " << G4endl
<< " kinetic n e = " << kineticEnergy << G4endl
<< " levelParam = " << levelParam << G4endl
<< " thresh= " << getThresh() << G4endl
<< " beta= " << beta() << G4endl;
return kineticEnergy;
}
G4DynamicParticle * G4BENeutronChannel::emit()
{
G4double u;
G4double v;
G4double w;
G4DynamicParticle * pParticle = new G4DynamicParticle;
pParticle -> SetDefinition( G4Neutron::Neutron() );
pParticle -> SetKineticEnergy( sampleKineticEnergy() );
isotropicCosines( u, v, w );
pParticle -> SetMomentumDirection( u , v , w );
return pParticle;
}
G4double G4BENeutronChannel::alpha()
{
const G4double residualA = nucleusA - particleA;
return 0.76 + 1.93 * pow( residualA, -0.33333 );
}
G4double G4BENeutronChannel::beta()
{
G4double residualA = nucleusA - particleA;
return ( 1.66 * pow ( residualA, -0.66666 ) - 0.05 )/alpha()*MeV;
}
source/processes/hadronic/models/cascade/evaporation/src/G4BEProtonChannel.cc
+71
View File
@@ -0,0 +1,71 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * authors in the GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// Implementation of the HETC88 code into Geant4.
// Evaporation and De-excitation parts
// T. Lampen, Helsinki Institute of Physics, 30-May-2000
#include "G4BEProtonChannel.hh"
#include "G4Proton.hh"
G4BEProtonChannel::G4BEProtonChannel()
{
name = "proton";
verboseLevel = 0;
particleA = 1;
particleZ = 1;
rho = 0;
A=1;
spin = 0.5;
}
G4BEProtonChannel::~G4BEProtonChannel()
{
}
G4DynamicParticle* G4BEProtonChannel::emit()
{
G4double u , v , w;
G4DynamicParticle * pParticle = new G4DynamicParticle;
pParticle -> SetDefinition( G4Proton::Proton() );
pParticle -> SetKineticEnergy( sampleKineticEnergy() );
isotropicCosines( u , v , w );
pParticle -> SetMomentumDirection( u , v , w );
return pParticle;
}
G4double G4BEProtonChannel::coulombFactor()
{
return coulombFactorForProton();
}
G4double G4BEProtonChannel::qmFactor()
{
// Coefficient representing the quantum mechanical barrier
// penetration, see Dostrovsky, Phys. Rev. 116, 1959.
return qmFactorForProton();
}
source/processes/hadronic/models/cascade/evaporation/src/G4BETritonChannel.cc
+71
View File
@@ -0,0 +1,71 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * authors in the GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// Implementation of the HETC88 code into Geant4.
// Evaporation and De-excitation parts
// T. Lampen, Helsinki Institute of Physics, May-2000
#include "G4BETritonChannel.hh"
#include "G4Triton.hh"
G4BETritonChannel::G4BETritonChannel()
{
name = "triton";
verboseLevel = 0;
particleA = 3;
particleZ = 1;
rho = 0.70588;
A=3;
spin = 0.5;
}
G4BETritonChannel::~G4BETritonChannel()
{
}
G4DynamicParticle* G4BETritonChannel::emit()
{
G4double u , v , w;
G4DynamicParticle * pParticle = new G4DynamicParticle;
pParticle -> SetDefinition( G4Triton::Triton() );
pParticle -> SetKineticEnergy( sampleKineticEnergy() );
isotropicCosines( u , v , w );
pParticle -> SetMomentumDirection( u , v , w );
return pParticle;
}
G4double G4BETritonChannel::coulombFactor()
{
return 0.333333*coulombFactorForProton();
}
G4double G4BETritonChannel::qmFactor()
{
// Coefficient representing the quantum mechanical barrier
// penetration, see Dostrovsky, Phys. Rev. 116, 1959.
return qmFactorForProton() + 0.12;
}
source/processes/hadronic/models/cascade/evaporation/src/G4BertiniEvaporation.cc
+413
View File
@@ -0,0 +1,413 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * authors in the GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// Implementation of the HETC88 code into Geant4.
// Evaporation and De-excitation parts
// T. Lampen, Helsinki Institute of Physics, May-2000
#include "globals.hh"
#include "G4BertiniEvaporation.hh"
#include "G4BENeutronChannel.hh"
#include "G4BEProtonChannel.hh"
#include "G4BEDeuteronChannel.hh"
#include "G4BETritonChannel.hh"
#include "G4BEHe3Channel.hh"
#include "G4BEHe4Channel.hh"
#include "G4BEGammaDeexcitation.hh"
// verboseLevels : 4 inform about basic probabilities and branchings
// 6 some details about calculations
// 8 inform about final values
// 10 inform everything
G4BertiniEvaporation::G4BertiniEvaporation()
{
G4cout << "Info G4BertiniEvaporation: This is still very fresh code."<< G4endl;
G4cout << " G4BertiniEvaporation: feed-back for improvement is very wellcome."<< G4endl;
verboseLevel = 0;
channelVector.push_back( new G4BENeutronChannel );
channelVector.push_back( new G4BEProtonChannel );
channelVector.push_back( new G4BEDeuteronChannel);
channelVector.push_back( new G4BETritonChannel );
channelVector.push_back( new G4BEHe3Channel );
channelVector.push_back( new G4BEHe4Channel );
}
G4BertiniEvaporation::~G4BertiniEvaporation()
{
while ( !channelVector.empty() )
{
delete channelVector.back();
channelVector.pop_back();
}
}
void G4BertiniEvaporation::setVerboseLevel( const G4int verbose )
{
verboseLevel = verbose;
// Update verbose level to all evaporation channels.
G4std::vector< G4BertiniEvaporationChannel * >::iterator iChannel = channelVector.begin();
for ( ; iChannel != channelVector.end() ; *iChannel++ )
( *iChannel )->setVerboseLevel( verboseLevel );
}
G4FragmentVector * G4BertiniEvaporation::BreakItUp( G4LayeredNucleus & nucleus )
{
G4int nucleusA;
G4int nucleusZ;
G4int i;
G4double totalProbability;
G4double excE;
G4double newExcitation;
G4double nucleusTotalMomentum;
G4double nucleusKineticEnergy;
G4double mRes; // Mass of residual nucleus.
G4ThreeVector nucleusMomentumVector;
G4DynamicParticle *pEmittedParticle;
G4std::vector< G4DynamicParticle * > secondaryParticleVector;
G4FragmentVector * result = new G4FragmentVector;
// Read properties of the nucleus.
nucleusA = ( G4int ) nucleus.GetN(); // GetN should in fact get GetA
nucleusZ = ( G4int ) nucleus.GetZ();
excE = nucleus.GetEnergyDeposit();
nucleusMomentumVector = nucleus.GetMomentum();
// Move to CMS frame, save initial velocity of the nucleus to boostToLab vector.
G4ThreeVector boostToLab( ( 1/G4NucleiProperties::GetAtomicMass( nucleusA, nucleusZ ) )
* nucleusMomentumVector ); // xx mass ok?
if ( verboseLevel >= 10 )
G4cout << " G4BertiniEvaporation : initial kinematics : boostToLab vector = " << boostToLab << G4endl
<< " excitation energy : " << excE<< G4endl;
if ( nucleusA == 8 && nucleusZ == 4 )
{
splitBe8( excE, boostToLab, secondaryParticleVector );
fillResult( secondaryParticleVector, result);
return result;
}
// Initialize evaporation channels and calculate sum of emission
// probabilities.
G4std::vector< G4BertiniEvaporationChannel * >::iterator iChannel = channelVector.begin();
totalProbability = 0;
for ( ; iChannel != channelVector.end() ; *iChannel++ )
{
( *iChannel )->setNucleusA( nucleusA );
( *iChannel )->setNucleusZ( nucleusZ );
( *iChannel )->setExcitationEnergy( excE );
( *iChannel )->setPairingCorrection( 1 );
( *iChannel )->calculateProbability();
totalProbability += ( *iChannel )->getProbability();
}
// If no evaporation process is possible, try without pairing energy.
if ( totalProbability == 0 )
{
if ( verboseLevel >= 4 )
G4cout << "G4BertiniEvaporation : no emission possible with pairing correction, trying without it" << G4endl;
for ( iChannel = channelVector.begin() ; iChannel != channelVector.end() ; *iChannel++ )
{
( *iChannel )->setPairingCorrection(0);
( *iChannel )->calculateProbability();
totalProbability += ( *iChannel )->getProbability();
}
if ( verboseLevel >= 4 )
G4cout << " probability without correction " << totalProbability << G4endl;
}
// Normal evaporation cycle follows.
// Particles are evaporated till all probabilities are zero.
while ( totalProbability > 0 )
{
G4BertiniEvaporationChannel *pSelectedChannel;
// Sample active emission channel.
G4double sampledProbability = G4UniformRand() * totalProbability;
if ( verboseLevel >= 10 ) G4cout << " RandomProb : " << sampledProbability << G4endl;
for ( iChannel = channelVector.begin() ; iChannel != channelVector.end() ; *iChannel++ )
{
sampledProbability -= ( *iChannel )->getProbability();
if ( sampledProbability < 0 ) break;
}
pSelectedChannel = ( *iChannel );
if ( iChannel == channelVector.end() )
G4Exception( "G4BertiniEvaporation : Error while sampling evaporation particle" );
if ( verboseLevel >= 4 )
G4cout << "G4BertiniEvaporation : particle " << pSelectedChannel->getName() << " selected " << G4endl;
// Max 10 tries to get a physically acceptable particle energy
// in this emission channel.
i = 0;
do
{
pEmittedParticle = pSelectedChannel->emit();
// This loop checks that particle with too large energy is not emitted.
// CMS frame is considered in this loop. Nonrelativistic treatment. xxx
const G4int zRes = nucleusZ - pSelectedChannel->getParticleZ();
const G4int aRes = nucleusA - pSelectedChannel->getParticleA();
const G4double eBind = G4NucleiProperties::GetBindingEnergy( aRes, zRes ); // Binding energy of the nucleus.
mRes = G4NucleiProperties::GetAtomicMass( aRes, zRes ); // Mass of the target nucleus
// In HETC88:
// eBind = Z * (-0.78244) + A * 8.36755 - cameron ( A , Z );
// mRes = zRes * 938.79304 + ( aRes - zRes ) * 939.57548 - eBind;
// where cameron ( A, Z ) is the mass excess by Cameron, see Canadian Journal of Physics,
// vol. 35, 1957, p.1022
nucleusTotalMomentum = pEmittedParticle->GetTotalMomentum(); // CMS frame
nucleusKineticEnergy = pow( nucleusTotalMomentum, 2 ) / ( 2 * mRes );
newExcitation = excE - pEmittedParticle->GetKineticEnergy() - nucleusKineticEnergy - pSelectedChannel->getQ();
if ( verboseLevel >= 10)
G4cout << "G4BertiniEvaporation : Kinematics " << G4endl
<< " part kinetic E in CMS = "
<< pEmittedParticle->GetKineticEnergy() << G4endl
<< " new excitation E = "
<< newExcitation << G4endl;
i++;
if ( !( newExcitation > 0 ) && i < 10) delete pEmittedParticle;
} while ( !( newExcitation > 0 ) && i < 10 );
if ( i >= 10 )
{
// No appropriate particle energy found.
// Set probability of this channel to zero
// and try to sample another particle on the
// next round.
delete pEmittedParticle;
if ( verboseLevel >= 4 )
G4cout << "G4BertiniEvaporation : No appropriate energy for particle "
<< pSelectedChannel->getName() << " found." << G4endl;
pSelectedChannel->setProbability( 0 );
totalProbability = 0;
for ( ; iChannel != channelVector.end() ; *iChannel++ )
totalProbability += ( *iChannel )->getProbability();
} // Treatment of physically unacceptable particle ends.
else
{
// Good particle found.
// Transform particle properties to lab frame and save it.
G4LorentzVector particleFourVector = pEmittedParticle->Get4Momentum();
G4LorentzVector nucleusFourVector( - pEmittedParticle->GetMomentum(), // CMS Frame.
nucleusKineticEnergy + mRes ); // Total energy.
particleFourVector.boost( boostToLab );
nucleusFourVector.boost( boostToLab );
G4DynamicParticle *pPartLab = new G4DynamicParticle( pEmittedParticle->GetDefinition(),
particleFourVector.e(), // Total energy
particleFourVector.vect() ); // momentum vector
secondaryParticleVector.push_back( pPartLab );
// Update residual nucleus and boostToLab vector.
nucleusA = nucleusA - pSelectedChannel->getParticleA();
nucleusZ = nucleusZ - pSelectedChannel->getParticleZ();
excE = newExcitation;
boostToLab = G4ThreeVector ( ( 1/mRes ) * nucleusFourVector.vect() );
if ( verboseLevel >= 10 )
G4cout << " particle mom in cms " << pEmittedParticle->GetMomentum() << G4endl
<< " particle mom in cms " << pEmittedParticle->GetTotalMomentum() << G4endl
<< " Etot in cms " << pEmittedParticle->GetTotalEnergy() << G4endl
<< " Ekin in cms " << pEmittedParticle->GetKineticEnergy() << G4endl
<< " particle mass " << pEmittedParticle->GetMass() << G4endl
<< " boost vect " << boostToLab << G4endl
<< " boosted 4v " << particleFourVector << G4endl
<< " nucleus 4v " << nucleusFourVector << G4endl
<< " nucl cm mom " << nucleusTotalMomentum << G4endl
<< " particle k.e. in lab " << pPartLab->GetKineticEnergy() << G4endl
<< " new boost vector " << boostToLab << G4endl;
delete pEmittedParticle;
// If the residual nucleus is Be8, split it.
if ( nucleusA == 8 && nucleusZ == 4 )
{
splitBe8( excE, boostToLab, secondaryParticleVector );
fillResult( secondaryParticleVector, result);
return result;
}
// Update evaporation channels and
// total emission probability.
totalProbability = 0;
for ( iChannel = channelVector.begin() ; iChannel != channelVector.end() ; *iChannel++ )
{
( *iChannel )->setNucleusA( nucleusA );
( *iChannel )->setNucleusZ( nucleusZ );
( *iChannel )->setExcitationEnergy( excE );
( *iChannel )->calculateProbability();
totalProbability += ( *iChannel )->getProbability();
}
} // Treatment of physically acceptable particle ends.
} // End of evaporation cycle.
// Gamma de-excitation.
G4BEGammaDeexcitation *pGammaChannel = new G4BEGammaDeexcitation;
pGammaChannel->setNucleusA( nucleusA );
pGammaChannel->setNucleusZ( nucleusZ );
pGammaChannel->setVerboseLevel( verboseLevel );
pGammaChannel->setExcitationEnergy( excE );
// Emit equally sampled photons until all the excitation energy is
// used; the last photon gets the remaining de-excitation energy.
// Change of momentum of the nucleus is neglected.
G4double gammaEnergy;
G4double totalDeExcEnergy = 0;
while ( excE > 0 )
{
pEmittedParticle = pGammaChannel->emit();
gammaEnergy = pEmittedParticle->GetKineticEnergy();
if ( ( totalDeExcEnergy + gammaEnergy ) > excE )
{
// All the remaining energy is used here.
gammaEnergy = excE - totalDeExcEnergy;
excE = 0;
}
totalDeExcEnergy += gammaEnergy;
if ( verboseLevel >= 10 )
G4cout << " G4BertiniEvaporation : gamma de-excitation, g of " << gammaEnergy << " MeV " << G4endl;
G4LorentzVector gammaFourVector( pEmittedParticle->GetMomentum(),
pEmittedParticle->GetKineticEnergy() );
gammaFourVector.boost( boostToLab );
pEmittedParticle->SetKineticEnergy( gammaFourVector.e() );
pEmittedParticle->SetMomentumDirection( gammaFourVector.vect().unit() );
secondaryParticleVector.push_back( pEmittedParticle );
}
delete pGammaChannel;
// Residual nucleus is not returned.
fillResult( secondaryParticleVector, result);
return result;
}
void G4BertiniEvaporation::splitBe8( const G4double E,
const G4ThreeVector boostToLab,
G4std::vector< G4DynamicParticle * > & secondaryParticleVector )
{
G4double kineticEnergy;
G4double u;
G4double v;
G4double w;
const G4double Be8DecayEnergy = 0.093 * MeV;
if ( E <= 0 ) G4Exception( "G4BertiniEvaporation : excitation energy < 0 " );
if ( verboseLevel >= 4 ) G4cout << " Be8 split to 2 x He4" << G4endl;
kineticEnergy = 0.5 * ( E + Be8DecayEnergy );
// Create two alpha particles in CMS frame.
isotropicCosines( u , v , w );
G4ThreeVector momentumDirectionCMS( u, v, w );
G4DynamicParticle *pP1Cms = new G4DynamicParticle( G4Alpha::Alpha(),
momentumDirectionCMS,
kineticEnergy );
G4DynamicParticle *pP2Cms = new G4DynamicParticle( G4Alpha::Alpha(),
-momentumDirectionCMS,
kineticEnergy );
G4LorentzVector fourVector1( pP1Cms->GetMomentum(),
pP1Cms->GetTotalEnergy() );
G4LorentzVector fourVector2( pP2Cms->GetMomentum(),
pP2Cms->GetTotalEnergy() );
// Transform into lab frame by transforming the four vectors. Then
// add to the vector of secondary particles.
fourVector1.boost( boostToLab );
fourVector2.boost( boostToLab );
G4DynamicParticle * pP1Lab = new G4DynamicParticle( G4Alpha::Alpha(),
fourVector1.vect(),
fourVector1.e() );
G4DynamicParticle * pP2Lab = new G4DynamicParticle( G4Alpha::Alpha(),
fourVector2.vect(),
fourVector2.e() );
secondaryParticleVector.push_back( pP1Lab );
secondaryParticleVector.push_back( pP2Lab );
delete pP1Cms;
delete pP2Cms;
return;
}
void G4BertiniEvaporation::fillResult( G4std::vector<G4DynamicParticle *> secondaryParticleVector,
G4FragmentVector * aResult )
{
// Fill the vector pParticleChange with secondary particles stored in vector.
for ( G4int i = 0 ; i < secondaryParticleVector.size() ; i++ )
{
G4int aZ = secondaryParticleVector[i]->GetDefinition()->GetPDGCharge();
G4int aA = secondaryParticleVector[i]->GetDefinition()->GetBaryonNumber();
G4LorentzVector aMomentum = secondaryParticleVector[i]->Get4Momentum();
if(aA>0)
{
aResult->push_back( new G4Fragment(aA, aZ, aMomentum) );
}
else
{
aResult->push_back( new G4Fragment(aMomentum, secondaryParticleVector[i]->GetDefinition()) );
}
}
return;
}
void G4BertiniEvaporation::isotropicCosines( G4double & u, G4double & v, G4double & w )
{
// Samples isotropic random direction cosines.
G4double CosTheta = 1.0 - 2.0 * G4UniformRand();
G4double SinTheta = sqrt( 1.0 - CosTheta * CosTheta );
G4double Phi = twopi * G4UniformRand();
u = cos( Phi ) * SinTheta;
v = cos( Phi ) * CosTheta,
w = sin( Phi );
return;
}
source/processes/hadronic/models/cascade/evaporation/src/G4BertiniEvaporationChannel.cc
+400
View File
@@ -0,0 +1,400 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * 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. *
// * *
// * This code implementation is the intellectual property of the *
// * authors in the GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// Implementation of the HETC88 code into Geant4.
// Evaporation and De-excitation parts
// T. Lampen, Helsinki Institute of Physics, May-2000
#include "globals.hh"
#include "G4ios.hh"
#include "Randomize.hh"
#include "G4Neutron.hh"
#include "G4Proton.hh"
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4Alpha.hh"
#include "G4ParticleTable.hh"
#include "G4Nucleus.hh"
#include "G4BertiniEvaporationChannel.hh"
G4BertiniEvaporationChannel::G4BertiniEvaporationChannel()
{
verboseLevel = 0;
}
G4BertiniEvaporationChannel::~G4BertiniEvaporationChannel()
{
}
void G4BertiniEvaporationChannel::setVerboseLevel( G4int level )
{
verboseLevel = level;
}
void G4BertiniEvaporationChannel::setNucleusA( G4int a )
{
nucleusA = a;
}
void G4BertiniEvaporationChannel::setNucleusZ( G4int z )
{
nucleusZ = z;
}
G4int G4BertiniEvaporationChannel::getParticleA()
{
return particleA;
}
G4int G4BertiniEvaporationChannel::getParticleZ()
{
return particleZ;
}
void G4BertiniEvaporationChannel::setExcitationEnergy(G4double energy )
{
excitationEnergy = energy;
}
void G4BertiniEvaporationChannel::setPairingCorrection( G4int isCorrection )
{
G4int residualZ = nucleusZ - particleZ;
G4int residualA = nucleusA - particleA;
// Note: pairing energy is zero for odd nucleon number.
if ( isCorrection ) correction = pairingEnergyProtons( residualZ )
+ pairingEnergyNeutrons( residualA - residualZ );
else correction = 0;
}
G4double G4BertiniEvaporationChannel::getProbability()
{
if ( verboseLevel >= 4 )
G4cout << "G4BerEvaporationChannel : probability of particle " << name
<< " is " << emissionProbability << G4endl;
return emissionProbability;
}
G4String G4BertiniEvaporationChannel::getName()
{
return name;
}
void G4BertiniEvaporationChannel::setProbability( G4double newProb )
{
emissionProbability = newProb;
return;
}
G4double G4BertiniEvaporationChannel::getQ()
{
// The reaction Q is calculated by using the excess masses of the
// secondary particle and the initial and residual nuclei
G4int residualZ = nucleusZ - particleZ;
G4int residualA = nucleusA - particleA;
G4int residualN = residualA - residualZ;
G4int nucleusN = nucleusA - nucleusZ;
// All the following are by default in MeV
const G4double e1 = G4NucleiProperties::GetMassExcess( residualA, residualZ );
const G4double e2 = G4NucleiProperties::GetMassExcess( nucleusA, nucleusZ );
return e1 - e2 + G4NucleiProperties::GetMassExcess( particleA, particleZ );
// In HETC88 : Mass excesses were calculated with the Cameron mass excess formula,
// see Cameron, Canadian Journal of Physics,
// vol. 35, 1957, p.1022
// Also mass excesses of particles were
// 8.3675, 7.5851, 13.7279, 15.8381, 15.8195, 3.6092 for
// n, p, D, T, 3He, 4He
}
G4double G4BertiniEvaporationChannel::getThresh()
{
G4double threshold = getQ() + getCoulomb();
return threshold;
}
G4double G4BertiniEvaporationChannel::getCoulomb()
{
G4int residualZ = nucleusZ - particleZ;
G4int residualA = nucleusA - particleA;
const G4double factor = 0.84696; // = e / ( 4 pi epsilon_0 r0 ) * 10^-6, r0=1.7E-15
// In HETC88 this factor was 0.88235, perhaps due to different r0
G4double coulomb = factor * particleZ * qmFactor() * residualZ /
( pow( residualA, 0.33333333 ) + rho ) * MeV;
if ( verboseLevel >= 10 )
G4cout << " G4BertiniEvaporationChannel::getThresh() " << G4endl
<< " residualZ " << residualZ << G4endl
<< " residualA " << residualA << G4endl
<< " qmFactor " << qmFactor() << G4endl
<< " Q " << getQ() << G4endl
<< " rho " << rho << G4endl
<< " part Z " << particleZ << G4endl
<< " (correction) " << correction << G4endl;
return coulomb;
}
G4double G4BertiniEvaporationChannel::qmFactor()
{
// Coefficient k_p for empirical cross section
// formula presented in Dostrovsky, Phys. Rev.,
// vol. 116, 1959
return 0;
}
G4double G4BertiniEvaporationChannel::getLevelDensityParameter()
{
G4int residualZ = nucleusZ - particleZ;
G4int residualA = nucleusA - particleA;
G4double b0 = 8;
G4double y0 = 1.5;
G4double temp = ( residualA - 2.0 * residualZ ) / residualA;
G4double smallA = residualA * ( 1.0 + y0 * pow( temp, 2 ) ) / b0 / MeV;
// In HETC98 b0 = b0(E).
return smallA;
}
void G4BertiniEvaporationChannel::isotropicCosines( G4double & u, G4double & v, G4double & w )
{
// Samples isotropic random direction cosines.
G4double CosTheta = 1.0 - 2.0 * G4UniformRand();
G4double SinTheta = sqrt( 1.0 - CosTheta * CosTheta );
G4double Phi = twopi * G4UniformRand();
u = cos( Phi ) * SinTheta;
v = cos( Phi ) * CosTheta,
w = sin( Phi );
return;
}
G4double G4BertiniEvaporationChannel::pairingEnergyProtons(G4int Z)
{
// Pairing energy for protons P(Z), see
// Cameron, Nuclear Level Spacings, p. 1040
// Canadian Journal of Physics, vol 36, 1958
G4double table [130] = {
0.00000000E+00, 0.54399996E+01, 0.00000000E+00, 0.27599993E+01, 0.00000000E+00,
0.33399992E+01, 0.00000000E+00, 0.26999998E+01, 0.00000000E+00, 0.18999996E+01,
0.00000000E+00, 0.21199999E+01, 0.00000000E+00, 0.21299992E+01, 0.00000000E+00,
0.15399990E+01, 0.00000000E+00, 0.14199991E+01, 0.00000000E+00, 0.15099993E+01,
0.00000000E+00, 0.17299995E+01, 0.00000000E+00, 0.14399996E+01, 0.00000000E+00,
0.14499998E+01, 0.00000000E+00, 0.13699999E+01, 0.00000000E+00, 0.10899992E+01,
0.00000000E+00, 0.13599997E+01, 0.00000000E+00, 0.14199991E+01, 0.00000000E+00,
0.13299990E+01, 0.00000000E+00, 0.11999998E+01, 0.00000000E+00, 0.99999988E+00,
0.00000000E+00, 0.11599998E+01, 0.00000000E+00, 0.12799997E+01, 0.00000000E+00,
0.13799992E+01, 0.00000000E+00, 0.13799992E+01, 0.00000000E+00, 0.13199997E+01,
0.00000000E+00, 0.10399990E+01, 0.00000000E+00, 0.11099997E+01, 0.00000000E+00,
0.11299992E+01, 0.00000000E+00, 0.12099991E+01, 0.00000000E+00, 0.14299994E+01,
0.00000000E+00, 0.11499996E+01, 0.00000000E+00, 0.98999995E+00, 0.00000000E+00,
0.90999997E+00, 0.00000000E+00, 0.91999996E+00, 0.00000000E+00, 0.99999988E+00,
0.00000000E+00, 0.11099997E+01, 0.00000000E+00, 0.12299995E+01, 0.00000000E+00,
0.84999996E+00, 0.00000000E+00, 0.97999996E+00, 0.00000000E+00, 0.71999997E+00,
0.00000000E+00, 0.79999995E+00, 0.00000000E+00, 0.76999998E+00, 0.00000000E+00,
0.88999999E+00, 0.00000000E+00, 0.91999996E+00, 0.00000000E+00, 0.79999995E+00,
0.00000000E+00, 0.80999994E+00, 0.00000000E+00, 0.69000000E+00, 0.00000000E+00,
0.69999999E+00, 0.00000000E+00, 0.75999999E+00, 0.00000000E+00, 0.72999996E+00,
0.00000000E+00, 0.79999995E+00, 0.00000000E+00, 0.73999995E+00, 0.00000000E+00,
0.72999996E+00, 0.00000000E+00, 0.71999997E+00, 0.00000000E+00, 0.71999997E+00,
0.00000000E+00, 0.71999997E+00, 0.00000000E+00, 0.70999998E+00, 0.00000000E+00,
0.69000000E+00, 0.00000000E+00, 0.67999995E+00, 0.00000000E+00, 0.65999997E+00,
0.00000000E+00, 0.60999995E+00, 0.00000000E+00, 0.41999996E+00, 0.00000000E+00,
0.35999995E+00, 0.00000000E+00, 0.40999997E+00, 0.00000000E+00, 0.48999995E+00
};
if ( Z>130 ) G4Exception( " G4BertiniEvaporationChannel: pairing energy for protons called with too large Z " );
return table[ Z-1 ]*MeV;
}
G4double G4BertiniEvaporationChannel::pairingEnergyNeutrons(G4int N)
{
// Pairing energy for neutrons P(N), see
// Cameron, Nuclear Level Spacings, p. 1040
// Canadian Journal of Physics, vol 36, 1958
G4double table[200] = {
0.00000000E+00, 0.59799995E+01, 0.00000000E+00, 0.27699995E+01, 0.00000000E+00,
0.31599998E+01, 0.00000000E+00, 0.30099993E+01, 0.00000000E+00, 0.16799994E+01,
0.00000000E+00, 0.17299995E+01, 0.00000000E+00, 0.21699991E+01, 0.00000000E+00,
0.17399998E+01, 0.00000000E+00, 0.17500000E+01, 0.00000000E+00, 0.17199993E+01,
0.00000000E+00, 0.16299992E+01, 0.00000000E+00, 0.14099998E+01, 0.00000000E+00,
0.12899990E+01, 0.00000000E+00, 0.14699993E+01, 0.00000000E+00, 0.13199997E+01,
0.00000000E+00, 0.14599991E+01, 0.00000000E+00, 0.14399996E+01, 0.00000000E+00,
0.14599991E+01, 0.00000000E+00, 0.15199995E+01, 0.00000000E+00, 0.15099993E+01,
0.00000000E+00, 0.14699993E+01, 0.00000000E+00, 0.14499998E+01, 0.00000000E+00,
0.12799997E+01, 0.00000000E+00, 0.12299995E+01, 0.00000000E+00, 0.12699995E+01,
0.00000000E+00, 0.61999995E+00, 0.00000000E+00, 0.75999999E+00, 0.00000000E+00,
0.12299995E+01, 0.00000000E+00, 0.12199993E+01, 0.00000000E+00, 0.13999996E+01,
0.00000000E+00, 0.13599997E+01, 0.00000000E+00, 0.12999992E+01, 0.00000000E+00,
0.12899990E+01, 0.00000000E+00, 0.12399998E+01, 0.00000000E+00, 0.12799997E+01,
0.00000000E+00, 0.12399998E+01, 0.00000000E+00, 0.11999998E+01, 0.00000000E+00,
0.94000000E+00, 0.00000000E+00, 0.99999988E+00, 0.00000000E+00, 0.10499992E+01,
0.00000000E+00, 0.53999996E+00, 0.00000000E+00, 0.59999996E+00, 0.00000000E+00,
0.75000000E+00, 0.00000000E+00, 0.75000000E+00, 0.00000000E+00, 0.84999996E+00,
0.00000000E+00, 0.96999997E+00, 0.00000000E+00, 0.10199995E+01, 0.00000000E+00,
0.10499992E+01, 0.00000000E+00, 0.10599995E+01, 0.00000000E+00, 0.10699997E+01,
0.00000000E+00, 0.10599995E+01, 0.00000000E+00, 0.10499992E+01, 0.00000000E+00,
0.10199995E+01, 0.00000000E+00, 0.96999997E+00, 0.00000000E+00, 0.90999997E+00,
0.00000000E+00, 0.82999998E+00, 0.00000000E+00, 0.73999995E+00, 0.00000000E+00,
0.65999997E+00, 0.00000000E+00, 0.60999995E+00, 0.00000000E+00, 0.60999995E+00,
0.00000000E+00, 0.89999998E+00, 0.00000000E+00, 0.51999998E+00, 0.00000000E+00,
0.80999994E+00, 0.00000000E+00, 0.67999995E+00, 0.00000000E+00, 0.71999997E+00,
0.00000000E+00, 0.76999998E+00, 0.00000000E+00, 0.67999995E+00, 0.00000000E+00,
0.66999996E+00, 0.00000000E+00, 0.79999995E+00, 0.00000000E+00, 0.67999995E+00,
0.00000000E+00, 0.63999999E+00, 0.00000000E+00, 0.57999998E+00, 0.00000000E+00,
0.54999995E+00, 0.00000000E+00, 0.56999993E+00, 0.00000000E+00, 0.56999993E+00,
0.00000000E+00, 0.54999995E+00, 0.00000000E+00, 0.59999996E+00, 0.00000000E+00,
0.57999998E+00, 0.00000000E+00, 0.57999998E+00, 0.00000000E+00, 0.60999995E+00,
0.00000000E+00, 0.63000000E+00, 0.00000000E+00, 0.64999998E+00, 0.00000000E+00,
0.65999997E+00, 0.00000000E+00, 0.64999998E+00, 0.00000000E+00, 0.64999998E+00,
0.00000000E+00, 0.63999999E+00, 0.00000000E+00, 0.63999999E+00, 0.00000000E+00,
0.63000000E+00, 0.00000000E+00, 0.60999995E+00, 0.00000000E+00, 0.58999997E+00,
0.00000000E+00, 0.54999995E+00, 0.00000000E+00, 0.38999999E+00, 0.00000000E+00,
0.35999995E+00, 0.00000000E+00, 0.39999998E+00, 0.00000000E+00, 0.39999998E+00,
0.00000000E+00, 0.39999998E+00, 0.00000000E+00, 0.39999998E+00, 0.00000000E+00,
0.39999998E+00, 0.00000000E+00, 0.39999998E+00, 0.00000000E+00, 0.39999998E+00
};
if ( N > 200 ) G4Exception( " G4BertiniEvaporationChannel: pairing energy for neutrons called with too large Z " );
return table[ N-1 ]*MeV;
}
G4double G4BertiniEvaporationChannel::cameronShellCorrectionP(G4int Z)
{
// Gives the binding energy correction depending in Z
// due to shell correction and pairing energies in MeV
//
// see Cameron, Canadian Journal of Physics,
// vol. 35, 1957, p.1022
G4double table[130] = {
0.26169998E+02, 0.19250000E+02, 0.24209991E+02, 0.20919998E+02, 0.23149994E+02,
0.18009995E+02, 0.19549988E+02, 0.16939987E+02, 0.19729996E+02, 0.17069992E+02,
0.18209991E+02, 0.14990000E+02, 0.16009995E+02, 0.12040000E+02, 0.13270000E+02,
0.11089998E+02, 0.12169999E+02, 0.10259998E+02, 0.11040000E+02, 0.84099998E+01,
0.97899990E+01, 0.73599997E+01, 0.81499996E+01, 0.56299992E+01, 0.58799992E+01,
0.31699991E+01, 0.33199997E+01, 0.81999993E+00, 0.18299999E+01, 0.96999997E+00,
0.23299999E+01, 0.12699995E+01, 0.29199991E+01, 0.16099997E+01, 0.29099998E+01,
0.13499994E+01, 0.23999996E+01, 0.88999999E+00, 0.17399998E+01, 0.35999995E+00,
0.94999999E+00, -0.64999998E+00, -0.39999995E-01, -0.17299995E+01, -0.95999998E+00,
-0.28699999E+01, -0.20499992E+01, -0.40499992E+01, -0.33999996E+01, -0.57199993E+01,
-0.37499990E+01, -0.41299992E+01, -0.24199991E+01, -0.28499994E+01, -0.10099993E+01,
-0.13299990E+01, 0.53999996E+00, -0.20000000E-01, 0.17399998E+01, 0.75000000E+00,
0.22399998E+01, 0.99999988E+00, 0.19799995E+01, 0.78999996E+00, 0.15399990E+01,
0.38999999E+00, 0.10799999E+01, 0.00000000E+00, 0.77999997E+00, -0.34999996E+00,
0.57999998E+00, -0.54999995E+00, 0.58999997E+00, -0.60999995E+00, 0.58999997E+00,
-0.34999996E+00, 0.31999993E+00, -0.95999998E+00, -0.51999998E+00, -0.20799999E+01,
-0.24599991E+01, -0.36399994E+01, -0.15499992E+01, -0.95999998E+00, 0.96999997E+00,
0.88000000E+00, 0.23699999E+01, 0.17500000E+01, 0.27199993E+01, 0.18999996E+01,
0.25499992E+01, 0.14599991E+01, 0.19299994E+01, 0.85999995E+00, 0.11699991E+01,
0.79999983E-01, 0.38999999E+00, -0.75999999E+00, -0.38999999E+00, -0.15099993E+01,
-0.11699991E+01, -0.23599997E+01, -0.19499998E+01, -0.30599995E+01, -0.26199999E+01,
-0.35499992E+01, -0.29499998E+01, -0.37499990E+01, -0.30699997E+01, -0.37899990E+01,
-0.30599995E+01, -0.37699995E+01, -0.30499992E+01, -0.37799997E+01, -0.31199999E+01,
-0.38999996E+01, -0.33499994E+01, -0.42399998E+01, -0.38599997E+01, -0.49199991E+01,
-0.50599995E+01, -0.67699995E+01, -0.74099998E+01, -0.91799994E+01, -0.10160000E+02,
-0.11120000E+02, -0.97599993E+01, -0.92299995E+01, -0.79599991E+01, -0.76499996E+01,
};
if ( Z > 130 ) G4Exception( " G4BertiniEvaporationChannel: shell correction for protons called with too large Z " );
return table[ Z-1 ]*MeV;
}
G4double G4BertiniEvaporationChannel::cameronShellCorrectionN(G4int N)
{
// Gives the binding energy correction depending in N
// due to shell correction and pairing energies in MeV
//
// see Cameron, Canadian Journal of Physics,
// vol. 35, 1957, p.1022
G4double table[200] = {
-0.83199997E+01, -0.15899999E+02, -0.11509999E+02, -0.14309999E+02, -0.11570000E+02,
-0.15899999E+02, -0.13909999E+02, -0.16029999E+02, -0.12129999E+02, -0.13869999E+02,
-0.12249998E+02, -0.14399999E+02, -0.13069999E+02, -0.15799998E+02, -0.13809999E+02,
-0.14980000E+02, -0.12629999E+02, -0.13759999E+02, -0.11369999E+02, -0.12379998E+02,
-0.92299995E+01, -0.96499996E+01, -0.76399994E+01, -0.91699991E+01, -0.80499992E+01,
-0.97199993E+01, -0.88699989E+01, -0.10759999E+02, -0.86399994E+01, -0.88899994E+01,
-0.65999994E+01, -0.71299992E+01, -0.47699995E+01, -0.53299990E+01, -0.30599995E+01,
-0.37899990E+01, -0.17199993E+01, -0.27899990E+01, -0.92999995E+00, -0.21899996E+01,
-0.51999998E+00, -0.18999996E+01, -0.44999999E+00, -0.21999998E+01, -0.12199993E+01,
-0.30699997E+01, -0.24199991E+01, -0.43699999E+01, -0.39399996E+01, -0.60799999E+01,
-0.44899998E+01, -0.45000000E+01, -0.31399994E+01, -0.29299994E+01, -0.10399990E+01,
-0.13599997E+01, 0.69000000E+00, 0.20999998E+00, 0.21099997E+01, 0.13299990E+01,
0.32900000E+01, 0.24599991E+01, 0.42999992E+01, 0.33199997E+01, 0.47899990E+01,
0.36199999E+01, 0.49699993E+01, 0.36399994E+01, 0.46299992E+01, 0.30699997E+01,
0.40599995E+01, 0.24899998E+01, 0.32999992E+01, 0.14599991E+01, 0.20599995E+01,
0.50999999E+00, 0.73999995E+00, -0.11799994E+01, -0.12599993E+01, -0.35399990E+01,
-0.39699993E+01, -0.52599993E+01, -0.41799994E+01, -0.37099991E+01, -0.20999994E+01,
-0.16999998E+01, -0.79999983E-01, -0.17999995E+00, 0.94000000E+00, 0.26999998E+00,
0.11299992E+01, 0.79999983E-01, 0.90999997E+00, -0.30999994E+00, 0.48999995E+00,
-0.77999997E+00, 0.79999983E-01, -0.11499996E+01, -0.22999996E+00, -0.14099998E+01,
-0.41999996E+00, -0.15499992E+01, -0.54999995E+00, -0.16599998E+01, -0.65999997E+00,
-0.17299995E+01, -0.75000000E+00, -0.17399998E+01, -0.77999997E+00, -0.16899996E+01,
-0.77999997E+00, -0.15999994E+01, -0.75000000E+00, -0.14599991E+01, -0.66999996E+00,
-0.12599993E+01, -0.50999999E+00, -0.10399990E+01, -0.52999997E+00, -0.18399992E+01,
-0.24199991E+01, -0.45199995E+01, -0.47599993E+01, -0.63299990E+01, -0.67599993E+01,
-0.78099995E+01, -0.57999992E+01, -0.53699999E+01, -0.36299992E+01, -0.33499994E+01,
-0.17500000E+01, -0.18799992E+01, -0.60999995E+00, -0.89999998E+00, 0.89999974E-01,
-0.31999993E+00, 0.54999995E+00, -0.13000000E+00, 0.69999999E+00, -0.59999999E-01,
0.48999995E+00, -0.19999999E+00, 0.39999998E+00, -0.21999997E+00, 0.35999995E+00,
-0.89999974E-01, 0.57999998E+00, 0.11999995E+00, 0.75000000E+00, 0.14999998E+00,
0.69999999E+00, 0.16999996E+00, 0.11099997E+01, 0.88999999E+00, 0.18499994E+01,
0.16199999E+01, 0.25399990E+01, 0.22899990E+01, 0.31999998E+01, 0.29099998E+01,
0.38399992E+01, 0.35299997E+01, 0.44799995E+01, 0.41499996E+01, 0.51199999E+01,
0.47799997E+01, 0.57500000E+01, 0.53899994E+01, 0.63099995E+01, 0.59099998E+01,
0.68699999E+01, 0.63299990E+01, 0.71299992E+01, 0.66099997E+01, 0.72999992E+01,
0.63099995E+01, 0.62699995E+01, 0.48299999E+01, 0.44899998E+01, 0.28499994E+01,
0.23199997E+01, 0.57999998E+00, -0.10999995E+00, -0.97999996E+00, 0.80999994E+00,
0.17699995E+01, 0.33699999E+01, 0.41299992E+01, 0.55999994E+01, 0.61499996E+01,
0.72899990E+01, 0.73499994E+01, 0.79499998E+01, 0.76699991E+01, 0.81599998E+01,
0.78299990E+01, 0.83099995E+01, 0.80099993E+01, 0.85299997E+01, 0.82699995E+01
};
if ( N > 130 ) G4Exception( " G4BertiniEvaporationChannel: shell correction for protons called with too large N " );
return table[ N-1 ]*MeV;
}