#include <G4INCLNuclearDensity.hh>

Public Member Functions
	NuclearDensity (const G4int A, const G4int Z, const G4int S, InterpolationTable const const rpCorrelationTableProton, InterpolationTable const const rpCorrelationTableNeutron, InterpolationTable const *const rpCorrelationTableLambda)

	~NuclearDensity ()

	NuclearDensity (const NuclearDensity &rhs)
	Copy constructor.

NuclearDensity &	operator= (const NuclearDensity &rhs)
	Assignment operator.

void	swap (NuclearDensity &rhs)
	Helper method for the assignment operator.

G4double	getMaxRFromP (const ParticleType t, const G4double p) const
	Get the maximum allowed radius for a given momentum.

G4double	getMinPFromR (const ParticleType t, const G4double r) const

G4double	getMaximumRadius () const

G4double	getTransmissionRadius (Particle const *const p) const
	The radius used for calculating the transmission coefficient.

G4double	getTransmissionRadius (ParticleType type) const
	The radius used for calculating the transmission coefficient.

G4int	getA () const
	Get the mass number.

G4int	getZ () const
	Get the charge number.

G4int	getS () const
	Get the strange number.

G4double	getProtonNuclearRadius () const

void	setProtonNuclearRadius (const G4double r)

Detailed Description

Definition at line 54 of file G4INCLNuclearDensity.hh.

Constructor & Destructor Documentation

◆ NuclearDensity() [1/2]

G4INCL::NuclearDensity::NuclearDensity	(	const G4int	A,
		const G4int	Z,
		const G4int	S,
		InterpolationTable const *const	rpCorrelationTableProton,
		InterpolationTable const *const	rpCorrelationTableNeutron,
		InterpolationTable const *const	rpCorrelationTableLambda
	)

Definition at line 45 of file G4INCLNuclearDensity.cc.

                                                                                                                                                                                                                                                              :
    theA(A),
    theZ(Z),
    theS(S),
    theMaximumRadius(std::min((*rpCorrelationTableProton)(1.), (*rpCorrelationTableNeutron)(1.))),
    theProtonNuclearRadius(ParticleTable::getNuclearRadius(Proton,theA,theZ))
  {
    std::fill(rFromP, rFromP + UnknownParticle, static_cast<InterpolationTable*>(NULL));
    rFromP[Proton] = rpCorrelationTableProton;
    rFromP[Neutron] = rpCorrelationTableNeutron;
    rFromP[Lambda] = rpCorrelationTableLambda;
    rFromP[DeltaPlusPlus] = rpCorrelationTableProton;
    rFromP[DeltaPlus] = rpCorrelationTableProton;
    rFromP[DeltaZero] = rpCorrelationTableNeutron;
    rFromP[DeltaMinus] = rpCorrelationTableNeutron;
    // The interpolation table for local-energy look-ups is simply obtained by
    // inverting the r-p correlation table.
    std::fill(pFromR, pFromR + UnknownParticle, static_cast<InterpolationTable*>(NULL));
    pFromR[Proton] = new InterpolationTable(rFromP[Proton]->getNodeValues(), rFromP[Proton]->getNodeAbscissae());
    pFromR[Neutron] = new InterpolationTable(rFromP[Neutron]->getNodeValues(), rFromP[Neutron]->getNodeAbscissae());
    pFromR[Lambda] = new InterpolationTable(rFromP[Lambda]->getNodeValues(), rFromP[Lambda]->getNodeAbscissae());
    pFromR[DeltaPlusPlus] = new InterpolationTable(rFromP[DeltaPlusPlus]->getNodeValues(), rFromP[DeltaPlusPlus]->getNodeAbscissae());
    pFromR[DeltaPlus] = new InterpolationTable(rFromP[DeltaPlus]->getNodeValues(), rFromP[DeltaPlus]->getNodeAbscissae());
    pFromR[DeltaZero] = new InterpolationTable(rFromP[DeltaZero]->getNodeValues(), rFromP[DeltaZero]->getNodeAbscissae());
    pFromR[DeltaMinus] = new InterpolationTable(rFromP[DeltaMinus]->getNodeValues(), rFromP[DeltaMinus]->getNodeAbscissae());
    INCL_DEBUG("Interpolation table for proton local energy (A=" << theA << ", Z=" << theZ << ") initialised:"
          << '\n'
          << pFromR[Proton]->print()
          << '\n'
          << "Interpolation table for neutron local energy (A=" << theA << ", Z=" << theZ << ") initialised:"
          << '\n'
          << pFromR[Neutron]->print()
          << '\n'
          << "Interpolation table for lambda local energy (A=" << theA << ", Z=" << theZ << ", S=" << theS << ") initialised:"
          << '\n'
          << pFromR[Lambda]->print()
          << '\n'
          << "Interpolation table for delta++ local energy (A=" << theA << ", Z=" << theZ << ") initialised:"
          << '\n'
          << pFromR[DeltaPlusPlus]->print()
          << '\n'
          << "Interpolation table for delta+ local energy (A=" << theA << ", Z=" << theZ << ") initialised:"
          << '\n'
          << pFromR[DeltaPlus]->print()
          << '\n'
          << "Interpolation table for delta0 local energy (A=" << theA << ", Z=" << theZ << ") initialised:"
          << '\n'
          << pFromR[DeltaZero]->print()
          << '\n'
          << "Interpolation table for delta- local energy (A=" << theA << ", Z=" << theZ << ") initialised:"
          << '\n'
          << pFromR[DeltaMinus]->print()
          << '\n');
    initializeTransmissionRadii();
  }

