AngularKetFJ

Class Methods

`__init__`([i_c, s_c, l_c, s_r, l_r, j_c, ...])
`calc_exp_qn`(qn)	Calculate the expectation value of a quantum number qn.
`calc_matrix_element`(other, operator, kappa, q)	Calculate the dimensionless angular matrix element.
`calc_reduced_matrix_element`(other, operator, ...)	Calculate the reduced angular matrix element.
`calc_reduced_overlap`(other)	Calculate the reduced overlap <self\|\|other> (ignoring the magnetic quantum number m).
`calc_std_qn`(qn)	Calculate the standard deviation of a quantum number qn.
`get_core_ket`()	Get the core ket corresponding to this FJ ket.
`get_qn`(qn, *[, allow_unknown])
`replace_m`(m)	Return a copy of this ket with the given magnetic quantum number m.
`sanity_check`([msgs])	Check that the quantum numbers are valid.
`to_state`([coupling_scheme])

Class Attributes and Properties

`j_c`	Total core electron angular quantum number (s_c + l_c).
`f_c`	Total core angular quantum number (j_c + i_c).
`j_r`	Total rydberg electron angular quantum number (s_r + l_r).
`contains_unknown`	Return True if any of the quantum numbers is Unknown.
`coupled_quantum_numbers`	Mapping of coupled quantum numbers to their constituent quantum numbers.
`coupling_scheme`	Name of the coupling scheme, e.g. 'LS', 'JJ', or 'FJ'.
`f_tot`	Total atom angular quantum number (including nuclear, core electron and rydberg electron contributions).
`i_c`	Nuclear spin quantum number.
`l_c`	Core electron orbital quantum number (usually 0).
`l_r`	Rydberg electron orbital quantum number.
`label`	Optional label for this ket, should only be used, if the ket has Unknown quantum numbers.
`m`	Magnetic quantum number, which is the projection of f_tot onto the quantization axis.
`parity`	Parity of the angular ket, which is given by (-1)^(l_c + l_r).
`quantum_number_names`	Names of all well defined spin quantum numbers (without the magnetic quantum number m) in this class.
`quantum_numbers`	The quantum numbers corresponding to the quantum_number_names (without the magnetic quantum number m).
`s_c`	Core electron spin quantum number (0 for alkali atoms, 0.5 for alkaline earth atoms).
`s_r`	Rydberg electron spin quantum number (always 0.5).

class rydstate.angular.AngularKetFJ(i_c=None, s_c=None, l_c=0, s_r=0.5, l_r=Unknown, j_c=None, f_c=None, j_r=None, f_tot=None, m=NotSet, *, parity=None, label=None, species=None, allow_unknown=False)[source]

Initialize the Spin ket.

Parameters:

args (object)
kwargs (object)

Return type:

CachedT

calc_exp_qn(qn)

Calculate the expectation value of a quantum number qn.

If the quantum number is a good quantum number simply return it, otherwise calculate it, see also AngularState.calc_exp_qn for more details.

Parameters:: qn (Literal['i_c', 's_c', 'l_c', 's_r', 'l_r', 's_tot', 'l_tot', 'j_c', 'j_r', 'j_tot', 'f_c', 'f_tot']) – The quantum number to calculate the expectation value for.
Return type:: Union[float, TypeVar(GenericT_Unknown, Never, Unknown)]

calc_matrix_element(other, operator, kappa, q)

Calculate the dimensionless angular matrix element.

Use the Wigner-Eckart theorem to calculate the angular matrix element from the reduced matrix element. We stick to the convention from Edmonds 1985 “Angular Momentum in Quantum Mechanics”, see equation (5.4.1). This means, calculate the following matrix element:

