Reactions

jitr.reactions provides tools for specifying the reacting system.

Reaction-system models and helpers for common nuclear processes.

class jitr.reactions.reaction.Particle(m0, q)

Bases: object

Represents a particle with rest mass and charge.

Variables:

• m0 – The rest mass of the particle in MeV/c^2.

• q – The electric charge of the particle.

• Z – Integer charge number (alias for int(q)).

• A – Mass number (0 for non-nuclear particles).

Parameters:

• m0 (float)

• q (float)

m0: float

q: float

Z: int

A: int

latex()

Returns the LaTeX representation of the particle.

Return type:

str

Returns:

LaTeX string.

classmethod parse(p, mass_kwargs=None)

Parse a particle-like object into a concrete particle instance.

Parameters:

• p (object) – A Particle instance, a (A, Z) tuple, or a string.

• mass_kwargs (dict[str, str] | None) – Keyword arguments forwarded to the mass database.

Raises:

• NotImplementedError – When p is a string (not yet supported).

• ValueError – When p cannot be interpreted as a particle.

Return type:

Particle

Returns:

A concrete Particle instance.

class jitr.reactions.reaction.Nucleus(A, Z, mass_kwargs=None)

Bases: Particle

Represents a Nucleus with atomic mass number A and atomic number Z. Nucleons can also be represented as a Nucleus.

Variables:

• A – Atomic mass number.

• Z – Atomic number.

• Efn – Neutron Fermi energy in MeV.

• Efp – Proton Fermi energy in MeV.

Parameters:

• A (int)

• Z (int)

• mass_kwargs (dict[str, str])

Z: int

mass_kwargs: dict[str, str]

A: int

Efn: float

Efp: float

latex()

Returns the LaTeX representation of the nucleus.

Return type:

str

Returns:

LaTeX string.

class jitr.reactions.reaction.Gamma

Bases: Particle

Represents a gamma-ray

Inherits from Particle with m0=0 and q=0

latex()

Returns the LaTeX representation of the particle.

Return type:

str

Returns:

LaTeX string.

class jitr.reactions.reaction.Electron

Bases: Particle

Represents an electron

Inherits from Particle

latex()

Returns the LaTeX representation of the particle.

Return type:

str

Returns:

LaTeX string.

class jitr.reactions.reaction.Positron

Bases: Particle

Represents a positron

Inherits from Particle

latex()

Returns the LaTeX representation of the particle.

Return type:

str

Returns:

LaTeX string.

class jitr.reactions.reaction.Reaction(target, projectile, product=None, residual=None, process=None, mass_kwargs=None)

Bases: object

Represents a 2-body nuclear reaction of the form A + a -> b + B.

Variables:

• target – The target particle.

• projectile – The projectile particle.

• product – The light product, or None for absorption/total processes.

• residual – The residual particle, or None for ‘abs’ or ‘tot’ processes.

• compound_system – The compound system formed by target and projectile.

• process – Short process label (e.g. 'el', 'abs'), or None.

• Q – The Q-value of the reaction in MeV. None when unspecified.

• reaction_string – The string representation of the reaction.

• reaction_latex – The LaTeX representation of the reaction.

• Ef – Effective Fermi energy in MeV, or None for non-nuclear reactions.

• threshold – Cluster separation energy threshold in MeV, or None.

• compound_system_threshold – Compound-system separation energy in MeV, or None.

Parameters:

• target (Particle)

• projectile (Particle)

• product (Particle | None)

• residual (Particle | None)

• process (str | None)

• mass_kwargs (dict[str, str] | None)

target: Particle

projectile: Particle

compound_system: Particle

process: str | None

product: Particle | None

residual: Particle | None

Q: float | None

reaction_string: str

reaction_latex: str

threshold: float | None

compound_system_threshold: float | None

Ef: float | None

kinematics(Elab)

Entrance channel kinematics given projectile incident on target with lab energy Elab in MeV.

Parameters:

Elab (float) – The laboratory energy of the projectile.

Return type:

ChannelKinematics

Returns:

The entrance channel kinematics.

kinematics_cm(Ecm)

Entrance channel kinematics given a kinetic energy of Ecm in the projectile-target center-of-mass frame.

Parameters:

Ecm (float) – The kinetic energy in the center-of-mass frame.

