Observables and workspaces

The xs submodule contains the Workspace classes which are used to compute observables.

Elastic-scattering observables built from the R-matrix solver.

class jitr.xs.elastic.ElasticXS(dsdo, Ay, Q, t, rxn)[source]

Bases: object

Container for elastic-scattering observables.

Variables:

  • dsdo – Differential cross section in mb/sr.

  • Ay – Analyzing power.

  • Q – Spin-rotation function.

  • t – Total cross section in mb.

  • rxn – Reaction cross section in mb.

Parameters:
dsdo: ndarray
Ay: ndarray
Q: ndarray
t: float64
rxn: float64
class jitr.xs.elastic.IntegralWorkspace(reaction, kinematics, channel_radius_fm, solver, lmax, smatrix_abs_tol=1e-06)[source]

Bases: object

Workspace for integral elastic observables with spin-orbit coupling.

Parameters:
radial_grid()[source]

Return the physical quadrature grid used for local potentials.

Return type:

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

smatrix(central_potential, spin_orbit_potential=None, coulomb_potential=None)[source]

Compute the elastic S-matrix for j=l±1/2 channels.

Return type:

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

Parameters:

  • central_potential (ArrayLike)

  • spin_orbit_potential (ArrayLike | None)

  • coulomb_potential (ArrayLike | None)

xs(central_potential, spin_orbit_potential=None, coulomb_potential=None)[source]

Return total and reaction cross sections in mb.

Return type:

tuple[float, float]

Parameters:

  • central_potential (ArrayLike)

  • spin_orbit_potential (ArrayLike | None)

  • coulomb_potential (ArrayLike | None)

transmission_coefficients(central_potential, spin_orbit_potential=None, coulomb_potential=None)[source]

Return transmission coefficients for j=l±1/2 channels.

Return type:

tuple[ndarray, ndarray]

Parameters:

  • central_potential (ArrayLike)

  • spin_orbit_potential (ArrayLike | None)

  • coulomb_potential (ArrayLike | None)

class jitr.xs.elastic.DifferentialWorkspace(integral_workspace, angles)[source]

Bases: object

Workspace for angular elastic-scattering observables.

Parameters:
classmethod build_from_system(reaction, kinematics, channel_radius_fm, solver, lmax, angles, smatrix_abs_tol=1e-06)[source]

Construct a differential workspace from the raw system inputs.

Return type:

DifferentialWorkspace

Parameters:
f_c: ndarray[tuple[Any, ...], dtype[float64]] | ndarray[tuple[Any, ...], dtype[complex128]]
rutherford: ndarray[tuple[Any, ...], dtype[float64]] | None
radial_grid()[source]

Return the physical quadrature grid used for local potentials.

Return type:

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

rutherford_xs(angles)[source]

Return the Rutherford cross section in mb/sr.

Return type:

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

Parameters:

angles (ndarray[tuple[Any, ...], dtype[float64]])

coulomb_amplitude(angles, sigma_0)[source]

Return the Coulomb scattering amplitude.

Return type:

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

Parameters:
coulomb_phase_shift(ls)[source]

Return Coulomb phase shifts for the supplied partial waves.

Return type:

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

Parameters:

ls (ndarray[tuple[Any, ...], dtype[float64]])

xs(central_potential, spin_orbit_potential=None, coulomb_potential=None)[source]

Return differential and integral elastic observables.

Return type:

ElasticXS

Parameters:

  • central_potential (ArrayLike)

  • spin_orbit_potential (ArrayLike | None)

  • coulomb_potential (ArrayLike | None)

jitr.xs.elastic.integral_elastic_xs(k, Splus, Sminus, ls)[source]

Return total and reaction cross sections for spin-1/2 on spin-0 scattering.

Return type:

tuple[float, float]

Parameters:
jitr.xs.elastic.differential_elastic_xs(k, angles, splus, sminus, ls, P_l_costheta, P_1_l_costheta, f_c=0, sigma_l=0, eps=1e-30)[source]

Return differential and integral elastic observables.

