Gabriele Cosmo
524 lines
19 KiB
C++
524 lines
19 KiB
C++
//
|
|
// ********************************************************************
|
|
// * 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. *
|
|
// ********************************************************************
|
|
//
|
|
// neutron_hp -- source file
|
|
// J.P. Wellisch, Nov-1996
|
|
// A prototype of the low energy neutron transport model.
|
|
//
|
|
// 25-08-06 New Final State type (refFlag==3 , Legendre (Low Energy) + Probability (High Energy) )
|
|
// is added by T. KOI
|
|
// 080904 Add Protection for negative energy results in very low energy ( 1E-6 eV ) scattering by T.
|
|
// Koi
|
|
//
|
|
// P. Arce, June-2014 Conversion neutron_hp to particle_hp
|
|
//
|
|
#include "G4ParticleHPElasticFS.hh"
|
|
|
|
#include "G4Alpha.hh"
|
|
#include "G4Deuteron.hh"
|
|
#include "G4HadronicParameters.hh"
|
|
#include "G4IonTable.hh"
|
|
#include "G4LorentzVector.hh"
|
|
#include "G4Nucleus.hh"
|
|
#include "G4ParticleHPDataUsed.hh"
|
|
#include "G4ParticleHPManager.hh"
|
|
#include "G4PhysicalConstants.hh"
|
|
#include "G4PhysicsModelCatalog.hh"
|
|
#include "G4Pow.hh"
|
|
#include "G4Proton.hh"
|
|
#include "G4ReactionProduct.hh"
|
|
#include "G4SystemOfUnits.hh"
|
|
#include "G4ThreeVector.hh"
|
|
#include "G4Triton.hh"
|
|
|
|
#include "zlib.h"
|
|
|
|
G4ParticleHPElasticFS::G4ParticleHPElasticFS()
|
|
{
|
|
svtEmax = 0.0;
|
|
dbrcEmax = 0.0;
|
|
dbrcEmin = 0.0;
|
|
dbrcAmin = 0.0;
|
|
dbrcUse = false;
|
|
xsForDBRC = nullptr;
|
|
|
|
secID = G4PhysicsModelCatalog::GetModelID("model_NeutronHPElastic");
|
|
|
|
hasXsec = false;
|
|
theCoefficients = nullptr;
|
|
theProbArray = nullptr;
|
|
|
|
repFlag = 0;
|
|
tE_of_repFlag3 = 0.0;
|
|
targetMass = 0.0;
|
|
frameFlag = 0;
|
|
}
|
|
|
|
void G4ParticleHPElasticFS::Init(G4double A, G4double Z, G4int M,
|
|
const G4String& dirName, const G4String&,
|
|
G4ParticleDefinition*)
|
|
{
|
|
G4String tString = "/FS";
|
|
G4bool dbool = true;
|
|
SetA_Z(A, Z, M);
|
|
const G4ParticleHPDataUsed& aFile =
|
|
theNames.GetName(theBaseA, theBaseZ, M, dirName, tString, dbool);
|
|
const G4String& filename = aFile.GetName();
|
|
SetAZMs(aFile);
|
|
if (!dbool) {
|
|
hasAnyData = false;
|
|
hasFSData = false;
|
|
hasXsec = false;
|
|
return;
|
|
}
|
|
|
|
// 130205 For compressed data files
|
|
std::istringstream theData(std::ios::in);
|
|
G4ParticleHPManager::GetInstance()->GetDataStream(filename, theData);
|
|
// 130205 END
|
|
theData >> repFlag >> targetMass >> frameFlag;
|
|
|
|
if (repFlag == 1) {
|
|
G4int nEnergy;
|
|
theData >> nEnergy;
|
|
theCoefficients = new G4ParticleHPLegendreStore(nEnergy);
|
|
theCoefficients->InitInterpolation(theData);
|
|
G4double temp, energy;
|
|
G4int tempdep, nLegendre;
|
|
G4int i, ii;
|
|
for (i = 0; i < nEnergy; i++) {
|
|
theData >> temp >> energy >> tempdep >> nLegendre;
|
|
energy *= eV;
|
|
theCoefficients->Init(i, energy, nLegendre);
|
|
theCoefficients->SetTemperature(i, temp);
|
|
G4double coeff = 0;
|
|
for (ii = 0; ii < nLegendre; ii++) {
|
|
// load legendre coefficients.
|
|
theData >> coeff;
|
|
theCoefficients->SetCoeff(i, ii + 1, coeff); // @@@HPW@@@
|
|
}
|
|
}
|
|
}
|
|
else if (repFlag == 2) {
|
|
G4int nEnergy;
|
|
theData >> nEnergy;
|
|
theProbArray = new G4ParticleHPPartial(nEnergy, nEnergy);
|
|
theProbArray->InitInterpolation(theData);
|
|
G4double temp, energy;
|
|
G4int tempdep, nPoints;
|
|
for (G4int i = 0; i < nEnergy; i++) {
|
|
theData >> temp >> energy >> tempdep >> nPoints;
|
|
energy *= eV;
|
|
theProbArray->InitInterpolation(i, theData);
|
|
theProbArray->SetT(i, temp);
|
|
theProbArray->SetX(i, energy);
|
|
G4double prob, costh;
|
|
for (G4int ii = 0; ii < nPoints; ii++) {
|
|
// fill probability arrays.
|
|
theData >> costh >> prob;
|
|
theProbArray->SetX(i, ii, costh);
|
|
theProbArray->SetY(i, ii, prob);
|
|
}
|
|
theProbArray->DoneSetXY(i);
|
|
}
|
|
}
|
|
else if (repFlag == 3) {
|
|
G4int nEnergy_Legendre;
|
|
theData >> nEnergy_Legendre;
|
|
if (nEnergy_Legendre <= 0) {
|
|
std::stringstream iss;
|
|
iss << "G4ParticleHPElasticFS::Init Data Error repFlag is 3 but nEnergy_Legendre <= 0";
|
|
iss << "Z, A and M of problematic file is " << theNDLDataZ << ", " << theNDLDataA << " and "
|
|
<< theNDLDataM << " respectively.";
|
|
throw G4HadronicException(__FILE__, __LINE__, iss.str());
|
|
}
|
|
theCoefficients = new G4ParticleHPLegendreStore(nEnergy_Legendre);
|
|
theCoefficients->InitInterpolation(theData);
|
|
G4double temp, energy;
|
|
G4int tempdep, nLegendre;
|
|
|
|
for (G4int i = 0; i < nEnergy_Legendre; i++) {
|
|
theData >> temp >> energy >> tempdep >> nLegendre;
|
|
energy *= eV;
|
|
theCoefficients->Init(i, energy, nLegendre);
|
|
theCoefficients->SetTemperature(i, temp);
|
|
G4double coeff = 0;
|
|
for (G4int ii = 0; ii < nLegendre; ii++) {
|
|
// load legendre coefficients.
|
|
theData >> coeff;
|
|
theCoefficients->SetCoeff(i, ii + 1, coeff); // @@@HPW@@@
|
|
}
|
|
}
|
|
|
|
tE_of_repFlag3 = energy;
|
|
|
|
G4int nEnergy_Prob;
|
|
theData >> nEnergy_Prob;
|
|
theProbArray = new G4ParticleHPPartial(nEnergy_Prob, nEnergy_Prob);
|
|
theProbArray->InitInterpolation(theData);
|
|
G4int nPoints;
|
|
for (G4int i = 0; i < nEnergy_Prob; i++) {
|
|
theData >> temp >> energy >> tempdep >> nPoints;
|
|
energy *= eV;
|
|
|
|
// consistency check
|
|
if (i == 0)
|
|
// if ( energy != tE_of_repFlag3 ) //110620TK This is too tight for 32bit machines
|
|
if (std::abs(energy - tE_of_repFlag3) / tE_of_repFlag3 > 1.0e-15)
|
|
G4cout << "Warning Transition Energy of repFlag3 is not consistent." << G4endl;
|
|
|
|
theProbArray->InitInterpolation(i, theData);
|
|
theProbArray->SetT(i, temp);
|
|
theProbArray->SetX(i, energy);
|
|
G4double prob, costh;
|
|
for (G4int ii = 0; ii < nPoints; ii++) {
|
|
// fill probability arrays.
|
|
theData >> costh >> prob;
|
|
theProbArray->SetX(i, ii, costh);
|
|
theProbArray->SetY(i, ii, prob);
|
|
}
|
|
theProbArray->DoneSetXY(i);
|
|
}
|
|
}
|
|
else if (repFlag == 0) {
|
|
theData >> frameFlag;
|
|
}
|
|
else {
|
|
G4cout << "unusable number for repFlag: repFlag=" << repFlag << G4endl;
|
|
throw G4HadronicException(__FILE__, __LINE__,
|
|
"G4ParticleHPElasticFS::Init -- unusable number for repFlag");
|
|
}
|
|
// 130205 For compressed data files(theData changed from ifstream to istringstream)
|
|
// theData.close();
|
|
}
|
|
|
|
G4HadFinalState* G4ParticleHPElasticFS::ApplyYourself(const G4HadProjectile& theTrack)
|
|
{
|
|
if (theResult.Get() == nullptr) theResult.Put(new G4HadFinalState);
|
|
theResult.Get()->Clear();
|
|
G4double eKinetic = theTrack.GetKineticEnergy();
|
|
const G4HadProjectile* incidentParticle = &theTrack;
|
|
G4ReactionProduct theNeutron(
|
|
const_cast<G4ParticleDefinition*>(incidentParticle->GetDefinition()));
|
|
theNeutron.SetMomentum(incidentParticle->Get4Momentum().vect());
|
|
theNeutron.SetKineticEnergy(eKinetic);
|
|
|
|
G4ThreeVector neuVelo =
|
|
(1. / incidentParticle->GetDefinition()->GetPDGMass()) * theNeutron.GetMomentum();
|
|
G4ReactionProduct theTarget =
|
|
GetBiasedThermalNucleus(targetMass, neuVelo, theTrack.GetMaterial()->GetTemperature());
|
|
|
|
// Neutron and target defined as G4ReactionProducts
|
|
// Prepare Lorentz transformation to lab
|
|
|
|
G4ThreeVector the3Neutron = theNeutron.GetMomentum();
|
|
G4double nEnergy = theNeutron.GetTotalEnergy();
|
|
G4ThreeVector the3Target = theTarget.GetMomentum();
|
|
G4double tEnergy = theTarget.GetTotalEnergy();
|
|
G4ReactionProduct theCMS;
|
|
G4double totE = nEnergy + tEnergy;
|
|
G4ThreeVector the3CMS = the3Target + the3Neutron;
|
|
theCMS.SetMomentum(the3CMS);
|
|
G4double cmsMom = std::sqrt(the3CMS * the3CMS);
|
|
G4double sqrts = std::sqrt((totE - cmsMom) * (totE + cmsMom));
|
|
theCMS.SetMass(sqrts);
|
|
theCMS.SetTotalEnergy(totE);
|
|
|
|
// Data come as function of n-energy in nuclear rest frame
|
|
G4ReactionProduct boosted;
|
|
boosted.Lorentz(theNeutron, theTarget);
|
|
eKinetic = boosted.GetKineticEnergy(); // get kinetic energy for scattering
|
|
G4double cosTh = -2;
|
|
|
|
if (repFlag == 1) {
|
|
cosTh = theCoefficients->SampleElastic(eKinetic);
|
|
}
|
|
else if (repFlag == 2) {
|
|
cosTh = theProbArray->Sample(eKinetic);
|
|
}
|
|
else if (repFlag == 3) {
|
|
if (eKinetic <= tE_of_repFlag3) {
|
|
cosTh = theCoefficients->SampleElastic(eKinetic);
|
|
}
|
|
else {
|
|
cosTh = theProbArray->Sample(eKinetic);
|
|
}
|
|
}
|
|
else if (repFlag == 0) {
|
|
cosTh = 2. * G4UniformRand() - 1.;
|
|
}
|
|
else {
|
|
G4cout << "Unusable number for repFlag: repFlag=" << repFlag << G4endl;
|
|
throw G4HadronicException(__FILE__, __LINE__,
|
|
"G4ParticleHPElasticFS::Init -- unusable number for repFlag");
|
|
}
|
|
|
|
if (cosTh < -1.1) {
|
|
return nullptr;
|
|
}
|
|
|
|
G4double phi = twopi * G4UniformRand();
|
|
G4double cosPhi = std::cos(phi);
|
|
G4double sinPhi = std::sin(phi);
|
|
G4double theta = std::acos(cosTh);
|
|
G4double sinth = std::sin(theta);
|
|
|
|
if (frameFlag == 1) {
|
|
// Projectile scattering values cosTh are in target rest frame
|
|
// In this frame, do relativistic calculation of scattered projectile and
|
|
// target 4-momenta
|
|
|
|
theNeutron.Lorentz(theNeutron, theTarget);
|
|
G4double mN = theNeutron.GetMass();
|
|
G4double Pinit = theNeutron.GetTotalMomentum(); // Incident momentum
|
|
G4double Einit = theNeutron.GetTotalEnergy(); // Incident energy
|
|
G4double mT = theTarget.GetMass();
|
|
|
|
G4double ratio = mT / mN;
|
|
G4double sqt = std::sqrt(ratio * ratio - 1.0 + cosTh * cosTh);
|
|
G4double beta = Pinit / (mT + Einit); // CMS beta
|
|
G4double denom = 1. - beta * beta * cosTh * cosTh;
|
|
G4double term1 = cosTh * (Einit * ratio + mN) / (mN * ratio + Einit);
|
|
G4double pN = beta * mN * (term1 + sqt) / denom;
|
|
|
|
// Get the scattered momentum and rotate it in theta and phi
|
|
G4ThreeVector pDir = theNeutron.GetMomentum() / Pinit;
|
|
G4double px = pN * pDir.x();
|
|
G4double py = pN * pDir.y();
|
|
G4double pz = pN * pDir.z();
|
|
|
|
G4ThreeVector pcmRot;
|
|
pcmRot.setX(px * cosTh * cosPhi - py * sinPhi + pz * sinth * cosPhi);
|
|
pcmRot.setY(px * cosTh * sinPhi + py * cosPhi + pz * sinth * sinPhi);
|
|
pcmRot.setZ(-px * sinth + pz * cosTh);
|
|
theNeutron.SetMomentum(pcmRot);
|
|
G4double eN = std::sqrt(pN * pN + mN * mN); // Scattered neutron energy
|
|
theNeutron.SetTotalEnergy(eN);
|
|
|
|
// Get the scattered target momentum
|
|
G4ReactionProduct toLab(-1. * theTarget);
|
|
theTarget.SetMomentum(pDir * Pinit - pcmRot);
|
|
G4double eT = Einit - eN + mT;
|
|
theTarget.SetTotalEnergy(eT);
|
|
|
|
// Now back to lab frame
|
|
theNeutron.Lorentz(theNeutron, toLab);
|
|
theTarget.Lorentz(theTarget, toLab);
|
|
|
|
// 111005 Protection for not producing 0 kinetic energy target
|
|
if (theNeutron.GetKineticEnergy() <= 0)
|
|
theNeutron.SetTotalEnergy(theNeutron.GetMass()
|
|
* (1. + G4Pow::GetInstance()->powA(10, -15.65)));
|
|
if (theTarget.GetKineticEnergy() <= 0)
|
|
theTarget.SetTotalEnergy(theTarget.GetMass() * (1. + G4Pow::GetInstance()->powA(10, -15.65)));
|
|
}
|
|
else if (frameFlag == 2) {
|
|
// Projectile scattering values cosTh taken from center of mass tabulation
|
|
|
|
G4LorentzVector proj(nEnergy, the3Neutron);
|
|
G4LorentzVector targ(tEnergy, the3Target);
|
|
G4ThreeVector boostToCM = proj.findBoostToCM(targ);
|
|
proj.boost(boostToCM);
|
|
targ.boost(boostToCM);
|
|
|
|
// Rotate projectile and target momenta by CM scattering angle
|
|
// Note: at this point collision axis is not along z axis, due to
|
|
// momentum given target nucleus by thermal process
|
|
G4double px = proj.px();
|
|
G4double py = proj.py();
|
|
G4double pz = proj.pz();
|
|
|
|
G4ThreeVector pcmRot;
|
|
pcmRot.setX(px * cosTh * cosPhi - py * sinPhi + pz * sinth * cosPhi);
|
|
pcmRot.setY(px * cosTh * sinPhi + py * cosPhi + pz * sinth * sinPhi);
|
|
pcmRot.setZ(-px * sinth + pz * cosTh);
|
|
proj.setVect(pcmRot);
|
|
targ.setVect(-pcmRot);
|
|
|
|
// Back to lab frame
|
|
proj.boost(-boostToCM);
|
|
targ.boost(-boostToCM);
|
|
|
|
theNeutron.SetMomentum(proj.vect());
|
|
theNeutron.SetTotalEnergy(proj.e());
|
|
|
|
theTarget.SetMomentum(targ.vect());
|
|
theTarget.SetTotalEnergy(targ.e());
|
|
|
|
// 080904 Add Protection for very low energy (1e-6eV) scattering
|
|
if (theNeutron.GetKineticEnergy() <= 0) {
|
|
theNeutron.SetTotalEnergy(theNeutron.GetMass()
|
|
* (1. + G4Pow::GetInstance()->powA(10, -15.65)));
|
|
}
|
|
|
|
// 080904 Add Protection for very low energy (1e-6eV) scattering
|
|
if (theTarget.GetKineticEnergy() <= 0) {
|
|
theTarget.SetTotalEnergy(theTarget.GetMass() * (1. + G4Pow::GetInstance()->powA(10, -15.65)));
|
|
}
|
|
}
|
|
else {
|
|
G4cout << "Value of frameFlag (1=LAB, 2=CMS): " << frameFlag;
|
|
throw G4HadronicException(__FILE__, __LINE__,
|
|
"G4ParticleHPElasticFS::ApplyYourSelf frameflag incorrect");
|
|
}
|
|
|
|
// Everything is now in the lab frame
|
|
// Set energy change and momentum change
|
|
theResult.Get()->SetEnergyChange(theNeutron.GetKineticEnergy());
|
|
theResult.Get()->SetMomentumChange(theNeutron.GetMomentum().unit());
|
|
|
|
// Make recoil a G4DynamicParticle
|
|
auto theRecoil = new G4DynamicParticle;
|
|
theRecoil->SetDefinition(G4IonTable::GetIonTable()->GetIon(static_cast<G4int>(theBaseZ),
|
|
static_cast<G4int>(theBaseA), 0));
|
|
theRecoil->SetMomentum(theTarget.GetMomentum());
|
|
theResult.Get()->AddSecondary(theRecoil, secID);
|
|
|
|
// Postpone the tracking of the primary neutron
|
|
theResult.Get()->SetStatusChange(suspend);
|
|
return theResult.Get();
|
|
}
|
|
|
|
void G4ParticleHPElasticFS::InitializeScatteringKernelParameters()
|
|
{
|
|
// Initialize DBRC variables
|
|
svtEmax = G4HadronicParameters::Instance()->GetNeutronKineticEnergyThresholdForSVT();
|
|
G4ParticleHPManager* manager = G4ParticleHPManager::GetInstance();
|
|
dbrcUse = manager->GetUseDBRC();
|
|
dbrcEmax = manager->GetMaxEnergyDBRC();
|
|
dbrcEmin = manager->GetMinEnergyDBRC();
|
|
dbrcAmin = manager->GetMinADBRC();
|
|
}
|
|
|
|
G4ReactionProduct G4ParticleHPElasticFS::GetBiasedThermalNucleus(const G4double aMass,
|
|
G4ThreeVector aVelocity,
|
|
const G4double temp)
|
|
{
|
|
// This new method implements the DBRC (Doppler Broadening Rejection Correction) algorithm
|
|
// on top of the SVT (Sampling of the Velocity of the Target nucleus) algorithm.
|
|
// The SVT algorithm was written by Loic Thulliez (CEA-Saclay) on 2021/05/04 in
|
|
// the method G4Nucleus::GetBiasedThermalNucleus; Marek Zmeskal on 2022/11/30
|
|
// implemented the DBRC algorithm on top of the SVT one.
|
|
// While the SVT algorithm is still present also in G4Nucleus::GetBiasedThermalNucleus,
|
|
// the DBRC algorithm on top of the SVT one has been moved in this new method, in
|
|
// order to avoid a cycle dependency between hadronic/util and hadronic/model/particle_hp.
|
|
|
|
InitializeScatteringKernelParameters();
|
|
|
|
// Set threshold for SVT algorithm
|
|
G4double E_threshold = svtEmax;
|
|
if (svtEmax == -1.) {
|
|
// If E_neutron <= 400*kB*T (400 is a common value encounter in MC neutron transport code)
|
|
// then apply the Sampling ot the Velocity of the Target (SVT) method;
|
|
// else consider the target nucleus being without motion
|
|
E_threshold = 400.0 * 8.617333262E-11 * temp;
|
|
}
|
|
|
|
// If DBRC is enabled and the nucleus is heavy enough, then update the energy threshold
|
|
if (dbrcUse && aMass >= dbrcAmin) {
|
|
E_threshold = std::max(svtEmax, dbrcEmax);
|
|
}
|
|
|
|
G4double E_neutron = 0.5 * aVelocity.mag2() * G4Neutron::Neutron()->GetPDGMass(); // E=0.5*m*v2
|
|
|
|
G4bool dbrcIsOn = dbrcUse && E_neutron >= dbrcEmin && aMass >= dbrcAmin && E_neutron <= dbrcEmax;
|
|
|
|
G4Nucleus aNucleus;
|
|
if (E_neutron > E_threshold || !dbrcIsOn) {
|
|
// Apply only the SVT algorithm, not the DBRC one
|
|
return aNucleus.GetBiasedThermalNucleus(targetMass, aVelocity, temp);
|
|
}
|
|
|
|
G4ReactionProduct result;
|
|
result.SetMass(aMass * G4Neutron::Neutron()->GetPDGMass());
|
|
|
|
// Beta = sqrt(m/2kT)
|
|
G4double beta =
|
|
std::sqrt(result.GetMass()
|
|
/ (2. * 8.617333262E-11 * temp)); // kT E-5[eV] mass E-11[MeV] => beta in [m/s]-1
|
|
|
|
// Neutron speed vn
|
|
G4double vN_norm = aVelocity.mag();
|
|
G4double vN_norm2 = vN_norm * vN_norm;
|
|
G4double y = beta * vN_norm;
|
|
|
|
// Normalize neutron velocity
|
|
aVelocity = (1. / vN_norm) * aVelocity;
|
|
|
|
// Variables for sampling of target speed and SVT rejection
|
|
G4double x2;
|
|
G4double randThresholdSVT;
|
|
G4double vT_norm, vT_norm2, mu;
|
|
G4double acceptThresholdSVT;
|
|
G4double vRelativeSpeed;
|
|
G4double cdf0 = 2. / (2. + std::sqrt(CLHEP::pi) * y);
|
|
|
|
// DBRC variables
|
|
G4double xsRelative = -99.;
|
|
G4double randThresholdDBRC = 0.;
|
|
// Calculate max cross-section in interval from v - 4/beta to v + 4/beta for rejection
|
|
G4double eMin =
|
|
0.5 * G4Neutron::Neutron()->GetPDGMass() * (vN_norm - 4. / beta) * (vN_norm - 4. / beta);
|
|
G4double eMax =
|
|
0.5 * G4Neutron::Neutron()->GetPDGMass() * (vN_norm + 4. / beta) * (vN_norm + 4. / beta);
|
|
G4double xsMax = xsForDBRC->GetMaxY(eMin, eMax);
|
|
|
|
do {
|
|
do {
|
|
// Sample the target velocity vT in the laboratory frame
|
|
if (G4UniformRand() < cdf0) {
|
|
// Sample in C45 from https://laws.lanl.gov/vhosts/mcnp.lanl.gov/pdf_files/la-9721.pdf
|
|
x2 = -std::log(G4UniformRand() * G4UniformRand());
|
|
}
|
|
else {
|
|
// Sample in C61 from https://laws.lanl.gov/vhosts/mcnp.lanl.gov/pdf_files/la-9721.pdf
|
|
G4double ampl = std::cos(CLHEP::pi / 2.0 * G4UniformRand());
|
|
x2 = -std::log(G4UniformRand()) - std::log(G4UniformRand()) * ampl * ampl;
|
|
}
|
|
|
|
vT_norm = std::sqrt(x2) / beta;
|
|
vT_norm2 = vT_norm * vT_norm;
|
|
|
|
// Sample cosine between the incident neutron and the target in the laboratory frame
|
|
mu = 2. * G4UniformRand() - 1.;
|
|
|
|
// Define acceptance threshold for SVT
|
|
vRelativeSpeed = std::sqrt(vN_norm2 + vT_norm2 - 2 * vN_norm * vT_norm * mu);
|
|
acceptThresholdSVT = vRelativeSpeed / (vN_norm + vT_norm);
|
|
randThresholdSVT = G4UniformRand();
|
|
} while (randThresholdSVT >= acceptThresholdSVT);
|
|
|
|
// Apply DBRC rejection
|
|
xsRelative = xsForDBRC->GetXsec(0.5 * G4Neutron::Neutron()->GetPDGMass() * vRelativeSpeed
|
|
* vRelativeSpeed);
|
|
randThresholdDBRC = G4UniformRand();
|
|
|
|
} while (randThresholdDBRC >= xsRelative / xsMax);
|
|
|
|
aNucleus.DoKinematicsOfThermalNucleus(mu, vT_norm, aVelocity, result);
|
|
|
|
return result;
|
|
}
|