Term symbols

struct Term

Represents a term symbol with specific parity in LS-coupling.

Only the $L$, $S$ and parity values of the symbol ${}^{2S+1}L_{J}$ are specified. To specify a level, the $J$ value would have to be specified separately. The valid $J$ values corresponding to given $L$ and $S$ fall in the following range:

\[|L - S| \leq J \leq L+S\]

Constructors

Term(L::Real, S::Real, parity::Union{Parity,Integer})

Constructs a Term object with the given $L$ and $S$ quantum numbers and parity. L and S both have to be convertible to HalfIntegers and parity must be of type Parity or ±1.

See also: @T_str

Properties

To access the quantum number values, you can use the .L, .S and .parity properties to access the $L$, $S$ and parity values (represented with Parity), respectively. E.g.:

julia> t = Term(2, 1//2, p"odd")
²Dᵒ

julia> t.L, t.S, t.parity
(2, 1/2, odd)

@T_str -> Term

Constructs a Term object out of its canonical string representation.

julia> T"1S"
¹S

julia> T"4Po"
⁴Pᵒ

julia> T"⁴Pᵒ"
⁴Pᵒ

julia> T"2[3/2]o" # jK coupling, common in noble gases
²[3/2]ᵒ

parse(::Type{Term}, ::AbstractString) -> Term

Parses a string into a Term object.

julia> parse(Term, "4Po")
⁴Pᵒ

julia> parse(Term, "⁴Pᵒ")
⁴Pᵒ

See also: @T_str

terms(orb::Orbital, w::Int=one(Int))

Returns a list of valid LS term symbols for the orbital orb with w occupancy.

Examples

julia> terms(o"3d", 3)
8-element Vector{Term}:
 ²P
 ²D
 ²D
 ²F
 ²G
 ²H
 ⁴P
 ⁴F

terms(config)

Generate all final $LS$ terms for config.

Examples

julia> terms(c"1s")
1-element Vector{Term}:
 ²S

julia> terms(c"1s 2p")
2-element Vector{Term}:
 ¹Pᵒ
 ³Pᵒ

julia> terms(c"[Ne] 3d3")
7-element Vector{Term}:
 ²P
 ²D
 ²F
 ²G
 ²H
 ⁴P
 ⁴F

terms(o::RelativisticOrbital, w = 1) -> Vector{HalfInt}

Returns a sorted list of valid $J$ values of w equivalent $jj$-coupled particles on orbital o (i.e. oʷ).

When there are degeneracies (i.e. multiple states with the same $J$ and $M$ quantum numbers), the corresponding $J$ value is repeated in the output array.

Examples

julia> terms(ro"3d", 3)
3-element Vector{HalfIntegers.Half{Int64}}:
 3/2
 5/2
 9/2

julia> terms(ro"3d-", 3)
1-element Vector{HalfIntegers.Half{Int64}}:
 3/2

julia> terms(ro"4f", 4)
8-element Vector{HalfIntegers.Half{Int64}}:
 0
 2
 2
 4
 4
 5
 6
 8

count_terms(orbital, occupation, term)

Count how many times term occurs among the valid terms of orbital^occupation.

julia> count_terms(o"1s", 2, T"1S")
1

julia> count_terms(ro"6h", 4, 8)
4

multiplicity(t::Term)

Returns the spin multiplicity of the Term t, i.e. the number of possible values of $J$ for a given value of $L$ and $S$.

Examples

julia> multiplicity(T"¹S")
1

julia> multiplicity(T"²S")
2

julia> multiplicity(T"³P")
3

weight(t::Term)

Returns the statistical weight of the Term t, i.e. the number of possible microstates: $(2S+1)(2L+1)$.

Examples

julia> weight(T"¹S")
1

julia> weight(T"²S")
2

julia> weight(T"³P")
9

struct IntermediateTerm{T,S}

Represents a term together with its extra disambiguating quantum number(s), labelled by ν.

The term symbol (::T) can either be a Term (for $LS$-coupling) or a HalfInteger (for $jj$-coupling).

The disambiguating quantum number(s) (::S) can be anything as long as they are sortable (i.e. implementing isless). It is up to the user to pick a scheme that is suitable for their application. See "Disambiguating quantum numbers" in the manual for discussion on how it is used in AtomicLevels.

See also: Term, Seniority

Constructors

IntermediateTerm(term, ν)

Constructs an intermediate term with the term symbol term and disambiguating quantum number(s) ν.

Properties

To access the term symbol and the disambiguating quantum number(s), you can use the .term :: T and .ν :: S (or .nu :: S) properties, respectively. E.g.:

julia> it = IntermediateTerm(T"2D", 2)
₍₂₎²D

julia> it.term, it.ν
(²D, 2)

julia> it = IntermediateTerm(5//2, Seniority(2))
₂5/2

julia> it.term, it.nu
(5/2, ₂)

intermediate_terms(orb::Orbital, w::Int=one(Int))

Generates all IntermediateTerm for a given non-relativstic orbital orb and occupation w.

Examples

julia> intermediate_terms(o"2p", 2)
3-element Vector{IntermediateTerm{Term, Seniority}}:
 ₀¹S
 ₂¹D
 ₂³P

The preceding subscript is the seniority number, which indicates at which occupancy a certain term is first seen, cf.

julia> intermediate_terms(o"3d", 1)
1-element Vector{IntermediateTerm{Term, Seniority}}:
 ₁²D

julia> intermediate_terms(o"3d", 3)
8-element Vector{IntermediateTerm{Term, Seniority}}:
 ₁²D
 ₃²P
 ₃²D
 ₃²F
 ₃²G
 ₃²H
 ₃⁴P
 ₃⁴F

In the second case, we see both ₁²D and ₃²D, since there are two ways of coupling 3 d electrons to a ²D symmetry.

intermediate_terms(config)

Generate the intermediate terms for each subshell of config.

Examples

julia> intermediate_terms(c"1s 2p3")
2-element Vector{Vector{IntermediateTerm{Term, Seniority}}}:
 [₁²S]
 [₁²Pᵒ, ₃²Dᵒ, ₃⁴Sᵒ]

julia> intermediate_terms(rc"3d2 5g3")
2-element Vector{Vector{IntermediateTerm{HalfIntegers.Half{Int64}, Seniority}}}:
 [₀0, ₂2, ₂4]
 [₁9/2, ₃3/2, ₃5/2, ₃7/2, ₃9/2, ₃11/2, ₃13/2, ₃15/2, ₃17/2, ₃21/2]

Seniority(ν)

Seniority is an extra quantum number introduced by Giulio Racah (1943) to disambiguate between terms belonging to a subshell with a specific occupancy, that are assigned the same term symbols. For partially filled f-shells (in $LS$ coupling) or partially filled $9/2$ shells (in $jj$ coupling), seniority alone is not enough to disambiguate all the arising terms.

The seniority number is defined as the minimum occupancy number ν ∈ n:-2:0 for which the term first appears, e.g. the ²D term first occurs in the d¹ configuration, then twice in the d³ configuration (which will then have the terms ₁²D and ₃²D).

couple_terms(t1, t2)

Generate all possible coupling terms between t1 and t2. It is assumed that t1 and t2 originate from non-equivalent electrons (i.e. from different subshells), since the vector model does not predict correct term couplings for equivalent electrons; some of the generated terms would violate the Pauli principle; cf. Cowan p. 108–109.

Examples

julia> couple_terms(T"1Po", T"2Se")
1-element Vector{Term}:
 ²Pᵒ

julia> couple_terms(T"3Po", T"2Se")
2-element Vector{Term}:
 ²Pᵒ
 ⁴Pᵒ

julia> couple_terms(T"3Po", T"2De")
6-element Vector{Term}:
 ²Pᵒ
 ²Dᵒ
 ²Fᵒ
 ⁴Pᵒ
 ⁴Dᵒ
 ⁴Fᵒ

couple_terms(t1s, t2s)

Generate all coupling between all terms in t1s and all terms in t2s.

final_terms(ts::Vector{<:Vector{<:Union{Term,Real}}})

Generate all possible final terms from the vector of vectors of individual subshell terms by coupling from left to right.

Examples

julia> ts = [[T"1S", T"3S"], [T"2P", T"2D"]]
2-element Vector{Vector{Term}}:
 [¹S, ³S]
 [²P, ²D]

julia> AtomicLevels.final_terms(ts)
4-element Vector{Term}:
 ²P
 ²D
 ⁴P
 ⁴D

intermediate_couplings(its::Vector{IntermediateTerm,Integer,HalfInteger}, t₀ = T"1S")

Generate all intermediate coupling trees from the vector of intermediate terms its, starting from the initial term t₀.

Examples

julia> intermediate_couplings([IntermediateTerm(T"2S", 1), IntermediateTerm(T"2D", 1)])
2-element Vector{Vector{Term}}:
 [¹S, ²S, ¹D]
 [¹S, ²S, ³D]

intermediate_couplings(J::Vector{<:Real}, j₀ = 0)

Examples

julia> intermediate_couplings([1//2, 3//2])
2-element Vector{Vector{HalfIntegers.Half{Int64}}}:
 [0, 1/2, 1]
 [0, 1/2, 2]

Level(csf, J)

Given a CSF with a final Term, a Level additionally specifies a total angular momentum $J$. By further specifying a projection quantum number $M_J$, we get a State.

weight(l::Level)

Returns the statistical weight of the Level l, i.e. the number of possible microstates: $2J+1$.

Example

julia> l = Level(first(csfs(c"1s 2p")), 1)
|1s(₁²S|²S) 2p(₁²Pᵒ|¹Pᵒ)-, J = 1⟩

julia> weight(l)
3

J_range(term::Term)

List the permissible values of the total angular momentum $J$ for term.

Examples

julia> J_range(T"¹S")
0:0

julia> J_range(T"²S")
1/2:1/2

julia> J_range(T"³P")
0:2

julia> J_range(T"²D")
3/2:5/2

J_range(J)

The permissible range of the total angular momentum $J$ in $jj$ coupling is simply the value of $J$ for the final term.

levels(csf)

Generate all permissible Levels given csf.

Examples

julia> levels.(csfs(c"1s 2p"))
2-element Vector{Vector{Level{Orbital{Int64}, Term, Seniority}}}:
 [|1s(₁²S|²S) 2p(₁²Pᵒ|¹Pᵒ)-, J = 1⟩]
 [|1s(₁²S|²S) 2p(₁²Pᵒ|³Pᵒ)-, J = 0⟩, |1s(₁²S|²S) 2p(₁²Pᵒ|³Pᵒ)-, J = 1⟩, |1s(₁²S|²S) 2p(₁²Pᵒ|³Pᵒ)-, J = 2⟩]

julia> levels.(csfs(rc"1s 2p"))
2-element Vector{Vector{Level{RelativisticOrbital{Int64}, HalfIntegers.Half{Int64}, Seniority}}}:
 [|1s(₁1/2|1/2) 2p(₁3/2|1)-, J = 1⟩]
 [|1s(₁1/2|1/2) 2p(₁3/2|2)-, J = 2⟩]

julia> levels.(csfs(rc"1s 2p-"))
2-element Vector{Vector{Level{RelativisticOrbital{Int64}, HalfIntegers.Half{Int64}, Seniority}}}:
 [|1s(₁1/2|1/2) 2p-(₁1/2|0)-, J = 0⟩]
 [|1s(₁1/2|1/2) 2p-(₁1/2|1)-, J = 1⟩]

State(level, M_J)

A states defines, in addition to the total angular momentum $J$ of level, its projection $M_J\in -J..J$.

states(level)

Generate all permissible State given level.

Example

julia> l = Level(first(csfs(c"1s 2p")), 1)
|1s(₁²S|²S) 2p(₁²Pᵒ|¹Pᵒ)-, J = 1⟩

julia> states(l)
3-element Vector{State{Orbital{Int64}, Term, Seniority}}:
 |1s(₁²S|²S) 2p(₁²Pᵒ|¹Pᵒ)-, J = 1, M_J = -1⟩
 |1s(₁²S|²S) 2p(₁²Pᵒ|¹Pᵒ)-, J = 1, M_J = 0⟩
 |1s(₁²S|²S) 2p(₁²Pᵒ|¹Pᵒ)-, J = 1, M_J = 1⟩

states(csf)

Directly generate all permissible States for csf.

Example

julia> c = first(csfs(c"1s 2p"))
1s(₁²S|²S) 2p(₁²Pᵒ|¹Pᵒ)-

julia> states(c)
1-element Vector{Vector{State{Orbital{Int64}, Term, Seniority}}}:
 [|1s(₁²S|²S) 2p(₁²Pᵒ|¹Pᵒ)-, J = 1, M_J = -1⟩, |1s(₁²S|²S) 2p(₁²Pᵒ|¹Pᵒ)-, J = 1, M_J = 0⟩, |1s(₁²S|²S) 2p(₁²Pᵒ|¹Pᵒ)-, J = 1, M_J = 1⟩]