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

Import Geant4 10.7.0.beta source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2020-06-26 10:23:25 +02:00
parent c02c370437
commit 67ba86d073
1871 changed files with 174422 additions and 131884 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/hadronic/cross_sections/src/G4CrossSectionElastic.cc
+7 -1
View File
@@ -86,7 +86,13 @@ G4CrossSectionElastic::GetElementCrossSection(const G4DynamicParticle* p,
void G4CrossSectionElastic::BuildPhysicsTable(const G4ParticleDefinition& p)
{
component->BuildPhysicsTable(p);
SetMaxKinEnergy(G4HadronicParameters::Instance()->GetMaxEnergy());
// For ions, the max energy of applicability of the cross sections must scale
// with the absolute baryonic number; however, the cross sections objects are
// often shared between the different types of ions (d, t, He3, alpha, and
// genericIon) therefore we scale by Zmax - which is safely larger than the
// number of nucleons of the heaviest nuclides.
SetMaxKinEnergy( G4HadronicParameters::Instance()->GetMaxEnergy() *
( std::abs( p.GetBaryonNumber() ) > 1 ? Zmax : 1 ) );
}
void G4CrossSectionElastic::DumpPhysicsTable(const G4ParticleDefinition& p)
source/processes/hadronic/cross_sections/src/G4CrossSectionInelastic.cc
+7 -1
View File
@@ -86,7 +86,13 @@ G4CrossSectionInelastic::GetElementCrossSection(const G4DynamicParticle* p,
void G4CrossSectionInelastic::BuildPhysicsTable(const G4ParticleDefinition& p)
{
component->BuildPhysicsTable(p);
SetMaxKinEnergy(G4HadronicParameters::Instance()->GetMaxEnergy());
// For ions, the max energy of applicability of the cross sections must scale
// with the absolute baryonic number; however, the cross sections objects are
// often shared between the different types of ions (d, t, He3, alpha, and
// genericIon) therefore we scale by Zmax - which is safely larger than the
// number of nucleons of the heaviest nuclides.
SetMaxKinEnergy( G4HadronicParameters::Instance()->GetMaxEnergy() *
( std::abs( p.GetBaryonNumber() ) > 1 ? Zmax : 1 ) );
}
void G4CrossSectionInelastic::DumpPhysicsTable(const G4ParticleDefinition& p)
source/processes/hadronic/cross_sections/src/G4ElNeutrinoNucleusTotXsc.cc
+359
View File
@@ -0,0 +1,359 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// 24.04.20 V. Grichine
//
// (nu_e,anti_nu_e)-nucleus xsc
#include "G4ElNeutrinoNucleusTotXsc.hh"
#include "G4PhysicalConstants.hh"
#include "G4SystemOfUnits.hh"
#include "G4DynamicParticle.hh"
#include "G4ParticleTable.hh"
#include "G4IonTable.hh"
#include "G4HadTmpUtil.hh"
#include "G4NistManager.hh"
#include "G4Material.hh"
#include "G4Element.hh"
#include "G4Isotope.hh"
#include "G4ElementVector.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
using namespace std;
using namespace CLHEP;
G4ElNeutrinoNucleusTotXsc::G4ElNeutrinoNucleusTotXsc()
: G4VCrossSectionDataSet("NuElNuclTotXsc")
{
fCofXsc = 1.e-38*cm2/GeV;
// G4cout<<"fCofXsc = "<<fCofXsc*GeV/cm2<<" cm2/GeV"<<G4endl;
// PDG2016: sin^2 theta Weinberg
fSin2tW = 0.23129; // 0.2312;
// 9 <-> 6, 5/9 or 5/6 ?
fCofS = 5.*fSin2tW*fSin2tW/9.;
fCofL = 1. - fSin2tW + fCofS;
// G4cout<<"fCosL = "<<fCofL<<", fCofS = "<<fCofS<<G4endl;
fCutEnergy = 0.; // default value
fBiasingFactor = 1.; // default as physics
fIndex = 50;
fTotXsc = 0.;
fCcTotRatio = 0.75; // from nc/cc~0.33 ratio
fCcFactor = fNcFactor = 1.;
theElectron = G4Electron::Electron();
thePositron = G4Positron::Positron();
}
G4ElNeutrinoNucleusTotXsc::~G4ElNeutrinoNucleusTotXsc()
{}
//////////////////////////////////////////////////////
/*
G4bool
G4ElNeutrinoNucleusTotXsc::IsIsoApplicable( const G4DynamicParticle* aPart, G4int, G4int, const G4Element*, const G4Material*)
{
G4bool result = false;
G4String pName = aPart->GetDefinition()->GetParticleName();
if( pName == "nu_e" || pName == "anti_nu_e" )
{
result = true;
}
return result;
}
//////////////////////////////////////
G4double G4ElNeutrinoNucleusTotXsc::GetElementCrossSection(const G4DynamicParticle* part,
G4int Z, const G4Material* mat )
{
G4int Zi(0);
size_t i(0), j(0);
const G4ElementVector* theElementVector = mat->GetElementVector();
for ( i = 0; i < theElementVector->size(); ++i )
{
Zi = (*theElementVector)[i]->GetZasInt();
if( Zi == Z ) break;
}
const G4Element* elm = (*theElementVector)[i];
size_t nIso = elm->GetNumberOfIsotopes();
G4double fact = 0.0;
G4double xsec = 0.0;
const G4Isotope* iso = nullptr;
const G4IsotopeVector* isoVector = elm->GetIsotopeVector();
const G4double* abundVector = elm->GetRelativeAbundanceVector();
for (j = 0; j<nIso; ++j)
{
iso = (*isoVector)[j];
G4int A = iso->GetN();
if( abundVector[j] > 0.0 && IsIsoApplicable(part, Z, A, elm, mat) )
{
fact += abundVector[j];
xsec += abundVector[j]*GetIsoCrossSection( part, Z, A, iso, elm, mat);
}
}
if( fact > 0.0) { xsec /= fact; }
return xsec;
}
*/
////////////////////////////////////////////////////
//
//
G4double G4ElNeutrinoNucleusTotXsc::GetIsoCrossSection(const G4DynamicParticle* aPart, G4int, G4int A,
const G4Isotope*, const G4Element*, const G4Material* )
{
fCcFactor = fNcFactor = 1.;
fCcTotRatio = 0.25;
G4double ccnuXsc, ccanuXsc, ncXsc, totXsc(0.);
G4double energy = aPart->GetTotalEnergy();
G4String pName = aPart->GetDefinition()->GetParticleName();
G4int index = GetEnergyIndex(energy);
if( index >= fIndex )
{
G4double pm = proton_mass_c2;
G4double s2 = 2.*energy*pm+pm*pm;
G4double aa = 1.;
G4double bb = 1.085;
G4double mw = 80.385*GeV;
fCcFactor = bb/(1.+ aa*s2/mw/mw);
G4double mz = 91.1876*GeV;
fNcFactor = bb/(1.+ aa*s2/mz/mz);
}
ccnuXsc = GetNuElTotCsXsc(index, energy);
ccnuXsc *= fCcFactor;
ccanuXsc = GetANuElTotCsXsc(index, energy);
ccanuXsc *= fCcFactor;
if( pName == "nu_e")
{
ncXsc = fCofL*ccnuXsc + fCofS*ccanuXsc;
ncXsc *= fNcFactor/fCcFactor;
totXsc = ccnuXsc + ncXsc;
if( totXsc > 0.) fCcTotRatio = ccnuXsc/totXsc;
}
else if( pName == "anti_nu_e")
{
ncXsc = fCofL*ccanuXsc + fCofS*ccnuXsc;
ncXsc *= fNcFactor/fCcFactor;
totXsc = ccanuXsc + ncXsc;
if( totXsc > 0.) fCcTotRatio = ccanuXsc/totXsc;
}
else return totXsc;
totXsc *= fCofXsc;
totXsc *= energy;
totXsc *= A; // incoherent sum over all isotope nucleons
totXsc *= fBiasingFactor; // biasing up, if set >1
fTotXsc = totXsc;
return totXsc;
}
/////////////////////////////////////////////////////
//
// Return index of nu/anu energy array corresponding to the neutrino energy
G4int G4ElNeutrinoNucleusTotXsc::GetEnergyIndex(G4double energy)
{
G4int i, eIndex = 0;
for( i = 0; i < fIndex; i++)
{
if( energy <= fNuElEnergy[i]*GeV )
{
eIndex = i;
break;
}
}
if( i >= fIndex-1 ) eIndex = fIndex-1;
// G4cout<<"eIndex = "<<eIndex<<G4endl;
return eIndex;
}
/////////////////////////////////////////////////////
//
// nu_e xsc for index-1, index linear over energy
G4double G4ElNeutrinoNucleusTotXsc::GetNuElTotCsXsc(G4int index, G4double energy)
{
G4double xsc(0.);
if( index <= 0 || energy < theElectron->GetPDGMass() ) xsc = fNuElTotXsc[0];
else if (index >= fIndex) xsc = fNuElTotXsc[fIndex-1];
else
{
G4double x1 = fNuElEnergy[index-1]*GeV;
G4double x2 = fNuElEnergy[index]*GeV;
G4double y1 = fNuElTotXsc[index-1];
G4double y2 = fNuElTotXsc[index];
if(x1 >= x2) return fNuElTotXsc[index];
else
{
G4double angle = (y2-y1)/(x2-x1);
xsc = y1 + (energy-x1)*angle;
}
}
return xsc;
}
/////////////////////////////////////////////////////
//
// anu_e xsc for index-1, index linear over energy
G4double G4ElNeutrinoNucleusTotXsc::GetANuElTotCsXsc(G4int index, G4double energy)
{
G4double xsc(0.);
if( index <= 0 || energy < thePositron->GetPDGMass() ) xsc = fANuElTotXsc[0];
else if (index >= fIndex) xsc = fANuElTotXsc[fIndex-1];
else
{
G4double x1 = fNuElEnergy[index-1]*GeV;
G4double x2 = fNuElEnergy[index]*GeV;
G4double y1 = fANuElTotXsc[index-1];
G4double y2 = fANuElTotXsc[index];
if( x1 >= x2 ) return fANuElTotXsc[index];
else
{
G4double angle = (y2-y1)/(x2-x1);
xsc = y1 + (energy-x1)*angle;
}
}
return xsc;
}
////////////////////////////////////////////////////////
//
// return fNuElTotXsc[index] if the index is in the array range
G4double G4ElNeutrinoNucleusTotXsc::GetNuElTotCsArray( G4int index)
{
if( index >= 0 && index < fIndex) return fNuElTotXsc[index];
else
{
G4cout<<"Inproper index of fNuElTotXsc array"<<G4endl;
return 0.;
}
}
////////////////////////////////////////////////////////
//
// return fANuElTotXsc[index] if the index is in the array range
G4double G4ElNeutrinoNucleusTotXsc::GetANuElTotCsArray( G4int index)
{
if( index >= 0 && index < fIndex) return fANuElTotXsc[index];
else
{
G4cout<<"Inproper index of fANuElTotXsc array"<<G4endl;
return 0.;
}
}
///////////////////////////////////////////////////////
//
// E_nu in GeV
const G4double G4ElNeutrinoNucleusTotXsc::fNuElEnergy[50] =
{
0.000561138, 0.000735091, 0.000962969, 0.00126149, 0.00165255,
0.00216484, 0.00283594, 0.00371508, 0.00486676, 0.00637546,
0.00835185, 0.0109409, 0.0143326, 0.0187757, 0.0245962,
0.032221, 0.0422095, 0.0552945, 0.0724358, 0.0948908,
0.124307, 0.162842, 0.213323, 0.279453, 0.366084,
0.47957, 0.628237, 0.82299, 1.07812, 1.41233,
1.85016, 2.42371, 3.17505, 4.15932, 5.44871,
7.13781, 9.35053, 12.2492, 16.0464, 21.0208,
27.5373, 36.0739, 47.2568, 61.9064, 81.0973,
106.238, 139.171, 182.314, 238.832, 312.869
};
/////////////////////////////////////////////////////////////
//
// nu_e CC xsc_tot/E_nu, in 10^-38 cm2/GeV
const G4double G4ElNeutrinoNucleusTotXsc::fNuElTotXsc[50] =
{
0.0026484, 0.00609503, 0.00939421, 0.0132163, 0.0178983,
0.0237692, 0.0312066, 0.0406632, 0.0526867, 0.0679357,
0.0871913, 0.111359, 0.141458, 0.178584, 0.223838,
0.27822, 0.342461, 0.416865, 0.501361, 0.596739,
0.713623, 0.905749, 1.20718, 1.52521, 1.75286,
1.82072, 1.67119, 1.50074, 1.3077, 1.14923,
1.0577, 0.977911, 0.918526, 0.792889, 0.702282,
0.678615, 0.687099, 0.725167, 0.706795, 0.678045,
0.649791, 0.651328, 0.651934, 0.658062, 0.660659,
0.662534, 0.662601, 0.660261, 0.656724, 0.65212
};
/////////////////////////////////////////////////////////////
//
// anu_e CC xsc_tot/E_nu, in 10^-38 cm2/GeV
const G4double G4ElNeutrinoNucleusTotXsc::fANuElTotXsc[50] =
{
0.00103385, 0.00237807, 0.00366358, 0.00515192, 0.00697434,
0.00925859, 0.0121508, 0.0158252, 0.0204908, 0.0263959,
0.0338304, 0.0431234, 0.0546346, 0.068735, 0.0857738,
0.106025, 0.129614, 0.15643, 0.186063, 0.21784,
0.251065, 0.28525, 0.319171, 0.348995, 0.369448,
0.378165, 0.377353, 0.371224, 0.363257, 0.355433,
0.348618, 0.343082, 0.338825, 0.33574, 0.333684,
0.332504, 0.332052, 0.332187, 0.332781, 0.333716,
0.33489, 0.336213, 0.337608, 0.339008, 0.340362,
0.341606, 0.342706, 0.343628, 0.344305, 0.344675
};
source/processes/hadronic/cross_sections/src/G4HadronNucleonXsc.cc
+153 -286
View File
@@ -42,75 +42,12 @@
#include "G4Pow.hh"
#include "G4NuclearRadii.hh"
#include "G4LambdacPlus.hh"
#include "G4AntiLambdacPlus.hh"
#include "G4AntiXibZero.hh"
#include "G4OmegacZero.hh"
#include "G4SigmacZero.hh"
#include "G4AntiLambdab.hh"
#include "G4AntiSigmabMinus.hh"
#include "G4AntiXicPlus.hh"
#include "G4AntiLambdacPlus.hh"
#include "G4AntiSigmabPlus.hh"
#include "G4AntiXicZero.hh"
#include "G4AntiSigmabZero.hh"
#include "G4XibMinus.hh"
#include "G4AntiSigmacPlus.hh"
#include "G4XibZero.hh"
#include "G4AntiOmegabMinus.hh"
#include "G4AntiSigmacPlusPlus.hh"
#include "G4Lambdab.hh"
#include "G4SigmabMinus.hh"
#include "G4XicPlus.hh"
#include "G4AntiOmegacZero.hh"
#include "G4AntiSigmacZero.hh"
#include "G4LambdacPlus.hh"
#include "G4SigmabPlus.hh"
#include "G4XicZero.hh"
#include "G4SigmabZero.hh"
#include "G4SigmacPlus.hh"
#include "G4AntiXibMinus.hh"
#include "G4OmegabMinus.hh"
#include "G4SigmacPlusPlus.hh"
#include "G4BMesonZero.hh"
#include "G4AntiBMesonZero.hh"
#include "G4DMesonZero.hh"
#include "G4AntiDMesonZero.hh"
#include "G4BsMesonZero.hh"
#include "G4AntiBsMesonZero.hh"
#include "G4BcMesonPlus.hh"
#include "G4BcMesonMinus.hh"
#include "G4DsMesonPlus.hh"
#include "G4DsMesonMinus.hh"
#include "G4Eta.hh"
#include "G4EtaPrime.hh"
#include "G4Etac.hh"
#include "G4BMesonPlus.hh"
#include "G4BMesonMinus.hh"
#include "G4DMesonPlus.hh"
#include "G4DMesonMinus.hh"
#include "G4JPsi.hh"
#include "G4Upsilon.hh"
#include "G4Lambda.hh"
#include "G4AntiLambda.hh"
#include "G4SigmaPlus.hh"
#include "G4AntiSigmaPlus.hh"
#include "G4SigmaMinus.hh"
#include "G4AntiSigmaMinus.hh"
#include "G4SigmaZero.hh"
#include "G4AntiSigmaZero.hh"
#include "G4XiMinus.hh"
#include "G4XiZero.hh"
#include "G4AntiXiMinus.hh"
#include "G4AntiXiZero.hh"
#include "G4OmegaMinus.hh"
#include "G4AntiOmegaMinus.hh"
#include "G4Neutron.hh"
#include "G4PionPlus.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4KaonZeroShort.hh"
#include "G4KaonZeroLong.hh"
static const G4double invGeV = 1.0/CLHEP::GeV;
static const G4double invGeV2 = 1.0/(CLHEP::GeV*CLHEP::GeV);
@@ -120,93 +57,21 @@ static const G4double cofLogE = .0557; // elastic (lnP-minLogP)^2
static const G4double cofLogT = .3; // total (lnP-minLogP)^2
static const G4double pMin = .1; // fast LE calculation
static const G4double pMax = 1000.; // fast HE calculation
static const G4double ekinmin = 0.1*CLHEP::MeV; // protection against zero ekin
static const G4double ekinmin = 0.1*CLHEP::MeV; // protection against zero ekin
static const G4double ekinmaxQB = 100*CLHEP::MeV; // max kinetic energy for Coulomb barrier
G4HadronNucleonXsc::G4HadronNucleonXsc()
: fTotalXsc(0.0), fElasticXsc(0.0), fInelasticXsc(0.0)
{
fHypTotXscCof = 0.88; // for transformation pp(pn) to hyperon-nucleon
theGamma = G4Gamma::Gamma();
theProton = G4Proton::Proton();
theNeutron = G4Neutron::Neutron();
theAProton = G4AntiProton::AntiProton();
theANeutron = G4AntiNeutron::AntiNeutron();
thePiPlus = G4PionPlus::PionPlus();
thePiMinus = G4PionMinus::PionMinus();
thePiZero = G4PionZero::PionZero();
theD = G4Deuteron::Deuteron();
theT = G4Triton::Triton();
theA = G4Alpha::Alpha();
theHe3 = G4He3::He3();
// strange
theKPlus = G4KaonPlus::KaonPlus();
theKMinus = G4KaonMinus::KaonMinus();
theK0S = G4KaonZeroShort::KaonZeroShort();
theK0L = G4KaonZeroLong::KaonZeroLong();
theL = G4Lambda::Lambda();
theAntiL = G4AntiLambda::AntiLambda();
theSPlus = G4SigmaPlus::SigmaPlus();
theASPlus = G4AntiSigmaPlus::AntiSigmaPlus();
theSMinus = G4SigmaMinus::SigmaMinus();
theASMinus = G4AntiSigmaMinus::AntiSigmaMinus();
theS0 = G4SigmaZero::SigmaZero();
theAS0 = G4AntiSigmaZero::AntiSigmaZero();
theXiMinus = G4XiMinus::XiMinus();
theXi0 = G4XiZero::XiZero();
theAXiMinus = G4AntiXiMinus::AntiXiMinus();
theAXi0 = G4AntiXiZero::AntiXiZero();
theOmega = G4OmegaMinus::OmegaMinus();
theAOmega = G4AntiOmegaMinus::AntiOmegaMinus();
// c- and b- hyperons
theLambdaCPlus = G4LambdacPlus::LambdacPlus();
theALambdaCPlus = G4AntiLambdacPlus::AntiLambdacPlus();
theOmegaC0 = G4OmegacZero::OmegacZero();
theAOmegaC0 = G4AntiOmegacZero::AntiOmegacZero();
theSigmaCPlus = G4SigmacPlus::SigmacPlus();
theASigmaCPlus = G4AntiSigmacPlus::AntiSigmacPlus();
theSigmacPP = G4SigmacPlusPlus::SigmacPlusPlus();
theASigmacPP = G4AntiSigmacPlusPlus::AntiSigmacPlusPlus();
theSigmaC0 = G4SigmacZero::SigmacZero();
theASigmaC0 = G4AntiSigmacZero::AntiSigmacZero();
theXiCPlus = G4XicPlus::XicPlus();
theAXiCPlus = G4AntiXicPlus::AntiXicPlus();
theXiC0 = G4XicZero::XicZero();
theAXiC0 = G4AntiXicZero::AntiXicZero();
theLambdaB = G4Lambdab::Lambdab();
theALambdaB = G4AntiLambdab::AntiLambdab();
theOmegaBMinus = G4OmegabMinus::OmegabMinus();
theAOmegaBMinus = G4AntiOmegabMinus::AntiOmegabMinus();
theSigmaBMinus = G4SigmabMinus::SigmabMinus();
theASigmaBMinus = G4AntiSigmabMinus::AntiSigmabMinus();
theSigmaBPlus = G4SigmabPlus::SigmabPlus();
theASigmaBPlus = G4AntiSigmabPlus::AntiSigmabPlus();
theSigmaB0 = G4SigmabZero::SigmabZero();
theASigmaB0 = G4AntiSigmabZero::AntiSigmabZero();
theXiBMinus = G4XibMinus::XibMinus();
theAXiBMinus = G4AntiXibMinus::AntiXibMinus();
theXiB0 = G4XibZero::XibZero();
theAXiB0 = G4AntiXibZero::AntiXibZero();
//(s-) c- and b-mesons
theBMeson0 = G4BMesonZero::BMesonZero();
theABMeson0 = G4AntiBMesonZero::AntiBMesonZero();
theDMeson0 = G4DMesonZero::DMesonZero();
theADMeson0 = G4AntiDMesonZero::AntiDMesonZero();
theBsMeson0 = G4BsMesonZero::BsMesonZero();
theABsMeson0 = G4AntiBsMesonZero::AntiBsMesonZero();
theBcMesonPlus = G4BcMesonPlus::BcMesonPlus();
theBcMesonMinus = G4BcMesonMinus::BcMesonMinus();
theDsMesonPlus = G4DsMesonPlus::DsMesonPlus();
theDsMesonMinus = G4DsMesonMinus::DsMesonMinus();
theDMesonPlus = G4DMesonPlus::DMesonPlus();
theDMesonMinus = G4DMesonMinus::DMesonMinus();
theBMesonPlus = G4BMesonPlus::BMesonPlus();
theBMesonMinus = G4BMesonMinus::BMesonMinus();
theEta = G4Eta::Eta();
theEtaPrime = G4EtaPrime::EtaPrime();
theEtaC = G4Etac::Etac();
theJPsi = G4JPsi::JPsi();
theUpsilon = G4Upsilon::Upsilon();
g4calc = G4Pow::GetInstance();
}
@@ -224,48 +89,53 @@ void G4HadronNucleonXsc::CrossSectionDescription(std::ostream& outFile) const
<< "is to be used to build a cross section data set.\n";
}
G4double G4HadronNucleonXsc::HadronNucleonXsc( const G4ParticleDefinition* theParticle,
const G4ParticleDefinition* nucleon, G4double ekin)
{
G4double xsc(0.);
G4int pdg = std::abs( theParticle->GetPDGEncoding() );
G4int pdg = std::abs(theParticle->GetPDGEncoding());
if ( pdg == 2212 || pdg == 2112 || pdg == 211 ) // p, n, pi+-
{
xsc = HadronNucleonXscNS( theParticle, nucleon, ekin);
// p, n, pi+-, pbar, nbar
if ( pdg == 2212 || pdg == 2112 || pdg == 211 ) {
xsc = HadronNucleonXscNS(theParticle, nucleon, ekin);
}
else if ( pdg == 321 || pdg == 310 || pdg == 130 ) // K+-, K0, Ks
else if ( pdg == 22 ) // gamma
{
xsc = KaonNucleonXscNS( theParticle, nucleon, ekin);
xsc = HadronNucleonXscPDG(theParticle, nucleon, ekin);
}
else if ( pdg == 3122 || pdg == 3222 || pdg == 3112 || pdg == 3212 || pdg == 3322 || pdg == 3312 || pdg == 3324 ||
pdg == 4122 || pdg == 4332 || pdg == 4122 || pdg == 4212 || pdg == 4222 || pdg == 4112 || pdg == 4232 || pdg == 4132 ||
pdg == 5122 || pdg == 5332 || pdg == 5122 || pdg == 5112 || pdg == 5222 || pdg == 5212 || pdg == 5132 || pdg == 5232
) // heavy s-,c-,b-hyperons
else if ( pdg == 321 || pdg == 310 || pdg == 130 ) // K+-, K0L, K0S
{
xsc = HyperonNucleonXscNS( theParticle, nucleon, ekin);
xsc = KaonNucleonXscNS(theParticle, nucleon, ekin);
}
else if ( pdg == 511 || pdg == 421 || pdg == 531 || pdg == 541 || pdg == 431 || pdg == 411 || pdg == 521 ||
pdg == 221 || pdg == 331 || pdg == 441 || pdg == 443 || pdg == 543
) // s-,c-,b-mesons
else if (pdg > 3000)
{
xsc = SCBMesonNucleonXscNS( theParticle, nucleon, ekin);
}
else
{
xsc = HadronNucleonXscNS( theParticle, nucleon, ekin);
if (pdg == 3122 || pdg == 3222 || pdg == 3112 || pdg == 3212 || pdg == 3322 || pdg == 3312 || pdg == 3324 ||
pdg == 4122 || pdg == 4332 || pdg == 4122 || pdg == 4212 || pdg == 4222 || pdg == 4112 || pdg == 4232 || pdg == 4132 ||
pdg == 5122 || pdg == 5332 || pdg == 5122 || pdg == 5112 || pdg == 5222 || pdg == 5212 || pdg == 5132 || pdg == 5232
) // heavy s-,c-,b-hyperons
{
xsc = HyperonNucleonXscNS(theParticle, nucleon, ekin);
}
else
{
xsc = HadronNucleonXscPDG(theParticle, nucleon, ekin);
}
} else if (pdg > 220) {
if (pdg == 511 || pdg == 421 || pdg == 531 || pdg == 541 || pdg == 431 || pdg == 411 || pdg == 521 ||
pdg == 221 || pdg == 331 || pdg == 441 || pdg == 443 || pdg == 543) // s-,c-,b-mesons
{
xsc = SCBMesonNucleonXscNS(theParticle, nucleon, ekin);
}
else
{
xsc = HadronNucleonXscPDG(theParticle, nucleon, ekin);
}
} else {
xsc = HadronNucleonXscPDG(theParticle, nucleon, ekin);
}
return xsc;
}
//////////////////////////////////////////////////////////////////////////////
//
// Returns hadron-nucleon Xsc according to PDG parametrisation (2017):
@@ -280,8 +150,9 @@ G4double G4HadronNucleonXsc::HadronNucleonXscPDG(
static const G4double eta2 = 0.5486;
static const G4double H = 0.272;
G4double mass1 = theParticle->GetPDGMass();
if(theParticle == theGamma) { mass1 = 770.; }
G4int pdg = theParticle->GetPDGEncoding();
G4double mass1 = (pdg == 22) ? 770. : theParticle->GetPDGMass();
G4double mass2 = nucleon->GetPDGMass();
G4double sMand = CalcMandelstamS(ekin, mass1, mass2)*invGeV2;
@@ -323,7 +194,8 @@ G4double G4HadronNucleonXsc::HadronNucleonXscPDG(
R2 = -7.394;
}
}
else if(theParticle == theAProton)
// pbar
else if(pdg == -2212)
{
if ( neutron )
{
@@ -338,7 +210,8 @@ G4double G4HadronNucleonXsc::HadronNucleonXscPDG(
R2 = 7.394;
}
}
else if(theParticle == theANeutron)
// nbar
else if(pdg == -2112)
{
if ( proton )
{
@@ -353,13 +226,15 @@ G4double G4HadronNucleonXsc::HadronNucleonXscPDG(
R2 = 7.394;
}
}
else if(theParticle == thePiPlus)
// pi+
else if(pdg == 211)
{
P = 18.75;
R1 = 9.56;
R2 = -1.767;
}
else if(theParticle == thePiMinus)
// pi-
else if(pdg == -211)
{
P = 18.75;
R1 = 9.56;
@@ -401,19 +276,20 @@ G4double G4HadronNucleonXsc::HadronNucleonXscPDG(
R1 = 2.5;
R2 = 0.;
}
else if(theParticle == theSMinus)
// sigma-
else if(pdg == 3112)
{
P = 34.7;
R1 = -46.;
R2 = 48.;
}
else if(theParticle == theGamma) // modify later on
// gamma
else if(pdg == 22) // modify later on
{
del= 0.003063;
P = 34.71*del;
R1 = (neutron) ? 0.0231 : 0.0139;
R2 = 0.;
}
else // as proton ???
{
@@ -435,7 +311,7 @@ G4double G4HadronNucleonXsc::HadronNucleonXscPDG(
fInelasticXsc = 0.75*fTotalXsc;
fElasticXsc = fTotalXsc - fInelasticXsc;
if( proton && theParticle->GetPDGCharge() > 0. && ekin < 100*MeV)
if( proton && theParticle->GetPDGCharge() > 0. && ekin < ekinmaxQB )
{
G4double cB = CoulombBarrier(theParticle, nucleon, ekin);
fTotalXsc *= cB;
@@ -462,12 +338,13 @@ G4double G4HadronNucleonXsc::HadronNucleonXscNS(
const G4ParticleDefinition* nucleon, G4double ekin0)
{
const G4double ekin = std::max(ekin0, ekinmin);
G4int pdg = theParticle->GetPDGEncoding();
/*
G4cout<< "HadronNucleonXscNS: Ekin(GeV)= " << ekin/GeV << " "
<< theParticle->GetParticleName() << " + "
<< nucleon->GetParticleName() << G4endl;
*/
if(theParticle == theAProton || theParticle == theANeutron) {
if(pdg == -2212 || pdg == -2112) {
return HadronNucleonXscPDG(theParticle, nucleon, ekin);
}
@@ -629,8 +506,7 @@ G4double G4HadronNucleonXsc::HadronNucleonXscNS(
}
}
// pi+ p; pi- n
else if((theParticle == thePiPlus && proton) ||
(theParticle == thePiMinus && neutron))
else if((pdg == 211 && proton) || (pdg == -211 && neutron))
{
if( pLab < 0.28 )
{
@@ -686,8 +562,7 @@ G4double G4HadronNucleonXsc::HadronNucleonXscNS(
}
}
// pi+ n; pi- p
else if((theParticle == thePiPlus && neutron) ||
(theParticle == thePiMinus && proton))
else if((pdg == 211 && neutron) || (pdg == -211 && proton))
{
if( pLab < 0.28 )
{
@@ -878,7 +753,7 @@ G4double G4HadronNucleonXsc::HadronNucleonXscNS(
fElasticXsc *= CLHEP::millibarn;
fElasticXsc = std::min(fElasticXsc, fTotalXsc);
if( proton && theParticle->GetPDGCharge() > 0. && ekin < 100*MeV)
if( proton && theParticle->GetPDGCharge() > 0. && ekin < ekinmaxQB )
{
G4double cB = G4NuclearRadii::CoulombFactor(theParticle, nucleon, ekin);
fTotalXsc *= cB;
@@ -935,15 +810,29 @@ G4double G4HadronNucleonXsc::KaonNucleonXscNS(
HadronNucleonXscNS(theParticle, nucleon, ekin);
} else if(theParticle == theK0S || theParticle == theK0L) {
G4double stot = HadronNucleonXscNS(theKMinus, nucleon, ekin);
G4double sel = fElasticXsc;
G4double sinel = fInelasticXsc;
stot += HadronNucleonXscNS(theKPlus, nucleon, ekin);
sel += fElasticXsc;
sinel += fInelasticXsc;
fTotalXsc = stot*0.5;
fElasticXsc = sel*0.5;
fInelasticXsc = sinel*0.5;
G4double fact = 0.5;
G4double stot = 0.0;
G4double sel = 0.0;
G4double sinel= 0.0;
if(ekin > ekinmaxQB) {
stot = HadronNucleonXscNS(theKMinus, nucleon, ekin);
sel = fElasticXsc;
sinel = fInelasticXsc;
stot += HadronNucleonXscNS(theKPlus, nucleon, ekin);
sel += fElasticXsc;
sinel += fInelasticXsc;
} else {
fact *= std::sqrt(ekinmaxQB/std::max(ekin, ekinmin));
stot = HadronNucleonXscNS(theKMinus, nucleon, ekinmaxQB);
sel = fElasticXsc;
sinel = fInelasticXsc;
stot += HadronNucleonXscNS(theKPlus, nucleon, ekinmaxQB);
sel += fElasticXsc;
sinel += fInelasticXsc;
}
fTotalXsc = stot*fact;
fElasticXsc = sel*fact;
fInelasticXsc = sinel*fact;
}
return fTotalXsc;
}
@@ -1106,66 +995,52 @@ G4double G4HadronNucleonXsc::HyperonNucleonXscNS(
const G4ParticleDefinition* nucleon, G4double ekin)
{
G4double coeff = 1.0;
static const G4double lBarCof1S = 0.88;
static const G4double lBarCof2S = 0.76;
static const G4double lBarCof3S = 0.64;
static const G4double lBarCof1C = 0.784378;
static const G4double lBarCofSC = 0.664378;
static const G4double lBarCof2SC = 0.544378;
static const G4double lBarCof1B = 0.740659;
static const G4double lBarCofSB = 0.620659;
static const G4double lBarCof2SB = 0.500659;
if( theParticle == theL || theParticle == theSPlus ||
theParticle == theSMinus || theParticle == theS0 ||
theParticle == theAntiL || theParticle == theASPlus ||
theParticle == theASMinus || theParticle == theAS0 )
G4int pdg = std::abs(theParticle->GetPDGEncoding());
// lambda, sigma+-0 and anti-hyperons
if( pdg == 3122 || pdg == 3112 || pdg == 3212 || pdg == 3222 )
{
coeff = lBarCof1S;
} else if( theParticle == theXiMinus || theParticle == theXi0 ||
theParticle == theAXiMinus || theParticle == theAXi0 )
coeff = 0.88;
}
// Xi hyperons and anti-hyperons
else if( pdg == 3312 || pdg == 3322 )
{
coeff = lBarCof2S;
coeff = 0.76;
}
else if( theParticle == theOmega || theParticle == theAOmega)
// omega, anti_omega
else if( pdg == 3334 )
{
coeff = lBarCof3S;
coeff = 0.64;
}
else if( theParticle == theLambdaCPlus || theParticle == theALambdaCPlus ||
theParticle == theSigmaCPlus || theParticle == theASigmaCPlus ||
theParticle == theSigmacPP || theParticle == theASigmacPP ||
theParticle == theSigmaC0 || theParticle == theASigmaC0
)
// lambdaC, sigmaC+-0 and anti-hyperonsC
else if( pdg == 4122 || pdg == 4112 || pdg == 4212 || pdg == 4222 )
{
coeff = lBarCof1C;
coeff = 0.784378;
}
else if( theParticle == theOmegaC0 || theParticle == theAOmegaC0 )
// omegaC0, anti_omegaC0
else if( pdg == 4332 )
{
coeff = lBarCof2SC;
coeff = 0.544378;
}
else if( theParticle == theXiCPlus || theParticle == theXiC0 ||
theParticle == theAXiCPlus || theParticle == theAXiC0)
// XiC+0 and anti-hyperonC
else if( pdg == 4132 || pdg == 4232 )
{
coeff = lBarCofSC;
coeff = 0.664378;
}
else if( theParticle == theLambdaB || theParticle == theALambdaB ||
theParticle == theSigmaBPlus || theParticle == theASigmaBPlus ||
theParticle == theSigmaBMinus || theParticle == theASigmaBMinus ||
theParticle == theSigmaB0 || theParticle == theASigmaB0
)
// lambdaB, sigmaB+-0 and anti-hyperonsB
else if( pdg == 5122 || pdg == 5112 || pdg == 5212 || pdg == 5222 )
{
coeff = lBarCof1B;
coeff = 0.740659;
}
else if( theParticle == theOmegaBMinus || theParticle == theAOmegaBMinus)
// omegaB0, anti_omegaB0
else if( pdg == 5332 )
{
coeff = lBarCof2SB;
coeff = 0.500659;
}
else if( theParticle == theXiBMinus || theParticle == theXiB0 ||
theParticle == theAXiBMinus || theParticle == theAXiB0)
// XiB+0 and anti-hyperonB
else if( pdg == 5132 || pdg == 5232 )
{
coeff = lBarCofSB;
coeff = 0.620659;
}
fTotalXsc = coeff*HadronNucleonXscNS( theProton, nucleon, ekin);
fInelasticXsc *= coeff;
@@ -1183,64 +1058,54 @@ G4double G4HadronNucleonXsc::SCBMesonNucleonXscNS(
const G4ParticleDefinition* nucleon, G4double ekin )
{
G4double coeff(1.0);
// static const G4double lMesCof1S = 0.82; // Kp/piP
static const G4double llMesCof1C = 0.676568;
static const G4double llMesCof1B = 0.610989;
static const G4double llMesCof2C = 0.353135;
static const G4double llMesCof2B = 0.221978;
static const G4double llMesCofSC = 0.496568;
static const G4double llMesCofSB = 0.430989;
static const G4double llMesCofCB = 0.287557;
static const G4double llMesCofEtaP = 0.88;
static const G4double llMesCofEta = 0.76;
G4int pdg = std::abs(theParticle->GetPDGEncoding());
if( theParticle == theBMeson0 || theParticle == theABMeson0 ||
theParticle == theBMesonPlus || theParticle == theBMesonMinus )
// B+-0 anti
if( pdg == 511 || pdg == 521 )
{
coeff = llMesCof1B;
coeff = 0.610989;
}
else if(theParticle == theDMeson0 || theParticle == theADMeson0 ||
theParticle == theDMesonPlus || theParticle == theDMesonMinus )
// D+-0 anti
else if( pdg == 411 || pdg == 421 )
{
coeff = llMesCof1C;
coeff = 0.676568;
}
else if(theParticle == theBsMeson0 || theParticle == theABsMeson0 )
// Bs, antiBs
else if( pdg == 531 )
{
coeff = llMesCofSB;
coeff = 0.430989;
}
else if(theParticle == theBcMesonPlus || theParticle == theBcMesonMinus )
// Bc+-
else if( pdg == 541 )
{
coeff = llMesCofCB;
coeff = 0.287557;
}
else if(theParticle == theDsMesonPlus || theParticle == theDsMesonMinus )
// Ds+-
else if( pdg == 431 )
{
coeff = llMesCofSC;
coeff = 0.496568;
}
else if(theParticle == theBMesonPlus || theParticle == theBMesonMinus )
// etaC, J/Psi
else if( pdg == 441 || pdg == 443 )
{
coeff = llMesCof1B;
coeff = 0.353135;
}
else if(theParticle == theDMesonPlus || theParticle == theDMesonMinus )
// Upsilon
else if( pdg == 553 )
{
coeff = llMesCof1C;
coeff = 0.221978;
}
else if(theParticle == theEtaC || theParticle == theJPsi )
// eta
else if( pdg == 221 )
{
coeff = llMesCof2C;
coeff = 0.76;
}
else if(theParticle == theUpsilon )
// eta'
else if( pdg == 331 )
{
coeff = llMesCof2B;
coeff = 0.88;
}
else if(theParticle == theEta )
{
coeff = llMesCofEta;
}
else if(theParticle == theEtaPrime )
{
coeff = llMesCofEtaP;
}
fTotalXsc = coeff*HadronNucleonXscNS( thePiPlus, nucleon, ekin);
fTotalXsc = coeff*HadronNucleonXscNS(thePiPlus, nucleon, ekin);
fElasticXsc *= coeff;
fInelasticXsc *= coeff;
return fTotalXsc;
@@ -1404,6 +1269,7 @@ G4double G4HadronNucleonXsc::HadronNucleonXscEL(
const G4ParticleDefinition* theParticle,
const G4ParticleDefinition*, G4double ekin)
{
G4int pdg = theParticle->GetPDGEncoding();
G4double xsection(0.);
static const G4double targ_mass =
0.5*(CLHEP::proton_mass_c2 + CLHEP::neutron_mass_c2);
@@ -1413,7 +1279,7 @@ G4double G4HadronNucleonXsc::HadronNucleonXscEL(
G4double x1 = G4Exp(G4Log(sMand)*0.0808);
G4double x2 = G4Exp(G4Log(-sMand)*0.4525);
if(theParticle == theGamma)
if(pdg == 22)
{
xsection = 0.0677*x1 + 0.129*x2;
}
@@ -1425,7 +1291,8 @@ G4double G4HadronNucleonXsc::HadronNucleonXscEL(
{
xsection = 21.70*x1 + 56.08*x2;
}
else if(theParticle == theAProton)
// pbar
else if(pdg == -2212)
{
xsection = 21.70*x1 + 98.39*x2;
}
@@ -1433,7 +1300,8 @@ G4double G4HadronNucleonXsc::HadronNucleonXscEL(
{
xsection = 13.63*x1 + 27.56*x2;
}
else if(theParticle == thePiMinus)
// pi-
else if(pdg == -211)
{
xsection = 13.63*x1 + 36.02*x2;
}
@@ -1469,9 +1337,9 @@ G4HadronNucleonXsc::CoulombBarrier(const G4ParticleDefinition* theParticle,
G4double tR = 0.895*CLHEP::fermi;
G4double pR = 0.5*CLHEP::fermi;
if ( theParticle == theProton ) pR = 0.895*fermi;
else if( theParticle == thePiPlus ) pR = 0.663*fermi;
else if( theParticle == theKPlus ) pR = 0.340*fermi;
if ( theParticle == theProton ) pR = 0.895*CLHEP::fermi;
else if( theParticle == thePiPlus ) pR = 0.663*CLHEP::fermi;
else if( theParticle == theKPlus ) pR = 0.340*CLHEP::fermi;
G4double pZ = theParticle->GetPDGCharge();
G4double tZ = nucleon->GetPDGCharge();
@@ -1497,4 +1365,3 @@ G4HadronNucleonXsc::CoulombBarrier(const G4ParticleDefinition* theParticle,
}
//////////////////////////////////////////////////////////////////////////////
source/processes/hadronic/cross_sections/src/G4PhotoNuclearCrossSection.cc
+111 -66
View File
@@ -1493,8 +1493,10 @@ static const G4double* SH[nHA]={
// Bug 2092 fix (ejc3) Init deuteron_GDR ptr to null
G4PhotoNuclearCrossSection::G4PhotoNuclearCrossSection()
: G4VCrossSectionDataSet(Default_Name()), lastZ(0), lastSig(0), lastGDR(0),
lastHEN(0), lastE(0), lastTH(0), lastSP(0), deuteron_GDR(0), deuteron_HR(0),
deuteron_TH(0), deuteron_SP(0),
lastHEN(0), lastE(0), lastTH(0), lastSP(0),
deuteron_GDR(0), deuteron_HR(0), deuteron_TH(0), deuteron_SP(0),
triton_GDR(0), triton_HR(0), triton_TH(0), triton_SP(0),
he3_GDR(0), he3_HR(0), he3_TH(0), he3_SP(0),
mNeut(G4NucleiProperties::GetNuclearMass(1,0)),
mProt(G4NucleiProperties::GetNuclearMass(1,1))
{
@@ -1532,15 +1534,17 @@ G4PhotoNuclearCrossSection::CrossSectionDescription(std::ostream& outFile) const
}
// Method added to fix Bug 2092 (ejc3)
// Allow D, T, 3He targets
G4bool
G4PhotoNuclearCrossSection::IsIsoApplicable(const G4DynamicParticle*,
G4int Z, G4int A,
const G4Element*,
const G4Material*)
{
// explicitly allow deuterium
if (Z == 1 && A == 2) return true;
// explicitly allow deuterium and tritium
// if (Z == 1 && (A == 2 || A == 3) ) return true;
if ((Z == 1 && A == 2) || (Z == 1 && A == 3) ||
(Z == 2 && A == 3) ) return true;
return false;
}
@@ -1552,7 +1556,8 @@ G4PhotoNuclearCrossSection::IsElementApplicable(const G4DynamicParticle* /*parti
return true;
}
// Method added to fix Bug 2092 (ejc3)
// Get cross sections for deuterium, tritium and 3He only
G4double
G4PhotoNuclearCrossSection::GetIsoCrossSection(const G4DynamicParticle* aPart,
G4int Z, G4int A,
@@ -1560,42 +1565,80 @@ G4PhotoNuclearCrossSection::GetIsoCrossSection(const G4DynamicParticle* aPart,
const G4Element*,
const G4Material* mat)
{
// if not deuterium, go back to old style
if (!(Z == 1 && A == 2)) return GetElementCrossSection(aPart, Z, mat);
// Otherwise, follow a similar routine
const G4double Energy = aPart->GetKineticEnergy()/MeV;
if (Energy < THmin) return 0.;
G4double sigma = 0.;
// init the XS table if need be
if (deuteron_GDR == NULL) {
deuteron_TH = ThresholdEnergy(1,1); // threshold calculation is correct
deuteron_GDR = new G4double[nL]; // direct copies
for (G4int i = 0 ; i < nL ; i++) deuteron_GDR[i] = SL[0][i]; // A = 2 -> SL0
deuteron_HR = new G4double[nH];
for (G4int i = 0 ; i < nH ; i++) deuteron_HR[i] = SH[1][i]; // A = 2 -> SH1
deuteron_SP = 1; // as would be assigned for proton
G4double sigma;
G4double lE;
if (Z == 1 && A == 2) {
// init the XS table if need be
if (deuteron_GDR == NULL) {
deuteron_TH = ThresholdEnergy(1,1); // threshold calculation is correct
deuteron_GDR = new G4double[nL]; // direct copies
for (G4int i = 0 ; i < nL ; i++) deuteron_GDR[i] = SL[0][i]; // A = 2 -> SL0
deuteron_HR = new G4double[nH];
for (G4int i = 0 ; i < nH ; i++) deuteron_HR[i] = SH[1][i]; // A = 2 -> SH1
deuteron_SP = 1; // as would be assigned for proton
}
if (Energy < deuteron_TH) {
sigma = 0.;
} else if (Energy < Emin) { // GDR region (approximated in E, not in lnE)
sigma = EquLinearFit(Energy,nL,THmin,dE,deuteron_GDR);
} else if (Energy < Emax) { // High Energy region
lE = G4Log(Energy);
sigma = EquLinearFit(lE,nH,milE,dlE,deuteron_HR);
} else { // Very high energy region
lE = G4Log(Energy);
sigma = deuteron_SP*(poc*(lE-pos)+shd*std::exp(-reg*lE));
}
} else if (Z == 1 && A == 3) {
if (triton_GDR == NULL) {
triton_TH = ThresholdEnergy(1,2);
triton_GDR = new G4double[nL]; // same as for deuteron since no A = 3 entry
for (G4int i = 0 ; i < nL ; i++) triton_GDR[i] = SL[0][i]; // A = 3 -> SL0
triton_HR = new G4double[nH];
for (G4int i = 0 ; i < nH ; i++) triton_HR[i] = SH[2][i]; // A = 3 -> SH2
triton_SP = 1;
}
if (Energy < triton_TH) {
sigma = 0.;
} else if (Energy < Emin) { // GDR region
sigma = EquLinearFit(Energy,nL,THmin,dE,triton_GDR);
} else if (Energy < Emax) { // High Energy region
lE = G4Log(Energy);
sigma = EquLinearFit(lE,nH,milE,dlE,triton_HR);
} else {
lE = G4Log(Energy);
sigma = triton_SP*(poc*(lE-pos)+shd*std::exp(-reg*lE));
}
} else if (Z == 2 && A == 3) {
if (he3_GDR == NULL) {
he3_TH = ThresholdEnergy(2,1);
he3_GDR = new G4double[nL]; // same as for deuteron since no A = 3 entry
for (G4int i = 0 ; i < nL ; i++) he3_GDR[i] = SL[0][i]; // A = 3 -> SL0
he3_HR = new G4double[nH];
for (G4int i = 0 ; i < nH ; i++) he3_HR[i] = SH[2][i]; // A = 3 -> SH2
he3_SP = 2;
}
if (Energy < he3_TH) {
sigma = 0.;
} else if (Energy < Emin) { // GDR region
sigma = EquLinearFit(Energy,nL,THmin,dE,he3_GDR);
} else if (Energy < Emax) { // High Energy region
lE = G4Log(Energy);
sigma = EquLinearFit(lE,nH,milE,dlE,he3_HR);
} else {
lE = G4Log(Energy);
sigma = he3_SP*(poc*(lE-pos)+shd*std::exp(-reg*lE));
}
} else {
return GetElementCrossSection(aPart, Z, mat);
}
// =================== now the "magic" formula ===================
if (Energy < deuteron_TH) {
return 0.;
} else if (Energy < Emin) { // GDR region (approximated in E, not in lnE)
sigma = EquLinearFit(Energy,nL,THmin,dE,deuteron_GDR);
} else if (Energy < Emax) { // High Energy region
G4double lE = G4Log(Energy);
sigma = EquLinearFit(lE,nH,milE,dlE,deuteron_HR);
} else { // UHE region (calculation, but not so frequent)
G4double lE = G4Log(Energy);
sigma = deuteron_SP*(poc*(lE-pos)+shd*std::exp(-reg*lE));
}
// End of "sigma" calculation
if(sigma < 0.) return 0.;
if(sigma < 0.) sigma = 0.;
return sigma*millibarn;
}
@@ -1675,37 +1718,39 @@ G4PhotoNuclearCrossSection::GetElementCrossSection(const G4DynamicParticle* aPar
return sigma*millibarn;
}
// Gives the threshold energy for different nuclei (min of p- and n-threshold)
// Threshold energy for nuclei: explicitly calculated for p, D, T, 3He,
// min of p- and n-threshold for heavier targets
G4double G4PhotoNuclearCrossSection::ThresholdEnergy(G4int Z, G4int N)
{
// ---------
G4int A=Z+N;
if(A<1) return infEn;
else if(A==1) return 134.9766; // Pi0 threshold for the nucleon
G4double mT= 0.;
if(G4NucleiProperties::IsInStableTable(A,Z))
mT=G4NucleiProperties::GetNuclearMass(A,Z);
else
{
return infEn;
}
// ---------
G4double mP= infEn;
if(Z && G4NucleiProperties::IsInStableTable(A-1,Z-1))
{
mP = G4NucleiProperties::GetNuclearMass(A-1,Z-1);
}
G4double mN= infEn;
if(N&&G4NucleiProperties::IsInStableTable(A-1,Z))
mN=G4NucleiProperties::GetNuclearMass(A-1,Z);
G4double dP= mP+mProt-mT;
G4double dN= mN+mNeut-mT;
if(dP<dN)dN=dP;
return dN;
G4int A = Z + N;
if (A < 1) return infEn;
// Thresholds for p, d, t, 3He in lab frame
else if (A == 1) return 144.6821; // pi0 production
else if (Z == 1 && N == 1) return 2.2263; // disintegration
else if (Z == 1 && N == 2) return 6.2650; // n separation
else if (Z == 2 && N == 1) return 5.4994; // p separation
G4double mT = 0.;
if (G4NucleiProperties::IsInStableTable(A,Z) ) {
mT = G4NucleiProperties::GetNuclearMass(A,Z);
} else {
return infEn;
}
G4double mP = infEn;
if (Z && G4NucleiProperties::IsInStableTable(A-1,Z-1) ) {
mP = G4NucleiProperties::GetNuclearMass(A-1,Z-1);
}
G4double mN = infEn;
if (N && G4NucleiProperties::IsInStableTable(A-1,Z) ) {
mN = G4NucleiProperties::GetNuclearMass(A-1,Z);
}
G4double dP = mP + mProt - mT;
G4double dN = mN + mNeut - mT;
if (dP < dN) dN = dP;
return dN;
}
//