Return type:

ChannelKinematics

Returns:

The entrance channel kinematics.

kinematics_exit(entrance, residual_excitation_energy=0, product_excitation_energy=0)

Exit channel kinematics given entrance channel kinematics and

excitation energies.

Parameters:

• entrance (ChannelKinematics) – The entrance channel kinematics.

• residual_excitation_energy (float) – The excitation energy of the residual nucleus.

• product_excitation_energy (float) – The excitation energy of the product nucleus.

Return type:

ChannelKinematics

Returns:

The kinematics in the exit channel.

to_lab_frame(theta_cm, Ecm, Q)

Convert angles from the center-of-mass frame to the laboratory frame (target rest frame).

Parameters:

• theta_cm (ndarray) – Angles in the center-of-mass frame in degrees.

• Ecm (float) – Center-of-mass energy.

• Q (float) – Q-value of the reaction.

Return type:

ndarray

to_cm_frame(theta_lab, Elab, Q)

Convert angles from the laboratory (target rest frame) frame to the center-of-mass frame.

Parameters:

• theta_lab (ndarray) – Angles in the laboratory frame in degrees.

• Elab (float) – Laboratory energy.

• Q (float) – Q-value of the reaction.

Return type:

ndarray

class jitr.reactions.reaction.ElasticReaction(target, projectile, mass_kwargs=None)

Bases: Reaction

Represents an elastic reaction.

Parameters:

• target (Particle | tuple[int, int]) – The target nucleus.

• projectile (Particle | tuple[int, int]) – The projectile nucleus.

• mass_kwargs (dict[str, str] | None) – Keyword arguments forwarded to the mass database.

class jitr.reactions.reaction.InelasticReaction(target, projectile, mass_kwargs=None)

Bases: Reaction

Represents an inelastic reaction.

Parameters:

• target (Particle | tuple[int, int]) – The target nucleus.

• projectile (Particle | tuple[int, int]) – The projectile nucleus.

• mass_kwargs (dict[str, str] | None) – Keyword arguments forwarded to the mass database.

class jitr.reactions.reaction.TotalReaction(target, projectile, mass_kwargs=None)

Bases: Reaction

Represents a total reaction.

Parameters:

• target (Particle | tuple[int, int]) – The target nucleus.

• projectile (Particle | tuple[int, int]) – The projectile nucleus.

• mass_kwargs (dict[str, str] | None) – Keyword arguments forwarded to the mass database.

class jitr.reactions.reaction.AbsorptionReaction(target, projectile, mass_kwargs=None)

Bases: Reaction

Represents an absorption reaction.

Parameters:

• target (Particle | tuple[int, int]) – The target nucleus.

• projectile (Particle | tuple[int, int]) – The projectile nucleus.

• mass_kwargs (dict[str, str] | None) – Keyword arguments forwarded to the mass database.

class jitr.reactions.reaction.InclusiveReaction(target, projectile, residual, mass_kwargs=None)

Bases: Reaction

Represents an inclusive reaction.

Parameters:

• target (Particle | tuple[int, int]) – The target nucleus.

• projectile (Particle | tuple[int, int]) – The projectile nucleus.

• residual (Particle | tuple[int, int]) – The residual nucleus.

• mass_kwargs (dict[str, str] | None) – Keyword arguments forwarded to the mass database.

class jitr.reactions.reaction.GammaCaptureReaction(target, projectile, mass_kwargs=None)

Bases: Reaction

Represents a gamma capture reaction.

Parameters:

• target (Particle | tuple[int, int]) – The target nucleus.

• projectile (Particle | tuple[int, int]) – The projectile nucleus.

• mass_kwargs (dict[str, str] | None) – Keyword arguments forwarded to the mass database.

jitr.reactions.reaction.get_latex(A, Z, Ex=None)

Returns the LaTeX representation of a nucleus.

Parameters:

• A (int) – Mass number.

• Z (int) – Atomic number.

• Ex (float | None) – Excitation energy (optional).

Return type:

str

Returns:

LaTeX string.

jitr.reactions.reaction.get_symbol(A, Z, Ex=None)

Returns the symbol representation of a nucleus.

Parameters:

• A (int) – Mass number.

• Z (int) – Atomic number.

• Ex (float | None) – Excitation energy (optional).

