Core Functions

noStoredParam(source) -> Bool

Detect if source has no reachable Quiqbox.ParamBox by reflection-type functions, getfieldand getindex. It returns true if uniqueParams(source) returns an empty collection. It is still possible for noStoredParam to return true if source is a generic function that indirectly references global variables being/storing Quiqbox.ParamBox.

sever(param::ParamBox, screenSource::Bool=false) -> ParamBox

Returns a copy of param with severable connection(s) eliminated. For param::SpanParam, sever returns a PrimitiveParam of which the output value is the same as param when called by obtain; for any param being nested ParamBox, it recursively severs every ParamBox inside param that is a SpanParam. screenSource determines whether the returned (or ints inside) ParamBox will be screened.

runHartreeFock(nucInfo::NuclearCluster{R, D}, basis::Union{AbstractVector{<:Quiqbox.OrbitalBasis{<:Union{Complex{T}, T}, D}}, Quiqbox.MultiOrbitalData{T, D, C, F, P} where {C<:Union{Complex{T}, T}, F<:(Quiqbox.StashedField{T, D, C, F} where {C<:Union{Complex{T}, T}, F<:(Quiqbox.ParamPipeFunc{F, R} where {F<:Quiqbox.AbstractParamFunc, R<:(Quiqbox.ParamCombiner{Quiqbox.TypedBinary{NTuple{D, T}, Base.Broadcast.BroadcastFunction{typeof(-)}, NTuple{D, T}, NTuple{D, T}}, Tuple{Quiqbox.InputConverter{Quiqbox.CartesianHeader{D, TypedReturn{NTuple{D, T}, typeof(itself)}}}, Quiqbox.ParamFormatter{M}}} where M<:(Quiqbox.ChainMapper{<:NTuple{D, Function}}))})}), P<:Union{GenericMemory{:not_atomic, Quiqbox.OrbCorePointer{D, C}, Core.AddrSpace{Core}(0x00)}, Tuple{Union{Quiqbox.CompOrbPointer{D, C}, Quiqbox.PrimOrbPointer{D, C}}, Union{Quiqbox.CompOrbPointer{D, C}, Quiqbox.PrimOrbPointer{D, C}}}, Tuple{Quiqbox.OrbCorePointer{D, C}, Quiqbox.OrbCorePointer{D, C}}, NTuple{4, Union{Quiqbox.CompOrbPointer{D, C}, Quiqbox.PrimOrbPointer{D, C}}}, NTuple{4, Quiqbox.OrbCorePointer{D, C}}, Memory{<:Union{Quiqbox.CompOrbPointer{D, C}, Quiqbox.PrimOrbPointer{D, C}}}}}} where {T<:Real, D}{R, D}, 
               config::MissingOr{HFconfig{R}}=missing; 
               printInfo::Bool=true, infoLevel::Int=2) where 
              {R<:Real, D} -> 
HFfinalInfo{R, D}

runHartreeFock(systemInfo::Pair{<:Union{Tuple{Int64, Int64}, Quiqbox.OccupationState{2}}, NuclearCluster{R, D}}, 
               basis::Union{AbstractVector{<:Quiqbox.OrbitalBasis{<:Union{Complex{T}, T}, D}}, Quiqbox.MultiOrbitalData{T, D, C, F, P} where {C<:Union{Complex{T}, T}, F<:(Quiqbox.StashedField{T, D, C, F} where {C<:Union{Complex{T}, T}, F<:(Quiqbox.ParamPipeFunc{F, R} where {F<:Quiqbox.AbstractParamFunc, R<:(Quiqbox.ParamCombiner{Quiqbox.TypedBinary{NTuple{D, T}, Base.Broadcast.BroadcastFunction{typeof(-)}, NTuple{D, T}, NTuple{D, T}}, Tuple{Quiqbox.InputConverter{Quiqbox.CartesianHeader{D, TypedReturn{NTuple{D, T}, typeof(itself)}}}, Quiqbox.ParamFormatter{M}}} where M<:(Quiqbox.ChainMapper{<:NTuple{D, Function}}))})}), P<:Union{GenericMemory{:not_atomic, Quiqbox.OrbCorePointer{D, C}, Core.AddrSpace{Core}(0x00)}, Tuple{Union{Quiqbox.CompOrbPointer{D, C}, Quiqbox.PrimOrbPointer{D, C}}, Union{Quiqbox.CompOrbPointer{D, C}, Quiqbox.PrimOrbPointer{D, C}}}, Tuple{Quiqbox.OrbCorePointer{D, C}, Quiqbox.OrbCorePointer{D, C}}, NTuple{4, Union{Quiqbox.CompOrbPointer{D, C}, Quiqbox.PrimOrbPointer{D, C}}}, NTuple{4, Quiqbox.OrbCorePointer{D, C}}, Memory{<:Union{Quiqbox.CompOrbPointer{D, C}, Quiqbox.PrimOrbPointer{D, C}}}}}} where {T<:Real, D}{R, D}, config::MissingOr{HFconfig{R}}=missing; 
               printInfo::Bool=true, infoLevel::Int=2) where 
              {R<:Real, D} -> 
