def add_esp(fchkfile, hdf5file):
npa_charges = IOData.from_file(fchkfile).npa_charges
esp_charges = IOData.from_file(fchkfile).esp_charges
mul_charges = IOData.from_file(fchkfile).mulliken_charges
g = h5py.File('pop_results.hdf5', 'a')
if 'npa' in g.keys():
del g['npa']
g.create_dataset('/npa', data=npa_charges)
if 'esp' in g.keys():
del g['esp']
g.create_dataset('/esp', data=esp_charges)
if 'mulliken' in g.keys():
del g['mulliken']
g.create_dataset('/mulliken', data=esp_charges)
def check_hf_cs_hf(scf_solver):
fn_fchk = context.get_fn('test/hf_sto3g.fchk')
mol = IOData.from_file(fn_fchk)
olp = mol.obasis.compute_overlap()
kin = mol.obasis.compute_kinetic()
na = mol.obasis.compute_nuclear_attraction(mol.coordinates, mol.pseudo_numbers)
er = mol.obasis.compute_electron_repulsion()
external = {'nn': compute_nucnuc(mol.coordinates, mol.pseudo_numbers)}
terms = [
RTwoIndexTerm(kin, 'kin'),
RDirectTerm(er, 'hartree'),
RExchangeTerm(er, 'x_hf'),
RTwoIndexTerm(na, 'ne'),
]
ham = REffHam(terms, external)
occ_model = AufbauOccModel(5)
check_solve(ham, scf_solver, occ_model, olp, kin, na, mol.orb_alpha)
# test orbital energies
expected_energies = np.array([
-2.59083334E+01, -1.44689996E+00, -5.57467136E-01, -4.62288194E-01,
-4.62288194E-01, 5.39578910E-01,
])
assert abs(mol.orb_alpha.energies - expected_energies).max() < 1e-5
ham.compute_energy()
# compare with g09
assert abs(ham.cache['energy'] - -9.856961609951867E+01) < 1e-8
assert abs(ham.cache['energy_kin'] - 9.766140786239E+01) < 2e-7
assert abs(ham.cache['energy_hartree'] + ham.cache['energy_x_hf'] - 4.561984106482E+01) < 1e-6
assert abs(ham.cache['energy_ne'] - -2.465756615329E+02) < 1e-6
assert abs(ham.cache['energy_nn'] - 4.7247965053) < 1e-8
def from_files(cls, fns, agspec='fine'):
'''
Construct a ProAtomDB from a series of HORTON checkpoint files.
**Arguments:**
fns_chk
A list of atomic output files.
**Optional arguments:**
agspec
A specifications of the atomic grid. This can either be an
instance of the AtomicGridSpec object, or the first argument
of its constructor.
'''
if not isinstance(agspec, AtomicGridSpec):
agspec = AtomicGridSpec(agspec)
records = []
for fn in fns:
# Load atomic data
with timer.section('Load proatom'):
mol = IOData.from_file(fn)
with timer.section('Proatom grid'):
records.append(ProAtomRecord.from_iodata(mol, agspec))
return cls(records)
def setUp(self):
super(Horton2Test, self).setUp()
self.data, self.logfile = getdatafile("Gaussian", "basicGaussian16",
["dvb_un_sp.fchk"])
datadir = os.path.abspath(
os.path.join(os.path.dirname(__file__), "..", "..", "data"))
inputfile = os.path.join(datadir, "Gaussian", "basicGaussian16",
"dvb_un_sp.fchk")
self._old_horton = False
self._found_horton = find_package("horton")
if self._found_horton:
try:
from horton import __version__
except:
self._old_horton = (
True # Old horton versions do not have this __version__ attribute
)
else:
if __version__[0] == "2":
from horton.io.iodata import IOData
from horton import log
log.set_level(
0
) # This suppresses horton outputs so that they do not flood the test log.
self._hortonver = 2
self.iodat = IOData.from_file(inputfile)
def check_hf_cs_hf(scf_solver):
fn_fchk = context.get_fn('test/hf_sto3g.fchk')
mol = IOData.from_file(fn_fchk)
olp = mol.obasis.compute_overlap(mol.lf)
kin = mol.obasis.compute_kinetic(mol.lf)
na = mol.obasis.compute_nuclear_attraction(mol.coordinates, mol.pseudo_numbers, mol.lf)
er = mol.obasis.compute_electron_repulsion(mol.lf)
external = {'nn': compute_nucnuc(mol.coordinates, mol.pseudo_numbers)}
terms = [
RTwoIndexTerm(kin, 'kin'),
RDirectTerm(er, 'hartree'),
RExchangeTerm(er, 'x_hf'),
RTwoIndexTerm(na, 'ne'),
]
ham = REffHam(terms, external)
occ_model = AufbauOccModel(5)
check_solve(ham, scf_solver, occ_model, mol.lf, olp, kin, na, mol.exp_alpha)
# test orbital energies
expected_energies = np.array([
-2.59083334E+01, -1.44689996E+00, -5.57467136E-01, -4.62288194E-01,
-4.62288194E-01, 5.39578910E-01,
])
assert abs(mol.exp_alpha.energies - expected_energies).max() < 1e-5
ham.compute_energy()
# compare with g09
assert abs(ham.cache['energy'] - -9.856961609951867E+01) < 1e-8
assert abs(ham.cache['energy_kin'] - 9.766140786239E+01) < 2e-7
assert abs(ham.cache['energy_hartree'] + ham.cache['energy_x_hf'] - 4.561984106482E+01) < 1e-6
assert abs(ham.cache['energy_ne'] - -2.465756615329E+02) < 1e-6
assert abs(ham.cache['energy_nn'] - 4.7247965053) < 1e-8
def check_lih_os_hf(scf_solver):
fn_fchk = context.get_fn('test/li_h_3-21G_hf_g09.fchk')
mol = IOData.from_file(fn_fchk)
olp = mol.obasis.compute_overlap(mol.lf)
kin = mol.obasis.compute_kinetic(mol.lf)
na = mol.obasis.compute_nuclear_attraction(mol.coordinates,
mol.pseudo_numbers, mol.lf)
er = mol.obasis.compute_electron_repulsion(mol.lf)
external = {'nn': compute_nucnuc(mol.coordinates, mol.pseudo_numbers)}
terms = [
UTwoIndexTerm(kin, 'kin'),
UDirectTerm(er, 'hartree'),
UExchangeTerm(er, 'x_hf'),
UTwoIndexTerm(na, 'ne'),
]
ham = UEffHam(terms, external)
occ_model = AufbauOccModel(2, 1)
check_solve(ham, scf_solver, occ_model, mol.lf, olp, kin, na,
mol.exp_alpha, mol.exp_beta)
expected_alpha_energies = np.array([
-2.76116635E+00,
-7.24564188E-01,
-1.79148636E-01,
-1.28235698E-01,
-1.28235698E-01,
-7.59817520E-02,
-1.13855167E-02,
6.52484445E-03,
6.52484445E-03,
7.52201895E-03,
9.70893294E-01,
])
expected_beta_energies = np.array([
-2.76031162E+00,
-2.08814026E-01,
-1.53071066E-01,
-1.25264964E-01,
-1.25264964E-01,
-1.24605870E-02,
5.12761388E-03,
7.70499854E-03,
7.70499854E-03,
2.85176080E-02,
1.13197479E+00,
])
assert abs(mol.exp_alpha.energies - expected_alpha_energies).max() < 1e-5
assert abs(mol.exp_beta.energies - expected_beta_energies).max() < 1e-5
ham.compute_energy()
# compare with g09
assert abs(ham.cache['energy'] - -7.687331212191962E+00) < 1e-8
assert abs(ham.cache['energy_kin'] - 7.640603924034E+00) < 2e-7
assert abs(ham.cache['energy_hartree'] + ham.cache['energy_x_hf'] -
2.114420907894E+00) < 1e-7
assert abs(ham.cache['energy_ne'] - -1.811548789281E+01) < 2e-7
assert abs(ham.cache['energy_nn'] - 0.6731318487) < 1e-8
def check_methyl_os_tpss(scf_solver):
"""Try to converge the SCF for the methyl radical molecule with the TPSS functional.
Parameters
----------
scf_solver : one of the SCFSolver types in HORTON
A configured SCF solver that must be tested.
"""
fn_fchk = context.get_fn('test/methyl_tpss_321g.fchk')
mol = IOData.from_file(fn_fchk)
grid = BeckeMolGrid(mol.coordinates, mol.numbers, mol.pseudo_numbers, 'fine',
random_rotate=False)
olp = mol.obasis.compute_overlap()
kin = mol.obasis.compute_kinetic()
na = mol.obasis.compute_nuclear_attraction(mol.coordinates, mol.pseudo_numbers)
er = mol.obasis.compute_electron_repulsion()
external = {'nn': compute_nucnuc(mol.coordinates, mol.pseudo_numbers)}
terms = [
UTwoIndexTerm(kin, 'kin'),
UDirectTerm(er, 'hartree'),
UGridGroup(mol.obasis, grid, [
ULibXCMGGA('x_tpss'),
ULibXCMGGA('c_tpss'),
]),
UTwoIndexTerm(na, 'ne'),
]
ham = UEffHam(terms, external)
# compute the energy before converging
dm_alpha = mol.orb_alpha.to_dm()
dm_beta = mol.orb_beta.to_dm()
ham.reset(dm_alpha, dm_beta)
ham.compute_energy()
assert abs(ham.cache['energy'] - -39.6216986265) < 1e-3
# The convergence should be reasonable, not perfect because of limited
# precision in the molden file:
assert convergence_error_eigen(ham, olp, mol.orb_alpha, mol.orb_beta) < 1e-3
# keep a copy of the orbital energies
expected_alpha_energies = mol.orb_alpha.energies.copy()
expected_beta_energies = mol.orb_beta.energies.copy()
# Converge from scratch
occ_model = AufbauOccModel(5, 4)
check_solve(ham, scf_solver, occ_model, olp, kin, na, mol.orb_alpha, mol.orb_beta)
# test orbital energies
assert abs(mol.orb_alpha.energies - expected_alpha_energies).max() < 2e-3
assert abs(mol.orb_beta.energies - expected_beta_energies).max() < 2e-3
ham.compute_energy()
# compare with
assert abs(ham.cache['energy_kin'] - 38.98408965928) < 1e-2
assert abs(ham.cache['energy_ne'] - -109.2368837076) < 1e-2
assert abs(ham.cache['energy_hartree'] + ham.cache['energy_libxc_mgga_x_tpss'] +
ham.cache['energy_libxc_mgga_c_tpss'] - 21.55131145126) < 1e-2
assert abs(ham.cache['energy'] - -39.6216986265) < 1e-3
assert abs(ham.cache['energy_nn'] - 9.0797839705) < 1e-5
def check_h3_os_pbe(scf_solver):
fn_fchk = context.get_fn("test/h3_pbe_321g.fchk")
mol = IOData.from_file(fn_fchk)
grid = BeckeMolGrid(mol.coordinates, mol.numbers, mol.pseudo_numbers, "veryfine", random_rotate=False)
olp = mol.obasis.compute_overlap(mol.lf)
kin = mol.obasis.compute_kinetic(mol.lf)
na = mol.obasis.compute_nuclear_attraction(mol.coordinates, mol.pseudo_numbers, mol.lf)
er = mol.obasis.compute_electron_repulsion(mol.lf)
external = {"nn": compute_nucnuc(mol.coordinates, mol.pseudo_numbers)}
terms = [
UTwoIndexTerm(kin, "kin"),
UDirectTerm(er, "hartree"),
UGridGroup(mol.obasis, grid, [ULibXCGGA("x_pbe"), ULibXCGGA("c_pbe")]),
UTwoIndexTerm(na, "ne"),
]
ham = UEffHam(terms, external)
# compute the energy before converging
dm_alpha = mol.exp_alpha.to_dm()
dm_beta = mol.exp_beta.to_dm()
ham.reset(dm_alpha, dm_beta)
ham.compute_energy()
assert abs(ham.cache["energy"] - -1.593208400939354e00) < 1e-5
# The convergence should be reasonable, not perfect because of limited
# precision in Gaussian fchk file:
assert convergence_error_eigen(ham, mol.lf, olp, mol.exp_alpha, mol.exp_beta) < 2e-6
# Converge from scratch
occ_model = AufbauOccModel(2, 1)
check_solve(ham, scf_solver, occ_model, mol.lf, olp, kin, na, mol.exp_alpha, mol.exp_beta)
# test orbital energies
expected_energies = np.array(
[-5.41141676e-01, -1.56826691e-01, 2.13089637e-01, 7.13565167e-01, 7.86810564e-01, 1.40663544e00]
)
assert abs(mol.exp_alpha.energies - expected_energies).max() < 2e-5
expected_energies = np.array(
[-4.96730336e-01, -5.81411249e-02, 2.73586652e-01, 7.41987185e-01, 8.76161160e-01, 1.47488421e00]
)
assert abs(mol.exp_beta.energies - expected_energies).max() < 2e-5
ham.compute_energy()
# compare with g09
assert abs(ham.cache["energy_ne"] - -6.934705182067e00) < 1e-5
assert abs(ham.cache["energy_kin"] - 1.948808793424e00) < 1e-5
assert (
abs(
ham.cache["energy_hartree"]
+ ham.cache["energy_libxc_gga_x_pbe"]
+ ham.cache["energy_libxc_gga_c_pbe"]
- 1.502769385597e00
)
< 1e-5
)
assert abs(ham.cache["energy"] - -1.593208400939354e00) < 1e-5
assert abs(ham.cache["energy_nn"] - 1.8899186021) < 1e-8
def check_water_cs_hfs(scf_solver):
fn_fchk = context.get_fn('test/water_hfs_321g.fchk')
mol = IOData.from_file(fn_fchk)
grid = BeckeMolGrid(mol.coordinates, mol.numbers, mol.pseudo_numbers, random_rotate=False)
olp = mol.obasis.compute_overlap()
kin = mol.obasis.compute_kinetic()
na = mol.obasis.compute_nuclear_attraction(mol.coordinates, mol.pseudo_numbers)
er = mol.obasis.compute_electron_repulsion()
external = {'nn': compute_nucnuc(mol.coordinates, mol.pseudo_numbers)}
terms = [
RTwoIndexTerm(kin, 'kin'),
RDirectTerm(er, 'hartree'),
RGridGroup(mol.obasis, grid, [
RDiracExchange(),
]),
RTwoIndexTerm(na, 'ne'),
]
ham = REffHam(terms, external)
# The convergence should be reasonable, not perfect because of limited
# precision in Gaussian fchk file and different integration grids:
assert convergence_error_eigen(ham, olp, mol.orb_alpha) < 3e-5
# Recompute the orbitals and orbital energies. This should be reasonably OK.
dm_alpha = mol.orb_alpha.to_dm()
ham.reset(dm_alpha)
ham.compute_energy()
fock_alpha = np.zeros(dm_alpha.shape)
ham.compute_fock(fock_alpha)
mol.orb_alpha.from_fock(fock_alpha, olp)
expected_energies = np.array([
-1.83691041E+01, -8.29412411E-01, -4.04495188E-01, -1.91740814E-01,
-1.32190590E-01, 1.16030419E-01, 2.08119657E-01, 9.69825207E-01,
9.99248500E-01, 1.41697384E+00, 1.47918828E+00, 1.61926596E+00,
2.71995350E+00
])
assert abs(mol.orb_alpha.energies - expected_energies).max() < 2e-4
assert abs(ham.cache['energy_ne'] - -1.977921986200E+02) < 1e-7
assert abs(ham.cache['energy_kin'] - 7.525067610865E+01) < 1e-9
assert abs(ham.cache['energy_hartree'] + ham.cache['energy_x_dirac'] - 3.864299848058E+01) < 2e-4
assert abs(ham.cache['energy'] - -7.474134898935590E+01) < 2e-4
assert abs(ham.cache['energy_nn'] - 9.1571750414) < 2e-8
# Converge from scratch and check energies
occ_model = AufbauOccModel(5)
check_solve(ham, scf_solver, occ_model, olp, kin, na, mol.orb_alpha)
ham.compute_energy()
assert abs(ham.cache['energy_ne'] - -1.977921986200E+02) < 1e-4
assert abs(ham.cache['energy_kin'] - 7.525067610865E+01) < 1e-4
assert abs(ham.cache['energy_hartree'] + ham.cache['energy_x_dirac'] - 3.864299848058E+01) < 2e-4
assert abs(ham.cache['energy'] - -7.474134898935590E+01) < 2e-4
def check_co_cs_pbe(scf_solver):
fn_fchk = context.get_fn('test/co_pbe_sto3g.fchk')
mol = IOData.from_file(fn_fchk)
grid = BeckeMolGrid(mol.coordinates,
mol.numbers,
mol.pseudo_numbers,
'fine',
random_rotate=False)
olp = mol.obasis.compute_overlap(mol.lf)
kin = mol.obasis.compute_kinetic(mol.lf)
na = mol.obasis.compute_nuclear_attraction(mol.coordinates,
mol.pseudo_numbers, mol.lf)
er = mol.obasis.compute_electron_repulsion(mol.lf)
external = {'nn': compute_nucnuc(mol.coordinates, mol.pseudo_numbers)}
terms = [
RTwoIndexTerm(kin, 'kin'),
RDirectTerm(er, 'hartree'),
RGridGroup(mol.obasis, grid, [
RLibXCGGA('x_pbe'),
RLibXCGGA('c_pbe'),
]),
RTwoIndexTerm(na, 'ne'),
]
ham = REffHam(terms, external)
# Test energy before scf
energy, focks = helper_compute(ham, mol.lf, mol.exp_alpha)
assert abs(energy - -1.116465967841901E+02) < 1e-4
# The convergence should be reasonable, not perfect because of limited
# precision in Gaussian fchk file:
assert convergence_error_eigen(ham, mol.lf, olp, mol.exp_alpha) < 1e-5
# Converge from scratch
occ_model = AufbauOccModel(7)
check_solve(ham, scf_solver, occ_model, mol.lf, olp, kin, na,
mol.exp_alpha)
# test orbital energies
expected_energies = np.array([
-1.86831122E+01, -9.73586915E+00, -1.03946082E+00, -4.09331776E-01,
-3.48686522E-01, -3.48686522E-01, -2.06049056E-01, 5.23730418E-02,
5.23730418E-02, 6.61093726E-01
])
assert abs(mol.exp_alpha.energies - expected_energies).max() < 1e-2
ham.compute_energy()
# compare with g09
assert abs(ham.cache['energy_ne'] - -3.072370116827E+02) < 1e-2
assert abs(ham.cache['energy_kin'] - 1.103410779827E+02) < 1e-2
assert abs(ham.cache['energy_hartree'] +
ham.cache['energy_libxc_gga_x_pbe'] +
ham.cache['energy_libxc_gga_c_pbe'] - 6.273115782683E+01) < 1e-2
assert abs(ham.cache['energy'] - -1.116465967841901E+02) < 1e-4
assert abs(ham.cache['energy_nn'] - 22.5181790889) < 1e-7
def check_water_cs_hfs(scf_solver):
fn_fchk = context.get_fn('test/water_hfs_321g.fchk')
mol = IOData.from_file(fn_fchk)
grid = BeckeMolGrid(mol.coordinates, mol.numbers, mol.pseudo_numbers, random_rotate=False)
olp = mol.obasis.compute_overlap(mol.lf)
kin = mol.obasis.compute_kinetic(mol.lf)
na = mol.obasis.compute_nuclear_attraction(mol.coordinates, mol.pseudo_numbers, mol.lf)
er = mol.obasis.compute_electron_repulsion(mol.lf)
external = {'nn': compute_nucnuc(mol.coordinates, mol.pseudo_numbers)}
terms = [
RTwoIndexTerm(kin, 'kin'),
RDirectTerm(er, 'hartree'),
RGridGroup(mol.obasis, grid, [
RDiracExchange(),
]),
RTwoIndexTerm(na, 'ne'),
]
ham = REffHam(terms, external)
# The convergence should be reasonable, not perfect because of limited
# precision in Gaussian fchk file and different integration grids:
assert convergence_error_eigen(ham, mol.lf, olp, mol.exp_alpha) < 3e-5
# Recompute the orbitals and orbital energies. This should be reasonably OK.
dm_alpha = mol.exp_alpha.to_dm()
ham.reset(dm_alpha)
ham.compute_energy()
fock_alpha = mol.lf.create_two_index()
ham.compute_fock(fock_alpha)
mol.exp_alpha.from_fock(fock_alpha, olp)
expected_energies = np.array([
-1.83691041E+01, -8.29412411E-01, -4.04495188E-01, -1.91740814E-01,
-1.32190590E-01, 1.16030419E-01, 2.08119657E-01, 9.69825207E-01,
9.99248500E-01, 1.41697384E+00, 1.47918828E+00, 1.61926596E+00,
2.71995350E+00
])
assert abs(mol.exp_alpha.energies - expected_energies).max() < 2e-4
assert abs(ham.cache['energy_ne'] - -1.977921986200E+02) < 1e-7
assert abs(ham.cache['energy_kin'] - 7.525067610865E+01) < 1e-9
assert abs(ham.cache['energy_hartree'] + ham.cache['energy_x_dirac'] - 3.864299848058E+01) < 2e-4
assert abs(ham.cache['energy'] - -7.474134898935590E+01) < 2e-4
assert abs(ham.cache['energy_nn'] - 9.1571750414) < 2e-8
# Converge from scratch and check energies
occ_model = AufbauOccModel(5)
check_solve(ham, scf_solver, occ_model, mol.lf, olp, kin, na, mol.exp_alpha)
ham.compute_energy()
assert abs(ham.cache['energy_ne'] - -1.977921986200E+02) < 1e-4
assert abs(ham.cache['energy_kin'] - 7.525067610865E+01) < 1e-4
assert abs(ham.cache['energy_hartree'] + ham.cache['energy_x_dirac'] - 3.864299848058E+01) < 2e-4
assert abs(ham.cache['energy'] - -7.474134898935590E+01) < 2e-4
def check_water_cs_m05(scf_solver):
"""Try to converge the SCF for the water molecule with the M05 functional.
Parameters
----------
scf_solver : one of the SCFSolver types in HORTON
A configured SCF solver that must be tested.
"""
fn_fchk = context.get_fn('test/water_m05_321g.fchk')
mol = IOData.from_file(fn_fchk)
grid = BeckeMolGrid(mol.coordinates, mol.numbers, mol.pseudo_numbers, 'fine',
random_rotate=False)
olp = mol.obasis.compute_overlap()
kin = mol.obasis.compute_kinetic()
na = mol.obasis.compute_nuclear_attraction(mol.coordinates, mol.pseudo_numbers)
er = mol.obasis.compute_electron_repulsion()
external = {'nn': compute_nucnuc(mol.coordinates, mol.pseudo_numbers)}
libxc_term = RLibXCHybridMGGA('xc_m05')
terms = [
RTwoIndexTerm(kin, 'kin'),
RDirectTerm(er, 'hartree'),
RGridGroup(mol.obasis, grid, [libxc_term]),
RExchangeTerm(er, 'x_hf', libxc_term.get_exx_fraction()),
RTwoIndexTerm(na, 'ne'),
]
ham = REffHam(terms, external)
# compute the energy before converging
dm_alpha = mol.orb_alpha.to_dm()
ham.reset(dm_alpha)
ham.compute_energy()
assert abs(ham.cache['energy'] - -75.9532086800) < 1e-3
# The convergence should be reasonable, not perfect because of limited
# precision in the molden file:
assert convergence_error_eigen(ham, olp, mol.orb_alpha) < 1e-3
# keep a copy of the orbital energies
expected_alpha_energies = mol.orb_alpha.energies.copy()
# Converge from scratch
occ_model = AufbauOccModel(5)
check_solve(ham, scf_solver, occ_model, olp, kin, na, mol.orb_alpha)
# test orbital energies
assert abs(mol.orb_alpha.energies - expected_alpha_energies).max() < 2e-3
ham.compute_energy()
# compare with
assert abs(ham.cache['energy_kin'] - 75.54463056278) < 1e-2
assert abs(ham.cache['energy_ne'] - -198.3003887880) < 1e-2
assert abs(ham.cache['energy_hartree'] + ham.cache['energy_x_hf'] +
ham.cache['energy_libxc_hyb_mgga_xc_m05'] - 3.764537450376E+01) < 1e-2
assert abs(ham.cache['energy'] - -75.9532086800) < 1e-3
assert abs(ham.cache['energy_nn'] - 9.1571750414) < 1e-5
def check_lih_os_hf(scf_solver):
fn_fchk = context.get_fn("test/li_h_3-21G_hf_g09.fchk")
mol = IOData.from_file(fn_fchk)
olp = mol.obasis.compute_overlap(mol.lf)
kin = mol.obasis.compute_kinetic(mol.lf)
na = mol.obasis.compute_nuclear_attraction(mol.coordinates, mol.pseudo_numbers, mol.lf)
er = mol.obasis.compute_electron_repulsion(mol.lf)
external = {"nn": compute_nucnuc(mol.coordinates, mol.pseudo_numbers)}
terms = [UTwoIndexTerm(kin, "kin"), UDirectTerm(er, "hartree"), UExchangeTerm(er, "x_hf"), UTwoIndexTerm(na, "ne")]
ham = UEffHam(terms, external)
occ_model = AufbauOccModel(2, 1)
check_solve(ham, scf_solver, occ_model, mol.lf, olp, kin, na, mol.exp_alpha, mol.exp_beta)
expected_alpha_energies = np.array(
[
-2.76116635e00,
-7.24564188e-01,
-1.79148636e-01,
-1.28235698e-01,
-1.28235698e-01,
-7.59817520e-02,
-1.13855167e-02,
6.52484445e-03,
6.52484445e-03,
7.52201895e-03,
9.70893294e-01,
]
)
expected_beta_energies = np.array(
[
-2.76031162e00,
-2.08814026e-01,
-1.53071066e-01,
-1.25264964e-01,
-1.25264964e-01,
-1.24605870e-02,
5.12761388e-03,
7.70499854e-03,
7.70499854e-03,
2.85176080e-02,
1.13197479e00,
]
)
assert abs(mol.exp_alpha.energies - expected_alpha_energies).max() < 1e-5
assert abs(mol.exp_beta.energies - expected_beta_energies).max() < 1e-5
ham.compute_energy()
# compare with g09
assert abs(ham.cache["energy"] - -7.687331212191962e00) < 1e-8
assert abs(ham.cache["energy_kin"] - 7.640603924034e00) < 2e-7
assert abs(ham.cache["energy_hartree"] + ham.cache["energy_x_hf"] - 2.114420907894e00) < 1e-7
assert abs(ham.cache["energy_ne"] - -1.811548789281e01) < 2e-7
assert abs(ham.cache["energy_nn"] - 0.6731318487) < 1e-8
def load_atom(self, dn_mult, ext):
fn = '%s/atom.%s' % (dn_mult, ext)
if not os.path.isfile(fn):
return None, None
try:
mol = IOData.from_file(fn)
except:
return None, None
mol.energy = self._get_energy(mol, dn_mult)
return mol, mol.energy
def write_random_lta_cube(dn, fn_cube):
'''Write a randomized cube file'''
# start from an existing cube file
mol = IOData.from_file(context.get_fn('test/lta_gulp.cif'))
# Define a uniform grid with only 1000 points, to make the tests fast.
ugrid = UniformGrid(np.zeros(3, float), mol.cell.rvecs*0.1, np.array([10, 10, 10]), np.array([1, 1, 1]))
# Write to the file dn/fn_cube
mol.cube_data = np.random.uniform(0, 1, ugrid.shape)
mol.grid = ugrid
mol.to_file(os.path.join(dn, fn_cube))
return mol
def check_h3_os_pbe(scf_solver):
fn_fchk = context.get_fn('test/h3_pbe_321g.fchk')
mol = IOData.from_file(fn_fchk)
grid = BeckeMolGrid(mol.coordinates, mol.numbers, mol.pseudo_numbers, 'veryfine', random_rotate=False)
olp = mol.obasis.compute_overlap()
kin = mol.obasis.compute_kinetic()
na = mol.obasis.compute_nuclear_attraction(mol.coordinates, mol.pseudo_numbers)
er = mol.obasis.compute_electron_repulsion()
external = {'nn': compute_nucnuc(mol.coordinates, mol.pseudo_numbers)}
terms = [
UTwoIndexTerm(kin, 'kin'),
UDirectTerm(er, 'hartree'),
UGridGroup(mol.obasis, grid, [
ULibXCGGA('x_pbe'),
ULibXCGGA('c_pbe'),
]),
UTwoIndexTerm(na, 'ne'),
]
ham = UEffHam(terms, external)
# compute the energy before converging
dm_alpha = mol.orb_alpha.to_dm()
dm_beta = mol.orb_beta.to_dm()
ham.reset(dm_alpha, dm_beta)
ham.compute_energy()
assert abs(ham.cache['energy'] - -1.593208400939354E+00) < 1e-5
# The convergence should be reasonable, not perfect because of limited
# precision in Gaussian fchk file:
assert convergence_error_eigen(ham, olp, mol.orb_alpha, mol.orb_beta) < 2e-6
# Converge from scratch
occ_model = AufbauOccModel(2, 1)
check_solve(ham, scf_solver, occ_model, olp, kin, na, mol.orb_alpha, mol.orb_beta)
# test orbital energies
expected_energies = np.array([
-5.41141676E-01, -1.56826691E-01, 2.13089637E-01, 7.13565167E-01,
7.86810564E-01, 1.40663544E+00
])
assert abs(mol.orb_alpha.energies - expected_energies).max() < 2e-5
expected_energies = np.array([
-4.96730336E-01, -5.81411249E-02, 2.73586652E-01, 7.41987185E-01,
8.76161160E-01, 1.47488421E+00
])
assert abs(mol.orb_beta.energies - expected_energies).max() < 2e-5
ham.compute_energy()
# compare with g09
assert abs(ham.cache['energy_ne'] - -6.934705182067E+00) < 1e-5
assert abs(ham.cache['energy_kin'] - 1.948808793424E+00) < 1e-5
assert abs(ham.cache['energy_hartree'] + ham.cache['energy_libxc_gga_x_pbe'] + ham.cache['energy_libxc_gga_c_pbe'] - 1.502769385597E+00) < 1e-5
assert abs(ham.cache['energy'] - -1.593208400939354E+00) < 1e-5
assert abs(ham.cache['energy_nn'] - 1.8899186021) < 1e-8
def load_atom(self, dn_mult, ext):
fn = '%s/atom.%s' % (dn_mult, ext)
if not os.path.isfile(fn):
return None, None
try:
mol = IOData.from_file(fn)
except:
return None, None
mol.energy = self._get_energy(mol, dn_mult)
return mol, mol.energy
def write_random_lta_cube(dn, fn_cube):
'''Write a randomized cube file'''
# start from an existing cube file
mol = IOData.from_file(context.get_fn('test/lta_gulp.cif'))
# Define a uniform grid with only 1000 points, to make the tests fast.
ugrid = UniformGrid(np.zeros(3, float), mol.cell.rvecs * 0.1,
np.array([10, 10, 10]), np.array([1, 1, 1]))
# Write to the file dn/fn_cube
mol.cube_data = np.random.uniform(0, 1, ugrid.shape)
mol.grid = ugrid
mol.to_file(os.path.join(dn, fn_cube))
return mol
def check_co_cs_pbe(scf_solver):
fn_fchk = context.get_fn('test/co_pbe_sto3g.fchk')
mol = IOData.from_file(fn_fchk)
grid = BeckeMolGrid(mol.coordinates, mol.numbers, mol.pseudo_numbers, 'fine', random_rotate=False)
olp = mol.obasis.compute_overlap(mol.lf)
kin = mol.obasis.compute_kinetic(mol.lf)
na = mol.obasis.compute_nuclear_attraction(mol.coordinates, mol.pseudo_numbers, mol.lf)
er = mol.obasis.compute_electron_repulsion(mol.lf)
external = {'nn': compute_nucnuc(mol.coordinates, mol.pseudo_numbers)}
terms = [
RTwoIndexTerm(kin, 'kin'),
RDirectTerm(er, 'hartree'),
RGridGroup(mol.obasis, grid, [
RLibXCGGA('x_pbe'),
RLibXCGGA('c_pbe'),
]),
RTwoIndexTerm(na, 'ne'),
]
ham = REffHam(terms, external)
# Test energy before scf
energy, focks = helper_compute(ham, mol.lf, mol.exp_alpha)
assert abs(energy - -1.116465967841901E+02) < 1e-4
# The convergence should be reasonable, not perfect because of limited
# precision in Gaussian fchk file:
assert convergence_error_eigen(ham, mol.lf, olp, mol.exp_alpha) < 1e-5
# Converge from scratch
occ_model = AufbauOccModel(7)
check_solve(ham, scf_solver, occ_model, mol.lf, olp, kin, na, mol.exp_alpha)
# test orbital energies
expected_energies = np.array([
-1.86831122E+01, -9.73586915E+00, -1.03946082E+00, -4.09331776E-01,
-3.48686522E-01, -3.48686522E-01, -2.06049056E-01, 5.23730418E-02,
5.23730418E-02, 6.61093726E-01
])
assert abs(mol.exp_alpha.energies - expected_energies).max() < 1e-2
ham.compute_energy()
# compare with g09
assert abs(ham.cache['energy_ne'] - -3.072370116827E+02) < 1e-2
assert abs(ham.cache['energy_kin'] - 1.103410779827E+02) < 1e-2
assert abs(ham.cache['energy_hartree'] + ham.cache['energy_libxc_gga_x_pbe'] + ham.cache['energy_libxc_gga_c_pbe'] - 6.273115782683E+01) < 1e-2
assert abs(ham.cache['energy'] - -1.116465967841901E+02) < 1e-4
assert abs(ham.cache['energy_nn'] - 22.5181790889) < 1e-7
def load_rho(coordinates, numbers, fn_cube, ref_ugrid, stride, chop):
'''Load densities from a file, reduce by stride, chop and check ugrid
**Arguments:**
coordinates
An array with shape (N, 3) containing atomic coordinates.
numbers
A vector with shape (N,) containing atomic numbers.
fn_cube
The cube file with the electron density.
ref_ugrid
A reference ugrid that must match the one from the density cube
file (after reduction).
stride
The reduction factor.
chop
The number of slices to chop of the grid in each direction.
'''
if fn_cube is None:
# Load the built-in database of proatoms
natom = len(numbers)
numbers = np.unique(numbers)
proatomdb = ProAtomDB.from_refatoms(numbers, max_cation=0, max_anion=0, agspec='fine')
# Construct the pro-density
rho = np.zeros(ref_ugrid.shape)
for i in xrange(natom):
spline = proatomdb.get_spline(numbers[i])
ref_ugrid.eval_spline(spline, coordinates[i], rho)
else:
# Load cube
mol_rho = IOData.from_file(fn_cube)
rho = mol_rho.cube_data
ugrid = mol_rho.grid
# Reduce grid size
if stride > 1:
rho, ugrid = reduce_data(rho, ugrid, stride, chop)
# Compare with ref_ugrid (only shape)
if (ugrid.shape != ref_ugrid.shape).any():
raise ValueError('The densities file does not contain the same amount if information as the potential file.')
return rho
def check_lih_os_hf(scf_solver):
fn_fchk = context.get_fn('test/li_h_3-21G_hf_g09.fchk')
mol = IOData.from_file(fn_fchk)
olp = mol.obasis.compute_overlap()
kin = mol.obasis.compute_kinetic()
na = mol.obasis.compute_nuclear_attraction(mol.coordinates, mol.pseudo_numbers)
er = mol.obasis.compute_electron_repulsion()
external = {'nn': compute_nucnuc(mol.coordinates, mol.pseudo_numbers)}
terms = [
UTwoIndexTerm(kin, 'kin'),
UDirectTerm(er, 'hartree'),
UExchangeTerm(er, 'x_hf'),
UTwoIndexTerm(na, 'ne'),
]
ham = UEffHam(terms, external)
occ_model = AufbauOccModel(2, 1)
check_solve(ham, scf_solver, occ_model, olp, kin, na, mol.orb_alpha, mol.orb_beta)
expected_alpha_energies = np.array([
-2.76116635E+00, -7.24564188E-01, -1.79148636E-01, -1.28235698E-01,
-1.28235698E-01, -7.59817520E-02, -1.13855167E-02, 6.52484445E-03,
6.52484445E-03, 7.52201895E-03, 9.70893294E-01,
])
expected_beta_energies = np.array([
-2.76031162E+00, -2.08814026E-01, -1.53071066E-01, -1.25264964E-01,
-1.25264964E-01, -1.24605870E-02, 5.12761388E-03, 7.70499854E-03,
7.70499854E-03, 2.85176080E-02, 1.13197479E+00,
])
assert abs(mol.orb_alpha.energies - expected_alpha_energies).max() < 1e-5
assert abs(mol.orb_beta.energies - expected_beta_energies).max() < 1e-5
ham.compute_energy()
# compare with g09
assert abs(ham.cache['energy'] - -7.687331212191962E+00) < 1e-8
assert abs(ham.cache['energy_kin'] - 7.640603924034E+00) < 2e-7
assert abs(ham.cache['energy_hartree'] + ham.cache['energy_x_hf'] - 2.114420907894E+00) < 1e-7
assert abs(ham.cache['energy_ne'] - -1.811548789281E+01) < 2e-7
assert abs(ham.cache['energy_nn'] - 0.6731318487) < 1e-8
def add_npa(fchkfile, hdf5file):
npa_charges = IOData.from_file(fchkfile).npa_charges
g = h5py.File('pop_results.hdf5', 'a')
if 'npa' in g.keys():
del g['npa']
g.create_dataset('/npa', data=npa_charges)
def run_extensive_pop(fchkfile, hdf5file):
ref_charges = IOData.from_file(fchkfile).numbers
f = h5py.File('quasi_results.hdf5', 'r')
g = h5py.File('pop_results.hdf5', 'w')
quasitype_list = ['quasi', 'newquasi']
aao_list = ['aambs', 'ano-rcc', 'minao', 'sto-6g']
orbtype_list = ['quambo','quao','iao 1','iao 2', 'simple']
for aao in aao_list:
horton_data = wrapper_horton(fchkfile, aao+'.gbs')
print aao
for quasitype in quasitype_list:
for orbtype in orbtype_list:
pops = [np.zeros(ref_charges.size) for i in range(1+int(orbtype!='simple'))]
print quasitype, orbtype
for index, coeff_ab_mo, olp_ab_ab, olp_cao_ab, olp_cao_cao, occupations, basis_map in zip(range(2), *horton_data[:6]):
if quasitype == 'quasi':
quasi = QuasiTransformation(coeff_ab_mo, olp_ab_ab, olp_cao_ab, olp_cao_cao, occupations.astype(bool))
elif quasitype == 'newquasi':
quasi = NewQuasiTransformation(coeff_ab_mo, olp_ab_ab, olp_cao_ab, olp_cao_cao, occupations.astype(bool))
try:
coeff_ab_quasi = f['/'.join([aao, str(index), quasitype, orbtype, 'not_orth'])][:]
except KeyError:
print '/'.join([aao, str(index), quasitype, orbtype, 'not_orth'])
print f['/'.join([aao])].keys()
print f['/'.join([aao, str(index)])].keys()
print f['/'.join([aao, str(index), quasitype])].keys()
print f['/'.join([aao, str(index), quasitype, orbtype])].keys()
# orthogonalize
if orbtype == 'simple':
tmp_olp_ab_ab = quasi.olp_ab_ab
coeff_ab_omo = quasi.coeff_ab_omo
olp_quasi_quasi = coeff_ab_quasi.T.dot(tmp_olp_ab_ab).dot(coeff_ab_quasi)
olp_quasi_omo = coeff_ab_quasi.T.dot(tmp_olp_ab_ab).dot(coeff_ab_omo)
print np.linalg.matrix_rank(coeff_ab_quasi)
print np.linalg.matrix_rank(olp_quasi_quasi)
print 'xxxxxxxxxxxxxxx'
coeff_quasi_omo = project(olp_quasi_quasi, olp_quasi_omo)
print olp_quasi_omo.shape
print np.diag(olp_quasi_omo.T.dot(coeff_quasi_omo))
#print coeff_quasi_omo.T.dot(olp_quasi_quasi).dot(coeff_quasi_omo)
occ = occupations[occupations>0]
pops[0] += Mulliken(coeff_quasi_omo, occ, olp_quasi_quasi, len(set(basis_map)), basis_map).get_population()
continue
coeff_ab_oquasi = f['/'.join([aao, str(index), quasitype, orbtype, 'orth'])][:]
if orbtype == 'iao 2':
tmp_olp_ab_ab = np.zeros([quasi.num_ab+quasi.num_aao]*2)
tmp_olp_ab_ab[:quasi.num_ab] = np.hstack((quasi.olp_ab_ab, quasi.olp_ab_aao))
tmp_olp_ab_ab[quasi.num_ab:] = np.hstack((quasi.olp_aao_ab, quasi.olp_aao_aao))
coeff_ab_omo = np.vstack((quasi.coeff_ab_omo, np.zeros([quasi.num_aao, quasi.num_omo])))
else:
tmp_olp_ab_ab = quasi.olp_ab_ab
coeff_ab_omo = quasi.coeff_ab_omo
for i, coeff in enumerate([coeff_ab_quasi, coeff_ab_oquasi]):
olp_quasi_quasi = coeff.T.dot(tmp_olp_ab_ab).dot(coeff)
olp_quasi_omo = coeff.T.dot(tmp_olp_ab_ab).dot(coeff_ab_omo)
coeff_quasi_omo = project(olp_quasi_quasi, olp_quasi_omo)
occ = occupations[occupations>0]
pops[i] += Mulliken(coeff_quasi_omo, occ, olp_quasi_quasi, len(set(basis_map)), basis_map).get_population()
print '/'.join([aao, str(index), quasitype, orbtype, 'not_orth'])
print pops
g.create_dataset('/'.join([aao, str(index), quasitype, orbtype, 'not_orth']), data=ref_charges-pops[0])
if orbtype != 'simple':
g.create_dataset('/'.join([aao, str(index), quasitype, orbtype, 'orth']), data=ref_charges-pops[1])
def check_n2_cs_hfs(scf_solver):
fn_fchk = context.get_fn('test/n2_hfs_sto3g.fchk')
mol = IOData.from_file(fn_fchk)
grid = BeckeMolGrid(mol.coordinates, mol.numbers, mol.pseudo_numbers, 'veryfine', random_rotate=False)
olp = mol.obasis.compute_overlap(mol.lf)
kin = mol.obasis.compute_kinetic(mol.lf)
na = mol.obasis.compute_nuclear_attraction(mol.coordinates, mol.pseudo_numbers, mol.lf)
er = mol.obasis.compute_electron_repulsion(mol.lf)
external = {'nn': compute_nucnuc(mol.coordinates, mol.pseudo_numbers)}
libxc_term = RLibXCLDA('x')
terms1 = [
RTwoIndexTerm(kin, 'kin'),
RDirectTerm(er, 'hartree'),
RGridGroup(mol.obasis, grid, [libxc_term]),
RTwoIndexTerm(na, 'ne'),
]
ham1 = REffHam(terms1, external)
builtin_term = RDiracExchange()
terms2 = [
RTwoIndexTerm(kin, 'kin'),
RDirectTerm(er, 'hartree'),
RGridGroup(mol.obasis, grid, [builtin_term]),
RTwoIndexTerm(na, 'ne'),
]
ham2 = REffHam(terms2, external)
# Compare the potential computed by libxc with the builtin implementation
energy1, focks1 = helper_compute(ham1, mol.lf, mol.exp_alpha)
energy2, focks2 = helper_compute(ham2, mol.lf, mol.exp_alpha)
libxc_pot = ham1.cache.load('pot_libxc_lda_x_alpha')
builtin_pot = ham2.cache.load('pot_x_dirac_alpha')
# Libxc apparently approximates values of the potential below 1e-4 with zero.
assert abs(libxc_pot - builtin_pot).max() < 1e-4
# Check of the libxc energy matches our implementation
assert abs(energy1 - energy2) < 1e-10
ex1 = ham1.cache['energy_libxc_lda_x']
ex2 = ham2.cache['energy_x_dirac']
assert abs(ex1 - ex2) < 1e-10
# The convergence should be reasonable, not perfect because of limited
# precision in Gaussian fchk file:
assert convergence_error_eigen(ham1, mol.lf, olp, mol.exp_alpha) < 1e-5
assert convergence_error_eigen(ham2, mol.lf, olp, mol.exp_alpha) < 1e-5
occ_model = AufbauOccModel(7)
for ham in ham1, ham2:
# Converge from scratch
check_solve(ham, scf_solver, occ_model, mol.lf, olp, kin, na, mol.exp_alpha)
# test orbital energies
expected_energies = np.array([
-1.37107053E+01, -1.37098006E+01, -9.60673085E-01, -3.57928483E-01,
-3.16017655E-01, -3.16017655E-01, -2.12998316E-01, 6.84030479E-02,
6.84030479E-02, 7.50192517E-01,
])
assert abs(mol.exp_alpha.energies - expected_energies).max() < 3e-5
ham.compute_energy()
assert abs(ham.cache['energy_ne'] - -2.981579553570E+02) < 1e-5
assert abs(ham.cache['energy_kin'] - 1.061620887711E+02) < 1e-5
assert abs(ham.cache['energy'] - -106.205213597) < 1e-4
assert abs(ham.cache['energy_nn'] - 23.3180604505) < 1e-8
assert abs(ham1.cache['energy_hartree'] + ham1.cache['energy_libxc_lda_x'] - 6.247259253877E+01) < 1e-4
assert abs(ham2.cache['energy_hartree'] + ham2.cache['energy_x_dirac'] - 6.247259253877E+01) < 1e-4
def check_h3_os_hfs(scf_solver):
fn_fchk = context.get_fn('test/h3_hfs_321g.fchk')
mol = IOData.from_file(fn_fchk)
grid = BeckeMolGrid(mol.coordinates,
mol.numbers,
mol.pseudo_numbers,
'veryfine',
random_rotate=False)
olp = mol.obasis.compute_overlap(mol.lf)
kin = mol.obasis.compute_kinetic(mol.lf)
na = mol.obasis.compute_nuclear_attraction(mol.coordinates,
mol.pseudo_numbers, mol.lf)
er = mol.obasis.compute_electron_repulsion(mol.lf)
external = {'nn': compute_nucnuc(mol.coordinates, mol.pseudo_numbers)}
libxc_term = ULibXCLDA('x')
terms1 = [
UTwoIndexTerm(kin, 'kin'),
UDirectTerm(er, 'hartree'),
UGridGroup(mol.obasis, grid, [libxc_term]),
UTwoIndexTerm(na, 'ne'),
]
ham1 = UEffHam(terms1, external)
builtin_term = UDiracExchange()
terms2 = [
UTwoIndexTerm(kin, 'kin'),
UDirectTerm(er, 'hartree'),
UGridGroup(mol.obasis, grid, [builtin_term]),
UTwoIndexTerm(na, 'ne'),
]
ham2 = UEffHam(terms2, external)
# Compare the potential computed by libxc with the builtin implementation
energy1, focks1 = helper_compute(ham1, mol.lf, mol.exp_alpha, mol.exp_beta)
energy2, focks2 = helper_compute(ham2, mol.lf, mol.exp_alpha, mol.exp_beta)
libxc_pot = ham1.cache.load('pot_libxc_lda_x_both')[:, 0]
builtin_pot = ham2.cache.load('pot_x_dirac_alpha')
# Libxc apparently approximates values of the potential below 1e-4 with zero.
assert abs(libxc_pot - builtin_pot).max() < 1e-4
# Check of the libxc energy matches our implementation
assert abs(energy1 - energy2) < 1e-10
ex1 = ham1.cache['energy_libxc_lda_x']
ex2 = ham2.cache['energy_x_dirac']
assert abs(ex1 - ex2) < 1e-10
# The convergence should be reasonable, not perfect because of limited
# precision in Gaussian fchk file:
assert convergence_error_eigen(ham1, mol.lf, olp, mol.exp_alpha,
mol.exp_beta) < 1e-5
assert convergence_error_eigen(ham2, mol.lf, olp, mol.exp_alpha,
mol.exp_beta) < 1e-5
occ_model = AufbauOccModel(2, 1)
for ham in ham1, ham2:
# Converge from scratch
check_solve(ham, scf_solver, occ_model, mol.lf, olp, kin, na,
mol.exp_alpha, mol.exp_beta)
# test orbital energies
expected_energies = np.array([
-4.93959157E-01, -1.13961330E-01, 2.38730924E-01, 7.44216538E-01,
8.30143356E-01, 1.46613581E+00
])
assert abs(mol.exp_alpha.energies - expected_energies).max() < 1e-5
expected_energies = np.array([
-4.34824166E-01, 1.84114514E-04, 3.24300545E-01, 7.87622756E-01,
9.42415831E-01, 1.55175481E+00
])
assert abs(mol.exp_beta.energies - expected_energies).max() < 1e-5
ham.compute_energy()
# compare with g09
assert abs(ham.cache['energy_ne'] - -6.832069993374E+00) < 1e-5
assert abs(ham.cache['energy_kin'] - 1.870784279014E+00) < 1e-5
assert abs(ham.cache['energy'] - -1.412556114057104E+00) < 1e-5
assert abs(ham.cache['energy_nn'] - 1.8899186021) < 1e-8
assert abs(ham1.cache['energy_hartree'] +
ham1.cache['energy_libxc_lda_x'] - 1.658810998195E+00) < 1e-6
assert abs(ham2.cache['energy_hartree'] + ham2.cache['energy_x_dirac'] -
1.658810998195E+00) < 1e-6
def check_n2_cs_hfs(scf_solver):
fn_fchk = context.get_fn('test/n2_hfs_sto3g.fchk')
mol = IOData.from_file(fn_fchk)
grid = BeckeMolGrid(mol.coordinates,
mol.numbers,
mol.pseudo_numbers,
'veryfine',
random_rotate=False)
olp = mol.obasis.compute_overlap(mol.lf)
kin = mol.obasis.compute_kinetic(mol.lf)
na = mol.obasis.compute_nuclear_attraction(mol.coordinates,
mol.pseudo_numbers, mol.lf)
er = mol.obasis.compute_electron_repulsion(mol.lf)
external = {'nn': compute_nucnuc(mol.coordinates, mol.pseudo_numbers)}
libxc_term = RLibXCLDA('x')
terms1 = [
RTwoIndexTerm(kin, 'kin'),
RDirectTerm(er, 'hartree'),
RGridGroup(mol.obasis, grid, [libxc_term]),
RTwoIndexTerm(na, 'ne'),
]
ham1 = REffHam(terms1, external)
builtin_term = RDiracExchange()
terms2 = [
RTwoIndexTerm(kin, 'kin'),
RDirectTerm(er, 'hartree'),
RGridGroup(mol.obasis, grid, [builtin_term]),
RTwoIndexTerm(na, 'ne'),
]
ham2 = REffHam(terms2, external)
# Compare the potential computed by libxc with the builtin implementation
energy1, focks1 = helper_compute(ham1, mol.lf, mol.exp_alpha)
energy2, focks2 = helper_compute(ham2, mol.lf, mol.exp_alpha)
libxc_pot = ham1.cache.load('pot_libxc_lda_x_alpha')
builtin_pot = ham2.cache.load('pot_x_dirac_alpha')
# Libxc apparently approximates values of the potential below 1e-4 with zero.
assert abs(libxc_pot - builtin_pot).max() < 1e-4
# Check of the libxc energy matches our implementation
assert abs(energy1 - energy2) < 1e-10
ex1 = ham1.cache['energy_libxc_lda_x']
ex2 = ham2.cache['energy_x_dirac']
assert abs(ex1 - ex2) < 1e-10
# The convergence should be reasonable, not perfect because of limited
# precision in Gaussian fchk file:
assert convergence_error_eigen(ham1, mol.lf, olp, mol.exp_alpha) < 1e-5
assert convergence_error_eigen(ham2, mol.lf, olp, mol.exp_alpha) < 1e-5
occ_model = AufbauOccModel(7)
for ham in ham1, ham2:
# Converge from scratch
check_solve(ham, scf_solver, occ_model, mol.lf, olp, kin, na,
mol.exp_alpha)
# test orbital energies
expected_energies = np.array([
-1.37107053E+01,
-1.37098006E+01,
-9.60673085E-01,
-3.57928483E-01,
-3.16017655E-01,
-3.16017655E-01,
-2.12998316E-01,
6.84030479E-02,
6.84030479E-02,
7.50192517E-01,
])
assert abs(mol.exp_alpha.energies - expected_energies).max() < 3e-5
ham.compute_energy()
assert abs(ham.cache['energy_ne'] - -2.981579553570E+02) < 1e-5
assert abs(ham.cache['energy_kin'] - 1.061620887711E+02) < 1e-5
assert abs(ham.cache['energy'] - -106.205213597) < 1e-4
assert abs(ham.cache['energy_nn'] - 23.3180604505) < 1e-8
assert abs(ham1.cache['energy_hartree'] +
ham1.cache['energy_libxc_lda_x'] - 6.247259253877E+01) < 1e-4
assert abs(ham2.cache['energy_hartree'] + ham2.cache['energy_x_dirac'] -
6.247259253877E+01) < 1e-4
def check_h3_os_hfs(scf_solver):
fn_fchk = context.get_fn('test/h3_hfs_321g.fchk')
mol = IOData.from_file(fn_fchk)
grid = BeckeMolGrid(mol.coordinates, mol.numbers, mol.pseudo_numbers, 'veryfine', random_rotate=False)
olp = mol.obasis.compute_overlap(mol.lf)
kin = mol.obasis.compute_kinetic(mol.lf)
na = mol.obasis.compute_nuclear_attraction(mol.coordinates, mol.pseudo_numbers, mol.lf)
er = mol.obasis.compute_electron_repulsion(mol.lf)
external = {'nn': compute_nucnuc(mol.coordinates, mol.pseudo_numbers)}
libxc_term = ULibXCLDA('x')
terms1 = [
UTwoIndexTerm(kin, 'kin'),
UDirectTerm(er, 'hartree'),
UGridGroup(mol.obasis, grid, [libxc_term]),
UTwoIndexTerm(na, 'ne'),
]
ham1 = UEffHam(terms1, external)
builtin_term = UDiracExchange()
terms2 = [
UTwoIndexTerm(kin, 'kin'),
UDirectTerm(er, 'hartree'),
UGridGroup(mol.obasis, grid, [builtin_term]),
UTwoIndexTerm(na, 'ne'),
]
ham2 = UEffHam(terms2, external)
# Compare the potential computed by libxc with the builtin implementation
energy1, focks1 = helper_compute(ham1, mol.lf, mol.exp_alpha, mol.exp_beta)
energy2, focks2 = helper_compute(ham2, mol.lf, mol.exp_alpha, mol.exp_beta)
libxc_pot = ham1.cache.load('pot_libxc_lda_x_both')[:,0]
builtin_pot = ham2.cache.load('pot_x_dirac_alpha')
# Libxc apparently approximates values of the potential below 1e-4 with zero.
assert abs(libxc_pot - builtin_pot).max() < 1e-4
# Check of the libxc energy matches our implementation
assert abs(energy1 - energy2) < 1e-10
ex1 = ham1.cache['energy_libxc_lda_x']
ex2 = ham2.cache['energy_x_dirac']
assert abs(ex1 - ex2) < 1e-10
# The convergence should be reasonable, not perfect because of limited
# precision in Gaussian fchk file:
assert convergence_error_eigen(ham1, mol.lf, olp, mol.exp_alpha, mol.exp_beta) < 1e-5
assert convergence_error_eigen(ham2, mol.lf, olp, mol.exp_alpha, mol.exp_beta) < 1e-5
occ_model = AufbauOccModel(2, 1)
for ham in ham1, ham2:
# Converge from scratch
check_solve(ham, scf_solver, occ_model, mol.lf, olp, kin, na, mol.exp_alpha, mol.exp_beta)
# test orbital energies
expected_energies = np.array([
-4.93959157E-01, -1.13961330E-01, 2.38730924E-01, 7.44216538E-01,
8.30143356E-01, 1.46613581E+00
])
assert abs(mol.exp_alpha.energies - expected_energies).max() < 1e-5
expected_energies = np.array([
-4.34824166E-01, 1.84114514E-04, 3.24300545E-01, 7.87622756E-01,
9.42415831E-01, 1.55175481E+00
])
assert abs(mol.exp_beta.energies - expected_energies).max() < 1e-5
ham.compute_energy()
# compare with g09
assert abs(ham.cache['energy_ne'] - -6.832069993374E+00) < 1e-5
assert abs(ham.cache['energy_kin'] - 1.870784279014E+00) < 1e-5
assert abs(ham.cache['energy'] - -1.412556114057104E+00) < 1e-5
assert abs(ham.cache['energy_nn'] - 1.8899186021) < 1e-8
assert abs(ham1.cache['energy_hartree'] + ham1.cache['energy_libxc_lda_x'] - 1.658810998195E+00) < 1e-6
assert abs(ham2.cache['energy_hartree'] + ham2.cache['energy_x_dirac'] - 1.658810998195E+00) < 1e-6
