Racah algebra evaluations

JenaAtomicCalculator.RacahAlgebra.AbstractRecursionW3j — Type

abstract type RacahAlgebra.AbstractRecursionW3j ... defines an abstract and a number of singleton types for the recursion rules for Wigner 3-j symbols.

+ RecursionW3jMagnetic      ... Recursion wrt. the magnetic quantum numbers.
+ RecursionW3jOneStep       ... Recursion with step-1 of the j-quantum numbers.
+ RecursionW3jHalfStep      ... Recursion with step-1/2 of the j-quantum numbers.
+ RecursionW3jLouck         ... Recursion wrt. j-quantum numbers due to Louck.
source
JenaAtomicCalculator.RacahAlgebra.AngMomentum — Type

struct RacahAlgebra.AngMomentum ... defines an (abstract) data types for symbolic angular momenta which accept the types Basic, Symbol, Int64 and Rational{Int64} and check for being consistent with angular momenta.

source
JenaAtomicCalculator.RacahAlgebra.AngMomentum — Method

RacahAlgebra.AngMomentum(x::Rational{Int64}) ... converts a rational angular momentum to the symbolic Basic the algebra works in, ACCEPTING ONLY integer and half-integer values – a denominator other than 1 or 2 raises, since nothing else is an angular momentum. A value::Basic is returned. The companion methods take a Basic, an Int64 or a Symbol.

source
JenaAtomicCalculator.RacahAlgebra.AngMomentum — Method

RacahAlgebra.AngMomentum(x::Basic) ... passes a symbolic angular momentum through unchanged; a value::Basic is returned. The identity case of the family, so that a caller need not know whether its argument is already symbolic.

source
JenaAtomicCalculator.RacahAlgebra.AngMomentum — Method

RacahAlgebra.AngMomentum(x::Symbol) ... turns a Julia symbol such as :ja into the SymEngine symbol of the same name, so that an angular momentum may be left unspecified and carried through the algebra by name; a value::Basic is returned.

source
JenaAtomicCalculator.RacahAlgebra.Csq — Type

struct RacahAlgebra.Csq ... defines a type for a coupling sequence of two angular momenta (a,b) c or a + b -> c with symbolic arguments.

+ a    ::Union{Basic,RacahAlgebra.Csq}      ... First angular momentum or coupling sequence.
+ b    ::Union{Basic,RacahAlgebra.Csq}      ... Second angular momentum or coupling sequence.
+ c    ::Basic                              ... Angular momentum to which a + b is coupled.
source
JenaAtomicCalculator.RacahAlgebra.Djpq — Type

struct RacahAlgebra.Djpq ... defines a type for the (small and real !!) Wigner rotation matrix d^(j)_pq (beta) with symbolic arguments.

+ j, p, q              ::Basic   ... angular momenta
+ beta                 ::Basic   ... rotation angle
source
JenaAtomicCalculator.RacahAlgebra.Djpq — Method

RacahAlgebra.Djpq(j::AngMomentum, p::AngMomentum, q::AngMomentum, beta::Basic) ... constructor for defining the spherical harmonic Y_lm (theta,phi) either by Julia Symbol's or SymEngine Basic variables. A djpq::RacahAlgebra.Djpq is returned.

source
JenaAtomicCalculator.RacahAlgebra.Integral — Type

struct RacahAlgebra.Integral ... defines an (finite) integral, typically over some angle, Int_low^up d var with symbolic arguments.

+ var                  ::Basic   ... integration variable, typically an angle (theta, phi, beta, ...)
+ low, up              ::Basic   ... lower, upper integration bound
source
JenaAtomicCalculator.RacahAlgebra.Kronecker — Method

RacahAlgebra.Kronecker(i::AngMomentum, k::AngMomentum) ... constructor for defining a Kronecker delta symbol either by Julia Symbol's or SymEngine Basic variables. A kronecker::RacahAlgebra.Kronecker is returned.

source
JenaAtomicCalculator.RacahAlgebra.RacahExpression — Type

struct RacahAlgebra.RacahExpression ... defines a type for a RacahExpression with symbolic arguments.

+ summations    ::Array{Basic,1}      ... Summation indices.
+ integrals     ::Array{Integral,1}   ... Integrals.
+ phase         ::Basic               ... Phase of the Racah expression.
+ weight        ::Basic               ... Weight of the Racah expression.
+ deltas        ::Array{Kronecker,1}  ... List of Kronecker deltas.
+ triangles     ::Array{Triangle,1}   ... List of Triangle deltas.
+ w3js          ::Array{W3j,1}        ... List of Wigner 3-j symbols
+ w6js          ::Array{W6j,1}        ... List of Wigner 6-j symbols
+ w9js          ::Array{W9j,1}        ... List of Wigner 9-j symbols
+ ylms          ::Array{Ylm,1}        ... List of spherical harmonics
+ djpqs         ::Array{Djpq,1}       ... List of (small) Wigner rotation matrices
source
JenaAtomicCalculator.RacahAlgebra.RacahExpression — Method

RacahAlgebra.RacahExpression(rex::RacahAlgebra.RacahExpression; summations::Union{Nothing,Array{Basic,1}}=nothing, integrals::Union{Nothing,Array{Integral,1}}=nothing, phase::Union{Nothing,Basic}=nothing, weight::Union{Nothing,Basic}=nothing, deltas::Union{Nothing,Array{Kronecker,1}}=nothing, triangles::Union{Nothing,Array{Triangle,1}}=nothing, w3js::Union{Nothing,Array{W3j,1}}=nothing, w6js::Union{Nothing,Array{W6j,1}}=nothing, w9js::Union{Nothing,Array{W9j,1}}=nothing, ylms::Union{Nothing,Array{Ylm,1}}=nothing, djpqs::Union{Nothing,Array{Djpq,1}}=nothing)

... constructor for modifying a given rex::RacahExpression by 'overwriting' the explicitly selected parts of the 
    expression.
        A `racahExpression::RacahAlgebra.RacahExpression` is returned.
source
JenaAtomicCalculator.RacahAlgebra.Triangle — Method

RacahAlgebra.Triangle(ja::AngMomentum, jb::AngMomentum, jc::AngMomentum) ... constructor for defining a Triangle delta symbol either by Julia Symbol's or SymEngine Basic variables. A triangle::RacahAlgebra.Triangle is returned.

source
JenaAtomicCalculator.RacahAlgebra.W3j — Type

struct RacahAlgebra.W3j ... defines a type for a Wigner 3-j symbol with symbolic arguments.

+ ja, jb, jc     ::Basic   ... angular momenta
+ ma, mb, mc     ::Basic   ... projections of the angular momenta above
source
JenaAtomicCalculator.RacahAlgebra.W3j — Method

RacahAlgebra.W3j(ja::AngMomentum, jb::AngMomentum, jc::AngMomentum, ma::AngMomentum, mb::AngMomentum, mc::AngMomentum) ... constructor for defining the Wigner 3-j symbol either by Julia Symbol's or SymEngine Basic variables. A w3j::RacahAlgebra.W3j is returned.

source
JenaAtomicCalculator.RacahAlgebra.W6j — Method

RacahAlgebra.W6j(a::AngMomentum, b::AngMomentum, c::AngMomentum, d::AngMomentum, e::AngMomentum, f::AngMomentum) ... constructor for defining the Wigner 6-j symbol either by Julia Symbol's or SymEngine Basic variables. A w6j::RacahAlgebra.W6j is returned.

source
JenaAtomicCalculator.RacahAlgebra.W9j — Method

RacahAlgebra.W9j(a::AngMomentum, b::AngMomentum, c::AngMomentum, d::AngMomentum, e::AngMomentum, f::AngMomentum, g::AngMomentum, h::AngMomentum, i::AngMomentum) ... constructor for defining the Wigner 9j symbol either by Julia Symbol's or SymEngine Basic variables. A w9j::RacahAlgebra.W9j is returned.

source
JenaAtomicCalculator.RacahAlgebra.Ylm — Type

RacahAlgebra.Ylm(l::AngMomentum, m::AngMomentum, theta::Basic, phi::Basic, star::Bool=false) ... constructor for defining the spherical harmonic Y_lm (theta,phi) either by Julia Symbol's or SymEngine Basic variables. The variable star indicates a complex-conjugate function, and which case a Racah expression is returned.

+ (l::Basic, m::Basic, theta::Basic, phi::Basic, star::Bool)
source
JenaAtomicCalculator.RacahAlgebra.Ylm — Type

struct RacahAlgebra.Ylm ... defines a type for a spherical harmonic Y_lm (theta,phi) with symbolic arguments.

+ l, m                 ::Basic   ... angular momenta
+ theta, phi           ::Basic   ... polar and azimuthal angle
source
JenaAtomicCalculator.RacahAlgebra.Ylm — Method

RacahAlgebra.Ylm(wl::Basic, wm::Basic, theta::Basic, phi::Basic, star::Bool) ... returns the spherical harmonic Ylm(theta,phi), or its COMPLEX CONJUGATE if star = true. The conjugate is not formed by conjugating the function but by using Y*lm = (-1)^m Y_l,-m, so the result stays a RacahExpression the algebra can go on simplifying. A rex::RacahExpression is returned.

source
Base.:(==) — Method

Base.:(==)(da::Djpq, db::Djpq) ... compares two (symbolic) small Wigner rotation matrices d^(j)_pq (beta) and return true if all subfields are equal, and false otherwise. A value::Bool is returned.

source
Base.:(==) — Method

Base.:(==)(ntga::Integral, ntgb::Integral) ... compares two (symbolic) integrals and return true if all subfields are equal, and false otherwise. A value::Bool is returned.

source
Base.:(==) — Method

