RydbergStateSQDT

Class Methods

`__init__`(species, n, l[, j_tot, s_tot, m])	Initialize the Rydberg state.
`calc_angular_matrix_element`(other, operator, ...)	Calculate the dimensionless angular matrix element.
`calc_matrix_element`(other, operator, ...[, unit])	Calculate the matrix element.
`calc_radial_matrix_element`(other, k_radial)
`copy`()	Create a copy of the Rydberg state.
`create_element`(*[, use_nist_data])	Create the element for the Rydberg state.
`create_grid`([x_min, x_max, dz])	Create the grid object for the integration of the radial Schrödinger equation.
`create_model`([potential_type])	Create the model for the Rydberg state.
`create_wavefunction`([method, ...])
`get_black_body_transition_rates`(temperature)	Calculate the black body transition rates for the Rydberg state.
`get_energy`([unit])
`get_label`(fmt)	Label representing the ket.
`get_lifetime`([temperature, ...])	Calculate the lifetime of the Rydberg state.
`get_n_star`()	Calculate the effective quantum number n* for the Rydberg state.
`get_spontaneous_transition_rates`([unit, method])	Calculate the spontaneous transition rates for the Rydberg state.
`sanity_check`()	Check that the quantum numbers are valid.

Class Attributes and Properties

`element`	The element of the Rydberg state.
`grid`	The grid object for the integration of the radial Schrödinger equation.
`model`
`w_list`	The list of w values for the wavefunction.
`wavefunction`
`z_list`	The list of z values for the grid.
`n`
`species`
`l`

class ryd_numerov.RydbergStateSQDT(species, n, l, j_tot=None, s_tot=None, m=None)[source]

Initialize the Rydberg state.

Parameters:

species (str) – Atomic species.
n (int) – Principal quantum number of the rydberg electron.
l (int) – Orbital angular momentum quantum number of the rydberg electron.
j_tot (Optional[float]) – Angular momentum quantum number of the rydberg electron.
s_tot (Optional[float]) – Total spin quantum number Optional, only needed for alkaline earth atoms, where it can be 0 (singlet) or 1 (triplet).
m (Optional[float]) – Total magnetic quantum number. Optional, only needed for concrete angular matrix elements.

species: str

n: int

l: int

s_tot: float

j_tot: float

copy()[source]

Create a copy of the Rydberg state.

Return type:: Self

get_label(fmt)[source]

Label representing the ket.

Parameters:: fmt (Literal['raw', 'ket', 'bra']) – The format of the label, i.e. whether to return the raw label, or the label in ket or bra notation.
Return type:: str
Returns:: The label of the ket in the given format.

sanity_check()[source]

Check that the quantum numbers are valid.

Return type:: None

calc_radial_matrix_element(other, k_radial, unit=None)

Return type:

Union[PlainQuantity[float], float]

Parameters:

other (Self)
k_radial (int)
unit (str | None)

create_element(*, use_nist_data=True)

Create the element for the Rydberg state.

Return type:: None
Parameters:: use_nist_data (bool)

create_grid(x_min=None, x_max=None, dz=0.01)

Create the grid object for the integration of the radial Schrödinger equation.

Parameters:

x_min (Optional[float]) – The minimum value of the radial coordinate in dimensionless units (x = r/a_0). Default: Automatically calculate sensible value.
x_max (Optional[float]) – The maximum value of the radial coordinate in dimensionless units (x = r/a_0). Default: Automatically calculate sensible value.
dz (float) – The step size of the integration (z = r/a_0). Default: 1e-2.

Return type:

None

create_model(potential_type=None)

Create the model for the Rydberg state.

Parameters:: potential_type (Optional[Literal['coulomb', 'model_potential_marinescu_1993', 'model_potential_fei_2009']]) – Which potential to use for the model.
Return type:: None

create_wavefunction(method='numerov', sign_convention=None, *, run_backward=True, w0=1e-10, _use_njit=True)

Return type:

None

Parameters:

method (Literal['numerov', 'whittaker'])
sign_convention (Literal[None, 'positive_at_outer_bound', 'n_l_1'])
run_backward (bool)
w0 (float)
_use_njit (bool)

property element: BaseElement: The element of the Rydberg state.

get_n_star()

Calculate the effective quantum number n* for the Rydberg state.

We define n* as :rtype: float

\[n^* = \sqrt{-\frac{1}{2} \frac{\mu}{E} }\]

where mu = R_M/R_infty is the reduced mass and E the energy of the state.

Return type:: float

property grid: Grid: The grid object for the integration of the radial Schrödinger equation.

property model: Model

property w_list: ndarray[tuple[int, ...], dtype[Any]]: The list of w values for the wavefunction.

property wavefunction: Wavefunction

