G4Nucleus Class Reference

#include <G4Nucleus.hh>

Public Member Functions
	G4Nucleus ()
	G4Nucleus (const G4double A, const G4double Z, const G4int numberOfLambdas=0)
	G4Nucleus (const G4int A, const G4int Z, const G4int numberOfLambdas=0)
	G4Nucleus (const G4Material *aMaterial)
	~G4Nucleus ()
	G4Nucleus (const G4Nucleus &right)
G4Nucleus &	operator= (const G4Nucleus &right)
G4bool	operator== (const G4Nucleus &right) const
G4bool	operator!= (const G4Nucleus &right) const
void	ChooseParameters (const G4Material *aMaterial)
void	SetParameters (const G4double A, const G4double Z, const G4int numberOfLambdas=0)
void	SetParameters (const G4int A, const G4int Z, const G4int numberOfLambdas=0)
G4int	GetA_asInt () const
G4int	GetN_asInt () const
G4int	GetZ_asInt () const
G4int	GetL () const
const G4Isotope *	GetIsotope ()
void	SetIsotope (const G4Isotope *iso)
G4DynamicParticle *	ReturnTargetParticle () const
G4double	AtomicMass (const G4double A, const G4double Z, const G4int numberOfLambdas=0) const
G4double	AtomicMass (const G4int A, const G4int Z, const G4int numberOfLambdas=0) const
G4double	GetThermalPz (const G4double mass, const G4double temp) const
G4ReactionProduct	GetThermalNucleus (G4double aMass, G4double temp=-1) const
G4ReactionProduct	GetBiasedThermalNucleus (G4double aMass, G4ThreeVector aVelocity, G4double temp=-1) const
void	DoKinematicsOfThermalNucleus (const G4double mu, const G4double vT_norm, const G4ThreeVector &aVelocity, G4ReactionProduct &result) const
G4double	Cinema (G4double kineticEnergy)
G4double	EvaporationEffects (G4double kineticEnergy)
G4double	AnnihilationEvaporationEffects (G4double kineticEnergy, G4double ekOrg)
G4double	GetPNBlackTrackEnergy () const
G4double	GetDTABlackTrackEnergy () const
G4double	GetAnnihilationPNBlackTrackEnergy () const
G4double	GetAnnihilationDTABlackTrackEnergy () const
G4ThreeVector	GetFermiMomentum ()
G4ReactionProductVector *	Fragmentate ()
void	AddExcitationEnergy (G4double anEnergy)
void	AddMomentum (const G4ThreeVector aMomentum)
G4double	GetEnergyDeposit ()

Detailed Description

Definition at line 51 of file G4Nucleus.hh.

Constructor & Destructor Documentation

G4Nucleus() [1/5]

G4Nucleus::G4Nucleus

(

)

Definition at line 56 of file G4Nucleus.cc.

  : theA(0), theZ(0), theL(0), aEff(0.0), zEff(0)
{
  pnBlackTrackEnergy = 0.0;
  dtaBlackTrackEnergy = 0.0;
  pnBlackTrackEnergyfromAnnihilation = 0.0;
  dtaBlackTrackEnergyfromAnnihilation = 0.0;
  excitationEnergy = 0.0;
  momentum = G4ThreeVector(0.,0.,0.);
  fermiMomentum = 1.52*hbarc/fermi;
  theTemp = 293.16*kelvin;
  fIsotope = 0;
}

G4Nucleus() [2/5]

G4Nucleus::G4Nucleus	(	const G4double	A,
		const G4double	Z,
		const G4int	numberOfLambdas = 0 )

Definition at line 70 of file G4Nucleus.cc.

{
  SetParameters( A, Z, std::max(numberOfLambdas, 0) );
  pnBlackTrackEnergy = 0.0;
  dtaBlackTrackEnergy = 0.0;
  pnBlackTrackEnergyfromAnnihilation = 0.0;
  dtaBlackTrackEnergyfromAnnihilation = 0.0;
  excitationEnergy = 0.0;
  momentum = G4ThreeVector(0.,0.,0.);
  fermiMomentum = 1.52*hbarc/fermi;
  theTemp = 293.16*kelvin;
  fIsotope = 0;
}

G4Nucleus() [3/5]

G4Nucleus::G4Nucleus	(	const G4int	A,
		const G4int	Z,
		const G4int	numberOfLambdas = 0 )

Definition at line 84 of file G4Nucleus.cc.

{
  SetParameters( A, Z, std::max(numberOfLambdas, 0) );
  pnBlackTrackEnergy = 0.0;
  dtaBlackTrackEnergy = 0.0;
  pnBlackTrackEnergyfromAnnihilation = 0.0;
  dtaBlackTrackEnergyfromAnnihilation = 0.0;
  excitationEnergy = 0.0;
  momentum = G4ThreeVector(0.,0.,0.);
  fermiMomentum = 1.52*hbarc/fermi;
  theTemp = 293.16*kelvin;
  fIsotope = 0;
}

G4Nucleus() [4/5]

G4Nucleus::G4Nucleus

(

const G4Material *

aMaterial

)

Definition at line 98 of file G4Nucleus.cc.

{
  ChooseParameters( aMaterial );
  pnBlackTrackEnergy = 0.0;
  dtaBlackTrackEnergy = 0.0;
  pnBlackTrackEnergyfromAnnihilation = 0.0;
  dtaBlackTrackEnergyfromAnnihilation = 0.0;
  excitationEnergy = 0.0;
  momentum = G4ThreeVector(0.,0.,0.);
  fermiMomentum = 1.52*hbarc/fermi;
  theTemp = aMaterial->GetTemperature();
  fIsotope = 0;
}

