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.

genGaussTypeOrb(center::NTuple{D, T}, xpns::AbstractVector{T}, cons::AbstractVector{C}, 
                ijk::NonEmptyTuple{Int, D}=ntuple(_->0, Val(D)); 
                innerRenormalize::Bool=false, outerRenormalize::Bool=false) where 
               {T<:Real, C<:Union{Complex{T}, T}, D} -> 
CompositeOrb{T, D, C}

Generate a D-dimensional contracted Gaussian-type orbital (GTO) with Cartesian angular momentum specified by ijk, as a linear combination of con-centric primitive GTOs located at center, with exponent coefficients specified by xpns and contraction coefficients specified by cons. innerRenormalize and outerRenormalize determine whether the primitive GTOs and the contracted GTO should be renormalized, respectively.

genGaussTypeOrb(center::NTuple{D, T}, xpn::T, ijk::NTuple{D, Int}=ntuple(_->0, Val(D)); 
                renormalize::Bool=false) where {T<:Real, D} -> 
PrimitiveOrb{T, D, T}

Generate a D-dimensional primitive Gaussian-type orbital (GTO) located at center with exponent coefficients specified by xpn and Cartesian angular momentum specified by ijk. renormalize determines whether the generated orbital should be renormalized.

genGaussTypeOrbSeq(center::NTuple{3, T}, content::AbstractString; 
                   innerRenormalize::Bool=false, outerRenormalize::Bool=false, 
                   unlinkCenter::Bool=false) where {T<:Real} -> 
Vector{<:CompositeOrb{T, 3, T}}

Generate a sequence of Gaussian-type orbitals (GTOs) located at center based on the basis set information provided in content, which should the text of an atomic Gaussian basis set in the Gaussian (software) format. innerRenormalize and outerRenormalize determine whether the primitive GTOs and the contracted GTOs should be renormalized, respectively. unlinkCenter determines whether the center parameters of the generated GTOs should be unlinked from each other.

genGaussTypeOrbSeq(center::NTuple{3, UnitOrVal{T}}, atm::Symbol, basisKey::String; 
                   innerRenormalize::Bool=false, outerRenormalize::Bool=false, 
                   unlinkCenter::Bool=false) where {T<:Real} -> 
Vector{<:CompositeOrb{T, 3, T}}

Generate a sequence of Gaussian-type orbitals (GTOs) located at center based on the input atomic basis set specified by the atomic symbol atm and the basis-set name basisKey.

• Atomic symbol options: [:H, :He, :Li, :Be, :B, :C, :N, :O, :F, :Ne, :Na, :Mg, :Al, :Si, :P, :S, :Cl, :Ar, :K, :Ca].

• Basis-set name options: ["STO-2G", "STO-3G", "STO-6G", "3-21G", "6-31G", "cc-pVDZ", "cc-pVTZ", "cc-pVQZ"].

innerRenormalize and outerRenormalize determine whether the primitive GTOs and the contracted GTOs should be renormalized, respectively. unlinkCenter determines whether the center parameters of the generated GTOs should be unlinked from each other.