Base.:(==)(wa::Kronecker, wb::Kronecker) ... compares two (symbolic) Kronecker deltas and return true if all subfields are equal under permutation, and false otherwise. A value::Bool is returned.

source
Base.:(==) — Method

Base.:(==)(rexa::RacahExpression, rexb::RacahExpression) ... compares two (symbolic) Racah expressions and return true if all subfields are equal, and false otherwise. A value::Bool is returned.

source
Base.:(==) — Method

Base.:(==)(wa::Triangle, wb::Triangle) ... compares two (symbolic) Triangle deltas and return true if all subfields are equal under permutation, and false otherwise. A value::Bool is returned.

source
Base.:(==) — Method

Base.:(==)(wa::W3j, wb::W3j) ... compares two (symbolic) Wigner 3-j symbols and return true if all subfields are equal, and false otherwise. A value::Bool is returned.

source
Base.:(==) — Method

Base.:(==)(wa::W6j, wb::W6j) ... compares two (symbolic) Wigner 6j symbols and return true if all subfields are equal, and false otherwise. A value::Bool is returned.

source
Base.:(==) — Method

Base.:(==)(wa::W9j, wb::W9j) ... compares two (symbolic) Wigner 6j symbols and return true if all subfields are equal, and false otherwise. A value::Bool is returned.

source
Base.:(==) — Method

Base.:(==)(ya::Ylm, yb::Ylm) ... compares two (symbolic) spherical harmonics Y_lm (theta,phi) and return true if all subfields are equal, and false otherwise. A value::Bool is returned.

source
JenaAtomicCalculator.RacahAlgebra.ClebschGordan — Method

RacahAlgebra.ClebschGordan(ja::Basic, ma::Basic, jb::Basic, mb::Basic, jc::Basic, mc::Basic) ... returns the cg::RacahExpression for a standard Clebsch-Gordan coefficient either by Julia Symbol's or SymEngine Basic variables.

source
JenaAtomicCalculator.RacahAlgebra.ClebschGordanExpansion — Method

RacahAlgebra.ClebschGordanExpansion(ja::Basic, ma::Basic, jb::Basic, mb::Basic, jc::Basic, mc::Basic) ... returns the expansion rex::RacahExpression for a standard Clebsch-Gordan expansion |jc, mc > = Sum(ma, mb) |ja, ma > |jb, mb > <ja ma, jb mb| jc mc> either by Julia Symbol's or SymEngine Basic variables.

source
JenaAtomicCalculator.RacahAlgebra.DFunction — Method

RacahAlgebra.DFunction(j::Basic, p::Basic, q::Basic, alpha::Basic, beta::Basic, gamma::Basic) ... returns the rex::RacahExpression for a Wigner D-function D^(j)_pq (alpha, beta, gamma) by SymEngine Basic variables.

source
JenaAtomicCalculator.RacahAlgebra.equivalentForm — Method

RacahAlgebra.equivalentForm(rex::RacahAlgebra.RacahExpression; regge::Bool=false) ... generates an (random) equivalent form for the Racah expression rex by using either the classical (regge = false) or Regge symmetries (regge = true) for the Wigner 3j, 6j or 9j symbols. A rex:RacahExpression is returned.

source
JenaAtomicCalculator.RacahAlgebra.equivalentForm — Method

RacahAlgebra.equivalentForm(w3j::RacahAlgebra.W3j; regge::Bool=false) ... generates an (random) equivalent form for the Wigner 3j symbol w3j by using either the classical (regge = false) or Regge symmetries (regge = true). A rex:RacahExpression is returned.

source
JenaAtomicCalculator.RacahAlgebra.equivalentForm — Method

RacahAlgebra.equivalentForm(w6j::RacahAlgebra.W6j; regge::Bool=false) ... generates an (random) equivalent form for the Wigner 6j symbol w6j by using either the classical (regge = false) or Regge symmetries (regge = true). A rex:RacahExpression is returned.

source
JenaAtomicCalculator.RacahAlgebra.equivalentForm — Method

RacahAlgebra.equivalentForm(w9j::RacahAlgebra.W9j; regge::Bool=false) ... generates an (random) equivalent form for the Wigner 9-j symbol w9j by using either the classical (regge = false) or Regge symmetries (regge = true). A rex:RacahExpression is returned.

source
JenaAtomicCalculator.RacahAlgebra.evaluate — Method

RacahAlgebra.evaluate(djpq::Djpq) ... attempts to evaluate a symbolic (small) Wigner rotation matrix by means of special values. Either the special value, a rex::RacahExpression, or nothing where no special value is known, is returned.

source
JenaAtomicCalculator.RacahAlgebra.evaluate — Method

RacahAlgebra.evaluate(leftCsq::RacahAlgebra.Csq, rightCsq::RacahAlgebra.Csq) ... evaluates a general recoupling coefficient that is defined by two coupling sequences. It first translates the coupling sequences into Racah expressions, i.e. into sums of Wigner 3-j symbols. A non-zero coefficient is obtained only if leftCsq.c == rightCsq.c, since re-coupling coefficients are diagonal in the 'last' angular momentum. A newrex::RacahExpression is returned once a (single) simplification has been found, and nothing otherwise. No attempt is presently made to find further simplications, once a rule has been applied.

source
JenaAtomicCalculator.RacahAlgebra.evaluate — Method

RacahAlgebra.evaluate(rx::RacahExpression; special::Bool=false) ... attempts to evaluate and symbolically simplify a Racah expression by means of special values, if special=true, or by sum rules. A newrex::RacahExpression is returned once a (single) simplification has been found, and nothing otherwise. No attempt is presently made to find further simplication, once a rule has been applied.

source
JenaAtomicCalculator.RacahAlgebra.evaluate — Method

RacahAlgebra.evaluate(wj::Union{W3j,W6j,W9j}) ... attempts to evaluate a symbolic Wigner 3j, 6j or 9j symbols by means of special values. Either the special value, a rex::RacahExpression, or nothing where no special value is known, is returned.

source
JenaAtomicCalculator.RacahAlgebra.evaluate — Method

RacahAlgebra.evaluate(ylm::Ylm) ... attempts to evaluate a symbolic spherical harmonic by means of special values. Either the special value, a rex::RacahExpression, or nothing where no special value is known, is returned.

source
JenaAtomicCalculator.RacahAlgebra.evaluateNumerical — Method

RacahAlgebra.evaluateNumerical(rex::RacahExpression) ... attempts to evaluates a Racah expression numerically; it is supposed that the phase, weight and all angular momenta are given numerically. A newRex::RacahExpression is returned.

source
JenaAtomicCalculator.RacahAlgebra.hasNoVars — Method

RacahAlgebra.hasNoVars(indexList::Array{SymEngine.Basic,1}, djpqs::Array{RacahAlgebra.Djpq,1}) ... returns true if no (symbolic) index from indexList occurs in the array djpqs and false otherwise.

source
JenaAtomicCalculator.RacahAlgebra.hasNoVars — Method

RacahAlgebra.hasNoVars(indexList::Array{SymEngine.Basic,1}, integrals::Array{RacahAlgebra.Integral,1}) ... returns true if no (symbolic) index from indexList occurs in the array integrals and false otherwise.

source
JenaAtomicCalculator.RacahAlgebra.hasNoVars — Method

RacahAlgebra.hasNoVars(indexList::Array{SymEngine.Basic,1}, deltas::Array{RacahAlgebra.Kronecker,1}) ... returns true if no (symbolic) index from indexList occurs in the array deltas and false otherwise.

source
JenaAtomicCalculator.RacahAlgebra.hasNoVars — Method

RacahAlgebra.hasNoVars(indexList::Array{SymEngine.Basic,1}, triangles::Array{RacahAlgebra.Triangle,1}) ... returns true if no (symbolic) index from indexList occurs in the array triangles and false otherwise.

source
JenaAtomicCalculator.RacahAlgebra.hasNoVars — Method

RacahAlgebra.hasNoVars(indexList::Array{SymEngine.Basic,1}, w3js::Array{RacahAlgebra.W3j,1}) ... returns true if no (symbolic) index from indexList occurs in the array w3js and false otherwise.

source
JenaAtomicCalculator.RacahAlgebra.hasNoVars — Method

RacahAlgebra.hasNoVars(indexList::Array{SymEngine.Basic,1}, w6js::Array{RacahAlgebra.W6j,1}) ... returns true if no (symbolic) index from indexList occurs in the array w6js and false otherwise.

source
JenaAtomicCalculator.RacahAlgebra.hasNoVars — Method

RacahAlgebra.hasNoVars(indexList::Array{SymEngine.Basic,1}, w9js::Array{RacahAlgebra.W9j,1}) ... returns true if no (symbolic) index from indexList occurs in the array w3js and false otherwise.

source
JenaAtomicCalculator.RacahAlgebra.hasNoVars — Method

RacahAlgebra.hasNoVars(indexList::Array{SymEngine.Basic,1}, ylms::Array{RacahAlgebra.Ylm,1}) ... returns true if no (symbolic) index from indexList occurs in the array ylms and false otherwise.

source
JenaAtomicCalculator.RacahAlgebra.integralRulesForOneYlm — Method

