def test_load_wfn_lif_fci(): fn_wfn = context.get_fn('test/lif_fci.wfn') sys = System.from_file(fn_wfn) assert isinstance(sys.wfn, RestrictedWFN) assert sys.natom == 2 assert sys.obasis.nbasis == 44 sys.wfn.exp_alpha.check_normalization(sys.get_overlap(), 1e-5) #Check normalization assert sys.wfn.exp_alpha.occupations.shape == (18,) assert abs(sys.wfn.exp_alpha.occupations.sum() - 6.0) < 1.e-6 assert sys.wfn.exp_alpha.occupations[0] == 2.00000000/2 assert sys.wfn.exp_alpha.occupations[10] == 0.00128021/2 assert sys.wfn.exp_alpha.occupations[-1] == 0.00000054/2 assert sys.wfn.exp_alpha.energies.shape == (18,) assert sys.wfn.exp_alpha.energies[0] == -26.09321253 assert sys.wfn.exp_alpha.energies[15] == 1.70096290 assert sys.wfn.exp_alpha.energies[-1] == 2.17434072 assert sys.wfn.exp_alpha.coeffs.shape == (44, 18) ham = Hamiltonian(sys, [HartreeFockExchange()]) energy = ham.compute() #cannot be compared! kin = sys.extra['energy_kin'] nn = sys.extra['energy_nn'] expected_kin = 106.9326884815 #FCI kinetic energy expected_nn = 9.1130265227 assert (kin - expected_kin) < 1.e-6 assert (nn - expected_nn) < 1.e-6 charges = compute_mulliken_charges(sys) #Check charges expected_charge = np.array([-0.645282, 0.645282]) assert (abs(charges - expected_charge) < 1e-5).all() points = np.array([[0.0, 0.0,-0.17008], [0.0, 0.0, 0.0], [0.0, 0.0, 0.03779]]) density = sys.compute_grid_density(points) assert (abs(density - [0.492787, 0.784545, 0.867723]) < 1.e-4).all()
def test_load_wfn_li_sp_virtual(): fn_wfn = context.get_fn('test/li_sp_virtual.wfn') sys = System.from_file(fn_wfn) assert isinstance(sys.wfn, UnrestrictedWFN) assert sys.obasis.nbasis == 8 sys.wfn.exp_alpha.check_normalization(sys.get_overlap(), 1e-5) #Check normalization sys.wfn.exp_beta.check_normalization(sys.get_overlap(), 1e-5) #Check normalization assert abs(sys.wfn.exp_alpha.occupations.sum() - 2.0) < 1.e-6 assert abs(sys.wfn.exp_beta.occupations.sum() - 1.0) < 1.e-6 assert (sys.wfn.exp_alpha.occupations == [ 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ]).all() assert (sys.wfn.exp_beta.occupations == [ 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ]).all() assert (abs(sys.wfn.exp_alpha.energies - [ -0.087492, -0.080310, 0.158784, 0.158784, 1.078773, 1.090891, 1.090891, 49.643670 ]) < 1.e-6).all() assert (abs(sys.wfn.exp_beta.energies - [ -0.079905, 0.176681, 0.176681, 0.212494, 1.096631, 1.096631, 1.122821, 49.643827 ]) < 1.e-6).all() assert sys.wfn.exp_alpha.coeffs.shape == (8, 8) assert sys.wfn.exp_beta.coeffs.shape == (8, 8) ham = Hamiltonian(sys, [HartreeFockExchange()]) energy = ham.compute() assert abs(energy - ( -3.712905542719)) < 1.e-6 #Compare to the energy printed in wfn file charges = compute_mulliken_charges(sys) #Check charges expected_charge = np.array([0.0, 0.0]) assert (abs(charges - expected_charge) < 1e-5).all()
def test_load_wfn_lif_fci(): fn_wfn = context.get_fn('test/lif_fci.wfn') sys = System.from_file(fn_wfn) assert isinstance(sys.wfn, RestrictedWFN) assert sys.natom == 2 assert sys.obasis.nbasis == 44 sys.wfn.exp_alpha.check_normalization(sys.get_overlap(), 1e-5) #Check normalization assert sys.wfn.exp_alpha.occupations.shape == (18, ) assert abs(sys.wfn.exp_alpha.occupations.sum() - 6.0) < 1.e-6 assert sys.wfn.exp_alpha.occupations[0] == 2.00000000 / 2 assert sys.wfn.exp_alpha.occupations[10] == 0.00128021 / 2 assert sys.wfn.exp_alpha.occupations[-1] == 0.00000054 / 2 assert sys.wfn.exp_alpha.energies.shape == (18, ) assert sys.wfn.exp_alpha.energies[0] == -26.09321253 assert sys.wfn.exp_alpha.energies[15] == 1.70096290 assert sys.wfn.exp_alpha.energies[-1] == 2.17434072 assert sys.wfn.exp_alpha.coeffs.shape == (44, 18) ham = Hamiltonian(sys, [HartreeFockExchange()]) energy = ham.compute() #cannot be compared! kin = sys.extra['energy_kin'] nn = sys.extra['energy_nn'] expected_kin = 106.9326884815 #FCI kinetic energy expected_nn = 9.1130265227 assert (kin - expected_kin) < 1.e-6 assert (nn - expected_nn) < 1.e-6 charges = compute_mulliken_charges(sys) #Check charges expected_charge = np.array([-0.645282, 0.645282]) assert (abs(charges - expected_charge) < 1e-5).all() points = np.array([[0.0, 0.0, -0.17008], [0.0, 0.0, 0.0], [0.0, 0.0, 0.03779]]) density = sys.compute_grid_density(points) assert (abs(density - [0.492787, 0.784545, 0.867723]) < 1.e-4).all()
def test_load_wfn_h2_ccpvqz_virtual(): fn_wfn = context.get_fn('test/h2_ccpvqz.wfn') sys = System.from_file(fn_wfn) assert isinstance(sys.wfn, RestrictedWFN) assert sys.obasis.nbasis == 74 sys.wfn.exp_alpha.check_normalization(sys.get_overlap(), 1e-5) #Chech normalization assert (abs(sys.obasis.alphas[:5] - [82.64000, 12.41000, 2.824000, 0.7977000, 0.2581000]) < 1.e-5).all() assert (sys.wfn.exp_alpha.energies[:5] == [ -0.596838, 0.144565, 0.209605, 0.460401, 0.460401 ]).all() assert (sys.wfn.exp_alpha.energies[-5:] == [ 12.859067, 13.017471, 16.405834, 25.824716, 26.100443 ]).all() assert (sys.wfn.exp_alpha.occupations[:5] == [1.0, 0.0, 0.0, 0.0, 0.0]).all() assert abs(sys.wfn.exp_alpha.occupations.sum() - 1.0) < 1.e-6 ham = Hamiltonian(sys, [HartreeFockExchange()]) energy = ham.compute() assert abs(energy - ( -1.133504568400)) < 1.e-5 #Compare to the energy printed in wfn file charges = compute_mulliken_charges(sys) #Check charges expected_charge = np.array([0.0, 0.0]) assert (abs(charges - expected_charge) < 1e-5).all()
def test_load_wfn_he_spd(): sys, energy = check_load_wfn('he_spd_orbital') assert isinstance(sys.wfn, RestrictedWFN) assert abs(energy - (-2.855319016184)) < 1.e-6 #Compare to the energy printed in wfn file charges = compute_mulliken_charges(sys) #Check charges expected_charge = np.array([0.0]) assert (abs(charges - expected_charge) < 1e-5).all()
def test_load_wfn_he_spdfgh_virtual(): sys, energy = check_load_wfn('he_spdfgh_virtual') assert isinstance(sys.wfn, RestrictedWFN) assert abs(energy - (-1.048675168346)) < 1.e-6 #Compare to the energy printed in wfn file charges = compute_mulliken_charges(sys) #Check charges expected_charge = np.array([0.0]) assert (abs(charges - expected_charge) < 1e-5).all()
def check_load_wfn(name): # system out of *.wfn file mol1 = IOData.from_file(context.get_fn('test/%s.wfn' % name)) # system out of *.fchk file mol2 = IOData.from_file(context.get_fn('test/%s.fchk' % name)) # Coordinates check: assert (abs(mol1.coordinates - mol2.coordinates) < 1e-6).all() # Numbers check numbers1 = mol1.numbers numbers2 = mol2.numbers assert (numbers1 == numbers2).all() # Basis Set check: obasis1 = mol1.obasis obasis2 = mol2.obasis assert obasis1.nbasis == obasis2.nbasis assert (obasis1.shell_map == obasis2.shell_map).all() assert (obasis1.shell_types == obasis2.shell_types).all() assert (obasis1.nprims == obasis2.nprims).all() assert (abs(obasis1.alphas - obasis2.alphas) < 1.e-4).all() # Comparing MOs (*.wfn might not contain virtual orbitals): n_mo = mol1.orb_alpha.nfn assert (abs(mol1.orb_alpha.energies - mol2.orb_alpha.energies[:n_mo]) < 1.e-5).all() assert ( mol1.orb_alpha.occupations == mol2.orb_alpha.occupations[:n_mo]).all() assert (abs(mol1.orb_alpha.coeffs - mol2.orb_alpha.coeffs[:, :n_mo]) < 1.e-7).all() # Check overlap olp1 = obasis1.compute_overlap() olp2 = obasis2.compute_overlap() obasis2.compute_overlap(olp2) assert (abs(olp1 - olp2) < 1e-6).all() # Check normalization mol1.orb_alpha.check_normalization(olp1, 1e-5) # Check charges dm_full1 = mol1.get_dm_full() charges1 = compute_mulliken_charges(obasis1, numbers1, dm_full1) dm_full2 = mol2.get_dm_full() charges2 = compute_mulliken_charges(obasis2, numbers2, dm_full2) assert (abs(charges1 - charges2) < 1e-6).all() # Check energy energy1 = compute_hf_energy(mol1) energy2 = compute_hf_energy(mol2) # check loaded & computed energy from wfn file assert abs(energy1 - mol1.energy) < 1.e-5 assert abs(energy1 - energy2) < 1e-5 return energy1, charges1
def test_load_molden_neon_turbomole(): # The file tested here is created with Turbomole 7.1. fn_molden = context.get_fn('test/neon_turbomole_def2-qzvp.molden') mol = IOData.from_file(fn_molden) # Check Mulliken charges. dm_full = mol.get_dm_full() charges = compute_mulliken_charges(mol.obasis, mol.pseudo_numbers, dm_full) assert abs(charges).max() < 1e-3
def test_load_wfn_he_spd(): sys, energy = check_load_wfn('he_spd_orbital') assert isinstance(sys.wfn, RestrictedWFN) assert abs(energy - ( -2.855319016184)) < 1.e-6 #Compare to the energy printed in wfn file charges = compute_mulliken_charges(sys) #Check charges expected_charge = np.array([0.0]) assert (abs(charges - expected_charge) < 1e-5).all()
def test_load_wfn_he_spdfgh_virtual(): sys, energy = check_load_wfn('he_spdfgh_virtual') assert isinstance(sys.wfn, RestrictedWFN) assert abs(energy - ( -1.048675168346)) < 1.e-6 #Compare to the energy printed in wfn file charges = compute_mulliken_charges(sys) #Check charges expected_charge = np.array([0.0]) assert (abs(charges - expected_charge) < 1e-5).all()
def test_load_molden_neon_turbomole(): # The file tested here is created with Turbomole 7.1. fn_molden = context.get_fn('test/neon_turbomole_def2-qzvp.molden') mol = IOData.from_file(fn_molden) # Check Mulliken charges. dm_full = mol.get_dm_full() charges = compute_mulliken_charges(mol.obasis, mol.lf, mol.pseudo_numbers, dm_full) assert abs(charges).max() < 1e-3
def test_load_molden_nh3_molpro2012(): # The file tested here is created with MOLPRO2012. fn_molden = context.get_fn('test/nh3_molpro2012.molden') mol = IOData.from_file(fn_molden) # Check Mulliken charges. Comparison with numbers from the Molden program output. dm_full = mol.get_dm_full() charges = compute_mulliken_charges(mol.obasis, mol.lf, mol.pseudo_numbers, dm_full) molden_charges = np.array([0.0381, -0.2742, 0.0121, 0.2242]) assert abs(charges - molden_charges).max() < 1e-3
def test_load_molden_nh3_molpro2012(): # The file tested here is created with MOLPRO2012. fn_molden = context.get_fn('test/nh3_molpro2012.molden') mol = IOData.from_file(fn_molden) # Check Mulliken charges. Comparison with numbers from the Molden program output. dm_full = mol.get_dm_full() charges = compute_mulliken_charges(mol.obasis, mol.pseudo_numbers, dm_full) molden_charges = np.array([0.0381, -0.2742, 0.0121, 0.2242]) assert abs(charges - molden_charges).max() < 1e-3
def check_load_wfn(name): # system out of *.wfn file mol1 = IOData.from_file(context.get_fn('test/%s.wfn' % name)) # system out of *.fchk file mol2 = IOData.from_file(context.get_fn('test/%s.fchk' % name)) # Coordinates check: assert (abs(mol1.coordinates - mol2.coordinates) < 1e-6).all() # Numbers check numbers1 = mol1.numbers numbers2 = mol2.numbers assert (numbers1 == numbers2).all() # Basis Set check: obasis1 = mol1.obasis obasis2 = mol2.obasis assert obasis1.nbasis == obasis2.nbasis assert (obasis1.shell_map == obasis2.shell_map).all() assert (obasis1.shell_types == obasis2.shell_types).all() assert (obasis1.nprims == obasis2.nprims).all() assert (abs(obasis1.alphas - obasis2.alphas) < 1.e-4).all() # Comparing MOs (*.wfn might not contain virtual orbitals): n_mo = mol1.orb_alpha.nfn assert (abs(mol1.orb_alpha.energies - mol2.orb_alpha.energies[:n_mo]) < 1.e-5).all() assert (mol1.orb_alpha.occupations == mol2.orb_alpha.occupations[:n_mo]).all() assert (abs(mol1.orb_alpha.coeffs - mol2.orb_alpha.coeffs[:, :n_mo]) < 1.e-7).all() # Check overlap olp1 = obasis1.compute_overlap() olp2 = obasis2.compute_overlap() obasis2.compute_overlap(olp2) assert (abs(olp1 - olp2) < 1e-6).all() # Check normalization mol1.orb_alpha.check_normalization(olp1, 1e-5) # Check charges dm_full1 = mol1.get_dm_full() charges1 = compute_mulliken_charges(obasis1, numbers1, dm_full1) dm_full2 = mol2.get_dm_full() charges2 = compute_mulliken_charges(obasis2, numbers2, dm_full2) assert (abs(charges1 - charges2) < 1e-6).all() # Check energy energy1 = compute_hf_energy(mol1) energy2 = compute_hf_energy(mol2) # check loaded & computed energy from wfn file assert abs(energy1 - mol1.energy) < 1.e-5 assert abs(energy1 - energy2) < 1e-5 return energy1, charges1
def test_load_molden_nh3_psi4_1(): # The file tested here is created with PSI4 (version 1.0). It should be read in # properly by renormalizing the contractions. fn_molden = context.get_fn('test/nh3_psi4_1.0.molden') mol = IOData.from_file(fn_molden) # Check Mulliken charges. Comparison with numbers from the Molden program output. dm_full = mol.get_dm_full() charges = compute_mulliken_charges(mol.obasis, mol.lf, mol.pseudo_numbers, dm_full) molden_charges = np.array([0.0381, -0.2742, 0.0121, 0.2242]) assert abs(charges - molden_charges).max() < 1e-3
def test_load_molden_nh3_psi4_1(): # The file tested here is created with PSI4 (version 1.0). It should be read in # properly by renormalizing the contractions. fn_molden = context.get_fn('test/nh3_psi4_1.0.molden') mol = IOData.from_file(fn_molden) # Check Mulliken charges. Comparison with numbers from the Molden program output. dm_full = mol.get_dm_full() charges = compute_mulliken_charges(mol.obasis, mol.pseudo_numbers, dm_full) molden_charges = np.array([0.0381, -0.2742, 0.0121, 0.2242]) assert abs(charges - molden_charges).max() < 1e-3
def test_load_molden_nh3_orca(): # The file tested here is created with ORCA. It should be read in # properly by altering normalization and sign conventions. fn_molden = context.get_fn('test/nh3_orca.molden') mol = IOData.from_file(fn_molden) # Check Mulliken charges. Comparison with numbers from the Molden program output. dm_full = mol.get_dm_full() charges = compute_mulliken_charges(mol.obasis, mol.lf, mol.pseudo_numbers, dm_full) molden_charges = np.array([0.0381, -0.2742, 0.0121, 0.2242]) assert abs(charges - molden_charges).max() < 1e-3
def test_load_molden_nh3_orca(): # The file tested here is created with ORCA. It should be read in # properly by altering normalization and sign conventions. fn_molden = context.get_fn('test/nh3_orca.molden') mol = IOData.from_file(fn_molden) # Check Mulliken charges. Comparison with numbers from the Molden program output. dm_full = mol.get_dm_full() charges = compute_mulliken_charges(mol.obasis, mol.pseudo_numbers, dm_full) molden_charges = np.array([0.0381, -0.2742, 0.0121, 0.2242]) assert abs(charges - molden_charges).max() < 1e-3
def test_load_mkl_ethanol(): fn_mkl = context.get_fn('test/ethanol.mkl') mol = IOData.from_file(fn_mkl) # Direct checks with mkl file assert mol.numbers.shape == (9, ) assert mol.numbers[0] == 1 assert mol.numbers[4] == 6 assert mol.coordinates.shape == (9, 3) assert abs(mol.coordinates[2, 1] / angstrom - 2.239037) < 1e-5 assert abs(mol.coordinates[5, 2] / angstrom - 0.948420) < 1e-5 assert mol.obasis.nbasis == 39 assert mol.obasis.alphas[0] == 18.731137000 assert mol.obasis.alphas[10] == 7.868272400 assert mol.obasis.alphas[-3] == 2.825393700 #assert mol.obasis.con_coeffs[5] == 0.989450608 #assert mol.obasis.con_coeffs[7] == 2.079187061 #assert mol.obasis.con_coeffs[-1] == 0.181380684 assert (mol.obasis.shell_map[:5] == [0, 0, 1, 1, 1]).all() assert (mol.obasis.shell_types[:5] == [0, 0, 0, 0, 1]).all() assert (mol.obasis.nprims[-5:] == [3, 1, 1, 3, 1]).all() assert mol.exp_alpha.coeffs.shape == (39, 39) assert mol.exp_alpha.energies.shape == (39, ) assert mol.exp_alpha.occupations.shape == (39, ) assert (mol.exp_alpha.occupations[:13] == 1.0).all() assert (mol.exp_alpha.occupations[13:] == 0.0).all() assert mol.exp_alpha.energies[4] == -1.0206976 assert mol.exp_alpha.energies[-1] == 2.0748685 assert mol.exp_alpha.coeffs[0, 0] == 0.0000119 assert mol.exp_alpha.coeffs[1, 0] == -0.0003216 assert mol.exp_alpha.coeffs[-1, -1] == -0.1424743 # Comparison of derived properties with ORCA output file # nuclear-nuclear repulsion assert abs( compute_nucnuc(mol.coordinates, mol.pseudo_numbers) - 81.87080034) < 1e-5 # Check normalization olp = mol.obasis.compute_overlap(mol.lf) mol.exp_alpha.check_normalization(olp, 1e-5) # Mulliken charges dm_full = mol.get_dm_full() charges = compute_mulliken_charges(mol.obasis, mol.lf, mol.numbers, dm_full) expected_charges = np.array([ 0.143316, -0.445861, 0.173045, 0.173021, 0.024542, 0.143066, 0.143080, -0.754230, 0.400021 ]) assert abs(charges - expected_charges).max() < 1e-5 # Compute HF energy assert abs(compute_hf_energy(mol) - -154.01322894) < 1e-4
def test_load_wfn_h2o_sto3g(): fn_wfn = context.get_fn('test/h2o_sto3g.wfn') sys = System.from_file(fn_wfn) assert isinstance(sys.wfn, RestrictedWFN) sys.wfn.exp_alpha.check_normalization(sys.get_overlap(), 1e-5) #Check normalization ham = Hamiltonian(sys, [HartreeFockExchange()]) energy = ham.compute() assert abs(energy - (-74.965901217080)) < 1.e-5 #Compare to the energy printed in wfn file charges = compute_mulliken_charges(sys) #Check charges expected_charge = np.array([-0.330532, 0.165266, 0.165266]) assert (abs(charges - expected_charge) < 1e-5).all()
def test_load_molden_h2o(): fn_mkl = context.get_fn('test/h2o.molden.input') sys = System.from_file(fn_mkl) # Check normalization sys.wfn.exp_alpha.check_normalization(sys.get_overlap(), 1e-5) # Check charges charges = compute_mulliken_charges(sys) expected_charges = np.array([-0.816308, 0.408154, 0.408154]) assert abs(charges - expected_charges).max() < 1e-5
def test_load_molden_he2_ghost_psi4_1(): # The file tested here is created with PSI4 (version 1.0). It should be read in # properly by ignoring the ghost atoms. fn_molden = context.get_fn('test/he2_ghost_psi4_1.0.molden') mol = IOData.from_file(fn_molden) np.testing.assert_equal(mol.pseudo_numbers, np.array([2.0])) # Check Mulliken charges. Comparison with numbers from the Molden program output. dm_full = mol.get_dm_full() charges = compute_mulliken_charges(mol.obasis, mol.lf, np.array([0.0, 2.0]), dm_full) molden_charges = np.array([-0.0041, 0.0041]) assert abs(charges - molden_charges).max() < 5e-4
def test_load_molden_nh3_turbomole(): # The file tested here is created with Turbomole 7.1 fn_molden = context.get_fn('test/nh3_turbomole.molden') mol = IOData.from_file(fn_molden) # Check Mulliken charges. Comparison with numbers from the Turbomole output. These # are slightly different than in the other tests because we are using Cartesian # functions. dm_full = mol.get_dm_full() charges = compute_mulliken_charges(mol.obasis, mol.lf, mol.pseudo_numbers, dm_full) molden_charges = np.array([0.03801, -0.27428, 0.01206, 0.22421]) assert abs(charges - molden_charges).max() < 1e-3
def test_load_molden_nh3_molden_cart(): # The file tested here is created with molden. It should be read in # properly without altering normalization and sign conventions. fn_molden = context.get_fn('test/nh3_molden_cart.molden') mol = IOData.from_file(fn_molden) # Check Mulliken charges. Comparison with numbers from the Molden program output. dm_full = mol.get_dm_full() charges = compute_mulliken_charges(mol.obasis, mol.lf, mol.pseudo_numbers, dm_full) print charges molden_charges = np.array([0.3138, -0.4300, -0.0667, 0.1829]) assert abs(charges - molden_charges).max() < 1e-3
def test_load_molden_nh3_molden_cart(): # The file tested here is created with molden. It should be read in # properly without altering normalization and sign conventions. fn_molden = context.get_fn('test/nh3_molden_cart.molden') mol = IOData.from_file(fn_molden) # Check Mulliken charges. Comparison with numbers from the Molden program output. dm_full = mol.get_dm_full() charges = compute_mulliken_charges(mol.obasis, mol.pseudo_numbers, dm_full) print charges molden_charges = np.array([0.3138, -0.4300, -0.0667, 0.1829]) assert abs(charges - molden_charges).max() < 1e-3
def test_load_molden_nh3_turbomole(): # The file tested here is created with Turbomole 7.1 fn_molden = context.get_fn('test/nh3_turbomole.molden') mol = IOData.from_file(fn_molden) # Check Mulliken charges. Comparison with numbers from the Turbomole output. These # are slightly different than in the other tests because we are using Cartesian # functions. dm_full = mol.get_dm_full() charges = compute_mulliken_charges(mol.obasis, mol.pseudo_numbers, dm_full) molden_charges = np.array([0.03801, -0.27428, 0.01206, 0.22421]) assert abs(charges - molden_charges).max() < 1e-3
def test_load_wfn_h2o_sto3g_decontracted(): fn_wfn = context.get_fn('test/h2o_sto3g_decontracted.wfn') sys = System.from_file(fn_wfn) assert isinstance(sys.wfn, RestrictedWFN) assert sys.obasis.nbasis == 21 sys.wfn.exp_alpha.check_normalization(sys.get_overlap(), 1e-5) #Chech normalization ham = Hamiltonian(sys, [HartreeFockExchange()]) #Compare to the energy printed in wfn file energy = ham.compute() assert abs(energy - (-75.162231674351)) < 1.e-5 charges = compute_mulliken_charges(sys) #Check charges expected_charge = np.array([-0.546656, 0.273328, 0.273328]) assert (abs(charges - expected_charge) < 1e-5).all()
def test_load_mkl_li2(): fn_mkl = context.get_fn('test/li2.mkl') sys = System.from_file(fn_mkl) # Check normalization sys.wfn.exp_alpha.check_normalization(sys.get_overlap(), 1e-5) sys.wfn.exp_beta.check_normalization(sys.get_overlap(), 1e5) # Check charges charges = compute_mulliken_charges(sys) expected_charges = np.array([0.5, 0.5]) assert abs(charges - expected_charges).max() < 1e-5
def test_load_molden_he2_ghost_psi4_1(): # The file tested here is created with PSI4 (version 1.0). It should be read in # properly by ignoring the ghost atoms. fn_molden = context.get_fn('test/he2_ghost_psi4_1.0.molden') mol = IOData.from_file(fn_molden) np.testing.assert_equal(mol.pseudo_numbers, np.array([2.0])) # Check Mulliken charges. Comparison with numbers from the Molden program output. dm_full = mol.get_dm_full() charges = compute_mulliken_charges(mol.obasis, np.array([0.0, 2.0]), dm_full) molden_charges = np.array([-0.0041, 0.0041]) assert abs(charges - molden_charges).max() < 5e-4
def test_load_mkl_ethanol(): fn_mkl = context.get_fn('test/ethanol.mkl') sys = System.from_file(fn_mkl) # Direct checks with mkl file assert sys.natom == 9 assert sys.coordinates.shape == (9,3) assert sys.numbers[0] == 1 assert sys.numbers[4] == 6 assert abs(sys.coordinates[2,1]/angstrom - 2.239037) < 1e-5 assert abs(sys.coordinates[5,2]/angstrom - 0.948420) < 1e-5 assert sys.obasis.nbasis == 39 assert sys.obasis.alphas[0] == 18.731137000 assert sys.obasis.alphas[10] == 7.868272400 assert sys.obasis.alphas[-3] == 2.825393700 #assert sys.obasis.con_coeffs[5] == 0.989450608 #assert sys.obasis.con_coeffs[7] == 2.079187061 #assert sys.obasis.con_coeffs[-1] == 0.181380684 assert (sys.obasis.shell_map[:5] == [0, 0, 1, 1, 1]).all() assert (sys.obasis.shell_types[:5] == [0, 0, 0, 0, 1]).all() assert (sys.obasis.nprims[-5:] == [3, 1, 1, 3, 1]).all() assert sys.wfn.exp_alpha.coeffs.shape == (39,39) assert sys.wfn.exp_alpha.energies.shape == (39,) assert sys.wfn.exp_alpha.occupations.shape == (39,) assert (sys.wfn.exp_alpha.occupations[:13] == 1.0).all() assert (sys.wfn.exp_alpha.occupations[13:] == 0.0).all() assert sys.wfn.exp_alpha.energies[4] == -1.0206976 assert sys.wfn.exp_alpha.energies[-1] == 2.0748685 assert sys.wfn.exp_alpha.coeffs[0,0] == 0.0000119 assert sys.wfn.exp_alpha.coeffs[1,0] == -0.0003216 assert sys.wfn.exp_alpha.coeffs[-1,-1] == -0.1424743 # Comparison of derived properties with ORCA output file # nuclear-nuclear repulsion assert abs(sys.compute_nucnuc() - 81.87080034) < 1e-5 # Check normalization sys.wfn.exp_alpha.check_normalization(sys.get_overlap(), 1e-5) # Mulliken charges charges = compute_mulliken_charges(sys) expected_charges = np.array([ 0.143316, -0.445861, 0.173045, 0.173021, 0.024542, 0.143066, 0.143080, -0.754230, 0.400021 ]) assert abs(charges - expected_charges).max() < 1e-5 # Compute HF energy ham = Hamiltonian(sys, [HartreeFockExchange()]) energy = ham.compute() assert abs(energy - -154.01322894) < 1e-4
def test_load_mkl_ethanol(): fn_mkl = context.get_fn('test/ethanol.mkl') mol = IOData.from_file(fn_mkl) # Direct checks with mkl file assert mol.numbers.shape == (9,) assert mol.numbers[0] == 1 assert mol.numbers[4] == 6 assert mol.coordinates.shape == (9,3) assert abs(mol.coordinates[2,1]/angstrom - 2.239037) < 1e-5 assert abs(mol.coordinates[5,2]/angstrom - 0.948420) < 1e-5 assert mol.obasis.nbasis == 39 assert mol.obasis.alphas[0] == 18.731137000 assert mol.obasis.alphas[10] == 7.868272400 assert mol.obasis.alphas[-3] == 2.825393700 #assert mol.obasis.con_coeffs[5] == 0.989450608 #assert mol.obasis.con_coeffs[7] == 2.079187061 #assert mol.obasis.con_coeffs[-1] == 0.181380684 assert (mol.obasis.shell_map[:5] == [0, 0, 1, 1, 1]).all() assert (mol.obasis.shell_types[:5] == [0, 0, 0, 0, 1]).all() assert (mol.obasis.nprims[-5:] == [3, 1, 1, 3, 1]).all() assert mol.exp_alpha.coeffs.shape == (39,39) assert mol.exp_alpha.energies.shape == (39,) assert mol.exp_alpha.occupations.shape == (39,) assert (mol.exp_alpha.occupations[:13] == 1.0).all() assert (mol.exp_alpha.occupations[13:] == 0.0).all() assert mol.exp_alpha.energies[4] == -1.0206976 assert mol.exp_alpha.energies[-1] == 2.0748685 assert mol.exp_alpha.coeffs[0,0] == 0.0000119 assert mol.exp_alpha.coeffs[1,0] == -0.0003216 assert mol.exp_alpha.coeffs[-1,-1] == -0.1424743 # Comparison of derived properties with ORCA output file # nuclear-nuclear repulsion assert abs(compute_nucnuc(mol.coordinates, mol.pseudo_numbers) - 81.87080034) < 1e-5 # Check normalization olp = mol.obasis.compute_overlap(mol.lf) mol.exp_alpha.check_normalization(olp, 1e-5) # Mulliken charges dm_full = mol.get_dm_full() charges = compute_mulliken_charges(mol.obasis, mol.lf, mol.numbers, dm_full) expected_charges = np.array([ 0.143316, -0.445861, 0.173045, 0.173021, 0.024542, 0.143066, 0.143080, -0.754230, 0.400021 ]) assert abs(charges - expected_charges).max() < 1e-5 # Compute HF energy assert abs(compute_hf_energy(mol) - -154.01322894) < 1e-4
def test_load_mkl_ethanol(): fn_mkl = context.get_fn('test/ethanol.mkl') sys = System.from_file(fn_mkl) # Direct checks with mkl file assert sys.natom == 9 assert sys.coordinates.shape == (9, 3) assert sys.numbers[0] == 1 assert sys.numbers[4] == 6 assert abs(sys.coordinates[2, 1] / angstrom - 2.239037) < 1e-5 assert abs(sys.coordinates[5, 2] / angstrom - 0.948420) < 1e-5 assert sys.obasis.nbasis == 39 assert sys.obasis.alphas[0] == 18.731137000 assert sys.obasis.alphas[10] == 7.868272400 assert sys.obasis.alphas[-3] == 2.825393700 #assert sys.obasis.con_coeffs[5] == 0.989450608 #assert sys.obasis.con_coeffs[7] == 2.079187061 #assert sys.obasis.con_coeffs[-1] == 0.181380684 assert (sys.obasis.shell_map[:5] == [0, 0, 1, 1, 1]).all() assert (sys.obasis.shell_types[:5] == [0, 0, 0, 0, 1]).all() assert (sys.obasis.nprims[-5:] == [3, 1, 1, 3, 1]).all() assert sys.wfn.exp_alpha.coeffs.shape == (39, 39) assert sys.wfn.exp_alpha.energies.shape == (39, ) assert sys.wfn.exp_alpha.occupations.shape == (39, ) assert (sys.wfn.exp_alpha.occupations[:13] == 1.0).all() assert (sys.wfn.exp_alpha.occupations[13:] == 0.0).all() assert sys.wfn.exp_alpha.energies[4] == -1.0206976 assert sys.wfn.exp_alpha.energies[-1] == 2.0748685 assert sys.wfn.exp_alpha.coeffs[0, 0] == 0.0000119 assert sys.wfn.exp_alpha.coeffs[1, 0] == -0.0003216 assert sys.wfn.exp_alpha.coeffs[-1, -1] == -0.1424743 # Comparison of derived properties with ORCA output file # nuclear-nuclear repulsion assert abs(sys.compute_nucnuc() - 81.87080034) < 1e-5 # Check normalization sys.wfn.exp_alpha.check_normalization(sys.get_overlap(), 1e-5) # Mulliken charges charges = compute_mulliken_charges(sys) expected_charges = np.array([ 0.143316, -0.445861, 0.173045, 0.173021, 0.024542, 0.143066, 0.143080, -0.754230, 0.400021 ]) assert abs(charges - expected_charges).max() < 1e-5 # Compute HF energy ham = Hamiltonian(sys, [HartreeFockExchange()]) energy = ham.compute() assert abs(energy - -154.01322894) < 1e-4
def test_load_wfn_h2o_sto3g(): fn_wfn = context.get_fn('test/h2o_sto3g.wfn') sys = System.from_file(fn_wfn) assert isinstance(sys.wfn, RestrictedWFN) sys.wfn.exp_alpha.check_normalization(sys.get_overlap(), 1e-5) #Check normalization ham = Hamiltonian(sys, [HartreeFockExchange()]) energy = ham.compute() assert abs(energy - ( -74.965901217080)) < 1.e-5 #Compare to the energy printed in wfn file charges = compute_mulliken_charges(sys) #Check charges expected_charge = np.array([-0.330532, 0.165266, 0.165266]) assert (abs(charges - expected_charge) < 1e-5).all()
def test_load_mkl_li2(): fn_mkl = context.get_fn('test/li2.mkl') mol = IOData.from_file(fn_mkl) # Check normalization olp = mol.obasis.compute_overlap(mol.lf) mol.exp_alpha.check_normalization(olp, 1e-5) mol.exp_beta.check_normalization(olp, 1e-5) # Check charges dm_full = mol.get_dm_full() charges = compute_mulliken_charges(mol.obasis, mol.lf, mol.numbers, dm_full) expected_charges = np.array([0.5, 0.5]) assert abs(charges - expected_charges).max() < 1e-5
def test_load_wfn_h2o_sto3g_decontracted(): fn_wfn = context.get_fn('test/h2o_sto3g_decontracted.wfn') sys = System.from_file(fn_wfn) assert isinstance(sys.wfn, RestrictedWFN) assert sys.obasis.nbasis == 21 sys.wfn.exp_alpha.check_normalization(sys.get_overlap(), 1e-5) #Chech normalization ham = Hamiltonian( sys, [HartreeFockExchange()]) #Compare to the energy printed in wfn file energy = ham.compute() assert abs(energy - (-75.162231674351)) < 1.e-5 charges = compute_mulliken_charges(sys) #Check charges expected_charge = np.array([-0.546656, 0.273328, 0.273328]) assert (abs(charges - expected_charge) < 1e-5).all()
def test_load_molden_h2o_orca(): fn_molden = context.get_fn('test/h2o.molden.input') mol = IOData.from_file(fn_molden) # Checkt title assert mol.title == 'Molden file created by orca_2mkl for BaseName=h2o' # Check normalization olp = mol.obasis.compute_overlap() mol.orb_alpha.check_normalization(olp, 1e-5) # Check Mulliken charges dm_full = mol.get_dm_full() charges = compute_mulliken_charges(mol.obasis, mol.pseudo_numbers, dm_full) expected_charges = np.array([-0.816308, 0.408154, 0.408154]) assert abs(charges - expected_charges).max() < 1e-5
def test_load_molden_h2o_orca(): fn_molden = context.get_fn('test/h2o.molden.input') mol = IOData.from_file(fn_molden) # Checkt title assert mol.title == 'Molden file created by orca_2mkl for BaseName=h2o' # Check normalization olp = mol.obasis.compute_overlap(mol.lf) mol.exp_alpha.check_normalization(olp, 1e-5) # Check Mulliken charges dm_full = mol.get_dm_full() charges = compute_mulliken_charges(mol.obasis, mol.lf, mol.pseudo_numbers, dm_full) expected_charges = np.array([-0.816308, 0.408154, 0.408154]) assert abs(charges - expected_charges).max() < 1e-5
def test_load_wfn_h2_ccpvqz_virtual(): fn_wfn = context.get_fn('test/h2_ccpvqz.wfn') sys = System.from_file(fn_wfn) assert isinstance(sys.wfn, RestrictedWFN) assert sys.obasis.nbasis == 74 sys.wfn.exp_alpha.check_normalization(sys.get_overlap(), 1e-5) #Chech normalization assert (abs(sys.obasis.alphas[:5] - [82.64000, 12.41000, 2.824000, 0.7977000, 0.2581000]) < 1.e-5).all() assert (sys.wfn.exp_alpha.energies[:5] == [-0.596838, 0.144565, 0.209605, 0.460401, 0.460401]).all() assert (sys.wfn.exp_alpha.energies[-5:] == [12.859067, 13.017471, 16.405834, 25.824716, 26.100443]).all() assert (sys.wfn.exp_alpha.occupations[:5] == [1.0, 0.0, 0.0, 0.0, 0.0] ).all() assert abs(sys.wfn.exp_alpha.occupations.sum() - 1.0) < 1.e-6 ham = Hamiltonian(sys, [HartreeFockExchange()]) energy = ham.compute() assert abs(energy - (-1.133504568400)) < 1.e-5 #Compare to the energy printed in wfn file charges = compute_mulliken_charges(sys) #Check charges expected_charge = np.array([0.0, 0.0]) assert (abs(charges - expected_charge) < 1e-5).all()
def check_wfn(fn_wfn, restricted, nbasis, energy, charges): fn_wfn = context.get_fn(fn_wfn) mol = IOData.from_file(fn_wfn) assert mol.obasis.nbasis == nbasis olp = mol.obasis.compute_overlap(mol.lf) if restricted: mol.exp_alpha.check_normalization(olp, 1e-5) assert not hasattr(mol, 'exp_beta') else: mol.exp_alpha.check_normalization(olp, 1e-5) mol.exp_beta.check_normalization(olp, 1e-5) if energy is not None: myenergy = compute_hf_energy(mol) assert abs(energy - myenergy) < 1e-5 dm_full = mol.get_dm_full() mycharges = compute_mulliken_charges(mol.obasis, mol.lf, mol.numbers, dm_full) assert (abs(charges - mycharges) < 1e-5).all() return mol.obasis, mol.lf, mol.coordinates, mol.numbers, dm_full, mol.exp_alpha, getattr(mol, 'exp_beta', None)
def test_load_molden_li2_orca(): fn_molden = context.get_fn('test/li2.molden.input') mol = IOData.from_file(fn_molden) # Checkt title assert mol.title == 'Molden file created by orca_2mkl for BaseName=li2' # Check normalization olp = mol.obasis.compute_overlap(mol.lf) mol.exp_alpha.check_normalization(olp, 1e-5) mol.exp_beta.check_normalization(olp, 1e-5) # Check Mulliken charges dm_full = mol.get_dm_full() charges = compute_mulliken_charges(mol.obasis, mol.lf, mol.numbers, dm_full) expected_charges = np.array([0.5, 0.5]) assert abs(charges - expected_charges).max() < 1e-5
def test_load_wfn_lih_cation_fci(): fn_wfn = context.get_fn('test/lih_cation_fci.wfn') sys = System.from_file(fn_wfn) assert sys.natom == 2 assert sys.obasis.nbasis == 26 assert (sys.numbers == [3, 1]).all() sys.wfn.exp_alpha.check_normalization(sys.get_overlap(), 1e-5) #Check normalization ham = Hamiltonian(sys, [HartreeFockExchange()]) energy = ham.compute() #cannot be compared! kin = sys.extra['energy_kin'] nn = sys.extra['energy_nn'] expected_kin = 7.7989675958 #FCI kinetic energy expected_nn = 0.9766607347 assert (kin - expected_kin) < 1.e-6 assert (nn - expected_nn) < 1.e-6 assert sys.wfn.exp_alpha.occupations.shape == (11,) assert abs(sys.wfn.exp_alpha.occupations.sum() - 1.5) < 1.e-6 charges = compute_mulliken_charges(sys) #Check charges expected_charge = np.array([0.913206, 0.086794]) assert (abs(charges - expected_charge) < 1e-5).all() point = np.array([])
def test_load_wfn_li_sp_virtual(): fn_wfn = context.get_fn('test/li_sp_virtual.wfn') sys = System.from_file(fn_wfn) assert isinstance(sys.wfn, UnrestrictedWFN) assert sys.obasis.nbasis == 8 sys.wfn.exp_alpha.check_normalization(sys.get_overlap(), 1e-5) #Check normalization sys.wfn.exp_beta.check_normalization(sys.get_overlap(), 1e-5) #Check normalization assert abs(sys.wfn.exp_alpha.occupations.sum() - 2.0) < 1.e-6 assert abs(sys.wfn.exp_beta.occupations.sum() - 1.0) < 1.e-6 assert (sys.wfn.exp_alpha.occupations == [1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]).all() assert (sys.wfn.exp_beta.occupations == [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]).all() assert (abs(sys.wfn.exp_alpha.energies - [-0.087492, -0.080310, 0.158784, 0.158784, 1.078773, 1.090891, 1.090891, 49.643670]) < 1.e-6).all() assert (abs(sys.wfn.exp_beta.energies - [-0.079905, 0.176681, 0.176681, 0.212494, 1.096631, 1.096631, 1.122821, 49.643827]) < 1.e-6).all() assert sys.wfn.exp_alpha.coeffs.shape == (8, 8) assert sys.wfn.exp_beta.coeffs.shape == (8, 8) ham = Hamiltonian(sys, [HartreeFockExchange()]) energy = ham.compute() assert abs(energy - (-3.712905542719)) < 1.e-6 #Compare to the energy printed in wfn file charges = compute_mulliken_charges(sys) #Check charges expected_charge = np.array([0.0, 0.0]) assert (abs(charges - expected_charge) < 1e-5).all()
def test_load_wfn_lih_cation_fci(): fn_wfn = context.get_fn('test/lih_cation_fci.wfn') sys = System.from_file(fn_wfn) assert sys.natom == 2 assert sys.obasis.nbasis == 26 assert (sys.numbers == [3, 1]).all() sys.wfn.exp_alpha.check_normalization(sys.get_overlap(), 1e-5) #Check normalization ham = Hamiltonian(sys, [HartreeFockExchange()]) energy = ham.compute() #cannot be compared! kin = sys.extra['energy_kin'] nn = sys.extra['energy_nn'] expected_kin = 7.7989675958 #FCI kinetic energy expected_nn = 0.9766607347 assert (kin - expected_kin) < 1.e-6 assert (nn - expected_nn) < 1.e-6 assert sys.wfn.exp_alpha.occupations.shape == (11, ) assert abs(sys.wfn.exp_alpha.occupations.sum() - 1.5) < 1.e-6 charges = compute_mulliken_charges(sys) #Check charges expected_charge = np.array([0.913206, 0.086794]) assert (abs(charges - expected_charge) < 1e-5).all() point = np.array([])