~G4Nucleus()

G4Nucleus::~G4Nucleus

(

)

Definition at line 112 of file G4Nucleus.cc.

{}

G4Nucleus() [5/5]

G4Nucleus::G4Nucleus ( const G4Nucleus & right )

inline

Definition at line 62 of file G4Nucleus.hh.

    { *this = right; }

Member Function Documentation

AddExcitationEnergy()

void G4Nucleus::AddExcitationEnergy

(

G4double

anEnergy

)

Definition at line 578 of file G4Nucleus.cc.

{
  excitationEnergy+=anEnergy;
}

AddMomentum()

void G4Nucleus::AddMomentum

(

const G4ThreeVector

aMomentum

)

Definition at line 572 of file G4Nucleus.cc.

{
  momentum+=(aMomentum);
}

AnnihilationEvaporationEffects()

G4double G4Nucleus::AnnihilationEvaporationEffects	(	G4double	kineticEnergy,
		G4double	ekOrg )

Definition at line 465 of file G4Nucleus.cc.

{
  // Nuclear evaporation as a function of atomic number and kinetic 
  // energy (MeV) of primary particle.  Modified for annihilation effects. 
  //
  if( aEff < 1.5 || ekOrg < 0.)
  {
    pnBlackTrackEnergyfromAnnihilation = 0.0;
    dtaBlackTrackEnergyfromAnnihilation = 0.0;
    return 0.0;
  }
  G4double ek = kineticEnergy/GeV;
  G4float ekin = std::min( 4.0, std::max( 0.1, ek ) );
  const G4float atno = std::min( 120., aEff ); 
  const G4float gfa = 2.0*((aEff-1.0)/70.)*G4Exp(-(aEff-1.0)/70.);
 
  G4float cfa = std::max( 0.15, 0.35 + ((0.35-0.05)/2.3)*G4Log(ekin) );
  G4float exnu = 7.716 * cfa * G4Exp(-cfa)
    * ((atno-1.0)/120.)*G4Exp(-(atno-1.0)/120.);
  G4float fpdiv = std::max( 0.5, 1.0-0.25*ekin*ekin );
 
  pnBlackTrackEnergyfromAnnihilation = exnu*fpdiv;
  dtaBlackTrackEnergyfromAnnihilation = exnu*(1.0-fpdiv);
  
  G4double ran1 = -6.0;
  G4double ran2 = -6.0;
  for( G4int i=0; i<12; ++i ) {
    ran1 += G4UniformRand();
    ran2 += G4UniformRand();
  }
  pnBlackTrackEnergyfromAnnihilation *= 1.0 + ran1*gfa;
  dtaBlackTrackEnergyfromAnnihilation *= 1.0 + ran2*gfa;
 
  pnBlackTrackEnergyfromAnnihilation = std::max( 0.0, pnBlackTrackEnergyfromAnnihilation);
  dtaBlackTrackEnergyfromAnnihilation = std::max( 0.0, dtaBlackTrackEnergyfromAnnihilation);
  G4double blackSum = pnBlackTrackEnergyfromAnnihilation+dtaBlackTrackEnergyfromAnnihilation;
  if (blackSum >= ekOrg/GeV) {
    pnBlackTrackEnergyfromAnnihilation *= ekOrg/GeV/blackSum;
    dtaBlackTrackEnergyfromAnnihilation *= ekOrg/GeV/blackSum;
  }
 
  return (pnBlackTrackEnergyfromAnnihilation+dtaBlackTrackEnergyfromAnnihilation)*GeV;
}

AtomicMass() [1/2]

G4double G4Nucleus::AtomicMass	(	const G4double	A,
		const G4double	Z,
		const G4int	numberOfLambdas = 0 ) const

Definition at line 369 of file G4Nucleus.cc.

{
  // Now returns (atomic mass - electron masses)
  if ( numberOfLambdas > 0 ) {
    return G4HyperNucleiProperties::GetNuclearMass(G4int(A), G4int(Z), numberOfLambdas);
  } else {
    return G4NucleiProperties::GetNuclearMass(A, Z);
  }
}

Referenced by G4ANuElNucleusCcModel::ApplyYourself(), G4ANuElNucleusNcModel::ApplyYourself(), G4ANuMuNucleusCcModel::ApplyYourself(), G4ANuMuNucleusNcModel::ApplyYourself(), G4ANuTauNucleusCcModel::ApplyYourself(), G4ANuTauNucleusNcModel::ApplyYourself(), G4MuonMinusBoundDecay::ApplyYourself(), G4NuElNucleusCcModel::ApplyYourself(), G4NuElNucleusNcModel::ApplyYourself(), G4NuMuNucleusCcModel::ApplyYourself(), G4NuMuNucleusNcModel::ApplyYourself(), G4NuTauNucleusCcModel::ApplyYourself(), G4NuTauNucleusNcModel::ApplyYourself(), G4WilsonAbrasionModel::ApplyYourself(), G4NeutrinoNucleusModel::CoherentPion(), G4NeutrinoNucleusModel::FinalBarion(), G4ANuElNucleusCcModel::SampleLVkr(), G4ANuElNucleusNcModel::SampleLVkr(), G4ANuMuNucleusCcModel::SampleLVkr(), G4ANuMuNucleusNcModel::SampleLVkr(), G4ANuTauNucleusCcModel::SampleLVkr(), G4ANuTauNucleusNcModel::SampleLVkr(), G4NuElNucleusCcModel::SampleLVkr(), G4NuElNucleusNcModel::SampleLVkr(), G4NuMuNucleusCcModel::SampleLVkr(), G4NuMuNucleusNcModel::SampleLVkr(), G4NuTauNucleusCcModel::SampleLVkr(), and G4NuTauNucleusNcModel::SampleLVkr().

