RydbergStateMQDT

Class Methods

`__init__`(species, coefficients, ...)
`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_spontaneous_transition_rates`([unit])

Class Attributes and Properties

`norm`	Return the norm of the state (should be 1).
`nui`	Return the effective principal quantum numbers nui of the different channels.
`angular`	Return the angular part of the MQDT state as an AngularState.
`species`	The species of the Rydberg state.
`coefficients`	The channel coefficients of the different Rydberg ket channels that form the Rydberg state.
`rydberg_kets`	The Rydberg kets that form the Rydberg state.
`nu`	The effective principal quantum number nu.

class rydstate.rydberg_state.RydbergStateMQDT(species, coefficients, rydberg_kets, nu, energy_au, mqdt, potential_class)[source]

Parameters:

species (str)
coefficients (ndarray[tuple[Any, ...], dtype[Any]])
rydberg_kets (list[RydbergKet])
nu (float)
energy_au (float)
mqdt (MQDT)
potential_class (type[Potential])

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

coefficients: ndarray[tuple[Any, ...], dtype[Any]]: The channel coefficients of the different Rydberg ket channels that form the Rydberg state.

rydberg_kets: list[RydbergKet]: The Rydberg kets that form the Rydberg state.

nu: float: The effective principal quantum number nu. For SQDT states, this is also sometimes called n*. For MQDT nu is given in reference to the lowest ionization threshold.

angular: AngularState[AngularKetFJ[Any]]: Return the angular part of the MQDT state as an AngularState.

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)

free_memory()

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_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.