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

Import Geant4 10.1.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-10 12:08:39 +02:00
parent 286caacf06
commit c9b32a6c0a
5770 changed files with 1050949 additions and 367105 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/hadronic/models/coherent_elastic/src/G4ChargeExchangeProcess.cc
+2 -2
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4ChargeExchangeProcess.cc 66892 2013-01-17 10:57:59Z gunter $
// $Id: G4ChargeExchangeProcess.cc 83427 2014-08-21 15:44:43Z gcosmo $
//
//
// Geant4 Hadron Charge Exchange Process -- source file
@@ -91,7 +91,7 @@ G4ChargeExchangeProcess::G4ChargeExchangeProcess(const G4String& procName)
G4ChargeExchangeProcess::~G4ChargeExchangeProcess()
{
delete factors;
if (factors) delete factors;
}
void G4ChargeExchangeProcess::
source/processes/hadronic/models/coherent_elastic/src/G4DiffuseElastic.cc
+18 -12
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4DiffuseElastic.cc 70682 2013-06-04 07:57:01Z gcosmo $
// $Id: G4DiffuseElastic.cc 84417 2014-10-15 08:22:44Z gcosmo $
//
//
// Physics model class G4DiffuseElastic
@@ -55,6 +55,7 @@
#include "G4Element.hh"
#include "G4ElementTable.hh"
#include "G4NistManager.hh"
#include "G4PhysicsTable.hh"
#include "G4PhysicsLogVector.hh"
#include "G4PhysicsFreeVector.hh"
@@ -67,7 +68,7 @@
G4DiffuseElastic::G4DiffuseElastic()
: G4HadronElastic("DiffuseElastic"), fParticle(0)
{
SetMinEnergy( 0.01*GeV );
SetMinEnergy( 0.01*MeV ); // 0.01*GeV );
SetMaxEnergy( 1.*TeV );
verboseLevel = 0;
lowEnergyRecoilLimit = 100.*keV;
@@ -106,13 +107,18 @@ G4DiffuseElastic::G4DiffuseElastic()
G4DiffuseElastic::~G4DiffuseElastic()
{
if(fEnergyVector) delete fEnergyVector;
if( fAngleTable )
{
fAngleTable->clearAndDestroy();
delete fAngleTable ;
if ( fEnergyVector ) {
delete fEnergyVector;
fEnergyVector = 0;
}
for ( std::vector<G4PhysicsTable*>::iterator it = fAngleBank.begin();
it != fAngleBank.end(); ++it ) {
if ( (*it) ) (*it)->clearAndDestroy();
delete *it;
*it = 0;
}
fAngleTable = 0;
}
//////////////////////////////////////////////////////////////////////////////
@@ -131,7 +137,7 @@ void G4DiffuseElastic::Initialise()
for(jEl = 0 ; jEl < numOfEl; ++jEl) // application element loop
{
fAtomicNumber = (*theElementTable)[jEl]->GetZ(); // atomic number
fAtomicWeight = (*theElementTable)[jEl]->GetN(); // number of nucleons
fAtomicWeight = G4NistManager::Instance()->GetAtomicMassAmu( static_cast< G4int >( fAtomicNumber ) );
fNuclearRadius = CalculateNuclearRad(fAtomicWeight);
if(verboseLevel > 0)
@@ -820,7 +826,7 @@ G4DiffuseElastic::SampleTableThetaCMS(const G4ParticleDefinition* particle,
for(iAngle = 0; iAngle < fAngleBin-1; iAngle++)
{
if( position < (*(*fAngleTable)(iMomentum))(iAngle) ) break;
if( position > (*(*fAngleTable)(iMomentum))(iAngle) ) break;
}
if (iAngle >= fAngleBin-1) iAngle = fAngleBin-2;
@@ -896,10 +902,10 @@ G4DiffuseElastic::SampleTableThetaCMS(const G4ParticleDefinition* particle,
void G4DiffuseElastic::InitialiseOnFly(G4double Z, G4double A)
{
fAtomicNumber = Z; // atomic number
fAtomicWeight = A; // number of nucleons
fAtomicWeight = G4NistManager::Instance()->GetAtomicMassAmu( static_cast< G4int >( Z ) );
fNuclearRadius = CalculateNuclearRad(fAtomicWeight);
if( verboseLevel > 0 )
{
G4cout<<"G4DiffuseElastic::Initialise() the element with Z = "
source/processes/hadronic/models/coherent_elastic/src/G4LEHadronProtonElastic.cc
+303
View File
@@ -0,0 +1,303 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
// G4 Low energy model: n-p scattering
// F.W. Jones, L.G. Greeniaus, H.P. Wellisch
// 11-OCT-2007 F.W. Jones: removed erroneous code for identity
// exchange of particles.
// FWJ 27-AUG-2010: extended to 5 GeV by Tony Kwan TRIUMF
#include "G4LEHadronProtonElastic.hh"
#include "G4PhysicalConstants.hh"
#include "G4SystemOfUnits.hh"
#include "Randomize.hh"
#include "G4ios.hh"
#include "Randomize.hh"
G4LEHadronProtonElastic::G4LEHadronProtonElastic():
G4HadronElastic("G4LEHadronProtonElastic")
{
SetMinEnergy(0.);
SetMaxEnergy(20.*MeV);
}
G4LEHadronProtonElastic::~G4LEHadronProtonElastic()
{
theParticleChange.Clear();
}
G4HadFinalState*
G4LEHadronProtonElastic::ApplyYourself(const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus)
{
theParticleChange.Clear();
const G4HadProjectile* aParticle = &aTrack;
G4double P = aParticle->GetTotalMomentum();
G4double Px = aParticle->Get4Momentum().x();
G4double Py = aParticle->Get4Momentum().y();
G4double Pz = aParticle->Get4Momentum().z();
G4double ek = aParticle->GetKineticEnergy();
G4ThreeVector theInitial = aParticle->Get4Momentum().vect();
if (verboseLevel > 1)
{
G4double E = aParticle->GetTotalEnergy();
G4double E0 = aParticle->GetDefinition()->GetPDGMass();
G4double Q = aParticle->GetDefinition()->GetPDGCharge();
G4int A = targetNucleus.GetA_asInt();
G4int Z = targetNucleus.GetZ_asInt();
G4cout << "G4LEHadronProtonElastic:ApplyYourself: incident particle: "
<< aParticle->GetDefinition()->GetParticleName() << G4endl;
G4cout << "P = " << P/GeV << " GeV/c"
<< ", Px = " << Px/GeV << " GeV/c"
<< ", Py = " << Py/GeV << " GeV/c"
<< ", Pz = " << Pz/GeV << " GeV/c" << G4endl;
G4cout << "E = " << E/GeV << " GeV"
<< ", kinetic energy = " << ek/GeV << " GeV"
<< ", mass = " << E0/GeV << " GeV"
<< ", charge = " << Q << G4endl;
G4cout << "G4LEHadronProtonElastic:ApplyYourself: material:" << G4endl;
G4cout << "A = " << A
<< ", Z = " << Z
<< ", atomic mass "
<< G4Proton::Proton()->GetPDGMass()/GeV << "GeV"
<< G4endl;
//
// GHEISHA ADD operation to get total energy, mass, charge
//
E += proton_mass_c2;
G4double E02 = E*E - P*P;
E0 = std::sqrt(std::abs(E02));
if (E02 < 0)E0 *= -1;
Q += Z;
G4cout << "G4LEHadronProtonElastic:ApplyYourself: total:" << G4endl;
G4cout << "E = " << E/GeV << " GeV"
<< ", mass = " << E0/GeV << " GeV"
<< ", charge = " << Q << G4endl;
}
G4double theta = (0.5)*pi/180.;
// Get the target particle
G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
G4double E1 = aParticle->GetTotalEnergy();
G4double M1 = aParticle->GetDefinition()->GetPDGMass();
G4double E2 = targetParticle->GetTotalEnergy();
G4double M2 = targetParticle->GetDefinition()->GetPDGMass();
G4double totalEnergy = E1 + E2;
G4double pseudoMass = std::sqrt(totalEnergy*totalEnergy - P*P);
// Transform into centre of mass system
G4double px = (M2/pseudoMass)*Px;
G4double py = (M2/pseudoMass)*Py;
G4double pz = (M2/pseudoMass)*Pz;
G4double p = std::sqrt(px*px + py*py + pz*pz);
if (verboseLevel > 1) {
G4cout << " E1, M1 (GeV) " << E1/GeV << " " << M1/GeV << G4endl;
G4cout << " E2, M2 (GeV) " << E2/GeV << " " << M2/GeV << G4endl;
G4cout << " particle 1 momentum in CM " << px/GeV << " " << py/GeV << " "
<< pz/GeV << " " << p/GeV << G4endl;
}
// First scatter w.r.t. Z axis
G4double phi = G4UniformRand()*twopi;
G4double pxnew = p*std::sin(theta)*std::cos(phi);
G4double pynew = p*std::sin(theta)*std::sin(phi);
G4double pznew = p*std::cos(theta);
// Rotate according to the direction of the incident particle
if (px*px + py*py > 0)
{
G4double cost, sint, ph, cosp, sinp;
cost = pz/p;
sint = (std::sqrt(std::fabs((1-cost)*(1+cost)))
+ std::sqrt(px*px+py*py)/p)/2;
py < 0 ? ph = 3*halfpi : ph = halfpi;
if (std::abs(px) > 0.000001*GeV) ph = std::atan2(py,px);
cosp = std::cos(ph);
sinp = std::sin(ph);
px = (cost*cosp*pxnew - sinp*pynew + sint*cosp*pznew);
py = (cost*sinp*pxnew + cosp*pynew + sint*sinp*pznew);
pz = (-sint*pxnew + cost*pznew);
}
else {
px = pxnew;
py = pynew;
pz = pznew;
}
if (verboseLevel > 1) {
G4cout << " AFTER SCATTER..." << G4endl;
G4cout << " particle 1 momentum in CM " << px/GeV
<< " " << py/GeV << " " << pz/GeV << " " << p/GeV
<< G4endl;
}
// Transform to lab system
G4double E1pM2 = E1 + M2;
G4double betaCM = P/E1pM2;
G4double betaCMx = Px/E1pM2;
G4double betaCMy = Py/E1pM2;
G4double betaCMz = Pz/E1pM2;
G4double gammaCM = E1pM2/std::sqrt(E1pM2*E1pM2 - P*P);
if (verboseLevel > 1) {
G4cout << " betaCM " << betaCMx << " " << betaCMy << " "
<< betaCMz << " " << betaCM << G4endl;
G4cout << " gammaCM " << gammaCM << G4endl;
}
// Now following GLOREN...
G4double BETA[5], PA[5], PB[5];
BETA[1] = -betaCMx;
BETA[2] = -betaCMy;
BETA[3] = -betaCMz;
BETA[4] = gammaCM;
//The incident particle...
PA[1] = px;
PA[2] = py;
PA[3] = pz;
PA[4] = std::sqrt(M1*M1 + p*p);
G4double BETPA = BETA[1]*PA[1] + BETA[2]*PA[2] + BETA[3]*PA[3];
G4double BPGAM = (BETPA * BETA[4]/(BETA[4] + 1.) - PA[4]) * BETA[4];
PB[1] = PA[1] + BPGAM * BETA[1];
PB[2] = PA[2] + BPGAM * BETA[2];
PB[3] = PA[3] + BPGAM * BETA[3];
PB[4] = (PA[4] - BETPA) * BETA[4];
G4DynamicParticle* newP = new G4DynamicParticle;
newP->SetDefinition(aParticle->GetDefinition());
newP->SetMomentum(G4ThreeVector(PB[1], PB[2], PB[3]));
//The target particle...
PA[1] = -px;
PA[2] = -py;
PA[3] = -pz;
PA[4] = std::sqrt(M2*M2 + p*p);
BETPA = BETA[1]*PA[1] + BETA[2]*PA[2] + BETA[3]*PA[3];
BPGAM = (BETPA * BETA[4]/(BETA[4] + 1.) - PA[4]) * BETA[4];
PB[1] = PA[1] + BPGAM * BETA[1];
PB[2] = PA[2] + BPGAM * BETA[2];
PB[3] = PA[3] + BPGAM * BETA[3];
PB[4] = (PA[4] - BETPA) * BETA[4];
targetParticle->SetMomentum(G4ThreeVector(PB[1], PB[2], PB[3]));
if (verboseLevel > 1) {
G4cout << " particle 1 momentum in LAB "
<< newP->GetMomentum()*(1./GeV)
<< " " << newP->GetTotalMomentum()/GeV << G4endl;
G4cout << " particle 2 momentum in LAB "
<< targetParticle->GetMomentum()*(1./GeV)
<< " " << targetParticle->GetTotalMomentum()/GeV << G4endl;
G4cout << " TOTAL momentum in LAB "
<< (newP->GetMomentum()+targetParticle->GetMomentum())*(1./GeV)
<< " "
<< (newP->GetMomentum()+targetParticle->GetMomentum()).mag()/GeV
<< G4endl;
}
theParticleChange.SetMomentumChange(newP->GetMomentumDirection());
theParticleChange.SetEnergyChange(newP->GetKineticEnergy());
delete newP;
theParticleChange.AddSecondary(targetParticle);
return &theParticleChange;
}
////////////////////////////////////////////////////////////////////
//
// sample momentum transfer using Lab. momentum
G4double
G4LEHadronProtonElastic::SampleInvariantT(const G4ParticleDefinition* p,
G4double plab, G4int , G4int )
{
G4double hMass = p->GetPDGMass();
G4double pCMS = 0.5*plab;
// pCMS *= 50;
G4double hEcms = std::sqrt(pCMS*pCMS+hMass*hMass);
// G4double gamma = hEcms/hMass;
// gamma *= 15;
G4double beta = pCMS/hEcms; // std::sqrt(1-1./gamma/gamma); //
// beta /= 0.8; // 0.95; // 1.0; // 1.1 // 0.5*pi; // pi; twopi;
G4double cosDipole = RandCosThetaDipPen();
G4double cosTheta = cosDipole + beta;
cosTheta /= 1. + cosDipole*beta;
G4double t = 2.*pCMS*pCMS*(1.-cosTheta);
return t;
}
///////////////////////////////////////////////////////////////
//
// 1 + cos^2(theta) random distribution in the projectile rest frame, Penelope algorithm
G4double G4LEHadronProtonElastic::RandCosThetaDipPen()
{
G4double x, cosTheta, signX, modX, power = 1./3.;
if( G4UniformRand() > 0.25)
{
cosTheta = 2.*G4UniformRand()-1.;
}
else
{
x = 2.*G4UniformRand()-1.;
if ( x < 0. )
{
modX = -x;
signX = -1.;
}
else
{
modX = x;
signX = 1.;
}
cosTheta = signX*std::pow(modX,power);
}
return cosTheta;
}
// end of file
source/processes/hadronic/models/coherent_elastic/src/G4LEnp.cc
+72 -2
View File
@@ -42,7 +42,8 @@
#include "Randomize.hh"
G4LEnp::G4LEnp():G4HadronicInteraction("G4LEnp")
G4LEnp::G4LEnp():
G4HadronElastic("G4LEnp") // G4HadronicInteraction("G4LEnp")
{
// theParticleChange.SetNumberOfSecondaries(1);
@@ -262,7 +263,7 @@ G4LEnp::ApplyYourself(const G4HadProjectile& aTrack, G4Nucleus& targetNucleus)
PB[4] = (PA[4] - BETPA) * BETA[4];
G4DynamicParticle* newP = new G4DynamicParticle;
newP->SetDefinition(const_cast<G4ParticleDefinition *>(aParticle->GetDefinition()));
newP->SetDefinition(aParticle->GetDefinition());
newP->SetMomentum(G4ThreeVector(PB[1], PB[2], PB[3]));
//The target particle...
@@ -304,4 +305,73 @@ G4LEnp::ApplyYourself(const G4HadProjectile& aTrack, G4Nucleus& targetNucleus)
return &theParticleChange;
}
////////////////////////////////////////////////////////////////////
//
// sample momentum transfer using Lab. momentum
G4double G4LEnp::SampleInvariantT(const G4ParticleDefinition* p,
G4double plab, G4int , G4int )
{
G4double nMass = p->GetPDGMass(); // 939.565346*MeV;
G4double ek = std::sqrt(plab*plab+nMass*nMass) - nMass;
// Find energy bin
G4int je1 = 0;
G4int je2 = NENERGY - 1;
ek = ek/GeV;
do
{
G4int midBin = (je1 + je2)/2;
if (ek < elab[midBin])
je2 = midBin;
else
je1 = midBin;
} while (je2 - je1 > 1);
G4double delab = elab[je2] - elab[je1];
// Sample the angle
G4double sample = G4UniformRand();
G4int ke1 = 0;
G4int ke2 = NANGLE - 1;
G4double dsig = sig[je2][0] - sig[je1][0];
G4double rc = dsig/delab;
G4double b = sig[je1][0] - rc*elab[je1];
G4double sigint1 = rc*ek + b;
G4double sigint2 = 0.;
do
{
G4int midBin = (ke1 + ke2)/2;
dsig = sig[je2][midBin] - sig[je1][midBin];
rc = dsig/delab;
b = sig[je1][midBin] - rc*elab[je1];
G4double sigint = rc*ek + b;
if (sample < sigint)
{
ke2 = midBin;
sigint2 = sigint;
}
else
{
ke1 = midBin;
sigint1 = sigint;
}
} while (ke2 - ke1 > 1);
dsig = sigint2 - sigint1;
rc = 1./dsig;
b = ke1 - rc*sigint1;
G4double kint = rc*sample + b;
G4double theta = (0.5 + kint)*pi/180.;
G4double t = 0.5*plab*plab*(1-std::cos(theta));
return t;
}
// end of file
source/processes/hadronic/models/coherent_elastic/src/G4LEpp.cc
+92 -105
View File
@@ -38,45 +38,14 @@
// Initialization of static data arrays:
#include "G4LEppData.hh"
G4LEpp::G4LEpp():G4HadronicInteraction("G4LEpp")
G4LEpp::G4LEpp():G4HadronElastic("G4LEpp")
{
// theParticleChange.SetNumberOfSecondaries(1);
// SetMinEnergy(10.*MeV);
// SetMaxEnergy(1200.*MeV);
SetCoulombEffects(0);
SetMinEnergy(0.);
SetMaxEnergy(5.*GeV);
}
G4LEpp::~G4LEpp()
{
// theParticleChange.Clear();
}
void
G4LEpp::SetCoulombEffects(G4int State)
{
if (State) {
for(G4int i=0; i<NANGLE; i++)
{
sig[i] = SigCoul[i];
}
elab = ElabCoul;
SetMaxEnergy(1.2*GeV);
}
else {
for(G4int i=0; i<NANGLE; i++)
{
sig[i] = Sig[i];
}
elab = Elab;
SetMaxEnergy(5.*GeV);
}
}
{}
G4HadFinalState*
G4LEpp::ApplyYourself(const G4HadProjectile& aTrack, G4Nucleus& targetNucleus)
@@ -88,11 +57,11 @@ G4LEpp::ApplyYourself(const G4HadProjectile& aTrack, G4Nucleus& targetNucleus)
G4double Px = aParticle->Get4Momentum().x();
G4double Py = aParticle->Get4Momentum().y();
G4double Pz = aParticle->Get4Momentum().z();
G4double ek = aParticle->GetKineticEnergy();
G4ThreeVector theInitial = aParticle->Get4Momentum().vect();
G4double E = aParticle->GetTotalEnergy();
G4ThreeVector theInitial = aParticle->Get4Momentum().vect().unit();
if (verboseLevel > 1) {
G4double E = aParticle->GetTotalEnergy();
G4double ek = aParticle->GetKineticEnergy();
G4double E0 = aParticle->GetDefinition()->GetPDGMass();
G4double Q = aParticle->GetDefinition()->GetPDGCharge();
G4int A = targetNucleus.GetA_asInt();
@@ -126,66 +95,12 @@ G4LEpp::ApplyYourself(const G4HadProjectile& aTrack, G4Nucleus& targetNucleus)
<< ", mass = " << E0/GeV << " GeV"
<< ", charge = " << Q << G4endl;
}
// Find energy bin
G4int je1 = 0;
G4int je2 = NENERGY - 1;
ek = ek/GeV;
do {
G4int midBin = (je1 + je2)/2;
if (ek < elab[midBin])
je2 = midBin;
else
je1 = midBin;
} while (je2 - je1 > 1);
G4double delab = elab[je2] - elab[je1];
// Sample the angle
G4float sample = G4UniformRand();
G4int ke1 = 0;
G4int ke2 = NANGLE - 1;
G4double dsig = sig[je2][0] - sig[je1][0];
G4double rc = dsig/delab;
G4double b = sig[je1][0] - rc*elab[je1];
G4double sigint1 = rc*ek + b;
G4double sigint2 = 0.;
if (verboseLevel > 1) G4cout << "sample=" << sample << G4endl
<< ke1 << " " << ke2 << " "
<< sigint1 << " " << sigint2 << G4endl;
do {
G4int midBin = (ke1 + ke2)/2;
dsig = sig[je2][midBin] - sig[je1][midBin];
rc = dsig/delab;
b = sig[je1][midBin] - rc*elab[je1];
G4double sigint = rc*ek + b;
if (sample < sigint) {
ke2 = midBin;
sigint2 = sigint;
}
else {
ke1 = midBin;
sigint1 = sigint;
}
if (verboseLevel > 1)G4cout << ke1 << " " << ke2 << " "
<< sigint1 << " " << sigint2 << G4endl;
} while (ke2 - ke1 > 1);
dsig = sigint2 - sigint1;
rc = 1./dsig;
b = ke1 - rc*sigint1;
G4double kint = rc*sample + b;
G4double theta = (0.5 + kint)*pi/180.;
if (theta < 0.) { theta = 0.; }
if (verboseLevel > 1) {
G4cout << " energy bin " << je1 << " energy=" << elab[je1] << G4endl;
G4cout << " angle bin " << kint << " angle=" << theta/degree << G4endl;
}
G4double t = SampleInvariantT(aParticle->GetDefinition(), P, 0, 0);
G4double cost = 1.0 - 2*t/(P*P);
if(cost > 1.0) { cost = 1.0; }
if(cost <-1.0) { cost =-1.0; }
G4double sint = std::sqrt((1.0 - cost)*(1.0 + cost));
G4double phi = twopi*G4UniformRand();
// Get the target particle
G4DynamicParticle* targetParticle = targetNucleus.ReturnTargetParticle();
@@ -206,21 +121,21 @@ G4LEpp::ApplyYourself(const G4HadProjectile& aTrack, G4Nucleus& targetNucleus)
if (verboseLevel > 1) {
G4cout << " E1, M1 (GeV) " << E1/GeV << " " << M1/GeV << G4endl;
G4cout << " E2, M2 (GeV) " << E2/GeV << " " << M2/GeV << G4endl;
G4cout << " particle 1 momentum in CM " << px/GeV << " " << py/GeV << " "
G4cout << " particle 1 momentum in CM " << px/GeV
<< " " << py/GeV << " "
<< pz/GeV << " " << p/GeV << G4endl;
}
// First scatter w.r.t. Z axis
G4double phi = G4UniformRand()*twopi;
G4double pxnew = p*std::sin(theta)*std::cos(phi);
G4double pynew = p*std::sin(theta)*std::sin(phi);
G4double pznew = p*std::cos(theta);
G4double pxnew = p*sint*std::cos(phi);
G4double pynew = p*sint*std::sin(phi);
G4double pznew = p*cost;
// Rotate according to the direction of the incident particle
if (px*px + py*py > 0) {
G4double cost, sint, ph, cosp, sinp;
G4double ph, cosp, sinp;
cost = pz/p;
sint = (std::sqrt(std::fabs((1-cost)*(1+cost))) + std::sqrt(px*px+py*py)/p)/2;
sint = (std::sqrt((1-cost)*(1+cost)) + std::sqrt(px*px+py*py)/p)/2;
py < 0 ? ph = 3*halfpi : ph = halfpi;
if (std::fabs(px) > 0.000001*GeV) ph = std::atan2(py,px);
cosp = std::cos(ph);
@@ -280,7 +195,7 @@ G4LEpp::ApplyYourself(const G4HadProjectile& aTrack, G4Nucleus& targetNucleus)
PB[4] = (PA[4] - BETPA) * BETA[4];
G4DynamicParticle* newP = new G4DynamicParticle;
newP->SetDefinition(const_cast<G4ParticleDefinition *>(aParticle->GetDefinition()) );
newP->SetDefinition(aParticle->GetDefinition());
newP->SetMomentum(G4ThreeVector(PB[1], PB[2], PB[3]));
//The target particle...
@@ -323,4 +238,76 @@ G4LEpp::ApplyYourself(const G4HadProjectile& aTrack, G4Nucleus& targetNucleus)
return &theParticleChange;
}
// end of file
////////////////////////////////////////////////////////////////////
//
// sample momentum transfer using Lab. momentum
G4double G4LEpp::SampleInvariantT(const G4ParticleDefinition* p,
G4double plab, G4int , G4int )
{
G4double nMass = p->GetPDGMass(); // 939.565346*MeV;
G4double ek = std::sqrt(plab*plab+nMass*nMass) - nMass;
// Find energy bin
G4int je1 = 0;
G4int je2 = NENERGY - 1;
ek /= GeV;
do
{
G4int midBin = (je1 + je2)/2;
if (ek < elab[midBin]) je2 = midBin;
else je1 = midBin;
}
while (je2 - je1 > 1);
G4double delab = elab[je2] - elab[je1];
// Sample the angle
G4double sample = G4UniformRand();
G4int ke1 = 0;
G4int ke2 = NANGLE - 1;
G4double dsig, b, rc;
dsig = Sig[je2][0] - Sig[je1][0];
rc = dsig/delab;
b = Sig[je1][0] - rc*elab[je1];
G4double sigint1 = rc*ek + b;
G4double sigint2 = 0.;
do
{
G4int midBin = (ke1 + ke2)/2;
dsig = Sig[je2][midBin] - Sig[je1][midBin];
rc = dsig/delab;
b = Sig[je1][midBin] - rc*elab[je1];
G4double sigint = rc*ek + b;
if (sample < sigint)
{
ke2 = midBin;
sigint2 = sigint;
}
else
{
ke1 = midBin;
sigint1 = sigint;
}
}
while (ke2 - ke1 > 1);
dsig = sigint2 - sigint1;
rc = 1./dsig;
b = ke1 - rc*sigint1;
G4double kint = rc*sample + b;
G4double theta = (0.5 + kint)*pi/180.;
G4double t = 0.5*plab*plab*(1 - std::cos(theta));
return t;
}
// end of file
source/processes/hadronic/models/coherent_elastic/src/G4LMsdGenerator.cc
+536
View File
@@ -0,0 +1,536 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id$
//
// G4LMsdGenerator
//
//
#include "G4DynamicParticle.hh"
#include "G4LMsdGenerator.hh"
#include "G4ReactionProductVector.hh"
#include "G4ReactionProduct.hh"
#include "G4IonTable.hh"
#include "G4NucleiProperties.hh"
#include "G4ParticleDefinition.hh"
#include "G4HadFinalState.hh"
#include "G4KineticTrack.hh"
#include "G4DecayKineticTracks.hh"
#include "G4KineticTrackVector.hh"
#include "G4Log.hh"
G4LMsdGenerator::G4LMsdGenerator(const G4String& name)
: G4HadronicInteraction(name)
{
fPDGencoding = 0;
// theParticleChange = new G4HadFinalState;
}
G4LMsdGenerator::~G4LMsdGenerator()
{
// delete theParticleChange;
}
void G4LMsdGenerator::ModelDescription(std::ostream& outFile) const
{
outFile << GetModelName() <<" consists of a "
<< " string model and a stage to de-excite the excited nuclear fragment."
<< "\n<p>"
<< "The string model simulates the interaction of\n"
<< "an incident hadron with a nucleus, forming \n"
<< "excited strings, decays these strings into hadrons,\n"
<< "and leaves an excited nucleus. \n"
<< "<p>The string model:\n";
}
/////////////////////////////////////////////////////////////////
//
// Particle and kinematical limitation od diffraction dissociation
G4bool
G4LMsdGenerator::IsApplicable( const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus )
{
G4bool applied = false;
if( ( aTrack.GetDefinition() == G4Proton::Proton() ||
aTrack.GetDefinition() == G4Neutron::Neutron() ) &&
targetNucleus.GetA_asInt() >= 1 &&
aTrack.GetKineticEnergy() > 1800*CLHEP::MeV ) // 750*CLHEP::MeV )
{
applied = true;
}
else if( ( aTrack.GetDefinition() == G4PionPlus::PionPlus() ||
aTrack.GetDefinition() == G4PionMinus::PionMinus() ) &&
targetNucleus.GetA_asInt() >= 1 &&
aTrack.GetKineticEnergy() > 2340*CLHEP::MeV )
{
applied = true;
}
else if( ( aTrack.GetDefinition() == G4KaonPlus::KaonPlus() ||
aTrack.GetDefinition() == G4KaonMinus::KaonMinus() ) &&
targetNucleus.GetA_asInt() >= 1 &&
aTrack.GetKineticEnergy() > 1980*CLHEP::MeV )
{
applied = true;
}
return applied;
}
/////////////////////////////////////////////////////////////////
//
// Return dissociated particle products and recoil nucleus
G4HadFinalState*
G4LMsdGenerator::ApplyYourself( const G4HadProjectile& aTrack,
G4Nucleus& targetNucleus )
{
theParticleChange.Clear();
const G4HadProjectile* aParticle = &aTrack;
G4double eTkin = aParticle->GetKineticEnergy();
if( eTkin <= 1.*CLHEP::GeV )
{
theParticleChange.SetEnergyChange(eTkin);
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
G4int A = targetNucleus.GetA_asInt();
G4int Z = targetNucleus.GetZ_asInt();
G4double plab = aParticle->GetTotalMomentum();
G4double plab2 = plab*plab;
const G4ParticleDefinition* theParticle = aParticle->GetDefinition();
G4double partMass = theParticle->GetPDGMass();
G4double oldE = partMass + eTkin;
G4double targMass = G4NucleiProperties::GetNuclearMass(A, Z);
G4double targMass2 = targMass*targMass;
G4LorentzVector partLV = aParticle->Get4Momentum();
G4double sumE = oldE + targMass;
G4double sumE2 = sumE*sumE;
G4ThreeVector p1 = partLV.vect();
// G4cout<<"p1 = "<<p1<<G4endl;
G4ParticleMomentum p1unit = p1.unit();
G4double Mx = SampleMx(aParticle); // in GeV
G4double t = SampleT( Mx);
Mx *= CLHEP::GeV;
G4double Mx2 = Mx*Mx;
// equation for q|| based on sum-E-P and new invariant mass
G4double B = sumE2 + targMass2 - Mx2 - plab2;
G4double a = 4*(plab2 - sumE2);
G4double b = 4*plab*B;
G4double c = B*B - 4*sumE2*targMass2;
G4double det2 = b*b - 4*a*c;
G4double qLong, det, eRetard; // , x2, x3, e2;
if( det2 >= 0.)
{
det = std::sqrt(det2);
qLong = (-b - det)/2./a;
eRetard = std::sqrt((plab-qLong)*(plab-qLong)+Mx2);
}
else
{
theParticleChange.SetEnergyChange(eTkin);
theParticleChange.SetMomentumChange(aTrack.Get4Momentum().vect().unit());
return &theParticleChange;
}
theParticleChange.SetStatusChange(stopAndKill);
plab -= qLong;
G4ThreeVector pRetard = plab*p1unit;
G4ThreeVector pTarg = p1 - pRetard;
G4double eTarg = std::sqrt( targMass2 + pTarg.mag2()); // std::sqrt( targMass*targMass + pTarg.mag2() );
G4LorentzVector lvRetard(pRetard, eRetard);
G4LorentzVector lvTarg(pTarg, eTarg);
lvTarg += lvRetard; // sum LV
G4ThreeVector bst = lvTarg.boostVector();
lvRetard.boost(-bst); // to CNS
G4ThreeVector pCMS = lvRetard.vect();
G4double momentumCMS = pCMS.mag();
G4double tMax = 4.0*momentumCMS*momentumCMS;
if( t > tMax ) t = tMax*G4UniformRand();
G4double cost = 1. - 2.0*t/tMax;
G4double phi = G4UniformRand()*CLHEP::twopi;
G4double sint;
if( cost > 1.0 || cost < -1.0 ) //
{
cost = 1.0;
sint = 0.0;
}
else // normal situation
{
sint = std::sqrt( (1.0-cost)*(1.0+cost) );
}
G4ThreeVector v1( sint*std::cos(phi), sint*std::sin(phi), cost);
v1 *= momentumCMS;
G4LorentzVector lvRes( v1.x(),v1.y(),v1.z(), std::sqrt( momentumCMS*momentumCMS + Mx2));
lvRes.boost(bst); // to LS
lvTarg -= lvRes;
G4double eRecoil = lvTarg.e() - targMass;
if( eRecoil > 100.*CLHEP::MeV ) // add recoil nucleus
{
G4ParticleDefinition * recoilDef = 0;
if ( Z == 1 && A == 1 ) { recoilDef = G4Proton::Proton(); }
else if ( Z == 1 && A == 2 ) { recoilDef = G4Deuteron::Deuteron(); }
else if ( Z == 1 && A == 3 ) { recoilDef = G4Triton::Triton(); }
else if ( Z == 2 && A == 3 ) { recoilDef = G4He3::He3(); }
else if ( Z == 2 && A == 4 ) { recoilDef = G4Alpha::Alpha(); }
else
{
recoilDef =
G4ParticleTable::GetParticleTable()->GetIonTable()->GetIon( Z, A, 0.0 );
}
G4DynamicParticle * aSec = new G4DynamicParticle( recoilDef, lvTarg);
theParticleChange.AddSecondary(aSec);
}
else if( eRecoil > 0.0 )
{
theParticleChange.SetLocalEnergyDeposit( eRecoil );
}
G4ParticleDefinition* ddPart = G4ParticleTable::GetParticleTable()->
FindParticle(fPDGencoding);
// G4cout<<fPDGencoding<<", "<<ddPart->GetParticleName()<<", "<<ddPart->GetPDGMass()<<" MeV; lvRes = "<<lvRes<<G4endl;
G4KineticTrack ddkt( ddPart, 0., G4ThreeVector(0.,0.,0.), lvRes);
G4KineticTrackVector* ddktv = ddkt.Decay();
for( unsigned int i = 0; i < ddktv->size(); i++ ) // add products to partchange
{
G4DynamicParticle * aNew =
new G4DynamicParticle( ddktv->operator[](i)->GetDefinition(),
ddktv->operator[](i)->Get4Momentum());
// G4cout<<" "<<i<<", "<<aNew->GetDefinition()->GetParticleName()<<", "<<aNew->Get4Momentum()<<G4endl;
theParticleChange.AddSecondary(aNew);
delete ddktv->operator[](i);
}
delete ddktv;
return &theParticleChange;
}
//////////////////////////////////////
//
// Sample Mx as Roper resonances, set PDG encoding
G4double G4LMsdGenerator::SampleMx(const G4HadProjectile* aParticle)
{
G4double Mx=0.;
G4int i;
G4double rand = G4UniformRand();
for( i = 0; i < 60; i++)
{
if( rand >= fProbMx[i][1] ) break;
}
if(i <= 0) Mx = fProbMx[0][0];
else if(i >= 59) Mx = fProbMx[59][0];
else Mx = fProbMx[i][0];
if ( Mx <= 1.45 )
{
if( aParticle->GetDefinition() == G4Proton::Proton() )
{
Mx = 1.44;
fPDGencoding = 12212;
}
else if( aParticle->GetDefinition() == G4Neutron::Neutron() )
{
Mx = 1.44;
fPDGencoding = 12112;
}
else if( aParticle->GetDefinition() == G4PionPlus::PionPlus() )
{
Mx = 1.3;
fPDGencoding = 100211;
}
else if( aParticle->GetDefinition() == G4PionMinus::PionMinus() )
{
Mx = 1.3;
fPDGencoding = -100211;
}
else if( aParticle->GetDefinition() == G4KaonPlus::KaonPlus() )
{
Mx = 1.27;
fPDGencoding = 10323;
}
else if( aParticle->GetDefinition() == G4KaonMinus::KaonMinus() )
{
Mx = 1.27;
fPDGencoding = -10323;
}
}
else if ( Mx <= 1.55 )
{
if( aParticle->GetDefinition() == G4Proton::Proton() )
{
Mx = 1.52;
fPDGencoding = 2124;
}
else if( aParticle->GetDefinition() == G4Neutron::Neutron() )
{
Mx = 1.52;
fPDGencoding = 1214;
}
else if( aParticle->GetDefinition() == G4PionPlus::PionPlus() )
{
Mx = 1.45;
fPDGencoding = 10211;
}
else if( aParticle->GetDefinition() == G4PionMinus::PionMinus() )
{
Mx = 1.45;
fPDGencoding = -10211;
}
else if( aParticle->GetDefinition() == G4KaonPlus::KaonPlus() )
{
Mx = 1.46;
fPDGencoding = 100321;
}
else if( aParticle->GetDefinition() == G4KaonMinus::KaonMinus() )
{
Mx = 1.46;
fPDGencoding = -100321;
}
}
else
{
if( aParticle->GetDefinition() == G4Proton::Proton() )
{
Mx = 1.68;
fPDGencoding = 12216;
}
else if( aParticle->GetDefinition() == G4Neutron::Neutron() )
{
Mx = 1.68;
fPDGencoding = 12116;
}
else if( aParticle->GetDefinition() == G4PionPlus::PionPlus() )
{
// Mx = 1.67;
// fPDGencoding = 10215;
Mx = 1.45;
fPDGencoding = 10211;
}
else if( aParticle->GetDefinition() == G4PionMinus::PionMinus() )
{
// Mx = 1.67; // f0 problems->4pi vmg 20.11.14
// fPDGencoding = -10215;
Mx = 1.45;
fPDGencoding = -10211;
}
else if( aParticle->GetDefinition() == G4KaonPlus::KaonPlus() )
{
Mx = 1.68;
fPDGencoding = 30323;
}
else if( aParticle->GetDefinition() == G4KaonMinus::KaonMinus() )
{
Mx = 1.68;
fPDGencoding = -30323;
}
}
if(fPDGencoding == 0)
{
Mx = 1.44;
fPDGencoding = 12212;
}
return Mx;
}
//////////////////////////////////////
//
// Sample t with kinematic limitations of Mx and Tkin
G4double G4LMsdGenerator::SampleT( // const G4HadProjectile* aParticle,
G4double Mx)
{
G4double t=0., b=0.;
G4int i;
for( i = 0; i < 23; ++i)
{
if( Mx <= fMxBdata[i][0] ) break;
}
if( i <= 0 ) b = fMxBdata[0][1];
else if( i >= 22 ) b = fMxBdata[22][1];
else b = fMxBdata[i][1];
G4double rand = G4UniformRand();
t = -G4Log(rand)/b;
t *= (CLHEP::GeV*CLHEP::GeV); // in G4 internal units
return t;
}
////////////////////////////////////////////////
//
// Integral spectrum of Mx (GeV)
const G4double G4LMsdGenerator::fProbMx[60][2] =
{
{1.000000e+00, 1.000000e+00},
{1.025000e+00, 1.000000e+00},
{1.050000e+00, 1.000000e+00},
{1.075000e+00, 1.000000e+00},
{1.100000e+00, 9.975067e-01},
{1.125000e+00, 9.934020e-01},
{1.150000e+00, 9.878333e-01},
{1.175000e+00, 9.805002e-01},
{1.200000e+00, 9.716846e-01},
{1.225000e+00, 9.604761e-01},
{1.250000e+00, 9.452960e-01},
{1.275000e+00, 9.265278e-01},
{1.300000e+00, 9.053632e-01},
{1.325000e+00, 8.775566e-01},
{1.350000e+00, 8.441969e-01},
{1.375000e+00, 8.076336e-01},
{1.400000e+00, 7.682520e-01},
{1.425000e+00, 7.238306e-01},
{1.450000e+00, 6.769306e-01},
{1.475000e+00, 6.303898e-01},
{1.500000e+00, 5.824632e-01},
{1.525000e+00, 5.340696e-01},
{1.550000e+00, 4.873736e-01},
{1.575000e+00, 4.422901e-01},
{1.600000e+00, 3.988443e-01},
{1.625000e+00, 3.583727e-01},
{1.650000e+00, 3.205405e-01},
{1.675000e+00, 2.856655e-01},
{1.700000e+00, 2.537508e-01},
{1.725000e+00, 2.247863e-01},
{1.750000e+00, 1.985798e-01},
{1.775000e+00, 1.750252e-01},
{1.800000e+00, 1.539777e-01},
{1.825000e+00, 1.352741e-01},
{1.850000e+00, 1.187157e-01},
{1.875000e+00, 1.040918e-01},
{1.900000e+00, 9.118422e-02},
{1.925000e+00, 7.980909e-02},
{1.950000e+00, 6.979378e-02},
{1.975000e+00, 6.097771e-02},
{2.000000e+00, 5.322122e-02},
{2.025000e+00, 4.639628e-02},
{2.050000e+00, 4.039012e-02},
{2.075000e+00, 3.510275e-02},
{2.100000e+00, 3.044533e-02},
{2.125000e+00, 2.633929e-02},
{2.150000e+00, 2.271542e-02},
{2.175000e+00, 1.951295e-02},
{2.200000e+00, 1.667873e-02},
{2.225000e+00, 1.416633e-02},
{2.250000e+00, 1.193533e-02},
{2.275000e+00, 9.950570e-03},
{2.300000e+00, 8.181515e-03},
{2.325000e+00, 6.601664e-03},
{2.350000e+00, 5.188025e-03},
{2.375000e+00, 3.920655e-03},
{2.400000e+00, 2.782246e-03},
{2.425000e+00, 1.757765e-03},
{2.450000e+00, 8.341435e-04},
{2.475000e+00, 0.000000e+00}
};
//////////////////////////////////////////////
//
// Slope b (1/GeV/GeV) vs Mx (GeV) for t-sampling over exp(-b*t)
const G4double G4LMsdGenerator::fMxBdata[23][2] =
{
{1.09014, 17.8620},
{1.12590, 19.2831},
{1.18549, 17.6907},
{1.21693, 16.4760},
{1.25194, 15.3867},
{1.26932, 14.4236},
{1.29019, 13.2931},
{1.30755, 12.2882},
{1.31790, 11.4509},
{1.33888, 10.6969},
{1.34911, 9.44130},
{1.37711, 8.56148},
{1.39101, 7.76593},
{1.42608, 6.88582},
{1.48593, 6.13019},
{1.53179, 5.87723},
{1.58111, 5.37308},
{1.64105, 4.95217},
{1.69037, 4.44803},
{1.81742, 3.89879},
{1.88096, 3.68693},
{1.95509, 3.43278},
{2.02219, 3.30445}
};
//
//
/////////////////////////////////////////////
source/processes/hadronic/models/coherent_elastic/src/G4NuclNuclDiffuseElastic.cc
+18 -11
View File
@@ -23,7 +23,7 @@
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4NuclNuclDiffuseElastic.cc 71874 2013-06-27 13:39:59Z gunter $
// $Id: G4NuclNuclDiffuseElastic.cc 83427 2014-08-21 15:44:43Z gcosmo $
//
//
// Physics model class G4NuclNuclDiffuseElastic
@@ -55,6 +55,7 @@
#include "G4Element.hh"
#include "G4ElementTable.hh"
#include "G4NistManager.hh"
#include "G4PhysicsTable.hh"
#include "G4PhysicsLogVector.hh"
#include "G4PhysicsFreeVector.hh"
@@ -112,12 +113,13 @@ G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic()
fCofDelta = 0.04;
fCofAlpha = 0.095;
fNuclearRadius1 = fNuclearRadius2 = fNuclearRadiusSquare = fNuclearRadiusCof
fNuclearRadius1 = fNuclearRadius2 = fNuclearRadiusSquare
= fRutherfordRatio = fCoulombPhase0 = fHalfRutThetaTg = fHalfRutThetaTg2
= fRutherfordTheta = fProfileLambda = fCofPhase = fCofFar = fCofAlphaMax
= fCofAlphaCoulomb = fSumSigma = fEtaRatio = fReZ = 0.0;
fMaxL = 0;
fNuclearRadiusCof = 1.0;
}
//////////////////////////////////////////////////////////////////////////////
@@ -126,13 +128,18 @@ G4NuclNuclDiffuseElastic::G4NuclNuclDiffuseElastic()
G4NuclNuclDiffuseElastic::~G4NuclNuclDiffuseElastic()
{
if(fEnergyVector) delete fEnergyVector;
if( fAngleTable )
{
fAngleTable->clearAndDestroy();
delete fAngleTable ;
if ( fEnergyVector ) {
delete fEnergyVector;
fEnergyVector = 0;
}
for ( std::vector<G4PhysicsTable*>::iterator it = fAngleBank.begin();
it != fAngleBank.end(); ++it ) {
if ( (*it) ) (*it)->clearAndDestroy();
delete *it;
*it = 0;
}
fAngleTable = 0;
}
//////////////////////////////////////////////////////////////////////////////
@@ -155,7 +162,7 @@ void G4NuclNuclDiffuseElastic::Initialise()
for(jEl = 0 ; jEl < numOfEl; ++jEl) // application element loop
{
fAtomicNumber = (*theElementTable)[jEl]->GetZ(); // atomic number
fAtomicWeight = (*theElementTable)[jEl]->GetN(); // number of nucleons
fAtomicWeight = G4NistManager::Instance()->GetAtomicMassAmu( static_cast< G4int >( fAtomicNumber ) );
fNuclearRadius = CalculateNuclearRad(fAtomicWeight);
fNuclearRadius += R1;
@@ -929,7 +936,7 @@ G4NuclNuclDiffuseElastic::SampleTableThetaCMS(const G4ParticleDefinition* partic
void G4NuclNuclDiffuseElastic::InitialiseOnFly(G4double Z, G4double A)
{
fAtomicNumber = Z; // atomic number
fAtomicWeight = A; // number of nucleons
fAtomicWeight = G4NistManager::Instance()->GetAtomicMassAmu( static_cast< G4int >( Z ) );
G4double A1 = G4double( fParticle->GetBaryonNumber() );
G4double R1 = CalculateNuclearRad(A1);
@@ -1960,7 +1967,7 @@ G4complex G4NuclNuclDiffuseElastic::GammaLogarithm(G4complex zz)
const G4double cof[6] = { 76.18009172947146, -86.50532032941677,
24.01409824083091, -1.231739572450155,
0.1208650973866179e-2, -0.5395239384953e-5 } ;
register G4int j;
G4int j;
G4complex z = zz - 1.0;
G4complex tmp = z + 5.5;
tmp -= (z + 0.5) * std::log(tmp);
source/processes/hadronic/models/coherent_elastic/src/G4hhElastic.cc
+715
View File
@@ -0,0 +1,715 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: G4hhElastic.cc,v 1.5 2010-11-09 09:04:29 grichine Exp $
// GEANT4 tag $Name: not supported by cvs2svn $
//
//
// Physics model class G4hhElastic
//
//
// G4 Model: qQ hadron hadron elastic scattering with 4-momentum balance
//
// 02.05.2014 V. Grichine 1-st version
//
#include "G4hhElastic.hh"
#include "G4ParticleTable.hh"
#include "G4ParticleDefinition.hh"
#include "G4IonTable.hh"
#include "G4NucleiProperties.hh"
#include "Randomize.hh"
#include "G4Integrator.hh"
#include "globals.hh"
#include "G4PhysicalConstants.hh"
#include "G4SystemOfUnits.hh"
#include "G4Proton.hh"
#include "G4Neutron.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4Element.hh"
#include "G4ElementTable.hh"
#include "G4PhysicsTable.hh"
#include "G4PhysicsLogVector.hh"
#include "G4PhysicsFreeVector.hh"
#include "G4HadronNucleonXsc.hh"
using namespace std;
/////////////////////////////////////////////////////////////////////////
//
// Tracking constructor. Target is proton
G4hhElastic::G4hhElastic()
: G4HadronElastic("HadrHadrElastic")
{
SetMinEnergy( 1.*GeV );
SetMaxEnergy( 10000.*TeV );
verboseLevel = 0;
lowEnergyRecoilLimit = 100.*keV;
lowEnergyLimitQ = 0.0*GeV;
lowEnergyLimitHE = 0.0*GeV;
lowestEnergyLimit= 0.0*keV;
plabLowLimit = 20.0*MeV;
fRhoReIm=fSigmaTot=fOptRatio=fSpp=fPcms=0.0;
fInTkin=0;
theProton = G4Proton::Proton();
theNeutron = G4Neutron::Neutron();
thePionPlus = G4PionPlus::PionPlus();
thePionMinus= G4PionMinus::PionMinus();
fTarget = G4Proton::Proton();
fProjectile = 0;
fHadrNuclXsc = new G4HadronNucleonXsc();
fEnergyBin = 200;
fBinT = 514; // 514; // 500; // 200;
fEnergyVector = new G4PhysicsLogVector( theMinEnergy, theMaxEnergy, fEnergyBin );
fTableT = 0;
fOldTkin = 0.;
SetParameters();
Initialise();
}
/////////////////////////////////////////////////////////////////////////
//
// test constructor
G4hhElastic::G4hhElastic( G4ParticleDefinition* target, G4ParticleDefinition* projectile, G4double plab)
: G4HadronElastic("HadrHadrElastic")
{
SetMinEnergy( 1.*GeV );
SetMaxEnergy( 10000.*TeV );
verboseLevel = 0;
lowEnergyRecoilLimit = 100.*keV;
lowEnergyLimitQ = 0.0*GeV;
lowEnergyLimitHE = 0.0*GeV;
lowestEnergyLimit = 0.0*keV;
plabLowLimit = 20.0*MeV;
fRhoReIm=fSigmaTot=fOptRatio=fSpp=fPcms=0.0;
fInTkin=0;
theProton = G4Proton::Proton();
theNeutron = G4Neutron::Neutron();
thePionPlus = G4PionPlus::PionPlus();
thePionMinus= G4PionMinus::PionMinus();
fTarget = target;
fProjectile = projectile;
fMassTarg = fTarget->GetPDGMass();
fMassProj = fProjectile->GetPDGMass();
fMassSum2 = (fMassTarg+fMassProj)*(fMassTarg+fMassProj);
fMassDif2 = (fMassTarg-fMassProj)*(fMassTarg-fMassProj);
fHadrNuclXsc = new G4HadronNucleonXsc();
fEnergyBin = 200;
fBinT = 514; // 200;
fEnergyVector = new G4PhysicsLogVector( theMinEnergy, theMaxEnergy, fEnergyBin );
fTableT = 0;
fOldTkin = 0.;
SetParameters();
SetParametersCMS( plab);
}
/////////////////////////////////////////////////////////////////////////
//
// constructor used for low mass diffraction
G4hhElastic::G4hhElastic( G4ParticleDefinition* target, G4ParticleDefinition* projectile)
: G4HadronElastic("HadrHadrElastic")
{
SetMinEnergy( 1.*GeV );
SetMaxEnergy( 10000.*TeV );
verboseLevel = 0;
lowEnergyRecoilLimit = 100.*keV;
lowEnergyLimitQ = 0.0*GeV;
lowEnergyLimitHE = 0.0*GeV;
lowestEnergyLimit= 0.0*keV;
plabLowLimit = 20.0*MeV;
fRhoReIm=fSigmaTot=fOptRatio=fSpp=fPcms=0.0;
fInTkin=0;
fTarget = target; // later vmg
fProjectile = projectile;
theProton = G4Proton::Proton();
theNeutron = G4Neutron::Neutron();
thePionPlus = G4PionPlus::PionPlus();
thePionMinus= G4PionMinus::PionMinus();
fTarget = G4Proton::Proton(); // later vmg
fProjectile = 0;
fMassTarg = fTarget->GetPDGMass();
fMassProj = fProjectile->GetPDGMass();
fMassSum2 = (fMassTarg+fMassProj)*(fMassTarg+fMassProj);
fMassDif2 = (fMassTarg-fMassProj)*(fMassTarg-fMassProj);
fHadrNuclXsc = new G4HadronNucleonXsc();
fEnergyBin = 200;
fBinT = 514; // 514; // 500; // 200;
fEnergyVector = new G4PhysicsLogVector( theMinEnergy, theMaxEnergy, fEnergyBin );
fTableT = 0;
fOldTkin = 0.;
SetParameters();
}
//////////////////////////////////////////////////////////////////////////////
//
// Destructor
G4hhElastic::~G4hhElastic()
{
if ( fEnergyVector ) {
delete fEnergyVector;
fEnergyVector = 0;
}
for ( std::vector<G4PhysicsTable*>::iterator it = fBankT.begin();
it != fBankT.end(); ++it ) {
if ( (*it) ) (*it)->clearAndDestroy();
delete *it;
*it = 0;
}
fTableT = 0;
if(fHadrNuclXsc) delete fHadrNuclXsc;
}
/////////////////////////////////////////////////////////////////////////////
///////////////////// Table preparation and reading ////////////////////////
//////////////////////////////////////////////////////////////////////////////
//
// Initialisation for given particle on the proton target
void G4hhElastic::Initialise()
{
// pp,pn
fProjectile = G4Proton::Proton();
BuildTableT(fTarget, fProjectile);
fBankT.push_back(fTableT); // 0
// pi+-p
fProjectile = G4PionPlus::PionPlus();
BuildTableT(fTarget, fProjectile);
fBankT.push_back(fTableT); // 1
//K+-p
fProjectile = G4KaonPlus::KaonPlus();
BuildTableT(fTarget, fProjectile);
fBankT.push_back(fTableT); // 2
}
///////////////////////////////////////////////////////////////////////////////
//
// Build for given particle and proton table of momentum transfers.
void G4hhElastic::BuildTableT( G4ParticleDefinition* target, G4ParticleDefinition* projectile) // , G4double plab)
{
G4int iTkin, jTransfer;
G4double plab, Tkin, tMax;
G4double t1, t2, dt, delta = 0., sum = 0.;
fTarget = target;
fProjectile = projectile;
fMassTarg = fTarget->GetPDGMass();
fMassProj = fProjectile->GetPDGMass();
fMassSum2 = (fMassTarg+fMassProj)*(fMassTarg+fMassProj);
fMassDif2 = (fMassTarg-fMassProj)*(fMassTarg-fMassProj);
G4Integrator<G4hhElastic,G4double(G4hhElastic::*)(G4double)> integral;
// G4HadronNucleonXsc* hnXsc = new G4HadronNucleonXsc();
fTableT = new G4PhysicsTable(fEnergyBin);
for( iTkin = 0; iTkin < fEnergyBin; iTkin++)
{
Tkin = fEnergyVector->GetLowEdgeEnergy(iTkin);
plab = std::sqrt( Tkin*( Tkin + 2*fMassProj ) );
// G4DynamicParticle* theDynamicParticle = new G4DynamicParticle(projectile,
// G4ParticleMomentum(0.,0.,1.),
// Tkin);
// fSigmaTot = fHadrNuclXsc->GetHadronNucleonXscNS( theDynamicParticle, target );
SetParametersCMS( plab );
tMax = 4.*fPcms*fPcms;
if( tMax > 15.*GeV*GeV ) tMax = 15.*GeV*GeV; // Check vs. energy ???
G4PhysicsFreeVector* vectorT = new G4PhysicsFreeVector(fBinT-1);
sum = 0.;
dt = tMax/fBinT;
// for(j = 1; j < fBinT; j++)
for( jTransfer = fBinT-1; jTransfer >= 1; jTransfer--)
{
t1 = dt*(jTransfer-1);
t2 = t1 + dt;
if( fMassProj > 900.*MeV ) // pp, pn
{
delta = integral.Legendre10(this, &G4hhElastic::GetdsdtF123, t1, t2);
// delta = integral.Legendre96(this, &G4hhElastic::GetdsdtF123, t1, t2);
}
else // pi+-p, K+-p
{
delta = integral.Legendre10(this, &G4hhElastic::GetdsdtF123qQgG, t1, t2);
// delta = integral.Legendre96(this, &G4hhElastic::GetdsdtF123qQgG, t1, t2);
}
sum += delta;
vectorT->PutValue( jTransfer-1, t1, sum ); // t2
}
// vectorT->PutValue( fBinT-1, dt*(fBinT-1), 0. ); // t2
fTableT->insertAt( iTkin, vectorT );
// delete theDynamicParticle;
}
// delete hnXsc;
return;
}
////////////////////////////////////////////////////////////////////////////
//
// Return inv momentum transfer -t > 0 from initialisation table
G4double G4hhElastic::SampleInvariantT( const G4ParticleDefinition* aParticle, G4double p,
G4int, G4int )
{
G4int iTkin, iTransfer;
G4double t, t2, position, m1 = aParticle->GetPDGMass();
G4double Tkin = std::sqrt(m1*m1+p*p) - m1;
if( aParticle == G4Proton::Proton() || aParticle == G4Neutron::Neutron() )
{
fTableT = fBankT[0];
}
if( aParticle == G4PionPlus::PionPlus() || aParticle == G4PionMinus::PionMinus() )
{
fTableT = fBankT[1];
}
if( aParticle == G4KaonPlus::KaonPlus() || aParticle == G4KaonMinus::KaonMinus() )
{
fTableT = fBankT[2];
}
G4double delta = std::abs(Tkin - fOldTkin)/(Tkin + fOldTkin);
G4double deltaMax = 1.e-2;
if ( delta < deltaMax ) iTkin = fInTkin;
else
{
for( iTkin = 0; iTkin < fEnergyBin; iTkin++)
{
if( Tkin < fEnergyVector->GetLowEdgeEnergy(iTkin) ) break;
}
}
if ( iTkin >= fEnergyBin ) iTkin = fEnergyBin-1; // Tkin is more then theMaxEnergy
if ( iTkin < 0 ) iTkin = 0; // against negative index, Tkin < theMinEnergy
fOldTkin = Tkin;
fInTkin = iTkin;
if (iTkin == fEnergyBin -1 || iTkin == 0 ) // the table edges
{
position = (*(*fTableT)(iTkin))(0)*G4UniformRand();
// G4cout<<"position = "<<position<<G4endl;
for(iTransfer = 0; iTransfer < fBinT-1; iTransfer++)
{
if( position >= (*(*fTableT)(iTkin))(iTransfer) ) break;
}
if (iTransfer >= fBinT-1) iTransfer = fBinT-2;
// G4cout<<"iTransfer = "<<iTransfer<<G4endl;
t = GetTransfer(iTkin, iTransfer, position);
// G4cout<<"t = "<<t<<G4endl;
}
else // Tkin inside between energy table edges
{
// position = (*(*fTableT)(iTkin))(fBinT-2)*G4UniformRand();
position = (*(*fTableT)(iTkin))(0)*G4UniformRand();
// G4cout<<"position = "<<position<<G4endl;
for(iTransfer = 0; iTransfer < fBinT-1; iTransfer++)
{
// if( position < (*(*fTableT)(iTkin))(iTransfer) ) break;
if( position >= (*(*fTableT)(iTkin))(iTransfer) ) break;
}
if (iTransfer >= fBinT-1) iTransfer = fBinT-2;
// G4cout<<"iTransfer = "<<iTransfer<<G4endl;
t2 = GetTransfer(iTkin, iTransfer, position);
return t2;
/*
G4double t1, E1, E2, W, W1, W2;
// G4cout<<"t2 = "<<t2<<G4endl;
E2 = fEnergyVector->GetLowEdgeEnergy(iTkin);
// G4cout<<"E2 = "<<E2<<G4endl;
iTkin--;
// position = (*(*fTableT)(iTkin))(fBinT-2)*G4UniformRand();
// G4cout<<"position = "<<position<<G4endl;
for(iTransfer = 0; iTransfer < fBinT-1; iTransfer++)
{
// if( position < (*(*fTableT)(iTkin))(iTransfer) ) break;
if( position >= (*(*fTableT)(iTkin))(iTransfer) ) break;
}
if (iTransfer >= fBinT-1) iTransfer = fBinT-2;
t1 = GetTransfer(iTkin, iTransfer, position);
// G4cout<<"t1 = "<<t1<<G4endl;
E1 = fEnergyVector->GetLowEdgeEnergy(iTkin);
// G4cout<<"E1 = "<<E1<<G4endl;
W = 1.0/(E2 - E1);
W1 = (E2 - Tkin)*W;
W2 = (Tkin - E1)*W;
t = W1*t1 + W2*t2;
*/
}
return t;
}
////////////////////////////////////////////////////////////////////////////
//
// Return inv momentum transfer -t > 0 from initialisation table
G4double G4hhElastic::SampleBisectionalT( const G4ParticleDefinition* aParticle, G4double p)
{
G4int iTkin, iTransfer;
G4double t, position, m1 = aParticle->GetPDGMass();
G4double Tkin = std::sqrt(m1*m1+p*p) - m1;
if( aParticle == G4Proton::Proton() || aParticle == G4Neutron::Neutron() )
{
fTableT = fBankT[0];
}
if( aParticle == G4PionPlus::PionPlus() || aParticle == G4PionMinus::PionMinus() )
{
fTableT = fBankT[1];
}
if( aParticle == G4KaonPlus::KaonPlus() || aParticle == G4KaonMinus::KaonMinus() )
{
fTableT = fBankT[2];
}
G4double delta = std::abs(Tkin - fOldTkin)/(Tkin + fOldTkin);
G4double deltaMax = 1.e-2;
if ( delta < deltaMax ) iTkin = fInTkin;
else
{
for( iTkin = 0; iTkin < fEnergyBin; iTkin++ )
{
if( Tkin < fEnergyVector->GetLowEdgeEnergy(iTkin) ) break;
}
}
if ( iTkin >= fEnergyBin ) iTkin = fEnergyBin-1; // Tkin is more then theMaxEnergy
if ( iTkin < 0 ) iTkin = 0; // against negative index, Tkin < theMinEnergy
fOldTkin = Tkin;
fInTkin = iTkin;
if (iTkin == fEnergyBin -1 || iTkin == 0 ) // the table edges
{
position = (*(*fTableT)(iTkin))(0)*G4UniformRand();
for(iTransfer = 0; iTransfer < fBinT-1; iTransfer++)
{
if( position >= (*(*fTableT)(iTkin))(iTransfer) ) break;
}
if (iTransfer >= fBinT-1) iTransfer = fBinT-2;
t = GetTransfer(iTkin, iTransfer, position);
}
else // Tkin inside between energy table edges
{
G4double rand = G4UniformRand();
position = (*(*fTableT)(iTkin))(0)*rand;
//
// (*fTableT)(iTkin)->GetLowEdgeEnergy(fBinT-2);
G4int sTransfer = 0, fTransfer = fBinT - 2, dTransfer = fTransfer - sTransfer;
G4double y2;
for( iTransfer = 0; iTransfer < fBinT - 1; iTransfer++ )
{
// dTransfer %= 2;
dTransfer /= 2;
// dTransfer *= 0.5;
y2 = (*(*fTableT)(iTkin))( sTransfer + dTransfer );
if( y2 > position ) sTransfer += dTransfer;
// if( dTransfer <= 1 ) break;
if( dTransfer < 1 ) break;
}
t = (*fTableT)(iTkin)->GetLowEdgeEnergy(sTransfer); // +(-0.5+rand)*(*fTableT)(iTkin)->GetLowEdgeEnergy(3);
}
return t;
}
///////////////////////////////////////////////////////////////////////////////
//
// Build for given particle and proton table of momentum transfers.
void G4hhElastic::BuildTableTest( G4ParticleDefinition* target, G4ParticleDefinition* projectile, G4double plab)
{
G4int jTransfer;
G4double tMax; // , sQq, sQG;
G4double t1, t2, dt, delta = 0., sum = 0. ; // , threshold;
fTarget = target;
fProjectile = projectile;
fMassTarg = fTarget->GetPDGMass();
fMassProj = fProjectile->GetPDGMass();
fMassSum2 = (fMassTarg+fMassProj)*(fMassTarg+fMassProj);
fMassDif2 = (fMassTarg-fMassProj)*(fMassTarg-fMassProj);
fSpp = fMassProj*fMassProj + fMassTarg*fMassTarg + 2.*fMassTarg*std::sqrt(plab*plab + fMassProj*fMassProj);
fPcms = std::sqrt( (fSpp - fMassSum2)*(fSpp - fMassDif2)/4./fSpp);
G4cout<<"fMassTarg = "<<fMassTarg<<" MeV; fMassProj = "<<fMassProj<<" MeV"<<G4endl;
tMax = 4.*fPcms*fPcms;
if( tMax > 15.*GeV*GeV ) tMax = 15.*GeV*GeV; // Check vs. energy ???
G4Integrator<G4hhElastic,G4double(G4hhElastic::*)(G4double)> integral;
fTableT = new G4PhysicsTable(1);
G4PhysicsFreeVector* vectorT = new G4PhysicsFreeVector(fBinT-1);
sum = 0.;
dt = tMax/G4double(fBinT);
G4cout<<"s = "<<std::sqrt(fSpp)/GeV<<" GeV; fPcms = "<<fPcms/GeV
<<" GeV; qMax = "<<tMax/GeV/GeV<<" GeV2; dt = "<<dt/GeV/GeV<<" GeV2"<<G4endl;
// G4cout<<"fRA = "<<fRA*GeV<<"; fRB = "<<fRB*GeV<<G4endl;
// for(jTransfer = 1; jTransfer < fBinT; jTransfer++)
for( jTransfer = fBinT-1; jTransfer >= 1; jTransfer-- )
{
t1 = dt*(jTransfer-1);
t2 = t1 + dt;
if( fMassProj > 900.*MeV ) // pp, pn
{
delta = integral.Legendre10(this, &G4hhElastic::GetdsdtF123, t1, t2);
// threshold = integral.Legendre96(this, &G4hhElastic::GetdsdtF123, t1, tMax);
}
else // pi+-p, K+-p
{
delta = integral.Legendre10(this, &G4hhElastic::GetdsdtF123qQgG, t1, t2);
// threshold = integral.Legendre96(this, &G4hhElastic::GetdsdtF123qQgG, t1, tMax);
// delta = integral.Legendre96(this, &G4hhElastic::GetdsdtF123, t1, t2);
}
sum += delta;
// G4cout<<delta<<"\t"<<sum<<"\t"<<threshold<<G4endl;
// sQq = GetdsdtF123(q1);
// sQG = GetdsdtF123qQgG(q1);
// G4cout<<q1/GeV<<"\t"<<sQG*GeV*GeV/millibarn<<"\t"<<sQq*GeV*GeV/millibarn<<G4endl;
// G4cout<<"sum = "<<sum<<", ";
vectorT->PutValue( jTransfer-1, t1, sum ); // t2
}
// vectorT->PutValue( fBinT-1, dt*(fBinT-1), 0. ); // t2
fTableT->insertAt( 0, vectorT );
fBankT.push_back( fTableT ); // 0
// for(jTransfer = 0; jTransfer < fBinT-1; jTransfer++)
// G4cout<<(*(*fTableT)(0))(jTransfer)/sum<<"\t\t"<<std::pow(2.,-G4double(jTransfer))<<G4endl;
return;
}
////////////////////////////////////////////////////////////////////////////
//
// Return inv momentum transfer -t > 0 from initialisation table
G4double G4hhElastic::SampleTest(G4double tMin ) // const G4ParticleDefinition* aParticle, )
{
G4int iTkin, iTransfer, iTmin;
G4double t, position;
// G4double qMin = std::sqrt(tMin);
fTableT = fBankT[0];
iTkin = 0;
for(iTransfer = 0; iTransfer < fBinT-1; iTransfer++)
{
// if( qMin <= (*fTableT)(iTkin)->GetLowEdgeEnergy(iTransfer) ) break;
if( tMin <= (*fTableT)(iTkin)->GetLowEdgeEnergy(iTransfer) ) break;
}
iTmin = iTransfer-1;
if(iTmin < 0 ) iTmin = 0;
position = (*(*fTableT)(iTkin))(iTmin)*G4UniformRand();
for( iTmin = 0; iTransfer < fBinT-1; iTransfer++)
{
if( position > (*(*fTableT)(iTkin))(iTransfer) ) break;
}
if (iTransfer >= fBinT-1) iTransfer = fBinT-2;
t = GetTransfer(iTkin, iTransfer, position);
return t;
}
/////////////////////////////////////////////////////////////////////////////////
//
// Check with PAI sampling
G4double
G4hhElastic:: GetTransfer( G4int iTkin, G4int iTransfer, G4double position )
{
G4double x1, x2, y1, y2, randTransfer, delta, mean, epsilon = 1.e-6;
if( iTransfer == 0 )
{
randTransfer = (*fTableT)(iTkin)->GetLowEdgeEnergy(iTransfer);
// iTransfer++;
}
else
{
if ( iTransfer >= G4int((*fTableT)(iTkin)->GetVectorLength()) )
{
iTransfer = (*fTableT)(iTkin)->GetVectorLength() - 1;
}
y1 = (*(*fTableT)(iTkin))(iTransfer-1);
y2 = (*(*fTableT)(iTkin))(iTransfer);
x1 = (*fTableT)(iTkin)->GetLowEdgeEnergy(iTransfer-1);
x2 = (*fTableT)(iTkin)->GetLowEdgeEnergy(iTransfer);
delta = y2 - y1;
mean = y2 + y1;
if ( x1 == x2 ) randTransfer = x2;
else
{
// if ( y1 == y2 )
if ( delta < epsilon*mean )
randTransfer = x1 + ( x2 - x1 )*G4UniformRand();
else randTransfer = x1 + ( position - y1 )*( x2 - x1 )/delta; // ( y2 - y1 );
}
}
return randTransfer;
}
const G4double G4hhElastic::theNuclNuclData[18][6] =
{
// sqrt(fSpp) in GeV, fRA in 1/GeV, fRB in 1/GeV, fBq, fBQ, fImCof
{ 2.76754, 4.8, 4.8, 0.05, 0.742441, 10.5 }, // pp 3GeV/c
{ 3.07744, 5.4, 5.4, 0.02, 0.83818, 6.5 }, // pp 4GeV/c
{ 3.36305, 5.2, 5.2, 0.02, 0.838893, 7.5 }, // np 5GeV/c
{ 4.32941, 6, 6, 0.03, 0.769389, 7.5 }, // np 9 GeV/c
{ 4.62126, 6, 6, 0.03, 0.770111, 6.5 }, // pp 10.4 GeV/c
{ 5.47416, 4.5, 4.5, 0.03, 0.813185, 7.5 }, // np 15 GeV/c
{ 6.15088, 6.5, 6.5, 0.02, 0.799539, 6.5 }, // pp 19.2 GeV/c
{ 6.77474, 5.2, 5.2, 0.03, 0.784901, 7.5 }, // np 23.5 GeV/c
{ 9.77775, 7, 7, 0.03, 0.742531, 6.5 }, // pp 50 GeV/c
// {9.77775, 7, 7, 0.011, 0.84419, 4.5 }, // pp 50 GeV/c
{ 10.4728, 5.2, 5.2, 0.03, 0.780439, 7.5 }, // np 57.5 GeV/c
{ 13.7631, 7, 7, 0.008, 0.8664, 5.0 }, // pp 100 GeV/c
{ 19.4184, 6.8, 6.8, 0.009, 0.861337, 2.5 }, // pp 200 GeV/c
{ 23.5, 6.8, 6.8, 0.007, 0.878112, 1.5 }, // pp 23.5 GeV
// {24.1362, 6.4, 6.4, 0.09, 0.576215, 7.5 }, // np 309.5 GeV/c
{ 24.1362, 7.2, 7.2, 0.008, 0.864745, 5.5 },
{ 52.8, 6.8, 6.8, 0.008, 0.871929, 1.5 }, // pp 58.2 GeV
{ 546, 7.4, 7.4, 0.013, 0.845877, 5.5 }, // pb-p 546 GeV
{ 1960, 7.8, 7.8, 0.022, 0.809062, 7.5 }, // pb-p 1960 GeV
{ 7000, 8, 8, 0.024, 0.820441, 5.5 } // pp TOTEM
};
//////////////////////////////////////////////////////////////////////////////////
const G4double G4hhElastic::thePiKaNuclData[8][6] =
{
// sqrt(fSpp) in GeV, fRA in 1/GeV, fRB in 1/GeV, fBq, fBQ, fImCof
{ 2.5627, 3.8, 3.3, 0.22, 0.222, 1.5 }, // pipp 3.017 GeV/c
{ 2.93928, 4.3, 3.8, 0.2, 0.250601, 1.3 }, // pipp 4.122 GeV/c
{ 3.22326, 4.8, 4.3, 0.13, 0.32751, 2.5 }, // pipp 5.055 GeV/c
{ 7.80704, 5.5, 5, 0.13, 0.340631, 2.5 }, // pipp 32 GeV/c
{ 9.7328, 5, 4.5, 0.05, 0.416319, 5.5 }, // pipp 50 GeV/c
{ 13.7315, 5.3, 4.8, 0.05, 0.418426, 5.5 }, // pipp 100 GeV/c
{ 16.6359, 6.3, 5.8, 0.05, 0.423817, 5.5 }, // pipp 147 GeV/c
{ 19.3961, 5, 4.5, 0.05, 0.413477, 3.5 } // pimp 200 GeV/c
};
//
//
/////////////////////////////////////////////////////////////////////////////////