HFfinalInfo{R, D}

Main function to run a Hartree–Fock method in Quiqbox. The returned result and relevant information is stored in a Quiqbox.HFfinalVars.

≡≡≡ Positional argument(s) ≡≡≡ nucInfo::NuclearCluster{R, D}: the nuclear geometry of the system. When nucInfo is the first argument the spin configuration is automatically set such that the target system is charge neutral and maximizing pairing electron spins.

systemInfoPair{<:Union{Tuple{Int64, Int64}, Quiqbox.OccupationState{2}}, NuclearCluster{R, D}}: A Pair information used to specify both the spin and nuclear-geometry configuration of the target system.

basis::Union{AbstractVector{<:Quiqbox.OrbitalBasis{<:Union{Complex{T}, T}, D}}, Quiqbox.MultiOrbitalData{T, D, C, F, P} where {C<:Union{Complex{T}, T}, F<:(Quiqbox.StashedField{T, D, C, F} where {C<:Union{Complex{T}, T}, F<:(Quiqbox.ParamPipeFunc{F, R} where {F<:Quiqbox.AbstractParamFunc, R<:(Quiqbox.ParamCombiner{Quiqbox.TypedBinary{NTuple{D, T}, Base.Broadcast.BroadcastFunction{typeof(-)}, NTuple{D, T}, NTuple{D, T}}, Tuple{Quiqbox.InputConverter{Quiqbox.CartesianHeader{D, TypedReturn{NTuple{D, T}, typeof(itself)}}}, Quiqbox.ParamFormatter{M}}} where M<:(Quiqbox.ChainMapper{<:NTuple{D, Function}}))})}), P<:Union{GenericMemory{:not_atomic, Quiqbox.OrbCorePointer{D, C}, Core.AddrSpace{Core}(0x00)}, Tuple{Union{Quiqbox.CompOrbPointer{D, C}, Quiqbox.PrimOrbPointer{D, C}}, Union{Quiqbox.CompOrbPointer{D, C}, Quiqbox.PrimOrbPointer{D, C}}}, Tuple{Quiqbox.OrbCorePointer{D, C}, Quiqbox.OrbCorePointer{D, C}}, NTuple{4, Union{Quiqbox.CompOrbPointer{D, C}, Quiqbox.PrimOrbPointer{D, C}}}, NTuple{4, Quiqbox.OrbCorePointer{D, C}}, Memory{<:Union{Quiqbox.CompOrbPointer{D, C}, Quiqbox.PrimOrbPointer{D, C}}}}}} where {T<:Real, D}{R, D}: The orbital basis-set configuration.

config::HFconfig: The Configuration of the Hartree–Fock method. For more information please refer to HFconfig.

≡≡≡ Keyword argument(s) ≡≡≡

printInfo::Bool: Whether print out the information of iteration steps and result.

infoLevel::Int: Printed info's level of details when printInfo=true. The higher (the absolute value of) infoLevel is, more intermediate steps will be printed. Once infoLevel achieve 5, every step will be printed.

getCharge(nuc::Union{Tuple{Vararg{Symbol}}, AbstractVector{Symbol}}) -> Int

Return the total electric charge (in 𝑒) of the input nucleus/nuclei.

changeOrbitalBasis(twoBodyInt::AbstractArray{T, 4}, 
             C1::AbstractMatrix{T}, C2::AbstractMatrix{T}) where {T} -> 
AbstractArray{T, 4}

Change the orbital basis of the input two-body integrals twoBodyInt based on two orbital coefficient matrices C1 and C2 for different spin configurations (e.g., the unrestricted case). The output is a 3-element Tuple of which the first 2 elements are the spatial integrals of each spin configurations respectively, while the last element is the Coulomb interactions between orbitals with different spins.

changeOrbitalBasis(DbodyInt::AbstractArray{T, D}, C::AbstractMatrix{T}) where {T} -> 
AbstractArray{T, D}

Change the orbital basis of the input one-body / two-body integrals DbodyInt based on the orbital coefficient matrix.