Spin package

sdefaultlatex

The default LaTeX format for a spin oid.

Matrix(sid::SID{S}, dtype::Type{<:Number}=Complex{Float}) where S -> Matrix{dtype}

Get the matrix representation of a sid.

SCID{T<:Tuple{Vararg{Char}}, A<:Tuple} <: SimpleID

The id of the atoms and tags part of a spin coupling.

SID{S} <: IID

The spin id.

SID{S}(tag::Char; orbital::Int=1) where S

Create a spin id.

SIndex{S, P} <: Index{PID{P}, SID{S}}

The spin index.

SIndex(pid::PID, sid::SID) -> SIndex

Construct a spin index by a pid and an sid.

SOperator{V<:Number, I<:ID{OID{<:SIndex}}} <: Operator{V, I}

Spin operator.

Spin{S} <: Internal{SID{S}}

The spin interanl degrees of freedom.

Spin{S}(; atom::Int=1, norbital::Int=1) where S

Construct a spin degrees of freedom.

SpinCoupling{V, T<:Tuple, A<:Tuple, O<:Subscripts, I<:Tuple{SCID, SubID}} <: Coupling{V, I}

Spin coupling.

SpinCoupling(value::Number,
    tags::NTuple{N, Char};
    atoms::Union{NTuple{N, Int}, Nothing}=nothing,
    orbitals::Union{NTuple{N, Int}, Subscripts, Nothing}=nothing
    ) where N

Spin coupling.

SpinTerm{R}(id::Symbol, value::Any, bondkind::Any;
    couplings::Union{Function, Coupling, Couplings},
    amplitude::Union{Function, Nothing}=nothing,
    modulate::Union{Function, Bool}=false,
    ) where R

Spin term.

Type alias for Term{:SpinTerm, R, id, V, <:Any, <:TermCouplings, <:TermAmplitude, <:TermModulate}.

dm"x sl[a₁ a₂] ⊗ ob[o₁ o₂]" -> Couplings
dm"y sl[a₁ a₂] ⊗ ob[o₁ o₂]" -> Couplings
dm"z sl[a₁ a₂] ⊗ ob[o₁ o₂]" -> Couplings

The DM couplings.

gamma"x sl[a₁ a₂] ⊗ ob[o₁ o₂]" -> Couplings
gamma"y sl[a₁ a₂] ⊗ ob[o₁ o₂]" -> Couplings
gamma"z sl[a₁ a₂] ⊗ ob[o₁ o₂]" -> Couplings

The Gamma couplings.

heisenberg"sl[a₁ a₂] ⊗ ob[o₁ o₂]" -> Couplings
heisenberg"xyz sl[a₁ a₂] ⊗ ob[o₁ o₂]" -> Couplings
heisenberg"+-z sl[a₁ a₂] ⊗ ob[o₁ o₂]" -> Couplings

The Heisenberg couplings.

ising"x sl[a₁ a₂] ⊗ ob[o₁ o₂]" -> Couplings
ising"y sl[a₁ a₂] ⊗ ob[o₁ o₂])" -> Couplings
ising"z sl[a₁ a₂] ⊗ ob[o₁ o₂]" -> Couplings

The Ising couplings.

sc"..." -> SpinCoupling

Construct a SpinCoupling from a literal string.

sˣ"sl[a]⊗ob[o]" -> Couplings
sʸ"sl[a]⊗ob[o]" -> Couplings
sᶻ"sl[a]⊗ob[o]" -> Couplings

The single Sˣ/Sʸ/Sᶻ coupling.

*(sc₁::SpinCoupling, sc₂::SpinCoupling) -> SpinCoupling

Get the multiplication between two spin couplings.

repr(sc::SpinCoupling) -> String

Get the repr representation of a spin coupling.

show(io::IO, sc::SpinCoupling)

Show a spin coupling.

script(::Val{:site}, index::SIndex; kwargs...) -> Int
script(::Val{:orbital}, index::SIndex; kwargs...) -> Int
script(::Val{:tag}, index::SIndex; kwargs...) -> Char

Get the required script of a spin oid.

DM(tag::Char; atoms::Union{NTuple{2, Int}, Nothing}=nothing, orbitals::Union{Int, NTuple{2, Int}, Subscripts}=2) -> Couplings

The DM couplings.

Gamma(tag::Char; atoms::Union{NTuple{2, Int}, Nothing}=nothing, orbitals::Union{Int, NTuple{2, Int}, Subscripts}=2) -> Couplings

The Gamma couplings.

Heisenberg(mode::String="+-z"; atoms::Union{NTuple{2, Int}, Nothing}=nothing, orbitals::Union{Int, NTuple{2, Int}, Subscripts}=2) -> Couplings

The Heisenberg couplings.

Ising(tag::Char; atoms::Union{NTuple{2, Int}, Nothing}=nothing, orbitals::Union{Int, NTuple{2, Int}, Subscripts}=2) -> Couplings

The Ising couplings.

Sʸ(; atom::Union{Int, Nothing}=nothing, orbital::Union{Int, Nothing}=nothing) -> Couplings

The single Sʸ coupling.

Sˣ(; atom::Union{Int, Nothing}=nothing, orbital::Union{Int, Nothing}=nothing) -> Couplings

The single Sˣ coupling.

Sᶻ(; atom::Union{Int, Nothing}=nothing, orbital::Union{Int, Nothing}=nothing) -> Couplings

The single Sᶻ coupling.

usualspinindextotuple

Indicate that the choosed fields are (:scope, :site, :orbital) when converting a spin index to tuple.

otype(T::Type{<:Term}, C::Type{<:Config{<:Spin}}, B::Type{<:AbstractBond})

Get the operator type of a spin term.

expand(sc::SpinCoupling, points::NTuple{R, Point}, spins::NTuple{R, Spin}, ::Val) where R  -> Union{SCExpand, Tuple{}}

Expand a spin coupling with the given set of points and spin degrees of freedom.

permute(::Type{<:SOperator}, id₁::OID{<:SIndex}, id₂::OID{<:SIndex}) -> Tuple{Vararg{SOperator}}

Permute two fermionic oid and get the result.