The returned tuple contains (dσ/dΩ, A_y, Q, σ_total, σ_reaction).

Return type:

tuple[ndarray, ndarray, ndarray, float, float]

Parameters:
jitr.xs.elastic.check_angles(angles)[source]

Validate that the angle grid is one-dimensional and lies on [0, π).

Return type:

None

Parameters:

angles (ndarray[tuple[Any, ...], dtype[float64]])

DWBA workspaces for quasi-elastic (p,n) scattering observables.

class jitr.xs.quasielastic_pn.QuasielasticPnXS(dsdo, Ay, Q)[source]

Bases: object

Container for quasi-elastic (p,n) observables.

Variables:

  • dsdo – Differential cross section in mb/sr.

  • Ay – Analyzing power.

  • Q – Spin-rotation function.

Parameters:
dsdo: ndarray[tuple[Any, ...], dtype[float64]]
Ay: ndarray[tuple[Any, ...], dtype[float64]]
Q: ndarray[tuple[Any, ...], dtype[float64]]
jitr.xs.quasielastic_pn.isovector_factor(reaction)[source]

Return \(\sqrt{|N-Z|}/(N-Z-1)\) for the target of reaction.

This scales the difference of the neutron and proton optical potentials into the default (p,n) transition potential.

Return type:

float

Parameters:

reaction (Reaction)

jitr.xs.quasielastic_pn.as_local_potential(potential, nbasis, name)[source]

Validate and cast a local potential array on the quadrature grid.

Return type:

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

Parameters:

  • potential (ArrayLike)

  • nbasis (int)

  • name (str)

jitr.xs.quasielastic_pn.as_optional_local_potential(potential, nbasis, name)[source]

Return a validated local potential or a zero array when omitted.

Return type:

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

Parameters:

  • potential (ArrayLike | None)

  • nbasis (int)

  • name (str)

jitr.xs.quasielastic_pn.pn_potentials(nbasis, isovector_factor, U_p_coulomb, U_p_central, U_p_spin_orbit=None, U_n_central=None, U_n_spin_orbit=None, U1_central=None, U1_spin_orbit=None)[source]

Validate the (p,n) potentials and fill in the default transition terms.

Parameters:

  • nbasis (int) – Size of the quadrature grid.

  • isovector_factor (float) – Scale applied to U_n - U_p in the default transition potentials (see isovector_factor()).

  • U_p_coulomb (TypeAliasType) – Coulomb interaction for the proton.

  • U_p_central (TypeAliasType) – Central interaction for the proton.

  • U_p_spin_orbit (TypeAliasType | None) – Spin-orbit interaction for the proton.

  • U_n_central (TypeAliasType | None) – Central interaction for the neutron (required).

  • U_n_spin_orbit (TypeAliasType | None) – Spin-orbit interaction for the neutron.

  • U1_central (TypeAliasType | None) – Central transition potential, used as-is. Defaults to -(U_n_central - U_p_central) * isovector_factor.

  • U1_spin_orbit (TypeAliasType | None) – Spin-orbit transition potential, used as-is. Defaults to -(U_n_spin_orbit - U_p_spin_orbit) * isovector_factor.

Return type:

dict[str, ndarray[tuple[Any, ...], dtype[cdouble]]]

Returns:

Validated complex arrays keyed by argument name; omitted spin-orbit terms are zero.

jitr.xs.quasielastic_pn.spin_half_transition_geometry(lmax, angles)[source]

Angular factors for a spin-1/2 transition on a spin-0 target.