\[\left\langle self | \hat{O}^{(\kappa)}_q | other \right\rangle = <\alpha',f_{tot}',m'| \hat{O}^{(\kappa)}_q |\alpha,f_{tot},m> = (-1)^{(f_{tot} - m)} \cdot \mathrm{Wigner3j}(f_{tot}', \kappa, f_{tot}, -m', q, m) \cdot <\alpha',f_{tot}' || \hat{O}^{(\kappa)} || \alpha,f_{tot}>\]

where alpha denotes all other quantum numbers and \(<\alpha',f_{tot}' || \hat{O}^{(\kappa)} || \alpha,f_{tot}>\) is the reduced matrix element (see calc_reduced_matrix_element).

Parameters:

other (AngularKetBase[Any]) – The other AngularKet \(|other>\).
operator (Literal['spherical', 'i_c', 's_c', 'l_c', 's_r', 'l_r', 's_tot', 'l_tot', 'j_c', 'j_r', 'j_tot', 'f_c', 'f_tot', 'identity_i_c', 'identity_s_c', 'identity_l_c', 'identity_s_r', 'identity_l_r', 'identity_s_tot', 'identity_l_tot', 'identity_j_c', 'identity_j_r', 'identity_j_tot', 'identity_f_c', 'identity_f_tot']) – The operator type \(\hat{O}^{(\kappa)}_q\) for which to calculate the matrix element. E.g. ‘spherical’, ‘s_tot’, ‘l_r’, etc.
kappa (int) – The rank \(\kappa\) of the angular momentum operator.
q (int) – The component \(q\) of the angular momentum operator.

Return type:

float

Returns:

The dimensionless angular matrix element.

calc_reduced_matrix_element(other, operator, kappa)

Calculate the reduced angular matrix element.

We follow equation (7.1.7) from Edmonds 1985 “Angular Momentum in Quantum Mechanics”. This means, calculate the following matrix element:

\[\left\langle self || \hat{O}^{(\kappa)} || other \right\rangle\]

Return type:

float

Parameters:

other (AngularKetBase[Any])
operator (Literal['spherical', 'i_c', 's_c', 'l_c', 's_r', 'l_r', 's_tot', 'l_tot', 'j_c', 'j_r', 'j_tot', 'f_c', 'f_tot', 'identity_i_c', 'identity_s_c', 'identity_l_c', 'identity_s_r', 'identity_l_r', 'identity_s_tot', 'identity_l_tot', 'identity_j_c', 'identity_j_r', 'identity_j_tot', 'identity_f_c', 'identity_f_tot'])
kappa (int)

calc_reduced_overlap(other)

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

If both kets are of the same type (=same coupling scheme), this is just a delta function of all spin quantum numbers. If the kets are of different types, the overlap is calculated using the corresponding Clebsch-Gordan coefficients (/ Wigner-j symbols).

Return type:: float
Parameters:: other (AngularKetBase[Any])

calc_std_qn(qn)

Calculate the standard deviation of a quantum number qn.

If the quantum number is a good quantum number return 0, otherwise calculate the std, see also AngularState.calc_std_qn for more details.

Parameters:: qn (Literal['i_c', 's_c', 'l_c', 's_r', 'l_r', 's_tot', 'l_tot', 'j_c', 'j_r', 'j_tot', 'f_c', 'f_tot']) – The quantum number to calculate the standard deviation for.
Return type:: Union[float, TypeVar(GenericT_Unknown, Never, Unknown)]

property contains_unknown: bool: Return True if any of the quantum numbers is Unknown.

get_qn(qn, *, allow_unknown=None)

Overloads:

self, qn (AngularMomentumQuantumNumbers), allow_unknown (None) → float | GenericT_Unknown
self, qn (AngularMomentumQuantumNumbers), allow_unknown (Literal[False]) → float
self, qn (AngularMomentumQuantumNumbers), allow_unknown (bool) → float | Unknown

Parameters:

qn (Literal['i_c', 's_c', 'l_c', 's_r', 'l_r', 's_tot', 'l_tot', 'j_c', 'j_r', 'j_tot', 'f_c', 'f_tot'])
allow_unknown (bool | None)

Return type:

float | Unknown

Get the value of a quantum number by name.

i_c: float: Nuclear spin quantum number.

l_c: int | GenericT_Unknown: Core electron orbital quantum number (usually 0).

l_r: int | GenericT_Unknown: Rydberg electron orbital quantum number.

label: str | None: Optional label for this ket, should only be used, if the ket has Unknown quantum numbers.

m: float | NotSet: Magnetic quantum number, which is the projection of f_tot onto the quantization axis. If NotSet, only reduced matrix elements can be calculated.

parity: Literal[-1, 1]: Parity of the angular ket, which is given by (-1)^(l_c + l_r).

quantum_numbers: tuple[float, ...]: The quantum numbers corresponding to the quantum_number_names (without the magnetic quantum number m).

replace_m(m)

Return a copy of this ket with the given magnetic quantum number m.

Return type:: Self
Parameters:: m (float | NotSet)

s_c: float: Core electron spin quantum number (0 for alkali atoms, 0.5 for alkaline earth atoms).

s_r: float: Rydberg electron spin quantum number (always 0.5).

to_state(coupling_scheme=None)

Overloads:

self (Self), coupling_scheme (None) → AngularState[Self]
self (AngularKetBase[T_Unknown]), coupling_scheme (Literal[‘LS’]) → AngularState[AngularKetLS[T_Unknown]]
self (AngularKetBase[T_Unknown]), coupling_scheme (Literal[‘JJ’]) → AngularState[AngularKetJJ[T_Unknown]]
self (AngularKetBase[T_Unknown]), coupling_scheme (Literal[‘FJ’]) → AngularState[AngularKetFJ[T_Unknown]]

Parameters:

coupling_scheme (Literal['LS', 'JJ', 'FJ'] | None)

Return type:

AngularState[Any]

Convert to state in the specified coupling scheme.

Parameters:: coupling_scheme (Optional[Literal['LS', 'JJ', 'FJ']]) – The coupling scheme to convert to (e.g. “LS”, “JJ”, “FJ”). If None, the state will be a trivial state (one component) in the current coupling scheme.
Returns:: The angular state in the specified coupling scheme.
Return type:: AngularState[Any]

quantum_number_names: ClassVar = ('i_c', 's_c', 'l_c', 's_r', 'l_r', 'j_c', 'f_c', 'j_r', 'f_tot'): Names of all well defined spin quantum numbers (without the magnetic quantum number m) in this class.

coupled_quantum_numbers: ClassVar = {'f_c': ('i_c', 'j_c'), 'f_tot': ('f_c', 'j_r'), 'j_c': ('s_c', 'l_c'), 'j_r': ('s_r', 'l_r')}: Mapping of coupled quantum numbers to their constituent quantum numbers.

coupling_scheme: Literal['LS', 'JJ', 'FJ'] = 'FJ': Name of the coupling scheme, e.g. ‘LS’, ‘JJ’, or ‘FJ’.

j_c: float | GenericT_Unknown: Total core electron angular quantum number (s_c + l_c).

j_r: float | GenericT_Unknown: Total rydberg electron angular quantum number (s_r + l_r).

f_c: float | GenericT_Unknown: Total core angular quantum number (j_c + i_c).

f_tot: float: Total atom angular quantum number (including nuclear, core electron and rydberg electron contributions).

sanity_check(msgs=None)[source]

Check that the quantum numbers are valid.

Return type:: None
Parameters:: msgs (list[str] | None)

get_core_ket()[source]

Get the core ket corresponding to this FJ ket.

Return type:: CoreKet