AtomicMass() [2/2]

G4double G4Nucleus::AtomicMass	(	const G4int	A,
		const G4int	Z,
		const G4int	numberOfLambdas = 0 ) const

Definition at line 381 of file G4Nucleus.cc.

{
  // Now returns (atomic mass - electron masses)
  if ( numberOfLambdas > 0 ) {
    return G4HyperNucleiProperties::GetNuclearMass(A, Z, numberOfLambdas);
  } else {
    return G4NucleiProperties::GetNuclearMass(A, Z);
  }
}

ChooseParameters()

void G4Nucleus::ChooseParameters

(

const G4Material *

aMaterial

)

Definition at line 277 of file G4Nucleus.cc.

{
  G4double random = G4UniformRand();
  G4double sum = aMaterial->GetTotNbOfAtomsPerVolume();
  const G4ElementVector* theElementVector = aMaterial->GetElementVector();
  G4double running(0);
  //  G4Element* element(0);
  const G4Element* element = (*theElementVector)[aMaterial->GetNumberOfElements()-1];
 
  for (unsigned int i = 0; i < aMaterial->GetNumberOfElements(); ++i) {
    running += aMaterial->GetVecNbOfAtomsPerVolume()[i];
    if (running > random*sum) {
      element = (*theElementVector)[i];
      break;
    }
  }
 
  if (element->GetNumberOfIsotopes() > 0) {
    G4double randomAbundance = G4UniformRand();
    G4double sumAbundance = element->GetRelativeAbundanceVector()[0];
    unsigned int iso=0;
    while (iso < element->GetNumberOfIsotopes() &&  /* Loop checking, 02.11.2015, A.Ribon */
           sumAbundance < randomAbundance) {
      ++iso;
      sumAbundance += element->GetRelativeAbundanceVector()[iso];
    }
    theA=element->GetIsotope(iso)->GetN();
    theZ=element->GetIsotope(iso)->GetZ();
    theL=0;
    aEff=theA;
    zEff=theZ;
  } else {   
    aEff = element->GetN();
    zEff = element->GetZ();
    theZ = G4int(zEff + 0.5);
    theA = G4int(aEff + 0.5);
    theL=0;
  }
}

Referenced by G4Nucleus().

Cinema()

G4double G4Nucleus::Cinema

(

G4double

kineticEnergy

)

Definition at line 511 of file G4Nucleus.cc.

{
  // derived from original FORTRAN code CINEMA by H. Fesefeldt (14-Oct-1987)
  //
  // input: kineticEnergy (MeV)
  // returns modified kinetic energy (MeV)
  //
  static const G4double expxu =  82.;           // upper bound for arg. of exp
  static const G4double expxl = -expxu;         // lower bound for arg. of exp
  
  G4double ek = kineticEnergy/GeV;
  G4double ekLog = G4Log( ek );
  G4double aLog = G4Log( aEff );
  G4double em = std::min( 1.0, 0.2390 + 0.0408*aLog*aLog );
  G4double temp1 = -ek * std::min( 0.15, 0.0019*aLog*aLog*aLog );
  G4double temp2 = G4Exp( std::max( expxl, std::min( expxu, -(ekLog-em)*(ekLog-em)*2.0 ) ) );
  G4double result = 0.0;
  if( std::abs( temp1 ) < 1.0 )
  {
    if( temp2 > 1.0e-10 )result = temp1*temp2;
  }
  else result = temp1*temp2;
  if( result < -ek )result = -ek;
  return result*GeV;
}

DoKinematicsOfThermalNucleus()

void G4Nucleus::DoKinematicsOfThermalNucleus	(	const G4double	mu,
		const G4double	vT_norm,
		const G4ThreeVector &	aVelocity,
		G4ReactionProduct &	result ) const