For a transition that conserves \(l\) and \(j\), the amplitude for projectile spin projection \(m \to m'\) is a sum over partial waves of

\[\sqrt{2l+1} \langle l 0 \tfrac{1}{2} m | j m \rangle \langle l, m-m'; \tfrac{1}{2} m' | j m \rangle Y_l^{m-m'}(\theta, 0)\]

times a partial-wave amplitude.

Parameters:
Return type:

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

Returns:

Array of shape (2, 2, lmax + 1, 2, len(angles)) indexed by [m, m', l, j], with m, m' in (-1/2, +1/2) and j in (l + 1/2, l - 1/2). Entries with no allowed j are zero.

jitr.xs.quasielastic_pn.pn_observables(f, xs_factor=0.5, eps=1e-30)[source]

Observables from the spin-1/2 transition amplitude matrix.

The scattering plane is taken at \(\phi = 0\), so the normal is \(\hat n = \hat k_{in} \times \hat k_{out} = \hat y\) and, for a transition with \(l = s = j = 0\) transfer, the amplitude matrix is

\[M = A + B\, \sigma \cdot \hat n ,\]

with \(A\) the non-spin-flip and \(B\) the spin-flip amplitude. In the f[m, m'] basis of spin_half_transition_geometry() this is \(A = f[1, 1] = f[0, 0]\) and \(\langle -|M|+\rangle = f[1, 0] = i B\), which gives

\[\frac{d\sigma}{d\Omega} = \frac{1}{2}\sum_{mm'}|f_{mm'}|^2 = |A|^2 + |B|^2, \qquad A_y = \frac{2\,\mathrm{Im}(A^* f[1,0])}{|A|^2 + |B|^2}, \qquad Q = \frac{2\,\mathrm{Re}(A^* f[1,0])}{|A|^2 + |B|^2}.\]

This is the same convention as jitr.xs.elastic.differential_elastic_xs() and as Eq. (12) of Gosset, Mayer and Escudie, Phys. Rev. C 14, 878 (1976).

The cross section is the full sum over m, m'. The analyzing power and spin-rotation function, on the other hand, are only meaningful when f really does reduce to two amplitudes, i.e. when the transition conserves l and j on a spin-0 target so that f[0, 0] == f[1, 1] and f[0, 1] == -f[1, 0].

Parameters:

  • f (ndarray[tuple[Any, ...], dtype[cdouble]]) – Amplitude matrix with shape (2, 2, len(angles)) indexed by [m, m', theta], with m, m' in (-1/2, +1/2).

  • xs_factor (float) – Overall factor multiplying \(\sum_{mm'}|f_{mm'}|^2\) to give the cross section in fm^2/sr. Defaults to the 1/(2s+1) spin average of a flux-normalized S-matrix amplitude.

  • eps (float) – Floor on the cross section used to regularize the ratios.

Return type:

QuasielasticPnXS

Returns:

The differential cross section in mb/sr, the analyzing power and the spin-rotation function at each angle.

class jitr.xs.quasielastic_pn.System(channel_radius_fm, lmax, reaction, kinematics_entrance, kinematics_exit)[source]

Bases: object

System for (p,n) quasi-elastic scattering observables for local interactions This system contains the entrance and exit channels, which are defined by the projectile and target masses, charges, and the channel radius.

Variables:

  • channel_radius_fm – The channel radius in femtometers.

  • lmax – The maximum angular momentum quantum number.

  • l – An array of angular momentum quantum numbers from 0 to lmax.

  • entrance – The entrance channel system, including projectile/target masses, charges, and the channel radius.

  • exit – The exit channel system, including product/residual masses, charges, and the channel radius.

Parameters:
class jitr.xs.quasielastic_pn.Workspace(reaction, kinematics_entrance, kinematics_exit, solver, angles, lmax, channel_radius_fm, tmatrix_abs_tol=1e-06)[source]

Bases: object

Workspace for (p,n) quasi-elastic scattering observables in the DWBA. This class computes the transition matrix and differential cross section for the (p,n) reaction using the distorted wave Born approximation (DWBA).

Parameters:
radial_grid()[source]

Return the physical quadrature grid used for local potentials.

Return type:

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

tmatrix(U_p_coulomb, U_p_central, U_p_spin_orbit=None, U_n_central=None, U_n_spin_orbit=None, U1_central=None, U1_spin_orbit=None)[source]

Calculate the transition matrix for (p,n) quasi-elastic scattering using the distorted wave Born approximation (DWBA).

Parameters:

  • U_p_coulomb (TypeAliasType) – Coulomb interaction for the proton.

  • U_p_central (TypeAliasType) – Central interaction for the proton.

  • U_p_spin_orbit (TypeAliasType | None) – Spin-orbit interaction for the proton.

  • U_n_central (TypeAliasType | None) – Central interaction for the neutron.

  • U_n_spin_orbit (TypeAliasType | None) – Spin-orbit interaction for the neutron.

  • U1_central (TypeAliasType | None) – Central (p,n) transition potential on the quadrature grid, used as-is in the radial integral. If None, defaults to -(U_n_central - U_p_central) * isovector_factor.

  • U1_spin_orbit (TypeAliasType | None) – Spin-orbit (p,n) transition potential on the quadrature grid, used as-is in the radial integral. If None, defaults to -(U_n_spin_orbit - U_p_spin_orbit) * isovector_factor.

Return type:

tuple[ndarray, ndarray, ndarray]

Returns:

Tuple (Tpn, Sn, Sp) where Tpn is the transition matrix for the (p,n) reaction, Sn is the S-matrix for the neutron elastic exit channel, and Sp is the S-matrix for the proton elastic entrance channel.

xs(U_p_coulomb, U_p_central, U_p_spin_orbit=None, U_n_central=None, U_n_spin_orbit=None, U1_central=None, U1_spin_orbit=None)[source]

Calculate the differential cross section for (p,n) quasi-elastic scattering in mb/Sr in the outgoing neutron angle using DWBA.

Parameters:

  • U_p_coulomb (TypeAliasType) – Coulomb interaction for the proton.

  • U_p_central (TypeAliasType) – Central interaction for the proton.

  • U_p_spin_orbit (TypeAliasType | None) – Spin-orbit interaction for the proton.

  • U_n_central (TypeAliasType | None) – Central interaction for the neutron.

  • U_n_spin_orbit (TypeAliasType | None) – Spin-orbit interaction for the neutron.

  • U1_central (TypeAliasType | None) – Central (p,n) transition potential on the quadrature grid, used as-is in the radial integral. If None, defaults to -(U_n_central - U_p_central) * isovector_factor.

  • U1_spin_orbit (TypeAliasType | None) – Spin-orbit (p,n) transition potential on the quadrature grid, used as-is in the radial integral. If None, defaults to -(U_n_spin_orbit - U_p_spin_orbit) * isovector_factor.

Return type:

ndarray

Returns:

Differential cross section for the (p,n) reaction in mb/Sr.

observables(U_p_coulomb, U_p_central, U_p_spin_orbit=None, U_n_central=None, U_n_spin_orbit=None, U1_central=None, U1_spin_orbit=None)[source]

Differential cross section, analyzing power and spin-rotation function for (p,n) quasi-elastic scattering in DWBA.

Args are as for xs().

Return type:

QuasielasticPnXS

Returns:

Observables at self.angles; the cross section is in mb/Sr.

Parameters:

  • U_p_coulomb (ArrayLike)

  • U_p_central (ArrayLike)

  • U_p_spin_orbit (ArrayLike | None)

  • U_n_central (ArrayLike | None)

  • U_n_spin_orbit (ArrayLike | None)

  • U1_central (ArrayLike | None)

  • U1_spin_orbit (ArrayLike | None)

amplitudes_from_tmatrix(Tlj)[source]

Spin-1/2 transition amplitude matrix from the DWBA T-matrix.

Parameters:

Tlj (ndarray[tuple[Any, ...], dtype[cdouble]]) – Partial-wave T-matrix from tmatrix(), with shape (lmax + 1, 2) indexed by [l, j].

Return type:

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

Returns:

Amplitudes \(T_{mm'}(\theta)\) with shape (2, 2, len(self.angles)).

observables_from_tmatrix(Tlj)[source]

Observables from the DWBA T-matrix.

Parameters:

Tlj (ndarray[tuple[Any, ...], dtype[cdouble]]) – Partial-wave T-matrix from tmatrix().

Return type:

QuasielasticPnXS

Returns:

Observables at self.angles; the cross section is in mb/Sr.