File size: 3,775 Bytes
d4fc45a |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 |
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
|