Definition at line 190 of file G4Nucleus.cc.

                                                                         {
 
  // Get target nucleus direction from the neutron direction and the relative angle between target nucleus and neutron (mu)
  G4double cosTh = mu;
  G4ThreeVector uNorm = aVelocity;
    
  G4double sinTh = std::sqrt(1. - cosTh*cosTh);
    
  // Sample randomly the phi angle between the neutron veloicty and the target velocity
  G4double phi = CLHEP::twopi*G4UniformRand();
  G4double sinPhi = std::sin(phi);
  G4double cosPhi = std::cos(phi);
 
  // Find orthogonal vector to aVelocity - solve equation xx' + yy' + zz' = 0
  G4ThreeVector ortho(1., 1., 1.);
  if      ( uNorm[0] )  ortho[0] = -(uNorm[1]+uNorm[2])/uNorm[0];
  else if ( uNorm[1] )  ortho[1] = -(uNorm[0]+uNorm[2])/uNorm[1];
  else if ( uNorm[2] )  ortho[2] = -(uNorm[0]+uNorm[1])/uNorm[2];
 
  // Normalize the vector
  ortho = (1/ortho.mag())*ortho;
    
  // Find vector to draw a plan perpendicular to uNorm (i.e neutron velocity) with vectors ortho & orthoComp
  G4ThreeVector orthoComp( uNorm[1]*ortho[2] - ortho[1]*uNorm[2],
                           uNorm[2]*ortho[0] - ortho[2]*uNorm[0],
                           uNorm[0]*ortho[1] - ortho[0]*uNorm[1] );
 
  // Find the direction of the target velocity in the laboratory frame
  G4ThreeVector directionTarget( cosTh*uNorm[0] + sinTh*(cosPhi*orthoComp[0] + sinPhi*ortho[0]),
                                 cosTh*uNorm[1] + sinTh*(cosPhi*orthoComp[1] + sinPhi*ortho[1]),
                                 cosTh*uNorm[2] + sinTh*(cosPhi*orthoComp[2] + sinPhi*ortho[2]) );
    
  // Normalize directionTarget
  directionTarget = ( 1./directionTarget.mag() )*directionTarget;
 
  // Set momentum
  G4double px = result.GetMass()*vT_norm*directionTarget[0];
  G4double py = result.GetMass()*vT_norm*directionTarget[1];
  G4double pz = result.GetMass()*vT_norm*directionTarget[2];
  result.SetMomentum(px, py, pz);
 
  G4double tMom = std::sqrt(px*px+py*py+pz*pz);
  G4double tEtot = std::sqrt( (tMom+result.GetMass())*(tMom+result.GetMass())
                      - 2.*tMom*result.GetMass() );
 
  if ( tEtot/result.GetMass() - 1. > 0.001 ) {
    // use relativistic energy for higher energies
    result.SetTotalEnergy(tEtot);
  } else {
    // use p**2/2M for lower energies (to preserve precision?)
    result.SetKineticEnergy(tMom*tMom/(2.*result.GetMass()));
  }
 
}

Referenced by GetBiasedThermalNucleus().

EvaporationEffects()

G4double G4Nucleus::EvaporationEffects

(

G4double

kineticEnergy

)

Definition at line 404 of file G4Nucleus.cc.

{
  // derived from original FORTRAN code EXNU by H. Fesefeldt (10-Dec-1986)
  //
  // Nuclear evaporation as function of atomic number
  // and kinetic energy (MeV) of primary particle
  //
  // returns kinetic energy (MeV)
  //
  if( aEff < 1.5 )
  {
    pnBlackTrackEnergy = dtaBlackTrackEnergy = 0.0;
    return 0.0;
  }
  G4double ek = kineticEnergy/GeV;
  G4float ekin = std::min( 4.0, std::max( 0.1, ek ) );
  const G4float atno = std::min( 120., aEff ); 
  const G4float gfa = 2.0*((aEff-1.0)/70.)*G4Exp(-(aEff-1.0)/70.);
  //
  // 0.35 value at 1 GeV
  // 0.05 value at 0.1 GeV
  //
  G4float cfa = std::max( 0.15, 0.35 + ((0.35-0.05)/2.3)*G4Log(ekin) );
  G4float exnu = 7.716 * cfa * G4Exp(-cfa)
    * ((atno-1.0)/120.)*G4Exp(-(atno-1.0)/120.);
  G4float fpdiv = std::max( 0.5, 1.0-0.25*ekin*ekin );
  //
  // pnBlackTrackEnergy  is the kinetic energy (in GeV) available for
  //                     proton/neutron black track particles
  // dtaBlackTrackEnergy is the kinetic energy (in GeV) available for
  //                     deuteron/triton/alpha black track particles
  //
  pnBlackTrackEnergy = exnu*fpdiv;
  dtaBlackTrackEnergy = exnu*(1.0-fpdiv);
  
  if( G4int(zEff+0.1) != 82 )
  { 
    G4double ran1 = -6.0;
    G4double ran2 = -6.0;
    for( G4int i=0; i<12; ++i )
    {
      ran1 += G4UniformRand();
      ran2 += G4UniformRand();
    }
    pnBlackTrackEnergy *= 1.0 + ran1*gfa;
    dtaBlackTrackEnergy *= 1.0 + ran2*gfa;
  }
  pnBlackTrackEnergy = std::max( 0.0, pnBlackTrackEnergy );
  dtaBlackTrackEnergy = std::max( 0.0, dtaBlackTrackEnergy );
  while( pnBlackTrackEnergy+dtaBlackTrackEnergy >= ek )  /* Loop checking, 02.11.2015, A.Ribon */
  {
    pnBlackTrackEnergy *= 1.0 - 0.5*G4UniformRand();
    dtaBlackTrackEnergy *= 1.0 - 0.5*G4UniformRand();
  }
  //G4cout << "EvaporationEffects "<<kineticEnergy<<" "
  //       <<pnBlackTrackEnergy+dtaBlackTrackEnergy<< G4endl;
  return (pnBlackTrackEnergy+dtaBlackTrackEnergy)*GeV;
}

Fragmentate()

G4ReactionProductVector * G4Nucleus::Fragmentate

(

)

Definition at line 565 of file G4Nucleus.cc.

{
  // needs implementation!
  return nullptr;
}

GetA_asInt()

G4int G4Nucleus::GetA_asInt ( ) const

inline

Definition at line 99 of file G4Nucleus.hh.

    { return theA; }   

