RydbergStateMQDT

Class Methods

`__init__`(species, coefficients, ...)
`calc_exp_qn`(qn)
`calc_matrix_element`(other, operator, q[, unit])	Calculate the matrix element.
`calc_reduced_matrix_element`(other, operator)	Calculate the reduced matrix element.
`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)	Calculate the black body transition rates of the Rydberg state.
`get_energy`([unit])	Get the energy of the Rydberg state.
`get_lifetime`([temperature, ...])	Calculate the lifetime of the Rydberg state.
`get_spontaneous_transition_rates`([unit])	Calculate the spontaneous transition rates for the Rydberg state.

Class Attributes and Properties

`coefficients`	Return the channel coefficients as numpy array.
`mqdt`	Return the MQDT object used to calculate this state.
`n`	Return the corresponding principal quantum number n of the state.
`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.
`rydberg_kets`	The Rydberg kets that form the Rydberg state.
`nu`	The effective principal quantum number nu.
`f_tot`	The total angular momentum quantum number f_tot of the Rydberg state.

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

Parameters:

species (str)
coefficients (Sequence[float] | NDArray)
rydberg_kets (list[RydbergKet])
nu (float)
energy_au (float)
model (FModel)
potential_class (type[Potential])

species: str: The species of 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 reference ionization threshold of the MQDT model, see reference_ionization_threshold_au.

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

f_tot: float: The total angular momentum quantum number f_tot of the Rydberg state.

calc_exp_qn(qn)

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

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

Calculate the matrix element.

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 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)

Calculate the reduced matrix element.

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 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)

property coefficients: ndarray[tuple[Any, ...], dtype[Any]]: Return the channel coefficients as numpy array.

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)

Calculate the black body transition rates of the Rydberg state.

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]]]]

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)

Get the energy of the Rydberg state.

Overloads:

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

Parameters:

unit (str | None)

Return type:

PlainQuantity[float] | float

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 threshold of the species.

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

Calculate the lifetime of the Rydberg state.

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]

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)

Calculate the spontaneous transition rates for the Rydberg state.

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]]]]

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 mqdt: MQDT: Return the MQDT object used to calculate this state.

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 n: int

Return the corresponding principal quantum number n of the state.

We define the corresponding principal quantum number n for MQDT states via the nodes of the main contributing rydberg ket (nodes = n - l_r - 1). For FModelSQDT states, the quantum defect is zero, so the channel dependent effective quantum number nui is already an integer and we simply round it to the nearest integer.