Return type:

str

Returns:

Symbol string.

jitr.reactions.reaction.these_things_are_all_nuclei(*things_that_might_be_nuclei)

Return True when each supplied object is a nucleus or None.

Return type:

bool

Parameters:

things_that_might_be_nuclei (object)

jitr.reactions.reaction.cluster_separation_energy(target, projectile, **mass_kwargs)

Return the separation energy for removing projectile from target.

Return type:

float

Parameters:

• target (Particle)

• projectile (Particle)

• mass_kwargs (str)

Channel-system objects used by the R-matrix solvers.

jitr.reactions.system.scalar_couplings(l)

Return the default single-channel coupling matrix for partial wave l.

Return type:

ndarray[tuple[Any, ...], dtype[double]]

Parameters:

l (int)

jitr.reactions.system.spin_half_orbit_coupling(l)

Return l · sigma expectation values for spin-1/2 on spin-0 scattering.

Parameters:

l (int) – Orbital angular momentum.

Return type:

ndarray[tuple[Any, ...], dtype[double]]

Returns:

A diagonal matrix containing the coupling strength in each j channel.

class jitr.reactions.system.Asymptotics(Hp, Hm, Hpp, Hmp)

Bases: object

Asymptotic solutions for a set of channels in one partial wave.

Parameters:

• Hp (ComplexArray)

• Hm (ComplexArray)

• Hpp (ComplexArray)

• Hmp (ComplexArray)

decouple()

Split diagonal asymptotics into one-channel objects.

Return type:

list[Asymptotics]

class jitr.reactions.system.Channels(E, k, mu, eta, a, l, couplings)

Bases: object

Channel metadata for one partial wave.

Parameters:

• E (FloatArray)

• k (FloatArray)

• mu (FloatArray)

• eta (FloatArray)

• a (float)

• l (FloatArray)

• couplings (FloatArray)

decouple()

Split diagonal channel data into one-channel objects.

Return type:

list[Channels]

class jitr.reactions.system.ProjectileTargetSystem(channel_radius, lmax, mass_target=0.0, mass_projectile=0.0, Ztarget=0.0, Zproj=0.0, coupling=<function scalar_couplings>, channel_levels=None)

Bases: object

System-level information for a projectile-target partition.

Parameters:

• channel_radius (float)

• lmax (int)

• mass_target (float)

• mass_projectile (float)

• Ztarget (float)

• Zproj (float)

• coupling (CouplingFunction)

• channel_levels (FloatArray | None)

get_partial_wave_channels(Elab, Ecm, mu, k, eta)

Build channel and asymptotic objects for every partial wave.

Return type:

tuple[list[Channels], list[Asymptotics]]

Parameters:

• Elab (float | ndarray[tuple[Any, ...], dtype[float64]])

• Ecm (float | ndarray[tuple[Any, ...], dtype[float64]])

• mu (float | ndarray[tuple[Any, ...], dtype[float64]])

• k (float | ndarray[tuple[Any, ...], dtype[float64]])

• eta (float | ndarray[tuple[Any, ...], dtype[float64]])

jitr.reactions.system.uniform_array_from_scalar_or_array(scalar_or_array, size)

Broadcast a scalar or list-like input to a one-dimensional array.

Return type:

ndarray[tuple[Any, ...], dtype[double]]

Parameters:

• scalar_or_array (float | list[float] | ndarray[tuple[Any, ...], dtype[float64]])

• size (int)

Wavefunction reconstruction for solved R-matrix channels.

class jitr.reactions.wavefunction.Wavefunctions(solver, coeffs, S, uext_prime_boundary, channels, incoming_weights=None, asym=<class 'jitr.utils.free_solutions.CoulombAsymptotics'>)

Bases: object

Internal and external wavefunction representations for solved channels.

Parameters:

• coeffs (ComplexArray)

• S (ComplexArray)

• uext_prime_boundary (ComplexArray)

• incoming_weights (npt.NDArray[np.float64] | None)

uext()

Return external-channel wavefunctions valid beyond the boundary.

Return type:

list[Callable[[TypeAliasType], ndarray[tuple[Any, ...], dtype[cdouble]]]]

uint()

Return internal wavefunctions expanded in the Lagrange basis.

Return type:

list[Callable[[float], complex]]