SphericalHarmonicModes.jl

FullRange(l::Int)

The range -l:l for an l ≥ 0.

L1L2Triangle(l1_min::Int, l1_max::Int, Δl_max::Int, l2_min::Int = max(0, l1_min - Δl_max), l2_max = l1_max + Δl_max)
L1L2Triangle(l1_range::AbstractUnitRange{Int}, Δl_max::Int, l2_range::AbstractUnitRange{Int})

Return an iterator that loops over pairs of (l1,l2) where l1 lies in l1_range, l2 lies in l2_range, and l2 and l1 obey the triangle condition max(0, l1 - Δl_max) ⩽ l2 ⩽ l1 + Δl_max. If l2_range is not specified, it defaults to the maximal range permissible.

Examples

julia> L1L2Triangle(1:2, 2) |> collect
9-element Vector{Tuple{Int64, Int64}}:
 (1, 0)
 (1, 1)
 (1, 2)
 (1, 3)
 (2, 0)
 (2, 1)
 (2, 2)
 (2, 3)
 (2, 4)

julia> L1L2Triangle(2:3, 1) |> collect
6-element Vector{Tuple{Int64, Int64}}:
 (2, 1)
 (2, 2)
 (2, 3)
 (3, 2)
 (3, 3)
 (3, 4)

julia> L1L2Triangle(2:3, 1, 2:3) |> collect
4-element Vector{Tuple{Int64, Int64}}:
 (2, 2)
 (2, 3)
 (3, 2)
 (3, 3)

L2L1Triangle(l1_min::Int, l1_max::Int, Δl_max::Int, l2_min::Int = max(0, l1_min - Δl_max), l2_max = l1_max + Δl_max)
L2L1Triangle(l1_range::AbstractUnitRange{Int}, Δl_max::Int, l2_range::AbstractUnitRange{Int})

Return an iterator that loops over pairs of (l2,l1) where l1 lies in l1_range, l2 lies in l2_range, and l2 and l1 obey the triangle condition max(0, l1 - Δl_max) ⩽ l2 ⩽ l1 + Δl_max. If l2_range is not specified, it defaults to the maximal range permissible.

Examples

julia> L2L1Triangle(1:2, 2) |> collect
9-element Vector{Tuple{Int64, Int64}}:
 (0, 1)
 (1, 1)
 (2, 1)
 (3, 1)
 (0, 2)
 (1, 2)
 (2, 2)
 (3, 2)
 (4, 2)

julia> L2L1Triangle(2:3, 1) |> collect
6-element Vector{Tuple{Int64, Int64}}:
 (1, 2)
 (2, 2)
 (3, 2)
 (2, 3)
 (3, 3)
 (4, 3)

julia> L2L1Triangle(2:3, 1, 2:3) |> collect
4-element Vector{Tuple{Int64, Int64}}:
 (2, 2)
 (3, 2)
 (2, 3)
 (3, 3)

LM(l_range::Union{Integer, AbstractUnitRange{<:Integer}}, m_range::Union{Integer, AbstractUnitRange{<:Integer}})
LM(l_range::Union{Integer, AbstractUnitRange{<:Integer}}, [T = FullRange]) where T<:Union{FullRange, ZeroTo, ToZero}

Return an iterator that loops over pairs of spherical harmonic modes (l,m), with l increasing faster than m. The loop runs over all the valid modes that may be obtained from the ranges provided. If m_range is not specified, the loop runs over all valid values of m for each l. Neither l_range nor m_range may be empty.

Optionally m_range may be provided implicitly using the range specifiers FullRange, ZeroTo and ToZero, or as a SingleValuedRange type. Additionally, l_range may be of type ZeroTo or SingleValuedRange. Iterators constructed using these special types would often permit optimizations.

Examples

julia> LM(0:1) |> collect
4-element Vector{Tuple{Int64, Int64}}:
 (1, -1)
 (0, 0)
 (1, 0)
 (1, 1)

julia> LM(0:1, 1:1) |> collect
1-element Vector{Tuple{Int64, Int64}}:
 (1, 1)

julia> r = LM(ZeroTo(1), FullRange);

julia> r |> collect
4-element Vector{Tuple{Int64, Int64}}:
 (1, -1)
 (0, 0)
 (1, 0)
 (1, 1)

See also: ML

ML(l_range::Union{Integer, AbstractUnitRange{<:Integer}}, m_range::Union{Integer, AbstractUnitRange{<:Integer}})
ML(l_range::Union{Integer, AbstractUnitRange{<:Integer}}, [T = FullRange]) where T<:Union{FullRange, ZeroTo, ToZero}

Return an iterator that loops over pairs of spherical harmonic modes (l,m), with m increasing faster than l. The loop runs over all the valid modes that may be obtained from the ranges provided. If m_range is not specified, the loop runs over all valid values of m for each l. Neither l_range nor m_range may be empty.

Optionally m_range may be provided implicitly using the range specifiers FullRange, ZeroTo and ToZero, or as a SingleValuedRange type. Additionally l_range may be of type ZeroTo or SingleValuedRange. Iterators constructed using these special types would often permit optimizations.

