RydbergState

Class Methods

`__init__`(species, n, l[, j, 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`([run_backward, w0, ...])
`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_spontaneous_transition_rates`([unit, method])	Calculate the spontaneous transition rates for the Rydberg state.
`sanity_check`()

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`
`s`	The total spin quantum number.
`w_list`	The list of w values for the wavefunction.
`wavefunction`
`z_list`	The list of z values for the grid.

class ryd_numerov.RydbergState(species, n, l, j=None, m=None)[source]

Initialize the Rydberg state.

Parameters:

species (str) – Atomic species
n (int) – Principal quantum number
l (int) – Orbital angular momentum quantum number
j (Optional[float]) – Total angular momentum quantum number
m (Optional[float]) – Magnetic quantum number Optional, only needed for concrete angular matrix elements.

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

Return type:: None

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

create_element(*, use_nist_data=True)[source]

Create the element for the Rydberg state.

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

property s: float: The total spin quantum number.

property model: Model

create_model(potential_type=None)[source]

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

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

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

create_grid(x_min=None, x_max=None, dz=0.01)[source]

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

property wavefunction: Wavefunction

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

create_wavefunction(run_backward=True, w0=1e-10, _use_njit=True)[source]

Return type:

None

Parameters:

run_backward (bool)
w0 (float)
_use_njit (bool)

get_energy(unit=None)[source]

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

calc_radial_matrix_element(other, k_radial, unit=None)[source]

Return type:

Union[PlainQuantity[float], float]

Parameters:

other (Self)
k_radial (int)
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’,m’} and ket{other}= ket{n,l,j,m}.

\[\langle n,l,j,m,s | r^k_radial \hat{O}_{k_angular,q} | n',l',j',m',s' \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,m,s} 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.