RacahAlgebra.integralRulesForOneYlm(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for one Wigner 3j symbol. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

source
JenaAtomicCalculator.RacahAlgebra.removeIndex — Method

RacahAlgebra.removeIndex(indices::Array{SymEngine.Basic,1}, indexList::Array{SymEngine.Basic,1}) ... removes the indices from the given indexList; a newList::Array{SymEngine.Basic,1} is returned.

source
JenaAtomicCalculator.RacahAlgebra.rewriteCsq — Method

RacahAlgebra.rewriteCsq(csq::RacahAlgebra.Csq, ms::String) ... attempts to rewrite the coupling sequence csq as Racah expressions, i.e. as (sum of) products of Wigner 3-j symbols. A rex::RacahExpression is returned.

source
JenaAtomicCalculator.RacahAlgebra.rewritePhase — Method

RacahAlgebra.rewritePhase(rex::RacahExpression, zeroTerms::Array{SymEngine.Basic,1}; printout::Bool=false, from::String="Unspecified source") ... attempts to rewrite (and shorten) the phase by adding one or several 'zero' terms so that (i) no obsolete indices appear; (ii) the number of phase indices becomes smaller A modified Racah expression is returned if the re-writing was successful, and nothing is changed otherwise.

source
JenaAtomicCalculator.RacahAlgebra.rewritePhase — Method

RacahAlgebra.rewritePhase(phase::Basic, zeroTerms::Array{SymEngine.Basic,1}, woIndex::Array{SymEngine.Basic,1}; printout::Bool=false, from::String="Unspecified source") ... attempts to rewrite the phase by adding one or several 'zero' terms so that it appears without the indices in woIndex. An equivalent newPhase::Basic either 'without' or 'with' the indicated indices is returned.

source
JenaAtomicCalculator.RacahAlgebra.selectRacahExpression — Method

RacahAlgebra.selectRacahExpression(n::Int64) ... selects one of various pre-defined Racah expression as they often occur on the lhs of some sum rule; this function has been implemented mainly for test purposes. A rex::RacahExpression is returned. If n = 99, all pre-defined RacahExpression are printed to screen and nothing is returned in this case.

source
JenaAtomicCalculator.RacahAlgebra.selectRacahIntegral — Method

RacahAlgebra.selectRacahIntegral(n::Int64) ... selects one of various pre-defined Racah integrals as they often occur on the lhs of some sum/integration rule; this function has been implemented mainly for test purposes. A rex::RacahExpression is returned. If n = 99, all pre-defined RacahExpression are printed to screen and nothing is returned in this case.

source
JenaAtomicCalculator.RacahAlgebra.selectW3j — Method

RacahAlgebra.selectW3j(n::Int64) ... selects one of various pre-defined Wigner 3j symbols for which usually special values are known; this function has been implemented mainly for test purposes. A w3j::W3j is returned. If n = 99, all pre-defined Wigner 3j symbols are printed to screen and nothing is returned in this case.

source
JenaAtomicCalculator.RacahAlgebra.selectW6j — Method

RacahAlgebra.selectW6j(n::Int64) ... selects one of various pre-defined Wigner 6j symbols for which usually special values are known; this function has been implemented mainly for test purposes. A w6j::W6j is returned. If n = 99, all pre-defined Wigner 6j symbols are printed to screen and nothing is returned in this case.

source
JenaAtomicCalculator.RacahAlgebra.selectW9j — Method

RacahAlgebra.selectW9j(n::Int64) ... selects one of various pre-defined Wigner 9j symbols for which usually special values are known; this function has been implemented mainly for test purposes. A w9j::W9j is returned. If n = 99, all pre-defined Wigner 9j symbols are printed to screen and nothing is returned in this case.

source
JenaAtomicCalculator.RacahAlgebra.simplifyTriangles — Method

RacahAlgebra.simplifyTriangles(rex::RacahExpression) ... simplifies the all Tringle deltas in rex; these triangles can be removed if the same condition is places by one of the Wigner symbols in rex. A new nrex::RacahExpression is returned.

source
JenaAtomicCalculator.RacahAlgebra.specialValue — Method

RacahAlgebra.specialValue(w3j::RacahAlgebra.W3j) ... attempts to find a special value for the Wigner 3j symbol w3j. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned, and where istrue determined of whether a special value is returned in rex. For istrue = false, rex has no meaning.

source
JenaAtomicCalculator.RacahAlgebra.specialValue — Method

RacahAlgebra.specialValue(w6j::RacahAlgebra.W6j) ... attempts to find a special value for the Wigner 6-j symbol w6j. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned, and where istrue determined of whether a special value is returned in rex. For istrue = false, rex has no meaning.

source
JenaAtomicCalculator.RacahAlgebra.specialValue — Method

RacahAlgebra.specialValue(w9j::RacahAlgebra.W9j) ... attempts to find a special value for the Wigner 9-j symbol w9j. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned, and where istrue determined of whether a special value is returned in rex. For istrue = false, rex has no meaning.

source
JenaAtomicCalculator.RacahAlgebra.subs — Method

RacahAlgebra.subs(delta::RacahAlgebra.Kronecker, wold::Basic, wnew::Basic) ... substitutes in triangle all occasions of wold by wnew; a newDelta::RacahAlgebra.Kronecker is returned.

source
JenaAtomicCalculator.RacahAlgebra.subs — Method

RacahAlgebra.subs(delta::RacahAlgebra.Kronecker, subList::Array{Pair{Symbol,Rational{Int64}},1}) ... substitutes in delta the symbols by the corresponding rational numbers in subList; a ww:Kronecker is returned.

source
JenaAtomicCalculator.RacahAlgebra.subs — Method

RacahAlgebra.subs(rex::RacahAlgebra.RacahExpression, subList::Array{Pair{Symbol,Rational{Int64}},1}) ... substitutes in rex the symbols by the corresponding rational numbers in subList; a ww:RacahExpression is returned.

source
JenaAtomicCalculator.RacahAlgebra.subs — Method

RacahAlgebra.subs(triangle::RacahAlgebra.Triangle, subList::Array{Pair{Symbol,Rational{Int64}},1}) ... substitutes in triangle the symbols by the corresponding rational numbers in subList; a ww:Triangle is returned.

source
JenaAtomicCalculator.RacahAlgebra.subs — Method

RacahAlgebra.subs(djpqs::Array{RacahAlgebra.Djpq,1}, wold::Basic, wnew::Basic) ... substitutes in djpqs all occasions of wold by wnew; a newYlms::Array{RacahAlgebra.Djpq,1} is returned.

source
JenaAtomicCalculator.RacahAlgebra.subs — Method

RacahAlgebra.subs(integrals::Array{RacahAlgebra.Integral,1}, wold::Basic, wnew::Basic) ... substitutes in integrals all occasions of wold by wnew; a newIntegrals::Array{RacahAlgebra.Integral,1} is returned.

source
JenaAtomicCalculator.RacahAlgebra.subs — Method

RacahAlgebra.subs(deltas::Array{RacahAlgebra.Kronecker,1}, wold::Basic, wnew::Basic) ... substitutes in triangle all occasions of wold by wnew; a newDeltass::Array{RacahAlgebra.Kronecker,1} is returned.

source
JenaAtomicCalculator.RacahAlgebra.subs — Method

RacahAlgebra.subs(triangles::Array{RacahAlgebra.Triangle,1}, wold::Basic, wnew::Basic) ... substitutes in triangle all occasions of wold by wnew; a newTriangles::Array{RacahAlgebra.Triangle,1} is returned.

source
JenaAtomicCalculator.RacahAlgebra.subs — Method

RacahAlgebra.subs(w3js::Array{RacahAlgebra.W3j,1}, wold::Basic, wnew::Basic) ... substitutes in w3js all occasions of wold by wnew; a newW3js::Array{RacahAlgebra.W3j,1} is returned.

source
JenaAtomicCalculator.RacahAlgebra.subs — Method

RacahAlgebra.subs(w6js::Array{RacahAlgebra.W6j,1}, wold::Basic, wnew::Basic) ... substitutes in w6js all occasions of wold by wnew; a newW6js::Array{RacahAlgebra.W6j,1} is returned.

source
JenaAtomicCalculator.RacahAlgebra.subs — Method

RacahAlgebra.subs(w9js::Array{RacahAlgebra.W9j,1}, wold::Basic, wnew::Basic) ... substitutes in w9js all occasions of wold by wnew; a newW9js::Array{RacahAlgebra.W9j,1} is returned.

source
JenaAtomicCalculator.RacahAlgebra.subs — Method

RacahAlgebra.subs(ylms::Array{RacahAlgebra.Ylm,1}, wold::Basic, wnew::Basic) ... substitutes in ylms all occasions of wold by wnew; a newYlms::Array{RacahAlgebra.Ylm,1} is returned.

source
JenaAtomicCalculator.RacahAlgebra.subs — Method

RacahAlgebra.subs(w3j::RacahAlgebra.W3j, subList::Array{Pair{Symbol,Rational{Int64}},1}) ... substitutes in w3j the symbols by the corresponding rational numbers in subList; a ww:W3j is returned.

source
JenaAtomicCalculator.RacahAlgebra.subs — Method

RacahAlgebra.subs(w6j::RacahAlgebra.W6j, subList::Array{Pair{Symbol,Rational{Int64}},1}) ... substitutes in w6j the symbols by the corresponding rational numbers in subList; a ww:W6j is returned.

source
JenaAtomicCalculator.RacahAlgebra.sumRulesForFiveW3j — Method

RacahAlgebra.sumRulesForFiveW3j(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for five Wigner 3j symbols. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

source
JenaAtomicCalculator.RacahAlgebra.sumRulesForFourW3j — Method

RacahAlgebra.sumRulesForFourW3j(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for four Wigner 3j symbols. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

source
JenaAtomicCalculator.RacahAlgebra.sumRulesForFourW6j — Method

RacahAlgebra.sumRulesForFourW6j(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for four Wigner 6j symbols. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

source
JenaAtomicCalculator.RacahAlgebra.sumRulesForOneW3j — Method

RacahAlgebra.sumRulesForOneW3j(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for one Wigner 3j symbol. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

source
JenaAtomicCalculator.RacahAlgebra.sumRulesForOneW6j — Method

RacahAlgebra.sumRulesForOneW6j(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for one Wigner 6-j symbol. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

source
JenaAtomicCalculator.RacahAlgebra.sumRulesForOneW6jOneW9j — Method

RacahAlgebra.sumRulesForOneW6jOneW9j(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for one Wigner 6j and one 9j symbol. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

source
JenaAtomicCalculator.RacahAlgebra.sumRulesForOneW6jThreeW9j — Method

RacahAlgebra.sumRulesForOneW6jThreeW9j(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for four Wigner 3j symbols. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

source
JenaAtomicCalculator.RacahAlgebra.sumRulesForOneW6jTwoW9j — Method

RacahAlgebra.sumRulesForOneW6jTwoW9j(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for three Wigner 3j symbols. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

source
JenaAtomicCalculator.RacahAlgebra.sumRulesForOneW9j — Method

RacahAlgebra.sumRulesForOneW9j(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for one Wigner 9-j symbol. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

source
JenaAtomicCalculator.RacahAlgebra.sumRulesForSixW3j — Method

RacahAlgebra.sumRulesForSixW3j(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for six Wigner 3j symbols. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

source
JenaAtomicCalculator.RacahAlgebra.sumRulesForThreeW3j — Method

RacahAlgebra.sumRulesForThreeW3j(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for three Wigner 3j symbols. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

source
JenaAtomicCalculator.RacahAlgebra.sumRulesForThreeW6j — Method

RacahAlgebra.sumRulesForThreeW6j(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for three Wigner 3j symbols. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

source
JenaAtomicCalculator.RacahAlgebra.sumRulesForThreeW6jOneW9j — Method

RacahAlgebra.sumRulesForThreeW6jOneW9j(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for four Wigner 3j symbols. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

source
JenaAtomicCalculator.RacahAlgebra.sumRulesForThreeW9j — Method

RacahAlgebra.sumRulesForThreeW9j(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for three Wigner 3j symbols. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

source
JenaAtomicCalculator.RacahAlgebra.sumRulesForTwoW3j — Method

RacahAlgebra.sumRulesForTwoW3j(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for one Wigner 3j symbol. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

source
JenaAtomicCalculator.RacahAlgebra.sumRulesForTwoW3jOneW6j — Method

RacahAlgebra.sumRulesForTwoW3jOneW6j(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for three Wigner 3j symbols. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

source
JenaAtomicCalculator.RacahAlgebra.sumRulesForTwoW6j — Method

RacahAlgebra.sumRulesForTwoW6j(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for one Wigner 6-j symbol. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

                                                2
                                    ( X  Y  Z )
            Sum(X,Y,Z)  [X,Y,Z]  {(         )}    =    [a,b,c]
                                    ( a  b  c )
                
                
                            ( a  b  X )   ( c  d  X )        1
            Sum(X) [X]  {(         )} {(         )}  =   ---  d(p,q) d(a,d,p) d(b,c,p)
                            ( c  d  p )   ( a  b  q )       [p]
source
JenaAtomicCalculator.RacahAlgebra.sumRulesForTwoW6jOneW9j — Method

RacahAlgebra.sumRulesForTwoW6jOneW9j(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for three Wigner 3j symbols. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

source
JenaAtomicCalculator.RacahAlgebra.sumRulesForTwoW6jTwoW9j — Method

RacahAlgebra.sumRulesForTwoW6jTwoW9j(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for four Wigner 3j symbols. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

source
JenaAtomicCalculator.RacahAlgebra.sumRulesForTwoW9j — Method

RacahAlgebra.sumRulesForTwoW9j(rex::RacahAlgebra.RacahExpression) ... attempts to find a simplification of the given Racah expression by using sum rules for two Wigner 9j symbols. Once a simplification is found, no attempt is made to find another simplifcation for this set of rules. A (istrue, rex)::Tuple{Bool, RacahExpression} is returned but where rex has no meaning for !istrue.

source
JenaAtomicCalculator.RacahAlgebra.symmetricForms — Method

RacahAlgebra.symmetricForms(djpq::RacahAlgebra.Djpq) ... generates a list of equivalent symmetric forms of the small rotation matrix djpq. There are 12 basic symmetric forms for a rotation matix, including the given one. A rexList:Array{RacahExpression,1} is returned.

source
JenaAtomicCalculator.RacahAlgebra.symmetricForms — Method

RacahAlgebra.symmetricForms(w3j::RacahAlgebra.W3j; regge::Bool=false) ... generates a list of equivalent symmetric forms of the Wigner 3j symbol w3j. There are 12 basic symmetric forms for a 3j-symbol, including the given one, and 72 symmetries due to Regge, including the 12 classical ones. A rexList:Array{RacahExpression,1} is returned.

source
JenaAtomicCalculator.RacahAlgebra.symmetricForms — Method

RacahAlgebra.symmetricForms(w6j::RacahAlgebra.W6j; regge::Bool=false) ... generates a list of equivalent symmetric forms of the Wigner 6j symbol w6j. There are 24 basic symmetric forms for a 6j-symbol, including the given one, and 144 symmetries due to Regge, including the 24 classical ones. A rexList:Array{RacahExpression,1} is returned.

source
JenaAtomicCalculator.RacahAlgebra.symmetricForms — Method

RacahAlgebra.symmetricForms(w9j::RacahAlgebra.W9j; regge::Bool=false) ... generates a list of equivalent symmetric forms of the Wigner 9-j symbol w9j. There are 72 basic symmetric forms for a 9-j-symbol, including the given one. The keyword regge has no effect since no additional Regge symmetries are known for the Wigner 9-j symbols. A rexList:Array{RacahExpression,1} is returned.

source
JenaAtomicCalculator.RacahAlgebra.symmetricForms — Method

RacahAlgebra.symmetricForms(ylm::RacahAlgebra.Ylm) ... generates a list of equivalent symmetric forms of the spherical harmonic ylm. There are 8 basic symmetric forms for a spherical harmonic, including the given one. A rexList:Array{RacahExpression,1} is returned.

source
JenaAtomicCalculator.RacahAlgebra.testIntegralRules — Method

RacahAlgebra.testIntegralRules(; short::Bool=true) ... tests the implemented integral rules by just comparing comparing the number of integrals symbols; this does not include tests on the proper phase nor the algebraic factors of the Racah expression. The success::Bool of these tests is returned.

source
JenaAtomicCalculator.RacahAlgebra.testPrint — Method

RacahAlgebra.testPrint(sa::String, success::Bool) ... writes one line of a self-test report – the label sa padded to column 100, then [OK] or [Fail] – to the test stream. Nothing is returned. The twin of TestFrames.testPrint, kept here so that this module's self-tests do not depend on the test framework.

source
JenaAtomicCalculator.RacahAlgebra.testRecursions — Method

RacahAlgebra.testRecursions(; short::Bool=true) ... tests the implemented recursion by just comparing comparing the number of Wigner symbols; this does not include tests on the proper phase nor the algebraic factors of the Racah expression(s). The success::Bool of these tests is returned.

source
JenaAtomicCalculator.RacahAlgebra.testSpecialValuesDjpq — Method

RacahAlgebra.testSpecialValuesDjpq(; short::Bool=true) ... tests the implemented special values of the small Wigner matrices by just comparing the number of these matrices, which must be 0 in all cases. The success::Bool of these tests is returned.

source
JenaAtomicCalculator.RacahAlgebra.testSpecialValuesW3j — Method

RacahAlgebra.testSpecialValuesW3j(; short::Bool=true) ... tests the implemented special values of the Wigner 3j symbols by just comparing comparing the number of Wigner symbols, which must be 0 in all cases. The success::Bool of these tests is returned.

source
JenaAtomicCalculator.RacahAlgebra.testSpecialValuesW6j — Method

RacahAlgebra.testSpecialValuesW6j(; short::Bool=true) ... tests the implemented special values of the Wigner 6j symbols by just comparing comparing the number of Wigner symbols, which must be 0 in all cases. The success::Bool of these tests is returned.

source
JenaAtomicCalculator.RacahAlgebra.testSpecialValuesW9j — Method

RacahAlgebra.testSpecialValuesW9j(; short::Bool=true) ... tests the implemented special values of the Wigner 9j symbols by just comparing comparing the number of Wigner symbols, which must be 0 in all cases. The success::Bool of these tests is returned.

source
JenaAtomicCalculator.RacahAlgebra.testSpecialValuesYlm — Method

RacahAlgebra.testSpecialValuesYlm(; short::Bool=true) ... tests the implemented special values of the spherical harmonics by just comparing the number of spherical harmonics, which must be 0 in all cases. The success::Bool of these tests is returned.

source
JenaAtomicCalculator.RacahAlgebra.testSumRules — Method

RacahAlgebra.testSumRules(; short::Bool=true) ... tests the implemented sum rules by just comparing comparing the number of Wigner symbols; this does not include tests on the proper phase nor the algebraic factors of the Racah expression. The success::Bool of these tests is returned.

source
JenaAtomicCalculator.RacahAlgebra.zeroPhases — Method

RacahAlgebra.zeroPhases(rex::RacahAlgebra.RacahExpression) ... determines a number of phase terms that do not modify the overall phase of the given Racah expression but may allow to elimate certain variables as required for sum-rule evaluation; a phaseList::Basic[] is returned.

source

Angular momentum

JenaAtomicCalculator.AngularMomentum.AbstractWignerMethod — Type

abstract type AngularMomentum.AbstractWignerMethod ... defines an abstract type to distinguish HOW the Wigner symbols are evaluated. The value of a symbol is the same either way to about one part in 1e16; what differs is the arithmetic used to reach it, and with it the cost.

+ ExactWigner       ... evaluates in exact rational arithmetic (Rational{BigInt}) and rounds only at the end.
+ FloatingWigner    ... evaluates in Float64 throughout; this is the DEFAULT.
+ GslWigner         ... evaluates with the GNU Scientific Library, which also has a DIRECT nine-j.
source
JenaAtomicCalculator.AngularMomentum.ExactWigner — Type

struct AngularMomentum.ExactWigner <: AngularMomentum.AbstractWignerMethod ... evaluates the Wigner symbols in exact rational arithmetic, rounding only when the result is returned. This is what JAC did until 25-Aug-2026 and is no longer the default; it is kept for the rare case where a result must not be rounded before it is returned. It is the slowest of the three, by roughly a factor of seven on 6-j symbols.

source
JenaAtomicCalculator.AngularMomentum.FloatingWigner — Type

struct AngularMomentum.FloatingWigner <: AngularMomentum.AbstractWignerMethod ... evaluates the Wigner symbols in Float64 throughout. THIS IS THE DEFAULT. Measured against the exact path over 6-j symbols with all arguments up to j = 40, the two agree to a worst relative difference of 3e-16 – one unit in the last place – with no degradation at large angular momentum. On a mid-size cascade it is 4.16x faster with BIT-IDENTICAL results, and all 54 approved test references pass unmodified under it.

source
JenaAtomicCalculator.AngularMomentum.GslWigner — Type

struct AngularMomentum.GslWigner <: AngularMomentum.AbstractWignerMethod ... evaluates the Wigner symbols with the GNU Scientific Library, whose coupling routines are already a dependency of this module and were imported here without ever being called. It is the fastest of the three by a wide margin – measured at 11.8x the exact path and 6.0x the Float64 path on 6-j symbols, and it computes the NINE-j DIRECTLY rather than summing three 6-j per term, which is 10.6x the exact path there.

    Its accuracy sits between the two: 9.3e-16 against the exact result on 4987 non-zero 6-j symbols, where the
    Float64 path gives 2.2e-16. Both are far below anything physical, but the ordering is worth knowing.

    ONE BEHAVIOURAL DIFFERENCE, and it is not a rounding matter: for arguments that violate a triangle condition the
    GSL routines return zero where `WignerSymbols` THROWS. That makes this method more forgiving than the other two,
    so a caller that relies on the error to catch its own bad arguments loses that check.
source
JenaAtomicCalculator.AngularMomentum.CL_reduced_me — Method

AngularMomentum.CL_reduced_me(suba::Subshell, L::Int64, subb::Subshell) ... calculates the reduced matrix element of the C^L spherical tensor <suba || C^(L) || subb> in Grant's normalisation, sqrt((2ja+1)(2jb+1)); a value::Float64 is returned.

    THIS IS THE ONE DEFINITION (10-Aug-2026). It previously lacked the PARITY SELECTION RULE: the
    reduced matrix element of C^(L) vanishes unless l_a + l_b + L is even, and the 3-j symbol alone does
    NOT enforce that -- it only imposes the triangle and m-sum conditions. Without the rule the function
    returned nonzero values where the physical quantity must be zero, e.g. <2s||C^(1)||2s> = -0.816497.
    Where a different normalisation is wanted, divide EXPLICITLY at the call site: the convention that
    was carried by the former CL_reduced_me_rb is this quantity divided by sqrt(2j_a+1), with j_a taken
    from the FIRST argument as passed.
source
JenaAtomicCalculator.AngularMomentum.ChengI — Method

AngularMomentum.ChengI(kapa::Int64, ma::AngularM64, kapb::Int64, mb::AngularM64, L::AngularJ64, M::AngularM64) ... evaluates the angular I (kappa m, kappa' m', LM) integral as defined by Cheng, NATO summerschool (198x), Eq. (A4.5), and including the full magnetic (orientational) dependence. A value::Float64 is returned.

source
JenaAtomicCalculator.AngularMomentum.ChengI — Method

AngularMomentum.ChengI(kapa::Int64, kapb::Int64, L::AngularJ64) ... evaluates the same angular I (kappa m, kappa' m', LM) integral but without the magnetic (orientational) dependence. A value::Float64 is returned.

source
JenaAtomicCalculator.AngularMomentum.ClebschGordan — Method

AngularMomentum.ClebschGordan(ja, ma, jb, mb, Jab, Mab) ... calculates the Clebsch-Gordan coefficient <ja, ma, jb, mb; Jab, Mab> for given quantum numbers by a proper call to a Wigner 3-j symbol. A value::Float64 is returned.

    THIS IS THE ONE DEFINITION (14-Aug-2026). A second one, `ClebschGordan_old`, stood beside it and was
    called from EIGHTEEN places in four modules -- StrongField (12), StrongField-inc-hydrogenic (2),
    SpinAngular (3) and LandeZeeman (1). The two were the SAME FUNCTION written twice:
    both form  (-1)^(ja-jb+Mab) sqrt(2 Jab + 1) * Wigner_3j(ja, jb, Jab, ma, mb, -Mab), differing only in
    whether the phase is spelled out here or delegated to AngularMomentum.phaseFactor. Measured over
    35728 combinations with ja, jb <= 3 and Jab <= 6 across all m: the worst difference was EXACTLY zero,
    2348 of them non-vanishing, and both raised on precisely the same improper combinations. The twelve
    call sites were therefore migrated with NO phase factor and no other change.

    One difference did not survive, and it was the retired version's only advantage: phaseFactor RAISES
    on an improper combination (ja - jb + Mab not an integer), whereas the exponent is formed here as a
    Float64 and (-1)^x of a half-integer x raises a DomainError instead. Both stop; only the message
    differs.
source
JenaAtomicCalculator.AngularMomentum.Wigner_3j — Method

AngularMomentum.Wigner_3j(a, b, c, m_a, m_b, m_c) ... calculates the value of a Wigner 3-j symbol for given quantum numbers as displayed in many texts on the theory of angular momentum (see R. D. Cowan, The Theory of Atomic Structure and Spectra; University of California Press, 1981, p. 142). It evaluates the symbol by the method currently in force, AngularMomentum.getWignerMethod(). A value::Float64 is returned.

source
JenaAtomicCalculator.AngularMomentum.Wigner_3j — Method

AngularMomentum.Wigner_3j(method::AngularMomentum.ExactWigner, a, b, c, m_a, m_b, m_c) ... calculates the Wigner 3-j symbol in EXACT rational arithmetic, rounding only on return. A value::Float64 is returned.

source
JenaAtomicCalculator.AngularMomentum.Wigner_6j — Method

AngularMomentum.Wigner_6j(a, b, c, d, e, f) ... calculates the value of a Wigner 6-j symbol for given quantum numbers as displayed in many texts on the theory of angular momentum (see R. D. Cowan, The Theory of Atomic Structure and Spectra; University of California Press, 1981, p. 142). It evaluates the symbol by the method currently in force, AngularMomentum.getWignerMethod(). A value::Float64 is returned.

source
JenaAtomicCalculator.AngularMomentum.Wigner_6j — Method

AngularMomentum.Wigner_6j(method::AngularMomentum.ExactWigner, a, b, c, d, e, f) ... calculates the Wigner 6-j symbol in EXACT rational arithmetic, rounding only on return. A value::Float64 is returned.

source
JenaAtomicCalculator.AngularMomentum.Wigner_9j — Method

AngularMomentum.Wigner_9j(j11, j12, j13, j21, j22, j23, j31, j32, j33) ... calculates the value of a Wigner NINE-j symbol for given quantum numbers as displayed in many texts on the theory of angular momentum (see R. D. Cowan, The Theory of Atomic Structure and Spectra; University of California Press, 1981, p. 142). It is not a library call: the symbol is summed from THREE 6-j symbols per term, so a 9-j costs several 6-j and the choice of Wigner method matters here more than anywhere else. The method in force is read once and passed down. A value::Float64 is returned.

source
JenaAtomicCalculator.AngularMomentum.Wigner_9j — Method

AngularMomentum.Wigner_9j(method::AngularMomentum.AbstractWignerMethod, j11, j12, j13, j21, j22, j23, j31, j32, j33) ... as the previous method, but summing the 9-j from THREE 6-j symbols per term, which is what is needed when the method has no direct nine-j of its own. A value::Float64 is returned.

source
JenaAtomicCalculator.AngularMomentum.Wigner_9j — Method

AngularMomentum.Wigner_9j( method::GslWigner, j11, j12, j13, j21, j22, j23, j31, j32, j33 ) ... as the previous method, but with the Wigner method given explicitly, so that the three 6-j symbols of each term are evaluated without re-reading the global. A value::Float64 is returned.

source
JenaAtomicCalculator.AngularMomentum.Wigner_DFunction — Method

AngularMomentum.Wigner_DFunction(j, p, q, alpha::Float64, beta::Float64, gamma::Float64) ... calculates the value of a Wigner D^j_pq (alpha, beta, gamma) for given quantum numbers and (Euler) angles (alpha, beta, gamma). It makes use of the small Wigner d(beta) matrix as the key part. A value::ComplexF64 is returned; the D-function is complex whenever alpha or gamma is non-zero.

source
JenaAtomicCalculator.AngularMomentum.Wigner_dmatrix — Method

AngularMomentum.Wigner_dmatrix(jj, mmp, mm, beta::Float64) ... calculates the value of the small Wigner d^jm',m (beta) for given quantum numbers and the angle beta. Wigner's formula is applied; a value::Float64 is returned. The quantum numbers are accepted in any of the forms that Basics.twice understands – AngularJ64, AngularM64, Integer, Rational or Float64 – exactly as Wigner3j and Wigner_6j accept them.

    THE ARITHMETIC IS DONE IN DOUBLED INTEGERS. Since j, m' and m are all integer or all half-integer, the combinations j+-m', 
    j+-m, j+m-s, m'-m+s and j-m'-s are always whole numbers; they are formed here as integers, so that every factorial is exact 
    and the powers of cos(beta/2) and sin(beta/2) carry integer exponents -- a Float64 exponent on the negative base that 
    cos(beta/2) becomes for beta > pi has no real value, and the power would fail rather than turn negative.
source
JenaAtomicCalculator.AngularMomentum.allowedDoubleKappaCouplingSequence — Method

AngularMomentum.allowedDoubleKappaCouplingSequence(syma::LevelSymmetry, symb::LevelSymmetry, maxKappa::Int64) ... to determine all allowed coupling sequences that fulfill syma + (kappa1, symx, kappa2) –> symb == syma + kappa1 –> symx + kappa2 –> symb, and where kappa1|, |kappa2| <= maxKappa. A list::Array{Tuple{Int64,LevelSymmetry,Int64},1}) of (kappa1, symx, kappa2) is returned.

source
JenaAtomicCalculator.AngularMomentum.allowedDoubleKappaSymmetries — Method

AngularMomentum.allowedDoubleKappaSymmetries(syma::LevelSymmetry, kappa1::Int64, kappa2::Int64, symb::LevelSymmetry) ... to determine all allowed level symmetries symx that can be coupled to the sequence syma + kappa1 –> {symx} + kappa2 –> symb. A list::Array{LevelSymmetry,1} of symx is returned.

source
JenaAtomicCalculator.AngularMomentum.allowedDoubleKappas — Method

AngularMomentum.allowedDoubleKappas(syma::LevelSymmetry, symb::LevelSymmetry, maxKappa::Int64) ... to determine all allowed pairs of kappa that fulfill syma + (kappa1, kappa2) –> symb, and where |kappa1|, |kappa2| <= maxKappa. A list::Array{Tuple{Int64,Int64},1}) of (kappa1, kappa2) is returned.

source
JenaAtomicCalculator.AngularMomentum.allowedKappaSymmetries — Method

AngularMomentum.allowedKappaSymmetries(syma::LevelSymmetry, symb::LevelSymmetry) ... to determine all allowed single-electron symmetries/partial waves kappa (l,j) that can be coupled to the given level symmetries. A list::Array{Int64,1} of kappa-values is returned.

source
JenaAtomicCalculator.AngularMomentum.allowedTotalSymmetries — Method

AngularMomentum.allowedTotalSymmetries(symf::LevelSymmetry, mp2::EmMultipole, mp1::EmMultipole, symi::LevelSymmetry) ... to determine all allowed total symmetries J^P that can be constructed by coupling a multipole wave mp1 to the initial symmetry symi, and which can be further coupled with mp2 to the final symmetry symf. A list::Array{LevelSymmetry,1} of total symmetries is returned.

source
JenaAtomicCalculator.AngularMomentum.allowedTotalSymmetries — Method

AngularMomentum.allowedTotalSymmetries(syma::LevelSymmetry, kappa::Int64) ... to determine all allowed total symmetries J^P that can be constructed by coupling a partial wave kappa (l,j) to the given level symmetry syma. A list::Array{LevelSymmetry,1} of total symmetries is returned.

source
JenaAtomicCalculator.AngularMomentum.isTriangle — Method

AngularMomentum.isTriangle(ja::AngularJ64, jb::AngularJ64, jc::AngularJ64) ... evaluates to true if Delta(ja,jb,jc) = 1, ie. if the angular momenta ja, jb and jc can couple to each other, and false otherwise. A value::Bool is returned.

source
JenaAtomicCalculator.AngularMomentum.isTriangle — Method

AngularMomentum.isTriangle(ja::Int64, jb::Int64, jc::Int64) ... evaluates to true if Delta(ja,jb,jc) = 1, ie. if the three integer (length) ja, jb and jc can form a triangle, and false otherwise. A value::Bool is returned.

source
JenaAtomicCalculator.AngularMomentum.parityEmMultipolePi — Method

AngularMomentum.parityEmMultipolePi(pa::Parity, multipole::EmMultipole, pb::Parity) ... evaluates to true if the given multipole fullfills the parity selection rule pi(a, multipole, b) = 1, and false otherwise. This includes a proper test for both, electric and magnetic multipoles, based on multipole.electric. A value::Bool is returned.

source
JenaAtomicCalculator.AngularMomentum.phaseFactor — Method

AngularMomentum.phaseFactor(list::Array{Any,1}) ... checks and calculates the phase factor (-1)^(ja + mb -jc ...) that occur frequently in angular momentum theory; a value +1. or -1. is returned. Use phaseFactor([ja::Union{AngularJ64,AngularM64), -1, mb::Union{AngularJ64,AngularM64), ..., 1, jc::Union{AngularJ64,AngularM64)]) to specify the phase.

source
JenaAtomicCalculator.AngularMomentum.setWignerMethod — Method

AngularMomentum.setWignerMethod(method::AngularMomentum.AbstractWignerMethod) ... to select how the Wigner symbols are evaluated from here on; the previous method::AbstractWignerMethod is returned, so that a caller can restore it.

source
JenaAtomicCalculator.AngularMomentum.sigma_TtL_reduced_me — Method

AngularMomentum.sigma_TtL_reduced_me(kapa::Int64, L::Int64, t::Int64, kapb::Int64) ... calculates the reduced matrix element of the vector spherical harmonic tensor <kapa || sigma . T^(tL) || kapb>, following the RATIP convention (Grant's formalism); a value::Float64 is returned. L must equal t-1, t or t+1.

source
JenaAtomicCalculator.AngularMomentum.sigma_reduced_me — Method

AngularMomentum.sigma_reduced_me(suba::Subshell, subb::Subshell) ... calculates the reduced matrix element of the sigma^(1) spherical tensor <suba || sigma^(1) || subb>; a value::Float64 is returned.

    NOT IMPLEMENTED, and it now says so instead of returning zero (08-Aug-2026). Until then the body was a
    commented-out formula followed by `redme = 0.`, so the routine returned 0.0 for EVERY pair of subshells
    that passed the parity rule -- a plausible number, silently, from a core module. It has no callers today,
    which is the only reason it never did harm; a documented routine that answers every question with zero is
    a trap left lying in the path of whoever calls it first.

    THE COMMENTED-OUT FORMULA CANNOT SIMPLY BE RE-ENABLED: it references a rank `L` that is never defined in
    this method and appears in no argument, so it never ran in this form. Deciding what `L` was meant to be
    is a physics question, not a repair.

    WORKING SIBLINGS EXIST for the closely related magnetic-quantum-number-resolved elements,
    `sigma_reduced_me_ma` and `sigma_reduced_me_mb`, which ARE implemented and are used by
    `RadialIntegrals`; they are the place to look when this one is completed.
source
JenaAtomicCalculator.AngularMomentum.sigma_reduced_me_ma — Method

AngularMomentum.sigma_reduced_me_ma(mkapa::Int64, kapb::Int64) ... computes the reduced matrix element <-kappaa || sigma^(1) || kappab> of the Pauli spin operator, i.e. with the sign of the FIRST kappa reversed (hence the ma in the name; sigma_reduced_me_mb reverses the second). The element vanishes unless 2ja - 1 = lb, and is otherwise a 6-j symbol times sqrt(6 (2ja+1)(2jb+1)). A redme::Float64 is returned, zero where the selection rule fails.

source
JenaAtomicCalculator.AngularMomentum.sigma_reduced_me_mb — Method

AngularMomentum.sigma_reduced_me_mb(kapa::Int64, mkapb::Int64) ... computes the reduced matrix element <kappaa || sigma^(1) || -kappab> of the Pauli spin operator, i.e. with the sign of the SECOND kappa reversed; the companion of sigma_reduced_me_ma, which reverses the first. A redme::Float64 is returned, zero where the selection rule fails.

source
JenaAtomicCalculator.AngularMomentum.sphericalYlm — Method

AngularMomentum.sphericalYlm(l::Int64, m::Int64, theta::Float64, phi::Float64) ... calculates the spherical harmonics for low l-values explicitly. A value::Complex{Float64} is returned. Ylm = sqrt( (2l+1) / (twotwo*pi) ) * spherical_Clm(l,m,theta,phi).

source
JenaAtomicCalculator.AngularMomentum.triangularDelta — Method

AngularMomentum.triangularDelta(ja::AngularJ64, jb::AngularJ64, jc::AngularJ64) ... calculates the tringular Delta(ja,jb,jc). The result is 0 if the triangular condition failes and 1 otherwise. A value::Int64, either 0 or 1, is returned.

source
JenaAtomicCalculator.AngularMomentum.triangularDelta — Method

AngularMomentum.triangularDelta(ia2::Int64, ib2::Int64, ic2::Int64) ... calculates the tringular Delta(ja,jb,jc). The arguments in this integer function are i2a = 2*ja+1, ... The result is 0 if the triangular condition failes and 1 otherwise. A value::Int64, either 0 or 1, is returned.

source
JenaAtomicCalculator.AngularMomentum.wigner6jValue — Method

AngularMomentum.wigner6jValue(method::AngularMomentum.ExactWigner, a::Float64, b::Float64, c::Float64, d::Float64, e::Float64, f::Float64) ... evaluates one 6-j symbol from arguments that are ALREADY the angular momenta themselves (not their doubled values), in exact rational arithmetic. It exists so that AngularMomentum.Wigner_9j, which builds each 9-j from three 6-j symbols per term, can pass the method down instead of re-reading the global for every one of them. A value::Float64 is returned.

source
JenaAtomicCalculator.AngularMomentum.wigner6jValue — Method

AngularMomentum.wigner6jValue(method::AngularMomentum.FloatingWigner, a::Float64, b::Float64, c::Float64, d::Float64, e::Float64, f::Float64) ... as the previous method, but evaluating in Float64 arithmetic throughout. A value::Float64 is returned.

source
JenaAtomicCalculator.AngularMomentum.wigner6jValue — Method

AngularMomentum.wigner6jValue(method::AngularMomentum.GslWigner, a::Float64, b::Float64, c::Float64, d::Float64, e::Float64, f::Float64) ... as the other methods of this name, but evaluating with the GNU Scientific Library, which takes the DOUBLED angular momenta as integers. A value::Float64 is returned.

source

LS-jj transformation of atomic levels

JenaAtomicCalculator.LSjj.BasisNR — Type

struct LSjj.BasisNR ... defines a type for a nonrelativistic atomic basis, including the (full) specification of the configuration space but without radial orbitals.

+ NoElectrons    ::Int64              ... No. of electrons.
+ shells         ::Array{Shell,1}     ... Explicitly given shell list for this basis.
+ csfs           ::Array{CsfNR,1}     ... List of nonrelativistic LS-coupled CSF.
source
JenaAtomicCalculator.LSjj.CsfNR — Type

struct CsfNR ... defines a type for a nonrelativistic configuration state function (CSF) in terms of its orbitals (sequence of orbitals), their occupation as well as the angular momenta, seniority and the coupling of the corresponding antisymmetric subshell states.

+ J                ::AngularJ64           ... Total angular momentum J.
+ parity           ::Parity               ... Total parity.
+ occupation       ::Array{Int64,1}       ... Occupation of the orbitals with regard to the specified shell list.
+ w                ::Array{Int64,1}       ... List of w quantum numbers of the antisymmetric subshell states.
+ QQ               ::Array{Int64,1}       ... List of total quasispin 2*Q, likely = seniority values of the 
                                                antisymmetric subshell states.
+ shellL           ::Array{AngularJ64,1}  ... List of L-values of the antisymmetric subshell states.
+ shellS           ::Array{AngularJ64,1}  ... List of S-values of the antisymmetric subshell states.
+ shellLX          ::Array{AngularJ64,1}  ... intermediate L-values in the coupling of the antisymmetric shell states.
+ shellSX          ::Array{AngularJ64,1}  ... intermediate S-values in the coupling of the antisymmetric shell states.
source
JenaAtomicCalculator.LSjj.GeneralOpenShells — Type

struct LSjj.GeneralOpenShells <: AbstractOpenShell ... marks a CSF with an arbitrary (>= 2) number of open shells, to be expanded via the general recursive jj-to-LSJ recoupling formula (Gaigalas, Atoms 14, 20 (2026), Eq. 17). Carries the open-shell count purely for documentation/display; the dispatch itself does not depend on its value.

+ nOpenShells  ::Int64   ... number of open (non-relativistic) shells in the CSF (>= 2).
source
JenaAtomicCalculator.LSjj.LS_jj_me — Type

struct LS_jj_me ... defines a struct for the generalized quantum numbers (qn) of a LS_jj matrix element.

+ qn          ::LS_jj_qn    ... list of quantum numbers of this LS_jj matrix element
+ factor      ::Int64       ... integer factor
+ nom         ::Int64       ... nominator
+ denom       ::Int64       ... denominator
source
JenaAtomicCalculator.LSjj.LS_jj_qn — Type

struct LS_jj_qn ... defines a struct for the generalized quantum numbers (qn) of a LS_jj matrix element.

+ w           ::Int64    ... w quantum number
+ QQ          ::Int64    ... subshell total quasispin 2*Q
+ LL          ::Int64    ... subshell total angular momentum 2*L
+ SS          ::Int64    ... subshell total angular momentum 2*S
+ JJ          ::Int64    ... subshell total angular momentum 2*J
+ Nm          ::Int64    ... occupation Nm
+ Qm          ::Int64    ... subshell quantum number 2*Qm
+ Jm          ::Int64    ... subshell quantum number 2*Jm
+ Qp          ::Int64    ... subshell quantum number 2*Qp
+ Jp          ::Int64    ... subshell quantum number 2*Jp
source
JenaAtomicCalculator.LSjj.LevelNR — Type

struct LSjj.LevelNR ... defines a type for an atomic level in terms of its quantum number, energy and with regard to a nonrelativistic basis.

+ J            ::AngularJ64       ... Total angular momentum J.
+ parity       ::Parity           ... Parity of the level.
+ index        ::Int64            ... Index of this level in its original multiplet, or 0.
+ energy       ::Float64          ... energy
+ basis        ::BasisNR          ... nonrelativistic atomic basis
+ mc           ::Vector{Float64}  ... Vector of mixing coefficients w.r.t basis.
source
JenaAtomicCalculator.LSjj.MultipletNR — Type

struct LSjj.MultipletNR ... defines a type for an ordered list of atomic levelsin a nonrelativistic basis.

+ name       ::String	         ... A name associated to the multiplet.
+ levels     ::Array{LevelNR,1}  ... A list of levels (pointers).
source
JenaAtomicCalculator.LSjj.ShellStateNR — Type

struct LSjj.ShellStateNR ... defines a struct for the nonrelativistic antisymmetric shell states in the seniority scheme; this struct can be accessed only internally and, therefore, only the standard constructor is supported.

+ shell        ::Shell           ... to refer to a particular shell. 
+ occ          ::Int64           ... occupation of the shell
+ w            ::Int64           ... w quantum number of shell state
+ QQ           ::Int64           ... 2*Q of the shell state
+ LL           ::Int64           ... 2*L of the shell state
+ SS           ::Int64           ... 2*S of the shell state
source
Base.:(==) — Method

Base.:(==)(csfa::CsfNR, csfb::CsfNR) ... compares (recursively) two nonrelativistic CSFs and return true if all subfields are equal, and false otherwise. A value::Bool is returned.

source
Base.show — Method

Base.show(io::IO, basis::BasisNR) ... prepares a proper printout of the variable basis::BasisNR. nothing is returned.

source
Base.show — Method

Base.show(io::IO, csf::CsfNR) ... prepares a proper printout of the variable csf::CsfNR. nothing is returned.

source
JenaAtomicCalculator.LSjj.displayLSexpansion — Method

LSjj.displayLSexpansion(stream::IO, multiplet::Multiplet, multipletNR::MultipletNR, settings::ManyElectron.LSjjSettings) ... to display, for the selected levels, the leading LS components as PERCENTAGES in a neat table, together with the leading nonrelativistic configuration and its own percentage. This is the composition a spectroscopist reads: a level of an intermediate-coupling system has no good LSJ label, only a leading one, and the percentage says how far that label may be trusted. Terms below settings.printWeight (a fraction, 0.1 by default) are omitted, and the components of one level are listed in decreasing order, the first beside the level and the remainder on continuation lines. nothing is returned.

source
JenaAtomicCalculator.LSjj.expandCsfRintoNonrelativisticBasis — Method

LSjj.expandCsfRintoNonrelativisticBasis(openShells::GeneralOpenShells, csfR::CsfR, basisR::Basis, basisNR::BasisNR) ... to expand a relativistic CsfR with an ARBITRARY number (>= 2) of nonrelativistic open shells into the given nonrelativistic basis, using the general recursive jj-to-LSJ recoupling formula (Gaigalas, Atoms 14, 20 (2026), Eq. 17): starting from the first open shell's own (L1,S1,J1=Xp1) – no recoupling needed there, exactly as in OneOpenShell – every subsequent shell i=2,...,u is folded in via ONE 9-j symbol (Eq. 15, "diagram A": couples the accumulated (L,S,J) of shells 1..i-1 with shell i's own (Li,Si,Ti) into the new accumulated (L,S,J) of shells 1..i), ONE 6-j symbol (Eq. 16, "diagram B": converts shell i's own jj-split (Jbari,Jplusi) into its LSJ-coupled Xbari given the accumulated J's before/after this shell) and ONE single-shell LS-jj coefficient (LSjj.getLSjjCoefficient, Eq. 12) – i.e. exactly the SAME three-factor step, repeated once per additional shell, with no new per-shell-count formula. The accumulated total J after shells 1..i is NOT a free (summed-over) quantum number for 2 <= i < u: this particular CsfR already fixes it, recorded (via the sequential minus-then-plus bookkeeping convention) in shell i's own "plus"-subshell X field, exactly as shell 1's Xp1 fixes T1 – only the LAST shell's accumulated total is externally fixed to csfR.J. A shell with l == 0 has only its "plus" (j=1/2) subshell – there is no jbar/jplus split to reconcile, so diagram B is skipped for that shell and it folds in via diagram A alone (still with diagram A's own normalization prefactor). Implemented via a running Dict{AngularJ64,Float64} of partial coefficients keyed by the accumulated J, extended one shell at a time (a small, explicit dynamic-programming recursion, since only terms whose accumulated J after shell i matches the accumulated J required for shell i+1 can combine). Validated at u=2,3,4,5 via the physical, SCF/CI-mixing-weighted per-level normalization test (weight sums to exactly 1 for every level, example-Ag.jl branches b-e), catching and fixing two real bugs in the process – see module-LSjj.jl's own development history. A mcVector::Array{Float64,1} is returned with the same length as length(basisNR.csfs).

source
JenaAtomicCalculator.LSjj.expandCsfRintoNonrelativisticBasis — Method

LSjj.expandCsfRintoNonrelativisticBasis(openShells::OneOpenShell, csfR::CsfR, basisR::Basis, basisNR::BasisNR) ... to expand a relativistic CsfR with one nonrelativistic open shell into the given nonrelativistic basis; a mcVector::Array{Float64,1} is returned with the same lengths as length(basisNR.csfs). It is checked that the expansion is complete, and a warning is issued if this is not the case.

source
JenaAtomicCalculator.LSjj.expandCsfRintoNonrelativisticBasis — Method

LSjj.expandCsfRintoNonrelativisticBasis(openShells::ZeroOpenShell, csfR::CsfR, basisR::Basis, basisNR::BasisNR) ... to expand a relativistic CsfR without any nonrelativistic open shell into the given nonrelativistic basis; a mcVector::Array{Float64,1} is returned with the same lengths as length(basisNR.csfs). It is checked that the expansion is complete, and a warning is issued if this is not the case.

source
JenaAtomicCalculator.LSjj.expandLevelsIntoLS — Method

LSjj.expandLevelsIntoLS(multiplet::Multiplet, settings::ManyElectron.LSjjSettings) ... expand and print all (selected) levels from the multiplet into their LS representation, i.e. the composition table a spectroscopist reads. The whole transformation happens ONLY on request: settings.makeIt is false by default, and this function then returns at once, so nothing is computed and nothing is printed unless it is asked for.

    Of the further settings, settings.levelSelection chooses which levels are transformed (an inactive LevelSelection(), the
    default, takes all of them) and settings.printWeight is the FRACTION below which an LS component is left out of the table
    -- 0.1, i.e. 10 %, from the LSjjSettings(makeIt) constructor. settings.minWeight is NOT honoured: it belongs to the
    expansion rather than to its display, and no CSF is skipped today. nothing is returned.
source
JenaAtomicCalculator.LSjj.extractOpenShellQNfromCsfNR — Method

LSjj.extractOpenShellQNfromCsfNR(csfNR::CsfNR, basisNR::BasisNR) ... extracts the quantum numbers of the nonrelativistic open shells from the given csfNR. Here, we assume that csfNR is defined in the given basis. An nrQN::Dict{Shell,NTuple{8,Int64}} = Dict(shell => qn ) is returned with qn = (idx, N, w, QQ, LL, SS, LLx, SSx) which contains all the shell quantum numbers and their coupling in csfNR.

source
JenaAtomicCalculator.LSjj.generateNonrelativisticCsfList — Method

LSjj.generateNonrelativisticCsfList(confList::Array{Configuration,1}, shellList::Array{Shell,1}) ... to construct from a given list of configuration all possible (nonrelativistic) CSF with regard to the given shellList; a unique list::Array{CsfNR,1} is returned.

source
JenaAtomicCalculator.LSjj.getLSjjCoefficient — Method

LSjj.getLSjjCoefficient(l::Int64, N::Int64, qn::LS_jj_qn) ... to return the value of the LS-jj transformation matrix element for a given set of quantum numbers. Note that all (generalized) angular momentum quantum numbers except of l must be given twice the original numbers, i.e. for the quantum numbers Q, L, S, J, Qm, Jm, Qp, Jp. A value::Float64 is returned.

source
JenaAtomicCalculator.LSjj.openShellString — Method

LSjj.openShellString(conf::String) ... reduces a nonrelativistic configuration string such as "1s^2 2s^2 2p^6 3s^2 3p^6 3d^10 4s^2 4p^6 4d^10 4f^9" to its OPEN shells alone, here "4f^9". The closed shells carry no LS structure and are the same for every level of a multiplet, so printing them costs the width that the open shells need – and truncating the full string instead would hide precisely the shell that determines the term. If every shell is closed, the string "closed shells" is returned. A string::String is returned.

source
JenaAtomicCalculator.LSjj.provideShellStates — Method

LSjj.provideShellStates(sh::Shell, occ::Int64) ... to provide all antisymmetric ShellStates within the nonrelativistic quasi-spin scheme for the given shell and occupation; these shell states are listed by Gaigalas et al., CPC 135 (2002) 219. An Array{ShellStateNR,1} is returned.

source
JenaAtomicCalculator.LSjj.shellStateString — Method

LSjj.shellStateString(shell::String, occ::Int64, w::Int64, Q::AngularJ64, L::AngularJ64, S::AngularJ64, LX::AngularJ64, SX::AngularJ64) ... to provide a string of a given shell state in the form !!To be worked out !! '[2p1/2^occ](seniorityNr, J_sub), X=Xo' ... . A sa::String is returned.

source
JenaAtomicCalculator.LSjj.shortString — Method

LSjj.shortString(csfNR::CsfNR, basisNR::BasisNR) ... to compose a single-line string of the nonrelativistic csfNR, if this is part of basisNR. Only the OPEN shells are printed explicitly, each as [nl^occ ^(2S+1)L] followed by the term accumulated up to and including that shell, and the total term ^(2S+1)L_J closes the string. The accumulated terms are what distinguishes two CSFs that carry the same total term, which is the common case: they cannot be told apart from the total alone. An sa::String is returned.

source

Spin angular coefficients

JenaAtomicCalculator.SpinAngular.AbstractOneElectronKind — Type

abstract type SpinAngular.AbstractOneElectronKind ... defines an abstract type to distinguish WHICH one-electron matrix element a spin-angular coefficient is to be multiplied by. The distinction is a property of the operator rank and cannot be normalized away, so it is carried in the type of the coefficient rather than left to a comment.

+ OrdinaryKind    ... the coefficient multiplies the ordinary matrix element <a| o |b>       (rank 0).
+ ReducedKind     ... the coefficient multiplies the reduced matrix element <a|| o^(k) ||b>  (rank > 0).
source
JenaAtomicCalculator.SpinAngular.AbstractTwoElectronKind — Type

abstract type SpinAngular.AbstractTwoElectronKind ... defines an abstract type to distinguish WHICH two-electron radial quantity a two-particle coefficient is to be multiplied by. This is not a hypothetical hazard: JAC and GRASP2018 decompose the electron-electron interaction onto DIFFERENT quantities, so their coefficients are not comparable term by term, and a coefficient carried from one into the other is wrong by the reduced C^L factors rather than obviously broken.

+ EffectiveStrengthKind   ... multiplies the effective strength X^L(abcd). This is JAC's convention and the GENERAL
                              one: the SAME coefficient serves the Coulomb, Breit and Gaunt operators, because the
                              tensorial structure that distinguishes them lives in X^L rather than in the
                              coefficient. `module-Hamiltonian.jl:282-292` uses one `coeff.V` with both
                              `XL_Coulomb` and `XL_Breit`, which is the whole argument for the design.
+ GraspCoulombKind        ... multiplies the plain Slater integral R^k(abcd). This is GRASP's COULOMB convention and
                              ONLY that -- it does not generalise. GRASP's Breit path uses a different callback
                              (BREID), carries a sixth label ITYPE in 1..6, and multiplies one of SIX integral
                              routines BRINT1..BRINT6 chosen by that tag, with the sign of the tag routing the
                              contribution. There is no single "plain radial integral" for Breit, so this kind
                              exists ONLY to express a comparison with the GRASP Coulomb oracle, and is not a way
                              anyone should compute anything.
source
JenaAtomicCalculator.SpinAngular.Coefficient1p — Type

struct SpinAngular.Coefficient1p{K<:AbstractOneElectronKind} ... a struct for a single spin-angular coefficient of a one-particle matrix element. The type parameter K records which one-electron matrix element the coefficient is to be multiplied by, so that the wrong pairing has no method rather than a wrong value.

+ nu       ::Int64      ... Rank (k) of the one-particle operator.
+ a        ::Subshell   ... Left-hand subshell (orbital).
+ b        ::Subshell   ... Right-hand subshell (orbital).
+ T        ::Float64    ... (Value of) the spin-angular coefficient, in GRASP convention.
source
JenaAtomicCalculator.SpinAngular.Coefficient2p — Type

struct SpinAngular.Coefficient2p{K<:AbstractTwoElectronKind} ... a struct for a single spin-angular coefficient of a two-particle matrix element. As for the one-particle case the type parameter records which radial quantity the coefficient belongs to, so that mixing the two conventions has no method rather than a plausible value.

+ nu       ::Int64      ... Rank (k) of the two-particle interaction strength.
+ a        ::Subshell   ... First left-hand subshell.
+ b        ::Subshell   ... Second left-hand subshell.
+ c        ::Subshell   ... First right-hand subshell.
+ d        ::Subshell   ... Second right-hand subshell.
+ V        ::Float64    ... (Value of) the spin-angular coefficient.
source
JenaAtomicCalculator.SpinAngular.OneElectronMe — Type

struct SpinAngular.OneElectronMe{K<:AbstractOneElectronKind, F} ... a struct that tags a caller's one-electron matrix element with the kind it returns, so that it can only be combined with coefficients of the same kind. F is kept concrete so that the wrapped call inlines and costs nothing.

+ f        ::F          ... A callable (a::Subshell, b::Subshell) -> Float64.
source
JenaAtomicCalculator.SpinAngular.OneParticleOperator — Type

struct SpinAngular.OneParticleOperator ... a struct for defining a (reduced) one-particle operator of given rank and parity.

+ rank     ::Int64      ... Rank (k) of the one-particle operator.
+ parity   ::Parity     ... Parity of the operator, plus or minus.
source
JenaAtomicCalculator.SpinAngular.TwoParticleOperator — Type

struct SpinAngular.TwoParticleOperator ... a struct for defining a (scalar) two-particle operator, i.e. the electron-electron interaction.

+ rank     ::Int64      ... Rank of the two-particle operator; only 0 is defined.
+ parity   ::Parity     ... Parity of the operator, plus or minus.
source