◆ ~NuclearDensity()

G4INCL::NuclearDensity::~NuclearDensity ( )

Definition at line 101 of file G4INCLNuclearDensity.cc.

                                  {
    // We don't delete the rFromP tables, which are cached in the
    // NuclearDensityFactory
    delete pFromR[Proton];
    delete pFromR[Neutron];
    delete pFromR[Lambda];
    delete pFromR[DeltaPlusPlus];
    delete pFromR[DeltaPlus];
    delete pFromR[DeltaZero];
    delete pFromR[DeltaMinus];
  }

◆ NuclearDensity() [2/2]

G4INCL::NuclearDensity::NuclearDensity ( const NuclearDensity & rhs )

Copy constructor.

Definition at line 113 of file G4INCLNuclearDensity.cc.

                                                          :
    theA(rhs.theA),
    theZ(rhs.theZ),
    theS(rhs.theS),
    theMaximumRadius(rhs.theMaximumRadius),
    theProtonNuclearRadius(rhs.theProtonNuclearRadius)
  {
    // rFromP is owned by NuclearDensityFactory, so shallow copy is sufficient
    std::fill(rFromP, rFromP + UnknownParticle, static_cast<InterpolationTable*>(NULL));
    rFromP[Proton] = rhs.rFromP[Proton];
    rFromP[Neutron] = rhs.rFromP[Neutron];
    rFromP[Lambda] = rhs.rFromP[Lambda];
    rFromP[DeltaPlusPlus] = rhs.rFromP[DeltaPlusPlus];
    rFromP[DeltaPlus] = rhs.rFromP[DeltaPlus];
    rFromP[DeltaZero] = rhs.rFromP[DeltaZero];
    rFromP[DeltaMinus] = rhs.rFromP[DeltaMinus];
    // deep copy for pFromR
    std::fill(pFromR, pFromR + UnknownParticle, static_cast<InterpolationTable*>(NULL));
    pFromR[Proton] = new InterpolationTable(*(rhs.pFromR[Proton]));
    pFromR[Neutron] = new InterpolationTable(*(rhs.pFromR[Neutron]));
    pFromR[Lambda] = new InterpolationTable(*(rhs.pFromR[Lambda]));
    pFromR[DeltaPlusPlus] = new InterpolationTable(*(rhs.pFromR[DeltaPlusPlus]));
    pFromR[DeltaPlus] = new InterpolationTable(*(rhs.pFromR[DeltaPlus]));
    pFromR[DeltaZero] = new InterpolationTable(*(rhs.pFromR[DeltaZero]));
    pFromR[DeltaMinus] = new InterpolationTable(*(rhs.pFromR[DeltaMinus]));
    std::copy(rhs.transmissionRadius, rhs.transmissionRadius+UnknownParticle, transmissionRadius);
  }

Member Function Documentation

◆ getA()

G4int G4INCL::NuclearDensity::getA ( ) const

inline

Get the mass number.

Definition at line 104 of file G4INCLNuclearDensity.hh.

104{ return theA; }

◆ getMaximumRadius()

G4double G4INCL::NuclearDensity::getMaximumRadius ( ) const

inline

Definition at line 78 of file G4INCLNuclearDensity.hh.

78{ return theMaximumRadius; };

Referenced by G4INCL::Nucleus::Nucleus().

◆ getMaxRFromP()

G4double G4INCL::NuclearDensity::getMaxRFromP	(	const ParticleType	t,
		const G4double	p
	)		const

Get the maximum allowed radius for a given momentum.

Parameters

t	type of the particle
p	absolute value of the particle momentum, divided by the relevant Fermi momentum.

Returns: maximum allowed radius.

Definition at line 188 of file G4INCLNuclearDensity.cc.

                                                                                    {
// assert(t==Proton || t==Neutron || t==Lambda || t==DeltaPlusPlus || t==DeltaPlus || t==DeltaZero || t==DeltaMinus);
    return (*(rFromP[t]))(p);
  }

Referenced by G4INCL::Nucleus::getSurfaceRadius().

◆ getMinPFromR()

G4double G4INCL::NuclearDensity::getMinPFromR	(	const ParticleType	t,
		const G4double	r
	)		const

Definition at line 193 of file G4INCLNuclearDensity.cc.

                                                                                    {
// assert(t==Proton || t==Neutron || t==Lambda || t==DeltaPlusPlus || t==DeltaPlus || t==DeltaZero || t==DeltaMinus);
    return (*(pFromR[t]))(r);
  }