Referenced by G4AblaInterface::ApplyYourself(), G4ANuElNucleusCcModel::ApplyYourself(), G4ANuElNucleusNcModel::ApplyYourself(), G4ANuMuNucleusCcModel::ApplyYourself(), G4ANuMuNucleusNcModel::ApplyYourself(), G4ANuTauNucleusCcModel::ApplyYourself(), G4ANuTauNucleusNcModel::ApplyYourself(), G4BinaryCascade::ApplyYourself(), G4BinaryLightIonReaction::ApplyYourself(), G4CascadeInterface::ApplyYourself(), G4ChargeExchange::ApplyYourself(), G4EmCaptureCascade::ApplyYourself(), G4EMDissociation::ApplyYourself(), G4HadronElastic::ApplyYourself(), G4INCLXXInterface::ApplyYourself(), G4LEHadronProtonElastic::ApplyYourself(), G4LENDCapture::ApplyYourself(), G4LENDCombinedModel::ApplyYourself(), G4LENDElastic::ApplyYourself(), G4LENDFission::ApplyYourself(), G4LENDGammaModel::ApplyYourself(), G4LENDInelastic::ApplyYourself(), G4LENDModel::ApplyYourself(), G4LENDorBERTModel::ApplyYourself(), G4LEnp::ApplyYourself(), G4LEpp::ApplyYourself(), G4LFission::ApplyYourself(), G4LightIonQMDReaction::ApplyYourself(), G4LMsdGenerator::ApplyYourself(), G4LowEGammaNuclearModel::ApplyYourself(), G4LowEIonFragmentation::ApplyYourself(), G4MuMinusCapturePrecompound::ApplyYourself(), G4MuonMinusBoundDecay::ApplyYourself(), G4NeutronFissionVI::ApplyYourself(), G4NeutronHPElasticVI::ApplyYourself(), G4NeutronHPInelasticVI::ApplyYourself(), G4NeutronRadCapture::ApplyYourself(), G4NeutronRadCaptureHP::ApplyYourself(), G4NuElNucleusCcModel::ApplyYourself(), G4NuElNucleusNcModel::ApplyYourself(), G4NuMuNucleusCcModel::ApplyYourself(), G4NuMuNucleusNcModel::ApplyYourself(), G4NuTauNucleusCcModel::ApplyYourself(), G4NuTauNucleusNcModel::ApplyYourself(), G4PreCompoundModel::ApplyYourself(), G4QMDReaction::ApplyYourself(), G4TheoFSGenerator::ApplyYourself(), G4WilsonAbrasionModel::ApplyYourself(), G4HadronStoppingProcess::AtRestDoIt(), G4MuonMinusAtomicCapture::AtRestDoIt(), G4HadronicProcess::CheckEnergyMomentumConservation(), G4HadronicProcess::CheckResult(), G4NeutrinoNucleusModel::CoherentPion(), G4CascadeInterface::createTarget(), G4NeutrinoNucleusModel::FermiMomentum(), G4HadronicProcess::FillResult(), G4NeutrinoNucleusModel::FinalBarion(), G4QuasiElasticChannel::GetFraction(), G4NeutrinoNucleusModel::GgSampleNM(), G4FTFModel::Init(), G4LMsdGenerator::IsApplicable(), G4NeutrinoNucleusModel::NucleonMomentum(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), G4HadronicProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4TauNeutrinoNucleusProcess::PostStepDoIt(), G4ANuElNucleusCcModel::SampleLVkr(), G4ANuElNucleusNcModel::SampleLVkr(), G4ANuMuNucleusCcModel::SampleLVkr(), G4ANuMuNucleusNcModel::SampleLVkr(), G4ANuTauNucleusCcModel::SampleLVkr(), G4ANuTauNucleusNcModel::SampleLVkr(), G4NuElNucleusCcModel::SampleLVkr(), G4NuElNucleusNcModel::SampleLVkr(), G4NuMuNucleusCcModel::SampleLVkr(), G4NuMuNucleusNcModel::SampleLVkr(), G4NuTauNucleusCcModel::SampleLVkr(), G4NuTauNucleusNcModel::SampleLVkr(), G4QuasiElasticChannel::Scatter(), and G4VPartonStringModel::Scatter().

GetAnnihilationDTABlackTrackEnergy()

G4double G4Nucleus::GetAnnihilationDTABlackTrackEnergy ( ) const

inline

Definition at line 155 of file G4Nucleus.hh.

    { return dtaBlackTrackEnergyfromAnnihilation; }

GetAnnihilationPNBlackTrackEnergy()

G4double G4Nucleus::GetAnnihilationPNBlackTrackEnergy ( ) const

inline

Definition at line 152 of file G4Nucleus.hh.

    { return pnBlackTrackEnergyfromAnnihilation; }

GetBiasedThermalNucleus()

G4ReactionProduct G4Nucleus::GetBiasedThermalNucleus	(	G4double	aMass,
		G4ThreeVector	aVelocity,
		G4double	temp = -1 ) const

Definition at line 119 of file G4Nucleus.cc.

