generation/ShellGen.jl

include("Shells.jl")

#--- Sample Basis sets --- 

"""
    PairParams(atom, normalize=false[, logdev_rate, logdev_max])

Sampling parameters for 2-center 2-shell basis sets.

# Note

When called as `PairParams(normalize::Bool)`, will sample random atomic numbers 
within `1:10`.

# Arguments
- `atom::Vector{Int64}`: length-2 vector of atomic numbers 
- `normalize::Bool`: whether to normalize integral outputs (if used?)
- `logdev_rate::Real`: exponential decay rate of the wavelength logarithm distribution
- `logdev_max::Real`: logarithm of the greatest wavelength
"""
struct PairParams 
    atom::Vector{Int64}
    normalize::Bool
    logdev_rate::Real  
    logdev_max::Real 
end
function PairParams(atom::Vector{Int64}, norm::Bool = false)
    PairParams(atom, norm, 2, .6)
end
function PairParams(normalize::Bool = false)  
    Z = rand(1:10, 2)
    return PairParams(Z, normalize)
end

"""
    randPair(l1, l2[, params])

Sample a random 2-shell `Basis`.
"""
function randPair(l1::Int, l2::Int, params::PairParams)::Basis
    # sample exponents 
    exps = begin
        max, rate = params.logdev_max, params.logdev_rate
        log_devs = max .- rand(Exponential(rate), 2)
        devs = exp.(log_devs)
        1 ./ (2 .* devs .^ 2)
    end
    exp_1 = SVector{1, Float64}(exps[1])
    exp_2 = SVector{1, Float64}(exps[2])
    # sample 2nd atomic position
    xyz = begin
        exp_12 = exps[1] * exps[2] / (exps[1] + exps[2])
        dev_12 = 1 / sqrt(2exp_12)
        SVector{3, Float64}(dev_12 * randn((3)))
    end
    # atom charges
    origin = SVector{3, Float64}(0., 0., 0.)
    pos = (origin, xyz)
    mol = map(zip(params.atom, pos)) do A
        Za, ra = A
        move(atom(Za), ra)
    end
    # basis sets 
    coef :: SMatrix{2, 1, Float64} = 
        params.normalize ? 
            vcat(exp_1, exp_2) ./ 2pi .^ (3 / 4 ) :
            [1., 1.]
    shells = [BasisFunction(l1, coef[1,:], exp_1, mol[1]),
              BasisFunction(l2, coef[2,:], exp_2, mol[2])]
    return (mol, shells)::Basis
    return basis
end
randPair(l1::Int, l2::Int, atom::Vector{Int64}) = randPair(l1, l2, PairParams(atom))
randPair(l1::Int, l2::Int) = begin p = PairParams(); randPair(l1, l2, p); end
randPair(l::Int, params::PairParams) = randPair(l, l, params)
randPair(l::Int) = randPair(l, l)

"""
    QuadParams(r12_dev[, pair])

Sampling parameters for 4-center basis sets.

# Arguments
- `r12_dev::Float64`: typical distance between pairwise barycenters
- `pair::Vector{PairParams}`: sampling parameters for center pairs
"""
struct QuadParams
    r12_dev::Float64 
    pair::Vector{PairParams}
end
QuadParams(r12_dev::Float64) = begin
    p = PairParams([1, 1])
    QuadParams(r12_dev, [p, p])
end
QuadParams() = QuadParams(.05)

"""
    randQuadruple(l1, l2, l3, l4[, params, shuflle=false)

Sample a random quadruple of shells.
"""
function randQuadruple(l1::Int, l2::Int, l3::Int, l4::Int, params::QuadParams, shuffle::Bool=false)
    if shuffle
        p = randperm(4)
        p_1 = sortperm(p)
        mol, shells = randQuadruple([l1, l2, l3, l4][p]..., params, false)
        return mol[p_1], shells[p_1]
    end
    # sample offset between the two R³ factors
    r12 = SVector{3, Float64}(params.r12_dev * randn(3))
    # sample pairs and move them
    AB, shells_AB = randPair(l1, l2, params.pair[1])
    CD, shells_CD = randPair(l3, l4, params.pair[2])
    ABCD = append!(center(AB), center(CD, r12))
    shells = append!(shells_AB, shells_CD)
    shells_ABCD = map(zip(ABCD, shells)) do pair
        atom, shell = pair
        BasisFunction(shell.l, shell.coef, shell.exp, atom)
    end
    return ABCD, shells_ABCD
end
function randQuadruple(l1::Int, l2::Int, l3::Int, l4::Int, ps...)
    p = QuadParams(ps...)
    randQuadruple(l1, l2, l3, l4, p)
end