| include("Shells.jl") |
|
|
| |
|
|
| """ |
| 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 |
| |
| 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]) |
| |
| 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 |
| |
| 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 |
| |
| 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 |
| |
| r12 = SVector{3, Float64}(params.r12_dev * randn(3)) |
| |
| 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 |
|
|