{
  // If E_neutron <= E_threshold, Then apply the Sampling ot the Velocity of the Target (SVT) method;
  // Else consider the target nucleus being without motion.
  G4double E_threshold = G4HadronicParameters::Instance()->GetNeutronKineticEnergyThresholdForSVT();
  if ( E_threshold == -1. ) {
    E_threshold = 400.0*8.617333262E-11*temp;
  }
  G4double E_neutron = 0.5*aVelocity.mag2()*G4Neutron::Neutron()->GetPDGMass(); // E=0.5*m*v2
 
  G4ReactionProduct result;
  result.SetMass(aMass*G4Neutron::Neutron()->GetPDGMass());
 
  if ( E_neutron <= E_threshold ) { 
    
    // 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;
 
    // Sample target speed
    G4double x2;
    G4double randThreshold;
    G4double vT_norm, vT_norm2, mu; //theta, val1, val2,
    G4double acceptThreshold;
    G4double vRelativeSpeed;
    G4double cdf0 = 2./(2.+std::sqrt(CLHEP::pi)*y);
 
    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
      vRelativeSpeed = std::sqrt(vN_norm2 + vT_norm2 - 2*vN_norm*vT_norm*mu);
      acceptThreshold = vRelativeSpeed/(vN_norm + vT_norm);
      randThreshold = G4UniformRand();
    } while ( randThreshold >= acceptThreshold );
 
    DoKinematicsOfThermalNucleus(mu, vT_norm, aVelocity, result);
    
  } else { // target nucleus considered as being without motion
    
    result.SetMomentum(0., 0., 0.);
    result.SetKineticEnergy(0.);
 
  }
 
  return result;
}

Referenced by G4FissionLibrary::ApplyYourself(), G4NeutronHPCaptureFS::ApplyYourself(), G4ParticleHPFissionFS::ApplyYourself(), G4ParticleHPInelasticBaseFS::BaseApply(), G4ParticleHPInelasticCompFS::CompositeApply(), and G4ParticleHPThermalBoost::GetThermalEnergy().

GetDTABlackTrackEnergy()

G4double G4Nucleus::GetDTABlackTrackEnergy ( ) const

inline

Definition at line 149 of file G4Nucleus.hh.

    { return dtaBlackTrackEnergy; }

GetEnergyDeposit()

G4double G4Nucleus::GetEnergyDeposit ( )

inline

Definition at line 180 of file G4Nucleus.hh.

{return excitationEnergy; }

Referenced by G4WilsonAbrasionModel::ApplyYourself().

GetFermiMomentum()

G4ThreeVector G4Nucleus::GetFermiMomentum

(

)

Definition at line 538 of file G4Nucleus.cc.

{
  // chv: .. we assume zero temperature!
  
  // momentum is equally distributed in each phasespace volume dpx, dpy, dpz.
  G4double ranflat1=
    G4RandFlat::shoot((G4double)0.,(G4double)fermiMomentum);   
  G4double ranflat2=
    G4RandFlat::shoot((G4double)0.,(G4double)fermiMomentum);   
  G4double ranflat3=
    G4RandFlat::shoot((G4double)0.,(G4double)fermiMomentum);   
  G4double ranmax = (ranflat1>ranflat2? ranflat1: ranflat2);
  ranmax = (ranmax>ranflat3? ranmax : ranflat3);
  
  // Isotropic momentum distribution
  G4double costheta = 2.*G4UniformRand() - 1.0;
  G4double sintheta = std::sqrt(1.0 - costheta*costheta);
  G4double phi = 2.0*pi*G4UniformRand();
  
  G4double pz=costheta*ranmax;
  G4double px=sintheta*std::cos(phi)*ranmax;
  G4double py=sintheta*std::sin(phi)*ranmax;
  G4ThreeVector p(px,py,pz);
  return p;
}

GetIsotope()

const G4Isotope * G4Nucleus::GetIsotope ( )

inline

Definition at line 111 of file G4Nucleus.hh.

    { return fIsotope; }

Referenced by G4LENDCapture::ApplyYourself(), G4LENDCombinedModel::ApplyYourself(), G4LENDElastic::ApplyYourself(), G4LENDFission::ApplyYourself(), G4LENDGammaModel::ApplyYourself(), G4LENDInelastic::ApplyYourself(), G4LENDModel::ApplyYourself(), G4LENDorBERTModel::ApplyYourself(), and G4HadronicProcess::GetTargetIsotope().

GetL()

G4int G4Nucleus::GetL ( ) const

inline

Definition at line 108 of file G4Nucleus.hh.

    { return theL; }

Referenced by G4INCLXXInterface::ApplyYourself().

GetN_asInt()

G4int G4Nucleus::GetN_asInt ( ) const

inline

Definition at line 102 of file G4Nucleus.hh.

    { return theA-theZ-theL; }   

Referenced by G4QuasiElasticChannel::GetFraction().

GetPNBlackTrackEnergy()

G4double G4Nucleus::GetPNBlackTrackEnergy ( ) const

inline

Definition at line 146 of file G4Nucleus.hh.

    { return pnBlackTrackEnergy; }

GetThermalNucleus()

G4ReactionProduct G4Nucleus::GetThermalNucleus	(	G4double	aMass,
		G4double	temp = -1 ) const

Definition at line 248 of file G4Nucleus.cc.