runHartreeFock(nucInfo::NuclearCluster{R, D}, basis::AbstractVector{<:Quiqbox.OrbitalBasis{<:Union{Complex{R}, 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}, OccupationState{2}}, NuclearCluster{R, D}}, 
               basis::AbstractVector{<:Quiqbox.OrbitalBasis{<:Union{Complex{R}, 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}, OccupationState{2}}, NuclearCluster{R, D}}: A Pair information used to specify both the spin and nuclear-geometry configuration of the target system.

basis::AbstractVector{<:Quiqbox.OrbitalBasis{<:Union{Complex{R}, R}, D}}: The input orbital basis set.

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 reaches 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.

coreHamiltonian(nucs::AbstractVector{Symbol}, nucCoords::AbstractVector{NTuple{D, T}}, 
                basisSet::AbstractVector{<:Quiqbox.OrbitalBasis{<:Union{Complex{T}, T}, D}}; 
                lazyCompute::Bool=true
                ) where {T<:Real, D} -> 
AbstractMatrix{<:Union{Complex{T}, T}}

coreHamiltonian(nucInfo::NuclearCluster{T, D}, 
                basisSet::AbstractVector{<:Quiqbox.OrbitalBasis{<:Union{Complex{T}, T}, D}}; 
                lazyCompute::Bool=true
                ) where {T<:Real, D} -> 
AbstractMatrix{<:Union{Complex{T}, T}}

Compute the core-Hamiltonian integrals for all pairs of orbital basis functions in basisSet, which is the matrix addition of the electronic kinetic-energy integrals and the nuclear-electron attraction integrals. If lazyCompute is set to true, the integrals will be computed in a lazy manner to avoid repetitive primitive integration.

≡≡≡ Positional argument(s) ≡≡≡

nucs::AbstractVector{Symbol}: A list of nuclear species.

nucCoords::AbstractVector{NTuple{D, T}}: The list of Cartesian nuclear coordinates in the order respective to nucs.

nucInfo::NuclearCluster{T, D}: A container storing the nuclear species and their respective coordinates.

elecKinetic(orbL::Quiqbox.OrbitalBasis{CL, D}, orbR::Quiqbox.OrbitalBasis{CR, D}; 
            lazyCompute::Bool=true
            ) where {T<:Real, CL<:Union{Complex{T}, T}, 
                              CR<:Union{Complex{T}, T}, D} -> 
Union{Complex{T}, T}

Compute the electronic kinetic-energy integral between two orbital basis functions orbL and orbR. If lazyCompute is set to true, the integral will be computed in a lazy manner to avoid repetitive primitive integration.

elecKinetics(basisSet::AbstractVector{<:Quiqbox.OrbitalBasis{<:Union{Complex{T}, T}, D}}; 
             lazyCompute::Bool=true
             ) where {T<:Real, D} -> 
AbstractMatrix{<:Union{Complex{T}, T}}

Compute the electronic kinetic-energy integrals for all pairs of orbital basis functions in basisSet. If lazyCompute is set to true, the integrals will be computed in a lazy manner to avoid repetitive primitive integration.

elecRepulsion(orbL1::Quiqbox.OrbitalBasis{CL1, D}, orbR1::Quiqbox.OrbitalBasis{CR1, D}, 
              orbL2::Quiqbox.OrbitalBasis{CL2, D}, orbR2::Quiqbox.OrbitalBasis{CR2, D}; 
              lazyCompute::Bool=true
              ) where {T<:Real, CL1<:Union{Complex{T}, T}, 
                                CR1<:Union{Complex{T}, T}, 
                                CL2<:Union{Complex{T}, T}, 
                                CR2<:Union{Complex{T}, T}, D} -> 
Union{Complex{T}, T}

Compute the electron-repulsion integral between two pairs of orbital basis functions (orbL1, orbR1) and (orbL2, orbR2) (ordered by the chemists' notation). If lazyCompute is set to true, the integral will be computed in a lazy manner to avoid repetitive primitive integration.

elecRepulsions(basisSet::AbstractVector{<:Quiqbox.OrbitalBasis{<:Union{Complex{T}, T}, D}}; 
               lazyCompute::Bool=true
               ) where {T<:Real, D} -> 
AbstractArray{<:Union{Complex{T}, T}, 4}

Compute the electron-repulsion integrals for all double pairs of orbital basis functions in basisSet (tensor indices are ordered by the chemists' notation). If lazyCompute is set to true, the integrals will be computed in a lazy manner to avoid repetitive primitive integration.

multipoleMoment(center::NTuple{D, Real}, degrees::NTuple{D, Int}, 
                orbL::Quiqbox.OrbitalBasis{CL, D}, orbR::Quiqbox.OrbitalBasis{CR, D}; 
                lazyCompute::Bool=true
                ) where {T<:Real, CL<:Union{Complex{T}, T}, 
                                  CR<:Union{Complex{T}, T}, D} -> 
Union{Complex{T}, T}

Compute the multipole-moment integral between two orbital basis functions orbL and orbR at the D-dimensional center with degrees specified for its axes. If lazyCompute is set to true, the integral will be computed in a lazy manner to avoid repetitive primitive integration.

multipoleMoments(center::NTuple{D, Real}, degrees::NTuple{D, Int}, 
                 basisSet::AbstractVector{<:Quiqbox.OrbitalBasis{<:Union{Complex{T}, T}, D}}; 
                 lazyCompute::Bool=true
                 ) where {T<:Real, D} -> 
AbstractMatrix{<:Union{Complex{T}, T}}

Compute the multipole-moment integrals for all pairs of orbital basis functions in basisSet at the D-dimensional center with degrees specified for its axes. If lazyCompute is set to true, the integrals will be computed in a lazy manner to avoid repetitive primitive integration.

nucAttraction(nucs::AbstractVector{Symbol}, nucCoords::AbstractVector{NTuple{D, T}}, 
              orbL::Quiqbox.OrbitalBasis{CL, D}, orbR::Quiqbox.OrbitalBasis{CR, D}; 
              lazyCompute::Bool=true
              ) where {T<:Real, CL<:Union{Complex{T}, T}, 
                                CR<:Union{Complex{T}, T}, D} ->
Union{Complex{T}, T}

nucAttraction(nucInfo::NuclearCluster{T, D}, 
              orbL::Quiqbox.OrbitalBasis{CL, D}, orbR::Quiqbox.OrbitalBasis{CR, D}; 
              lazyCompute::Bool=true
              ) where {T<:Real, CL<:Union{Complex{T}, T}, 
                                CR<:Union{Complex{T}, T}, D} ->
Union{Complex{T}, T}

Compute the nuclear-attraction integral between two orbital basis functions orbL and orbR. If lazyCompute is set to true, the integral will be computed in a lazy manner to avoid repetitive primitive integration.

≡≡≡ Positional argument(s) ≡≡≡

nucs::AbstractVector{Symbol}: A list of nuclear species.

nucCoords::AbstractVector{NTuple{D, T}}: The list of Cartesian nuclear coordinates in the order respective to nucs.

nucInfo::NuclearCluster{T, D}: A container storing the nuclear species and their respective coordinates.

nucAttractions(nucs::AbstractVector{Symbol}, nucCoords::AbstractVector{NTuple{D, T}}, 
               basisSet::AbstractVector{<:Quiqbox.OrbitalBasis{<:Union{Complex{T}, T}, D}}; 
               lazyCompute::Bool=true
               ) where {T<:Real, D} -> 
AbstractMatrix{<:Union{Complex{T}, T}}

nucAttractions(nucInfo::NuclearCluster{T, D}, 
               basisSet::AbstractVector{<:Quiqbox.OrbitalBasis{<:Union{Complex{T}, T}, D}}; 
               lazyCompute::Bool=true
               ) where {T<:Real, D} -> 
AbstractMatrix{<:Union{Complex{T}, T}}

Compute the nuclear-attraction integrals for all pairs of orbital basis functions in basisSet. If lazyCompute is set to true, the integrals will be computed in a lazy manner to avoid repetitive primitive integration.

≡≡≡ Positional argument(s) ≡≡≡

nucs::AbstractVector{Symbol}: A list of nuclear species.

nucCoords::AbstractVector{NTuple{D, T}}: The list of Cartesian nuclear coordinates in the order respective to nucs.

nucInfo::NuclearCluster{T, D}: A container storing the nuclear species and their respective coordinates.

overlap(orbL::Quiqbox.OrbitalBasis{CL, D}, orbR::Quiqbox.OrbitalBasis{CR, D}; 
        lazyCompute::Bool=true
        ) where {T<:Real, CL<:Union{Complex{T}, T}, 
                          CR<:Union{Complex{T}, T}, D} -> 
Union{Complex{T}, T}

Compute the overlap integral between two orbital basis functions orbL and orbR. If lazyCompute is set to true, the integral will be computed in a lazy manner to avoid repetitive primitive integration.

overlaps(basisSet::AbstractVector{<:Quiqbox.OrbitalBasis{<:Union{Complex{T}, T}, D}}; 
         lazyCompute::Bool=true
         ) where {T<:Real, D} -> 
AbstractMatrix{<:Union{Complex{T}, T}}

Compute the overlap integrals for all pairs of orbital basis functions in basisSet. If lazyCompute is set to true, the integrals will be computed in a lazy manner to avoid repetitive primitive integration.