Examples

julia> ML(0:1) |> collect
4-element Vector{Tuple{Int64, Int64}}:
 (0, 0)
 (1, -1)
 (1, 0)
 (1, 1)

julia> ML(0:1, 1:1) |> collect
1-element Vector{Tuple{Int64, Int64}}:
 (1, 1)

julia> r = ML(ZeroTo(1), FullRange);

julia> r |> collect
4-element Vector{Tuple{Int64, Int64}}:
 (0, 0)
 (1, -1)
 (1, 0)
 (1, 1)

See also: LM

SphericalHarmonicModes.ModeRange

Abstract type whose subtypes are iterators over combinations of spherical harmonic modes. This is the topmost node in the type hierarchy defined in this package.

Direct subtypes of ModeRange are SHModeRange and L2L1Triangle.

SphericalHarmonicModes.SHModeRange <: SphericalHarmonicModes.ModeRange

Abstract supertype of iterators that loop over (l,m) pairs. The types LM and ML are subtypes of this.

SingleValuedRange(n::Int)

The range n:n.

ToZero(l::Int)

The range -l:0 for an l ≥ 0.

ZeroTo(l::Int)

The range 0:l for an l ≥ 0.

SphericalHarmonicModes.flip(mr::SphericalHarmonicModes.SHModeRange)

Return an iterator that flips the order in which the modes (l,m) are iterated over. flip(::LM) will return an ML iterator and vice versa.

Examples

julia> LM(0:1) |> collect
4-element Vector{Tuple{Int64, Int64}}:
 (1, -1)
 (0, 0)
 (1, 0)
 (1, 1)

julia> SphericalHarmonicModes.flip(LM(0:1)) |> collect
4-element Vector{Tuple{Int64, Int64}}:
 (0, 0)
 (1, -1)
 (1, 0)
 (1, 1)

julia> SphericalHarmonicModes.flip(LM(0:1)) == ML(0:1)
true

l1_range(mr::L2L1Triangle)

Return the range of l1 spanned by the iterator.

l2_range(mr::L2L1Triangle, l1::Integer)

Return a subsection of the range of l2 spanned by the iterator for which (l1,l2) satisfy l1 - mr.Δl_max ⩽ l2 ⩽ l1 + mr.Δl_max.

Examples

julia> r = L2L1Triangle(1:2, 1);

julia> collect(r)
6-element Vector{Tuple{Int64, Int64}}:
 (0, 1)
 (1, 1)
 (2, 1)
 (1, 2)
 (2, 2)
 (3, 2)

julia> l2_range(r, 1)
0:2

julia> l2_range(r, 2)
1:3

l2_range(mr::L2L1Triangle)

Return the range of l2 spanned by the iterator.

l_range(mr::SphericalHarmonicModes.SHModeRange, m::Integer)

Return the subsection of the range of l spanned by the iterator for which (l,m) is a valid spherical harmonic mode.

Examples

julia> r = LM(1:2, 1:2);

julia> collect(r)
3-element Vector{Tuple{Int64, Int64}}:
 (1, 1)
 (2, 1)
 (2, 2)

julia> l_range(r, 1)
1:2

julia> l_range(r, 2)
2:2

l_range(mr::SphericalHarmonicModes.SHModeRange)

Return the range of l spanned by the iterator.

m_range(mr::SphericalHarmonicModes.SHModeRange, l::Integer)

Return the subsection of the range of m spanned by the iterator for which (l,m) is a valid spherical harmonic mode.

Examples

julia> r = LM(1:2, 1:2);

julia> collect(r)
3-element Vector{Tuple{Int64, Int64}}:
 (1, 1)
 (2, 1)
 (2, 2)

julia> m_range(r, 1)
1:1

julia> m_range(r, 2)
1:2

m_range(mr::SphericalHarmonicModes.SHModeRange)

Return the range of m spanned by the iterator.

modeindex(mr::SphericalHarmonicModes.ModeRange, mode::Tuple)

Return the index of mode in the iterator mr. Raise an error if mode is not present in mr.

Examples

julia> r = LM(1:2, 1:2);

julia> collect(r)
3-element Vector{Tuple{Int64, Int64}}:
 (1, 1)
 (2, 1)
 (2, 2)

julia> modeindex(r, (2,1))
2

julia> modeindex(r, (3,2))
ERROR: Mode with (l=3,m=2) is not included in the range given by LM(1:2, 1:2)

SphericalHarmonicModes.ofordering(S, m)

Convert m to the ordering of S.

Examples

julia> SphericalHarmonicModes.ofordering(LM(0:1), ML(0:1)) |> collect
4-element Vector{Tuple{Int64, Int64}}:
 (1, -1)
 (0, 0)
 (1, 0)
 (1, 1)

julia> SphericalHarmonicModes.ofordering(ML(0:1), ML(0:1)) |> collect
4-element Vector{Tuple{Int64, Int64}}:
 (0, 0)
 (1, -1)
 (1, 0)
 (1, 1)