{
  G4double currentTemp = temp;
  if (currentTemp < 0) currentTemp = theTemp;
  G4ReactionProduct theTarget;    
  theTarget.SetMass(targetMass*G4Neutron::Neutron()->GetPDGMass());
  G4double px, py, pz;
  px = GetThermalPz(theTarget.GetMass(), currentTemp);
  py = GetThermalPz(theTarget.GetMass(), currentTemp);
  pz = GetThermalPz(theTarget.GetMass(), currentTemp);
  theTarget.SetMomentum(px, py, pz);
  G4double tMom = std::sqrt(px*px+py*py+pz*pz);
  G4double tEtot = std::sqrt((tMom+theTarget.GetMass())*
                             (tMom+theTarget.GetMass())-
                              2.*tMom*theTarget.GetMass());
  //  if(1-tEtot/theTarget.GetMass()>0.001)  this line incorrect (Bug report 1911) 
  if (tEtot/theTarget.GetMass() - 1. > 0.001) {
    // use relativistic energy for higher energies
    theTarget.SetTotalEnergy(tEtot);
 
  } else {
    // use p**2/2M for lower energies (to preserve precision?) 
    theTarget.SetKineticEnergy(tMom*tMom/(2.*theTarget.GetMass()));
  }    
  return theTarget;
}

Referenced by G4NeutronHPCaptureData::GetCrossSection(), G4ParticleHPElasticData::GetCrossSection(), G4ParticleHPFissionData::GetCrossSection(), and G4ParticleHPInelasticData::GetCrossSection().

GetThermalPz()

G4double G4Nucleus::GetThermalPz	(	const G4double	mass,
		const G4double	temp ) const

Definition at line 393 of file G4Nucleus.cc.

{
  G4double result = G4RandGauss::shoot();
  result *= std::sqrt(k_Boltzmann*temp*mass); // Das ist impuls (Pz),
                                         // nichtrelativistische rechnung
                                         // Maxwell verteilung angenommen
  return result;
}

Referenced by GetThermalNucleus().

GetZ_asInt()

G4int G4Nucleus::GetZ_asInt ( ) const

inline

Definition at line 105 of file G4Nucleus.hh.

    { return theZ; }   

Referenced by G4AblaInterface::ApplyYourself(), G4ANuElNucleusCcModel::ApplyYourself(), G4ANuElNucleusNcModel::ApplyYourself(), G4ANuMuNucleusCcModel::ApplyYourself(), G4ANuMuNucleusNcModel::ApplyYourself(), G4ANuTauNucleusCcModel::ApplyYourself(), G4ANuTauNucleusNcModel::ApplyYourself(), G4BinaryCascade::ApplyYourself(), G4BinaryLightIonReaction::ApplyYourself(), G4ChargeExchange::ApplyYourself(), G4ElectroVDNuclearModel::ApplyYourself(), G4EmCaptureCascade::ApplyYourself(), G4EMDissociation::ApplyYourself(), G4HadronElastic::ApplyYourself(), G4INCLXXInterface::ApplyYourself(), G4LEHadronProtonElastic::ApplyYourself(), G4LENDCapture::ApplyYourself(), G4LENDCombinedModel::ApplyYourself(), G4LENDElastic::ApplyYourself(), G4LENDFission::ApplyYourself(), G4LENDGammaModel::ApplyYourself(), G4LENDInelastic::ApplyYourself(), G4LENDModel::ApplyYourself(), G4LENDorBERTModel::ApplyYourself(), G4LEnp::ApplyYourself(), G4LEpp::ApplyYourself(), G4LFission::ApplyYourself(), G4LightIonQMDReaction::ApplyYourself(), G4LMsdGenerator::ApplyYourself(), G4LowEGammaNuclearModel::ApplyYourself(), G4LowEIonFragmentation::ApplyYourself(), G4MuMinusCapturePrecompound::ApplyYourself(), G4MuonMinusBoundDecay::ApplyYourself(), G4NeutronFissionVI::ApplyYourself(), G4NeutronHPElasticVI::ApplyYourself(), G4NeutronHPInelasticVI::ApplyYourself(), G4NeutronRadCapture::ApplyYourself(), G4NeutronRadCaptureHP::ApplyYourself(), G4NuElNucleusCcModel::ApplyYourself(), G4NuElNucleusNcModel::ApplyYourself(), G4NuMuNucleusCcModel::ApplyYourself(), G4NuMuNucleusNcModel::ApplyYourself(), G4NuTauNucleusCcModel::ApplyYourself(), G4NuTauNucleusNcModel::ApplyYourself(), G4ParticleHPElastic::ApplyYourself(), G4ParticleHPThermalScattering::ApplyYourself(), G4PreCompoundModel::ApplyYourself(), G4QMDReaction::ApplyYourself(), G4TheoFSGenerator::ApplyYourself(), G4WilsonAbrasionModel::ApplyYourself(), G4HadronStoppingProcess::AtRestDoIt(), G4MuonMinusAtomicCapture::AtRestDoIt(), G4HadronicProcess::CheckEnergyMomentumConservation(), G4HadronicProcess::CheckResult(), G4NeutrinoNucleusModel::CoherentPion(), G4CascadeInterface::createTarget(), G4NeutrinoNucleusModel::FermiMomentum(), G4HadronicProcess::FillResult(), G4NeutrinoNucleusModel::FinalBarion(), G4QuasiElasticChannel::GetFraction(), G4FTFModel::Init(), G4DiffuseElastic::IsApplicable(), G4DiffuseElasticV2::IsApplicable(), G4hhElastic::IsApplicable(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), G4HadronicProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4TauNeutrinoNucleusProcess::PostStepDoIt(), G4ANuElNucleusCcModel::SampleLVkr(), G4ANuElNucleusNcModel::SampleLVkr(), G4ANuMuNucleusCcModel::SampleLVkr(), G4ANuMuNucleusNcModel::SampleLVkr(), G4ANuTauNucleusCcModel::SampleLVkr(), G4ANuTauNucleusNcModel::SampleLVkr(), G4NuElNucleusCcModel::SampleLVkr(), G4NuElNucleusNcModel::SampleLVkr(), G4NuMuNucleusCcModel::SampleLVkr(), G4NuMuNucleusNcModel::SampleLVkr(), G4NuTauNucleusCcModel::SampleLVkr(), G4NuTauNucleusNcModel::SampleLVkr(), G4QuasiElasticChannel::Scatter(), and G4VPartonStringModel::Scatter().