◆ getProtonNuclearRadius()

G4double G4INCL::NuclearDensity::getProtonNuclearRadius ( ) const

inline

Definition at line 112 of file G4INCLNuclearDensity.hh.

112{ return theProtonNuclearRadius; }

Referenced by G4INCL::ClusteringModelIntercomparison::getCluster().

◆ getS()

G4int G4INCL::NuclearDensity::getS ( ) const

inline

Get the strange number.

Definition at line 110 of file G4INCLNuclearDensity.hh.

110{ return theS; }

◆ getTransmissionRadius() [1/2]

G4double G4INCL::NuclearDensity::getTransmissionRadius ( Particle const *const p ) const

inline

The radius used for calculating the transmission coefficient.

Returns: the radius

Definition at line 84 of file G4INCLNuclearDensity.hh.

                                                                   {
      const ParticleType t = p->getType();
// assert(t!=Neutron && t!=PiZero && t!=DeltaZero && t!=Eta && t!=Omega && t!=EtaPrime && t!=Photon && t!= Lambda && t!=SigmaZero && t!=KZero && t!=KZeroBar && t!=KShort && t!=KLong); // no neutral particles here
      if(t==Composite) {
        return transmissionRadius[t] +
          ParticleTable::getNuclearRadius(t, p->getA(), p->getZ());
      } else
        return transmissionRadius[t];
    };

Referenced by G4INCL::CoulombNonRelativistic::distortOut(), and G4INCL::Nucleus::getTransmissionBarrier().

◆ getTransmissionRadius() [2/2]

G4double G4INCL::NuclearDensity::getTransmissionRadius ( ParticleType type ) const

inline

The radius used for calculating the transmission coefficient.

Returns: the radius

Definition at line 98 of file G4INCLNuclearDensity.hh.

                                                            {
// assert(type!=Composite);
      return transmissionRadius[type];
    };

◆ getZ()

G4int G4INCL::NuclearDensity::getZ ( ) const

inline

Get the charge number.

Definition at line 107 of file G4INCLNuclearDensity.hh.

107{ return theZ; }

◆ operator=()

NuclearDensity & G4INCL::NuclearDensity::operator= ( const NuclearDensity & rhs )

Assignment operator.

Definition at line 141 of file G4INCLNuclearDensity.cc.

                                                                     {
    NuclearDensity temporaryDensity(rhs);
    swap(temporaryDensity);
    return *this;
  }

◆ setProtonNuclearRadius()

void G4INCL::NuclearDensity::setProtonNuclearRadius ( const G4double r )

inline

Definition at line 113 of file G4INCLNuclearDensity.hh.

113{ theProtonNuclearRadius = r; }

◆ swap()

void G4INCL::NuclearDensity::swap ( NuclearDensity & rhs )

Helper method for the assignment operator.

Definition at line 147 of file G4INCLNuclearDensity.cc.

                                               {
    std::swap(theA, rhs.theA);
    std::swap(theZ, rhs.theZ);
    std::swap(theS, rhs.theS);
    std::swap(theMaximumRadius, rhs.theMaximumRadius);
    std::swap(theProtonNuclearRadius, rhs.theProtonNuclearRadius);
    std::swap_ranges(transmissionRadius, transmissionRadius+UnknownParticle, rhs.transmissionRadius);
    std::swap(rFromP[Proton], rhs.rFromP[Proton]);
    std::swap(rFromP[Neutron], rhs.rFromP[Neutron]);
    std::swap(rFromP[Lambda], rhs.rFromP[Lambda]);
    std::swap(rFromP[DeltaPlusPlus], rhs.rFromP[DeltaPlusPlus]);
    std::swap(rFromP[DeltaPlus], rhs.rFromP[DeltaPlus]);
    std::swap(rFromP[DeltaZero], rhs.rFromP[DeltaZero]);
    std::swap(rFromP[DeltaMinus], rhs.rFromP[DeltaMinus]);
    std::swap(pFromR[Proton], rhs.pFromR[Proton]);
    std::swap(pFromR[Neutron], rhs.pFromR[Neutron]);
    std::swap(pFromR[DeltaPlusPlus], rhs.pFromR[DeltaPlusPlus]);
    std::swap(pFromR[DeltaPlus], rhs.pFromR[DeltaPlus]);
    std::swap(pFromR[DeltaZero], rhs.pFromR[DeltaZero]);
    std::swap(pFromR[DeltaMinus], rhs.pFromR[DeltaMinus]);
 }

Referenced by operator=().

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

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

◆ NuclearDensity() [1/2]

◆ ~NuclearDensity()

◆ NuclearDensity() [2/2]

Member Function Documentation

◆ getA()

◆ getMaximumRadius()

◆ getMaxRFromP()

◆ getMinPFromR()

◆ getProtonNuclearRadius()

◆ getS()

◆ getTransmissionRadius() [1/2]

◆ getTransmissionRadius() [2/2]

◆ getZ()

◆ operator=()

◆ setProtonNuclearRadius()

◆ swap()