property z_list: ndarray[tuple[int, ...], dtype[Any]]: The list of z values for the grid.

get_energy(unit=None)[source]

Return type:: Union[PlainQuantity[float], float]
Parameters:: unit (str | None)

calc_angular_matrix_element(other, operator, k_angular, q)[source]

Calculate the dimensionless angular matrix element.

Return type:

float

Parameters:

other (Self)
operator (Literal['MAGNETIC', 'ELECTRIC', 'SPHERICAL', 'MAGNETIC_S', 'MAGNETIC_L'])
k_angular (int)
q (int)

calc_matrix_element(other, operator, k_radial, k_angular, q, unit=None)[source]

Calculate the matrix element.

Calculate the matrix element between two Rydberg states ket{self}=ket{n’,l’,j_tot’,s_tot’,m’} and ket{other}= ket{n,l,j_tot,s_tot,m}.

\[\langle n,l,j_tot,s_tot,m | r^k_radial \hat{O}_{k_angular,q} | n',l',j_tot',s_tot',m' \rangle\]

where hat{O}_{k_angular,q} is the operators of rank k_angular and component q, for which to calculate the matrix element.

Parameters:

other (Self) – The other Rydberg state ket{n,l,j_tot,s_tot,m} to which to calculate the matrix element.
operator (Literal['MAGNETIC', 'ELECTRIC', 'SPHERICAL', 'MAGNETIC_S', 'MAGNETIC_L']) – The operator type for which to calculate the matrix element. Can be one of “MAGNETIC”, “ELECTRIC”, “SPHERICAL”.
k_radial (int) – The radial matrix element power k.
k_angular (int) – The rank of the angular operator.
q (int) – The component of the angular operator.
unit (Optional[str]) – The unit to which to convert the radial matrix element. Can be “a.u.” for atomic units (so no conversion is done), or a specific unit. Default None will return a pint quantity.

Return type:

Union[PlainQuantity[float], float]

Returns:

The matrix element for the given operator.

get_spontaneous_transition_rates(unit=None, method='exact')[source]

Calculate the spontaneous transition rates for the Rydberg state.

The spontaneous transition rates are given by the Einstein A coefficients.

Parameters:

unit (Optional[str]) – The unit to which to convert the result to. Can be “a.u.” for atomic units (so no conversion is done), or a specific unit. Default None will return a pint quantity.
method (Literal['exact', 'approximation']) – How to calculate the transition rates. Can be “exact” or “approximation”. Defaults to “exact”.

Return type:

tuple[list[Self], Union[PlainQuantity[ndarray[tuple[int, ...], dtype[Any]]], ndarray[tuple[int, ...], dtype[Any]]]]

Returns:

The relevant states and the transition rates.

get_black_body_transition_rates(temperature, temperature_unit=None, unit=None, method='exact')[source]

Calculate the black body transition rates for the Rydberg state.

The black body transitions rates are given by the Einstein B coefficients, with a weight factor given by Planck’s law.

Parameters:

temperature (Union[float, PlainQuantity[float]]) – The temperature, for which to calculate the black body transition rates.
temperature_unit (Optional[str]) – The unit of the temperature. Default None will assume the temperature is given as pint quantity.
unit (Optional[str]) – The unit to which to convert the result. Can be “a.u.” for atomic units (so no conversion is done), or a specific unit. Default None will return a pint quantity.
method (Literal['exact', 'approximation']) – How to calculate the transition rates. Can be “exact” or “approximation”. Defaults to “exact”.

Return type:

tuple[list[Self], Union[PlainQuantity[ndarray[tuple[int, ...], dtype[Any]]], ndarray[tuple[int, ...], dtype[Any]]]]

Returns:

The relevant states and the transition rates.

get_lifetime(temperature=None, temperature_unit=None, unit=None, method='exact')[source]

Calculate the lifetime of the Rydberg state.

The lifetime is given by the inverse of the sum of the transition rates:

\[\begin{split}\tau = \frac{1}{\\sum_i A_i}\end{split}\]

where \(A_i\) are the transition rates (see get_spontaneous_transition_rates and get_black_body_transition_rates).

Parameters:

temperature (Union[float, PlainQuantity[float], None]) – The temperature, for which to calculate the lifetime. Default None will only consider the spontaneous transition rates for the lifetime.
temperature_unit (Optional[str]) – The unit of the temperature. Default None will assume the temperature is given as pint quantity.
unit (Optional[str]) – The unit to which to convert the result to. Can be “a.u.” for atomic units (so no conversion is done), or a specific unit. Default None will return a pint quantity.
method (Literal['exact', 'approximation']) – How to calculate the transition rates. Can be “exact” or “approximation”. Defaults to “exact”.

Return type:

Union[PlainQuantity[float], float]

Returns:

The lifetime of the Rydberg state in the given unit.