operator!=()

G4bool G4Nucleus::operator!= ( const G4Nucleus & right ) const

inline

Definition at line 91 of file G4Nucleus.hh.

    { return ( this != (G4Nucleus *) &right ); }

operator=()

G4Nucleus & G4Nucleus::operator= ( const G4Nucleus & right )

inline

Definition at line 65 of file G4Nucleus.hh.

    {
      if (this != &right) {
        theA=right.theA;
        theZ=right.theZ;
        theL=right.theL;
        aEff=right.aEff;
        zEff=right.zEff;
        fIsotope = right.fIsotope;
        pnBlackTrackEnergy=right.pnBlackTrackEnergy; 
        dtaBlackTrackEnergy=right.dtaBlackTrackEnergy;
        pnBlackTrackEnergyfromAnnihilation =
                     right.pnBlackTrackEnergyfromAnnihilation; 
        dtaBlackTrackEnergyfromAnnihilation =
                     right.dtaBlackTrackEnergyfromAnnihilation; 
        theTemp = right.theTemp;
        excitationEnergy = right.excitationEnergy;
        momentum = right.momentum;
        fermiMomentum = right.fermiMomentum;
      }
      return *this;
    }

operator==()

G4bool G4Nucleus::operator== ( const G4Nucleus & right ) const

inline

Definition at line 88 of file G4Nucleus.hh.

    { return ( this == (G4Nucleus *) &right ); }

ReturnTargetParticle()

G4DynamicParticle * G4Nucleus::ReturnTargetParticle

(

)

const

Definition at line 352 of file G4Nucleus.cc.

{
  // choose a proton or a neutron (or a lamba if a hypernucleus) as the target particle
  G4DynamicParticle *targetParticle = new G4DynamicParticle;
  const G4double rnd = G4UniformRand();
  if ( rnd < zEff/aEff ) {
    targetParticle->SetDefinition( G4Proton::Proton() );
  } else if ( rnd < (zEff + theL*1.0)/aEff ) {
    targetParticle->SetDefinition( G4Lambda::Lambda() );
  } else {
    targetParticle->SetDefinition( G4Neutron::Neutron() );
  }
  return targetParticle;
}

Referenced by G4LEHadronProtonElastic::ApplyYourself(), G4LEnp::ApplyYourself(), and G4LEpp::ApplyYourself().

SetIsotope()

void G4Nucleus::SetIsotope ( const G4Isotope * iso )

inline

Definition at line 114 of file G4Nucleus.hh.

    { 
      fIsotope = iso;
      if(iso) { 
    theZ = iso->GetZ();
        theA = iso->GetN();
    theL = 0;
        aEff = theA;
        zEff = theZ;
      }
    }

Referenced by G4FissLib::ApplyYourself(), G4NeutronHPCapture::ApplyYourself(), G4ParticleHPElastic::ApplyYourself(), G4ParticleHPFission::ApplyYourself(), G4ParticleHPInelastic::ApplyYourself(), and G4CrossSectionDataStore::SampleZandA().

SetParameters() [1/2]

void G4Nucleus::SetParameters	(	const G4double	A,
		const G4double	Z,
		const G4int	numberOfLambdas = 0 )

Definition at line 319 of file G4Nucleus.cc.

{
  theZ = G4lrint(Z);
  theA = G4lrint(A);
  theL = std::max(numberOfLambdas, 0);
  if (theA<1 || theZ<0 || theZ>theA) {
    throw G4HadronicException(__FILE__, __LINE__,
            "G4Nucleus::SetParameters called with non-physical parameters");
  }
  aEff = A;  // atomic weight
  zEff = Z;  // atomic number
  fIsotope = 0;
}

Referenced by G4FissLib::ApplyYourself(), G4NeutronHPCapture::ApplyYourself(), G4ParticleHPElastic::ApplyYourself(), G4ParticleHPFission::ApplyYourself(), G4ParticleHPInelastic::ApplyYourself(), G4Nucleus(), G4Nucleus(), and G4ElementSelector::SelectZandA().

SetParameters() [2/2]

void G4Nucleus::SetParameters	(	const G4int	A,
		const G4int	Z,
		const G4int	numberOfLambdas = 0 )

Definition at line 335 of file G4Nucleus.cc.

{
  theZ = Z;
  theA = A;
  theL = std::max(numberOfLambdas, 0);
  if( theA<1 || theZ<0 || theZ>theA )
    {
      throw G4HadronicException(__FILE__, __LINE__,
                "G4Nucleus::SetParameters called with non-physical parameters");
    }
  aEff = A;  // atomic weight
  zEff = Z;  // atomic number
  fIsotope = 0;
}

---

The documentation for this class was generated from the following files:

• G4Nucleus.hh
• G4Nucleus.cc