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 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 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_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