RydbergStateSQDT

Class Methods

`__init__`(species, n, *[, s_c, l_c, j_c, ...])
`calc_exp_qn`(qn)
`calc_matrix_element`(other, operator, q[, unit])
`calc_reduced_matrix_element`(other, operator)
`calc_reduced_overlap`(other)	Calculate the reduced overlap <self\|other> (ignoring the magnetic quantum number m).
`calc_std_qn`(qn)
`free_memory`()	Release the cached radial and angular data to reduce memory usage.
`get_black_body_transition_rates`(temperature)
`get_energy`([unit])
`get_lifetime`([temperature, ...])
`get_radial_energy`([unit])
`get_spontaneous_transition_rates`([unit])

Class Attributes and Properties

`coefficients`
`norm`	Return the norm of the state (should be 1).
`nu`
`nui`	Return the effective principal quantum numbers nui of the different channels.
`radial`	The radial part of the Rydberg electron.
`rydberg_kets`
`species`	The atomic species of the Rydberg state.
`angular`	The angular/spin part of the Rydberg electron.

class rydstate.rydberg_state.RydbergStateSQDT(species, n, *, s_c=None, l_c=None, j_c=None, f_c=None, s_r=None, l_r=None, j_r=None, s_tot=None, l_tot=None, j_tot=None, f_tot=None, m=NotSet, angular_ket=None, sqdt=None, potential=None)[source]

Initialize the Rydberg state.

Parameters:

species (str) – Atomic species.
n (int) – Principal quantum number of the rydberg electron.
s_c (float | None) – Spin quantum number of the core electron (0 for Alkali, 0.5 for divalent atoms).
l_c (int | None) – Orbital angular momentum quantum number of the core electron.
j_c (float | None) – Total angular momentum quantum number of the core electron.
f_c (float | None) – Total angular momentum quantum number of the core (core electron + nucleus).
s_r (float | None) – Spin quantum number of the rydberg electron always 0.5)
l_r (int | None) – Orbital angular momentum quantum number of the rydberg electron.
j_r (float | None) – Total angular momentum quantum number of the rydberg electron.
s_tot (float | None) – Total spin quantum number of all electrons.
l_tot (int | None) – Total orbital angular momentum quantum number of all electrons.
j_tot (float | None) – Total angular momentum quantum number of all electrons.
f_tot (float | None) – Total angular momentum quantum number of the atom (rydberg electron + core)
m (float | NotSet) – Total magnetic quantum number. Optional, only needed for concrete angular matrix elements.
angular_ket (Optional[AngularKetBase[Never]]) – The angular ket to use for the state. Either angular_ket or the quantum numbers for the angular ket must be given.
sqdt (str | SQDT | None) – The SQDT to use for the state. Either a string representing the tag of the SQDT class to use, or an instance of an SQDT class.
potential (str | Potential | None) – The potential to use for the radial ket. Either a string representing the tag of the potential to use, or an instance of a potential class.

species: str: The atomic species of the Rydberg state.

angular: GenericT_AngularKet: The angular/spin part of the Rydberg electron.

calc_exp_qn(qn)

Return type:: float
Parameters:: qn (str)

calc_matrix_element(other, operator, q, unit=None)

Overloads:

self, other (RydbergStateBase), operator (MatrixElementOperator), q (int), unit (None) → PintFloat
self, other (RydbergStateBase), operator (MatrixElementOperator), q (int), unit (str) → float

Parameters:

other (RydbergStateBase)
operator (Literal['magnetic_dipole', 'electric_dipole', 'electric_quadrupole', 'electric_octupole', 'electric_quadrupole_zero'])
q (int)
unit (str | None)

Return type:

PlainQuantity[float] | float

Calculate the matrix element.

Calculate the full matrix element between self and other, also considering the magnetic quantum numbers m of self and other.

\[\left\langle self | r^k_radial \hat{O}^{(k_{angular})}_q | other \right\rangle\]

where hat{O}^{(k_{angular})}_q is the operator of rank k_angular for which to calculate the matrix element. k_radial and k_angular are determined from the operator automatically.

Parameters:

other (RydbergStateBase) – The other Rydberg state for which to calculate the matrix element.
operator (Literal['magnetic_dipole', 'electric_dipole', 'electric_quadrupole', 'electric_octupole', 'electric_quadrupole_zero']) – The operator for which to calculate the matrix element.
q (int) – The component of the operator.
unit (str | None) – 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.

Returns:

The matrix element for the given operator.

Return type:

PlainQuantity[float] | float

calc_reduced_matrix_element(other, operator, unit=None)

Overloads:

self, other (RydbergStateBase), operator (MatrixElementOperator), unit (None) → PintFloat
self, other (RydbergStateBase), operator (MatrixElementOperator), unit (str) → float

Parameters:

other (RydbergStateBase)
operator (Literal['magnetic_dipole', 'electric_dipole', 'electric_quadrupole', 'electric_octupole', 'electric_quadrupole_zero'])
unit (str | None)

Return type:

PlainQuantity[float] | float

Calculate the reduced matrix element.

Calculate the reduced matrix element between self and other (ignoring m quantum numbers)

\[\left\langle self || r^k_radial \hat{O}^{(k_{angular})} || other \right\rangle\]

