RadialKet

Class Methods

`__init__`(nu, potential, *[, n_expected, dz, ...])	Initialize the radial ket.
`calc_matrix_element`(other, k_radial[, unit, ...])
`calc_overlap`(other, *[, integration_method])	Calculate the overlap <self\|other> of two radial kets.
`integrate_wavefunction`()	Integrate the wavefunction using the method given by the `integration_method` parameter.

Class Attributes and Properties

`dz`	The grid step size in the scaled dimensionless coordinate \(z = \sqrt{r/a_0}\).
`l_r`	Return the orbital quantum number of the rydberg electron.
`nodes`	The number of nodes (i.e. zero-crossings) of the wavefunction.
`norm`	The norm of the wavefunction.
`r_list`	The radial wavefunction in atomic units \(\tilde{R}(r) = a_0^{-3/2} R(r)\).
`steps`	The number of grid points.
`u_list`	The dimensionless wavefunction \(\tilde{u}(x) = \sqrt{a_0} r R(r)\).
`w_list`	The dimensionless scaled wavefunction \(w(z)\).
`x_list`	The grid in the dimensionless coordinate \(x = r/a_0\).
`z_list`	The grid in the scaled dimensionless coordinate \(z = \sqrt{r/a_0}\).

class rydstate.radial.RadialKet(nu, potential, *, n_expected=None, dz=0.01, x_min=None, x_max=None, run_backward=True, w0=1e-10, use_njit=True, integration_method='numerov', sign_convention='positive_at_outer_bound')[source]

Initialize the radial ket.

Parameters:

nu (float) – Effective principal quantum number of the rydberg electron, which is used to calculate the energy of the state.
potential (Potential | PotentialDummy) – The potential object.
n_expected (int | None) – Optional principal quantum number of the rydberg electron, used for additional sanity checks of the radial wavefunction (e.g. checking that the number of nodes matches n - l - 1). It is also required for the “n_l_1” sign convention.
dz (float) – The step size of the integration in the scaled dimensionless coordinate \(z = \sqrt{r/a_0}\).
x_min (float | None) – The minimum value of the radial coordinate in dimensionless units \(x = r/a_0\). None means a sensible value is calculated automatically.
x_max (float | None) – The maximum value of the radial coordinate in dimensionless units \(x = r/a_0\). None means a sensible value is calculated automatically.
run_backward (bool) – Whether to integrate the radial Schrödinger equation “backward” or “forward”.
w0 (float) – The initial magnitude of the radial wavefunction at the boundary.
use_njit (bool) – Whether to use the fast njit version of the Numerov integration.
integration_method (Literal['numerov', 'whittaker']) – The method used to integrate the wavefunction, either “numerov” or “whittaker”.
sign_convention (Optional[Literal['positive_at_outer_bound', 'n_l_1']]) – The sign convention applied to the wavefunction after the integration. One of “positive_at_outer_bound”, “n_l_1” or None (see _apply_sign_convention()). The “n_l_1” convention requires n_expected to be set.
args (object)
kwargs (object)

Return type:

CachedT

property l_r: int | Unknown: Return the orbital quantum number of the rydberg electron.

property z_list: ndarray[tuple[Any, ...], dtype[Any]]

The grid in the scaled dimensionless coordinate \(z = \sqrt{r/a_0}\).

In this coordinate the grid points are chosen equidistant, because the nodes of the wavefunction are equally spaced in this coordinate.

property x_list: ndarray[tuple[Any, ...], dtype[Any]]: The grid in the dimensionless coordinate \(x = r/a_0\).

property dz: float: The grid step size in the scaled dimensionless coordinate \(z = \sqrt{r/a_0}\).

property steps: int: The number of grid points.

property w_list: ndarray[tuple[Any, ...], dtype[Any]]

The dimensionless scaled wavefunction \(w(z)\).

The scaled wavefunction is defined as

\[w(z) = z^{-1/2} \tilde{u}(x=z^2) = (r/a_0)^{-1/4} \sqrt{a_0} r R(r)\]

property u_list: ndarray[tuple[Any, ...], dtype[Any]]: The dimensionless wavefunction \(\tilde{u}(x) = \sqrt{a_0} r R(r)\).

property r_list: ndarray[tuple[Any, ...], dtype[Any]]: The radial wavefunction in atomic units \(\tilde{R}(r) = a_0^{-3/2} R(r)\).

property norm: float: The norm of the wavefunction.

property nodes: int: The number of nodes (i.e. zero-crossings) of the wavefunction.

integrate_wavefunction()[source]

Integrate the wavefunction using the method given by the integration_method parameter.

Return type:: None

calc_overlap(other, *, integration_method='sum')[source]

Calculate the overlap <self|other> of two radial kets.

Parameters:

other (RadialKet) – Other radial ket
integration_method (Literal['sum', 'trapezoid', 'scipy_simpson', 'scipy_trapezoid']) – Integration method to use

Return type:

float

Returns:

The overlap integral between self and other.

calc_matrix_element(other, k_radial, unit=None, *, integration_method='sum')[source]

Overloads:

self, other (RadialKet), k_radial (int), unit (None), integration_method (INTEGRATION_METHODS) → PintFloat
self, other (RadialKet), k_radial (int), unit (str), integration_method (INTEGRATION_METHODS) → float

Parameters:

other (RadialKet)
k_radial (int)
unit (str | None)
integration_method (Literal['sum', 'trapezoid', 'scipy_simpson', 'scipy_trapezoid'])

Return type:

PlainQuantity[float] | float

Calculate the radial matrix element <self | r^k_radial | other>.

Computes the integral

\[\int_{0}^{\infty} dr r^2 r^k_{radial} R_1(r) R_2(r) = a_0^{k_{radial}} \int_{0}^{\infty} dx x^k_{radial} \tilde{u}_1(x) \tilde{u}_2(x) = a_0^{k_{radial}} \int_{0}^{\infty} dz 2 z^{2 + 2k_{radial}} w_1(z) w_2(z)\]

where R_1 and R_2 are the radial wavefunctions of self and other, and w(z) = z^{-1/2} tilde{u}(z^2) = (r/_a_0)^{1/4} sqrt{a_0} r R(r).

Parameters:

other (RadialKet) – Other radial ket
k_radial (int) – Power of r in the matrix element (default=0, this corresponds to the overlap integral int dr r^2 R_1(r) R_2(r))
unit (str | None) – Unit of the returned matrix element, default None returns a Pint quantity.
integration_method (Literal['sum', 'trapezoid', 'scipy_simpson', 'scipy_trapezoid']) – Integration method to use

Returns:

The radial matrix element in the desired unit.

Return type:

PlainQuantity[float] | float