where hat{O}^{(k_{angular})} is the operator of rank k_angular for which to calculate the matrix element. k_radial and k_angular are determined from the operator automatically.

Parameters:

other (RydbergStateBase) – The other Rydberg state for which to calculate the matrix element.
operator (Literal['magnetic_dipole', 'electric_dipole', 'electric_quadrupole', 'electric_octupole', 'electric_quadrupole_zero']) – The operator for which to calculate the matrix element.
unit (str | None) – 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.

Returns:

The reduced matrix element for the given operator.

Return type:

PlainQuantity[float] | float

calc_reduced_overlap(other)

Calculate the reduced overlap <self|other> (ignoring the magnetic quantum number m).

Return type:: float
Parameters:: other (RydbergStateBase)

calc_std_qn(qn)

Return type:: float
Parameters:: qn (str)

get_black_body_transition_rates(temperature, temperature_unit=None, unit=None)

Overloads:

self (Self), temperature (float | PintFloat), temperature_unit (str | None), unit (None) → tuple[list[Self], PintArray]
self (Self), temperature (PintFloat), unit (str) → tuple[list[Self], NDArray]
self (Self), temperature (float), temperature_unit (str), unit (str) → tuple[list[Self], NDArray]

Parameters:

self (Self)
temperature (float | PlainQuantity[float])
temperature_unit (str | None)
unit (str | None)

Return type:

tuple[list[Self], ndarray[tuple[Any, …], dtype[Any]] | PlainQuantity[ndarray[tuple[Any, …], dtype[Any]]]]

Calculate the black body transition rates of the Rydberg state.

The black body transition 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 (str | None) – The unit of the temperature. Default None will assume the temperature is given as pint.Quantity.
unit (str | None) – The unit to which to convert the result. Default None will return a pint.Quantity.
self (Self)

Returns:

The relevant states and the transition rates.

Return type:

tuple[list[Self], ndarray[tuple[Any, …], dtype[Any]] | PlainQuantity[ndarray[tuple[Any, …], dtype[Any]]]]

get_energy(unit=None)

Overloads:

self, unit (None) → PintFloat
self, unit (str) → float

Parameters:

unit (str | None)

Return type:

PlainQuantity[float] | float

Get the energy of the Rydberg state.

The energy is defined as

\[E = - \frac{1}{2} \frac{\mu}{\nu^2} + E_{ionization}\]

where mu = R_M/R_infty is the reduced mass and nu the effective principal quantum number, and E_{ionization} is the (reference) ionization energy of the species.

get_lifetime(temperature=None, temperature_unit=None, unit=None)

Overloads:

self, temperature (float | PintFloat | None), temperature_unit (str | None), unit (None) → PintFloat
self, unit (str) → float
self, temperature (PintFloat), unit (str) → float
self, temperature (float), temperature_unit (str), unit (str) → float

Parameters:

temperature (float | PlainQuantity[float] | None)
temperature_unit (str | None)
unit (str | None)

Return type:

float | PlainQuantity[float]

Calculate the lifetime of the Rydberg state.

The lifetime is the inverse of the sum of all transition rates.

Parameters:

temperature (Union[float, PlainQuantity[float], None]) – The temperature, for which to calculate the black body transition rates. Default None will not include black body transitions.
temperature_unit (str | None) – The unit of the temperature. Default None will assume the temperature is given as pint.Quantity.
unit (str | None) – The unit to which to convert the result. Default None will return a pint.Quantity.

Returns:

The lifetime of the state.

Return type:

float | PlainQuantity[float]

get_spontaneous_transition_rates(unit=None)

Overloads:

self (Self), unit (None) → tuple[list[Self], PintArray]
self (Self), unit (str) → tuple[list[Self], NDArray]

Parameters:

self (Self)
unit (str | None)

Return type:

tuple[list[Self], ndarray[tuple[Any, …], dtype[Any]] | PlainQuantity[ndarray[tuple[Any, …], dtype[Any]]]]

Calculate the spontaneous transition rates for the Rydberg state.

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

Parameters:

unit (str | None) – The unit to which to convert the result. Default None will return a pint.Quantity.
self (Self)

Returns:

The relevant states and the transition rates.

Return type:

tuple[list[Self], ndarray[tuple[Any, …], dtype[Any]] | PlainQuantity[ndarray[tuple[Any, …], dtype[Any]]]]

property norm: float: Return the norm of the state (should be 1).

property nui: list[float]: Return the effective principal quantum numbers nui of the different channels.

property nu: float

property radial: RadialKet: The radial part of the Rydberg electron.

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

property rydberg_kets: list[RydbergKet]

free_memory()[source]

Release the cached radial and angular data to reduce memory usage.

This drops the references to the (potentially large) radial wavefunctions of the rydberg kets. After calling this, matrix elements and overlaps can no longer be calculated for this state.

Return type:: None

get_radial_energy(unit=None)[source]

Overloads:

self, unit (None) → PintFloat
self, unit (str) → float

Parameters:

unit (str | None)

Return type:

PlainQuantity[float] | float

Get the energy of the radial part of the Rydberg state.

The radial part of the energy is given by

\[E = - \frac{1}{2} \frac{\mu}{\nu^2}\]

where mu = R_M/R_infty is the reduced mass and nu the effective principal quantum number.