def test_condense_from_molecule_fd_rmf_npa_h2o_fchk():
# expected populations of H2O from fchk file
expected_m = np.array([8, 1, 1]) - np.array(
[-3.64452391E-02, 5.18222784E-01, 5.18222455E-01])
expected_0 = np.array([8, 1, 1]) - np.array(
[-9.00876494E-01, 4.50438267E-01, 4.50438227E-01])
expected_p = np.array([8, 1, 1]) - np.array(
[-1.11332869E+00, 5.66635486E-02, 5.66651430E-02])
molecule = []
with path('chemtools.data', 'h2o_q+0_ub3lyp_ccpvtz.fchk') as file1:
molecule.append(Molecule.from_file(file1))
with path('chemtools.data', 'h2o_q-1_ub3lyp_ccpvtz.fchk') as file2:
molecule.append(Molecule.from_file(file2))
with path('chemtools.data', 'h2o_q+1_ub3lyp_ccpvtz.fchk') as file3:
molecule.append(Molecule.from_file(file3))
# check from_molecule linear
model = CondensedConceptualDFT.from_molecule(molecule, "linear", "RMF",
"npa")
check_condensed_reactivity(model, "linear", expected_0, expected_p,
expected_m, 10, 0.572546)
# check from_molecule quadratic
model = CondensedConceptualDFT.from_molecule(molecule, "quadratic", "RMF",
"npa")
check_condensed_reactivity(model, "quadratic", expected_0, expected_p,
expected_m, 10, 0.572546)
def from_file(cls, fname, spacing=0.2, extension=5.0, rotate=True):
"""
Initialize ``UniformGrid`` class based on the grid specifications of a file.
Parameters
----------
fname : str
Path to molecule's file.
spacing : float, optional
Increment between grid points along `x`, `y` and `z` direction.
extension : float, optional
The extension of the cube on each side of the molecule.
rotate : bool, optional
When True, the molecule is rotated so the axes of the cube file are
aligned with the principle axes of rotation of the molecule.
"""
# Load file
logging.basicConfig(level=logging.INFO,
format='%(levelname)s: %(message)s')
try:
mol = Molecule.from_file(str(fname))
except IOError as _:
try:
with path('chemtools.data.examples', str(fname)) as fname:
logging.info('Loading {0}'.format(str(fname)))
mol = Molecule.from_file(str(fname))
except IOError as error:
logging.info(error)
return cls.from_molecule(mol, spacing, extension, rotate)
def test_condense_from_molecule_fd_rmf_esp_h2o_fchk():
# expected populations of H2O from fchk file
expected_m = np.array([8, 1, 1]) - np.array(
[4.14233893E-02, 4.79288419E-01, 4.79288192E-01])
expected_0 = np.array([8, 1, 1]) - np.array(
[-7.00779373E-01, 3.50389629E-01, 3.50389744E-01])
expected_p = np.array([8, 1, 1]) - np.array(
[-5.81613550E-01, -2.09193820E-01, -2.09192630E-01])
molecule = []
with path('chemtools.data', 'h2o_q+0_ub3lyp_ccpvtz.fchk') as file1:
molecule.append(Molecule.from_file(file1))
with path('chemtools.data', 'h2o_q-1_ub3lyp_ccpvtz.fchk') as file2:
molecule.append(Molecule.from_file(file2))
with path('chemtools.data', 'h2o_q+1_ub3lyp_ccpvtz.fchk') as file3:
molecule.append(Molecule.from_file(file3))
# check from_molecule linear
model = CondensedConceptualDFT.from_molecule(molecule, "linear", "RMF",
"esp")
check_condensed_reactivity(model, "linear", expected_0, expected_p,
expected_m, 10, 0.572546)
# check from_molecule quadratic
model = CondensedConceptualDFT.from_molecule(molecule, "quadratic", "RMF",
"esp")
check_condensed_reactivity(model, "quadratic", expected_0, expected_p,
expected_m, 10, 0.572546)
def test_condense_from_molecule_fd_rmf_mulliken_h2o_fchk():
# expected populations of H2O from fchk file
expected_m = np.array([8, 1, 1]) - np.array(
[3.49417097E-01, 3.25291762E-01, 3.25291141E-01])
expected_0 = np.array([8, 1, 1]) - np.array(
[-4.32227787E-01, 2.16114060E-01, 2.16113727E-01])
expected_p = np.array([8, 1, 1]) - np.array(
[-2.64833827E-01, -3.67583325E-01, -3.67582849E-01])
molecule = []
with path('chemtools.data', 'h2o_q+0_ub3lyp_ccpvtz.fchk') as file1:
molecule.append(Molecule.from_file(file1))
with path('chemtools.data', 'h2o_q-1_ub3lyp_ccpvtz.fchk') as file2:
molecule.append(Molecule.from_file(file2))
with path('chemtools.data', 'h2o_q+1_ub3lyp_ccpvtz.fchk') as file3:
molecule.append(Molecule.from_file(file3))
# check from_molecule linear
model = CondensedConceptualDFT.from_molecule(molecule, "linear", "RMF",
"mulliken")
check_condensed_reactivity(model, "linear", expected_0, expected_p,
expected_m, 10, 0.572546)
# check from_molecule quadratic
model = CondensedConceptualDFT.from_molecule(molecule, "quadratic", "RMF",
"mulliken")
check_condensed_reactivity(model, "quadratic", expected_0, expected_p,
expected_m, 10, 0.572546)
def test_condense_linear_from_file_fmr_h_ch4_wfn():
# expected populations of CH4 computed with HORTON
with path('chemtools.data', 'ch4_uhf_ccpvdz.wfn') as fname:
model1 = CondensedConceptualDFT.from_file(fname, "linear", "FMR", "h")
model2 = CondensedConceptualDFT.from_file([fname], "linear", "FMR",
"h")
mol = Molecule.from_file(fname)
grid = MolecularGrid(mol.coordinates, mol.numbers, mol.pseudo_numbesr,
'insane', 3, False)
model3 = CondensedConceptualDFT.from_file(fname,
"linear",
"FMR",
"h",
grid=grid)
model4 = CondensedConceptualDFT.from_file([fname],
"linear",
"FMR",
"h",
grid=grid)
expected = np.array(
[6.11301651, 0.97175462, 0.97175263, 0.9717521, 0.97174353])
# check using fname given as a string
check_condensed_reactivity(model1, "linear", expected, None, None, 10,
0.736396)
# check using fname given as a list
check_condensed_reactivity(model2, "linear", expected, None, None, 10,
0.736396)
# check using fname as a string & passing grid
mol = Molecule.from_file(fname)
check_condensed_reactivity(model3, "linear", expected, None, None, 10,
0.736396)
# check using fname as a list & passing grid
check_condensed_reactivity(model4, "linear", expected, None, None, 10,
0.736396)
def test_get_matching_attr_raises():
# check molecule
with path('chemtools.data', 'ch4_uhf_ccpvdz.fchk') as file1:
with path('chemtools.data', 'h2o_q+0_ub3lyp_ccpvtz.fchk') as file2:
fname = [file1, file2]
assert_raises(ValueError, get_matching_attr, fname, "numbers")
assert_raises(ValueError, get_matching_attr, fname, "coordinates")
# check matching attribute
with path('chemtools.data', 'ch4_uhf_ccpvdz.fchk') as file1:
with path('chemtools.data', 'h2o_q+0_ub3lyp_ccpvtz.fchk') as file2:
molecule = [Molecule.from_file(file1), Molecule.from_file(file2)]
assert_raises(ValueError, get_matching_attr, molecule, "numbers")
assert_raises(ValueError, get_matching_attr, molecule, "coordinates")
def test_analyze_nci_h2o_dimer_fchk():
with path('chemtools.data', 'h2o_dimer_pbe_sto3g.fchk') as file_path:
mol = Molecule.from_file(file_path)
# Check against .cube files created with NCIPLOT by E.R. Johnson and J. Contreras-Garcia
with path('chemtools.data',
'h2o_dimer_pbe_sto3g-dens.cube') as dens_cube1_path:
cube = UniformGrid.from_cube(dens_cube1_path)
# Build the NCI tool
desp = NCI.from_molecule(mol, grid=cube)
# Check against .cube files created with NCIPLOT by E.R. Johnson and J. Contreras-Garcia
with path('chemtools.data',
'h2o_dimer_pbe_sto3g-grad.cube') as grad_cube1_path:
dmol1 = Molecule.from_file(str(dens_cube1_path))
gmol1 = Molecule.from_file(str(grad_cube1_path))
with tmpdir(
'chemtools.analysis.test.test_base.test_analyze_nci_h2o_dimer_fchk'
) as dn:
cube2 = '%s/%s' % (dn, 'h2o_dimer_pbe_sto3g')
desp.generate_scripts(cube2)
cube2 = '%s/%s' % (dn, 'h2o_dimer_pbe_sto3g-dens.cube')
mol2 = Molecule.from_file(cube2)
# Check coordinates
assert_almost_equal(dmol1.coordinates, mol2.coordinates, decimal=6)
assert_equal(dmol1.numbers, mol2.numbers)
# Check grid data
ugrid1 = dmol1.grid
ugrid2 = mol2.grid
assert_almost_equal(ugrid1.grid_rvecs, ugrid2.grid_rvecs, decimal=6)
assert_equal(ugrid1.shape, ugrid2.shape)
data1 = dmol1.cube_data / dmol1.cube_data
data2 = mol2.cube_data / dmol1.cube_data
assert_almost_equal(data1, data2, decimal=4)
assert_equal(dmol1.pseudo_numbers, mol2.pseudo_numbers)
cube2 = '%s/%s' % (dn, 'h2o_dimer_pbe_sto3g-grad.cube')
mol2 = Molecule.from_file(cube2)
# Check coordinates
assert_almost_equal(gmol1.coordinates, mol2.coordinates, decimal=6)
assert_equal(gmol1.numbers, mol2.numbers)
# Check grid data
ugrid1 = gmol1.grid
ugrid2 = mol2.grid
assert_almost_equal(ugrid1.grid_rvecs, ugrid2.grid_rvecs, decimal=6)
assert_equal(ugrid1.shape, ugrid2.shape)
data1 = gmol1.cube_data / gmol1.cube_data
data2 = mol2.cube_data / gmol1.cube_data
assert_almost_equal(data1, data2, decimal=4)
assert_equal(gmol1.pseudo_numbers, mol2.pseudo_numbers)
def test_orbital_based_from_molecule_orbital_expression_ch4_uhf_ccpvdz():
# load data computed with Fortran code
with path("chemtools.data", "data_fortran_ch4_uhf_ccpvdz.npz") as fname:
data = np.load(str(fname))
# test from_molecule initialization with exp_beta & check against Fortran code
with path("chemtools.data", "ch4_uhf_ccpvdz.fchk") as fname:
molecule = Molecule.from_file(fname)
tool = DFTBasedTool(molecule, data["points"])
check_orbital_expression(tool, data)
# test from_molecule initialization without exp_beta & check against Fortran code
del molecule._exp_beta
with path("chemtools.data", "ch4_uhf_ccpvdz.fchk") as fname:
molecule = Molecule.from_file(fname)
tool = DFTBasedTool(molecule, data["points"])
check_orbital_expression(tool, data)
def test_kinetic_from_molecule_ch4_uhf_ccpvdz():
# load data computed with Fortran code
with path("chemtools.data", "data_fortran_ch4_uhf_ccpvdz.npz") as fname:
data = np.load(str(fname))
# test from_molecule initialization with exp_beta & check against Fortran code
with path("chemtools.data", "ch4_uhf_ccpvdz.fchk") as fname:
molecule = Molecule.from_file(fname)
tool = KED.from_molecule(molecule, data['points'])
print('tool = ', tool)
check_kinetic_energy_density(tool, data)
# test from_molecule initialization without exp_beta & check against Fortran code
del molecule._exp_beta
with path("chemtools.data", "ch4_uhf_ccpvdz.fchk") as fname:
molecule = Molecule.from_file(fname)
tool = KED.from_molecule(molecule, data['points'])
check_kinetic_energy_density(tool, data)
def from_file(cls, fname, spin='ab', index=None, grid=None, trans='inverse_rational',
trans_k=1, trans_a=1, denscut=0.0005):
"""Initialize class from wave-function file.
Parameters
----------
fname : str
Path to a molecule's file.
spin : str, optional
Type of occupied spin orbitals; options are 'a', 'b' & 'ab'.
index : int or sequence of int, optional
Sequence of spin orbital indices to use. If None, all occupied spin orbitals are used.
grid : instance of `Grid`, optional
Grid used for computation of LOL. Only if this a CubeGrid one can generate the scripts.
If None, a cubic grid is constructed from molecule with spacing=0.1 & extension=2.0.
trans : str, optional
Type of transformation applied to LOL ratio; options are 'inverse_rational' or
'inverse_hyperbolic'.
trans_k : float, optional
Parameter :math:`k` of transformation.
trans_a : float, optional
Parameter :math:`a` of transformation.
denscut : float, optional
Value of density cut. LOL value of points with density < denscut is set to zero.
"""
molecule = Molecule.from_file(fname)
return cls.from_molecule(molecule, spin, index, grid, trans, trans_k, trans_a, denscut)
def test_uniformgrid_from_molecule_o2_uhf():
with path('chemtools.data', 'o2_uhf.fchk') as fpath:
mol = Molecule.from_file(str(fpath))
# create cube file from molecule:
cube = UniformGrid.from_molecule(mol)
# test the cube gives the right result:
origin_result = [-5.0, -5.0, -6.1]
axes_result = [[0.0, 0.0, 0.2], [0.0, 0.2, 0.0], [0.2, 0.0, 0.0]]
shape_result = [61, 50, 50]
weight_result = np.full(cube.npoints, 0.0080)
np.testing.assert_array_almost_equal(cube.origin, origin_result, decimal=7)
np.testing.assert_array_almost_equal(cube.axes, axes_result, decimal=7)
np.testing.assert_array_equal(cube.shape, shape_result)
np.testing.assert_array_almost_equal(cube.weights(), weight_result, decimal=7)
np.testing.assert_array_almost_equal(cube.weights(method='R0'), weight_result, decimal=7)
np.testing.assert_array_almost_equal(cube.weights(method='R'), weight_result, decimal=7)
# test integration of Fukui functions:
tool = LocalConceptualDFT.from_file(str(fpath), model='linear', points=cube.points)
ffm_default = cube.integrate(tool.ff_minus)
ffm_r = cube.integrate(tool.ff_minus, method='R')
ffm_r0 = cube.integrate(tool.ff_minus, method='R0')
np.testing.assert_almost_equal(ffm_default, ffm_r, decimal=7)
np.testing.assert_almost_equal(ffm_r, ffm_r0, decimal=7)
np.testing.assert_almost_equal(ffm_default, 1.000, decimal=2)
np.testing.assert_almost_equal(ffm_default, 1.000, decimal=2)
np.testing.assert_almost_equal(ffm_default, 1.000, decimal=2)
def test_kinetic_from_molecule_h2o_nuclei():
# test against multiwfn 3.6 dev src
with path('chemtools.data',
'data_multiwfn36_fchk_h2o_q+0_ub3lyp_ccpvtz.npz') as fname:
data = np.load(str(fname))
with path('chemtools.data', 'h2o_q+0_ub3lyp_ccpvtz.fchk') as fname:
molecule = Molecule.from_file(fname)
tool = KED.from_molecule(molecule, data['coords'])
# check attributes
assert_allclose(tool.density, data['nuc_dens'], rtol=1.e-6, atol=0.)
assert_allclose(tool.gradient, data['nuc_grad'], rtol=1.e-6, atol=0.)
assert_allclose(tool.laplacian, data['nuc_lap'], rtol=1.e-6, atol=0.)
# check ked at the position of nuclei
assert_allclose(tool.ked_positive_definite,
data['nuc_ked_pd'],
rtol=1.e-5,
atol=0.)
assert_allclose(tool.ked_hamiltonian,
data['nuc_ked_ham'],
rtol=1.e-5,
atol=0.)
assert_allclose(tool.ked_general(alpha=0.),
data['nuc_ked_ham'],
rtol=1.e-5,
atol=0.)
def test_condense_quadratic_from_molecule_fmr_mbis_ch4_fchk():
# expected populations of CH4 computed with HORTON
with path('chemtools.data', 'ch4_uhf_ccpvdz.fchk') as fname:
mol = Molecule.from_file(fname)
expected = np.array(
[6.46038055, 0.88489494, 0.88492901, 0.88493897, 0.88492396])
# check from_molecule
model = CondensedConceptualDFT.from_molecule(mol, "quadratic", "FMR",
"mbis")
check_condensed_reactivity(model, "quadratic", expected, None, None, 10,
0.736396)
# check from_molecule given as a list
model = CondensedConceptualDFT.from_molecule([mol], "quadratic", "FMR",
"mbis")
check_condensed_reactivity(model, "quadratic", expected, None, None, 10,
0.736396)
# check from_molecule & passing grid
grid = MolecularGrid(mol.coordinates, mol.numbers, mol.pseudo_numbesr,
'insane', 3, False)
model = CondensedConceptualDFT.from_molecule(mol,
"quadratic",
"FMR",
"mbis",
grid=grid)
check_condensed_reactivity(model, "quadratic", expected, None, None, 10,
0.736396)
# check from_molecule given as a list & passing grid
model = CondensedConceptualDFT.from_molecule([mol],
"quadratic",
"FMR",
"mbis",
grid=grid)
check_condensed_reactivity(model, "quadratic", expected, None, None, 10,
0.736396)
def test_condense_linear_from_file_fmr_mbis_ch4_fchk():
# expected populations of CH4 computed with HORTON
with path('chemtools.data', 'ch4_uhf_ccpvdz.fchk') as fname:
model1 = CondensedConceptualDFT.from_file(fname, "linear", "FMR",
"mbis")
model2 = CondensedConceptualDFT.from_file([fname], "linear", "FMR",
"mbis")
mol = Molecule.from_file(fname)
grid = MolecularGrid(mol.coordinates, mol.numbers, mol.pseudo_numbesr,
'insane', 3, False)
model3 = CondensedConceptualDFT.from_file(fname,
"linear",
"FMR",
"mbis",
grid=grid)
model4 = CondensedConceptualDFT.from_file([fname],
"linear",
"FMR",
"mbis",
grid=grid)
expected = np.array(
[6.46038055, 0.88489494, 0.88492901, 0.88493897, 0.88492396])
# check using fname given as a string
check_condensed_reactivity(model1, "linear", expected, None, None, 10,
0.736396)
# check using fname given as a list
check_condensed_reactivity(model2, "linear", expected, None, None, 10,
0.736396)
# check using fname as a string & passing grid
check_condensed_reactivity(model3, "linear", expected, None, None, 10,
0.736396)
# check using fname as a list & passing grid
check_condensed_reactivity(model4, "linear", expected, None, None, 10,
0.736396)
def test_critical_point_h2o():
# test against multiwfn 3.6 dev src
with path("chemtools.data",
"data_multiwfn36_fchk_h2o_q+0_ub3lyp_ccpvtz.npz") as fname:
data = np.load(str(fname))
nna, bcp = data["nna_coords"], data["bcp_coords"]
# find critical points
with path("chemtools.data", "h2o_q+0_ub3lyp_ccpvtz.fchk") as fpath:
mol = Molecule.from_file(fpath)
cub = UniformGrid.from_molecule(mol,
spacing=0.15,
extension=0.1,
rotate=False)
top = TopologicalTool.from_molecule(mol, points=cub.points)
# check NA
assert len(top.nna) == 3
assert sum([np.allclose(top.nna[0].coordinate, c, rtol=0.0)
for c in nna]) == 1
assert sum([np.allclose(top.nna[1].coordinate, c, rtol=0.0)
for c in nna]) == 1
assert sum([np.allclose(top.nna[2].coordinate, c, rtol=0.0)
for c in nna]) == 1
# check BCP
assert len(top.bcp) == 2
assert sum([np.allclose(top.bcp[0].coordinate, c, rtol=0.0)
for c in bcp]) == 1
assert sum([np.allclose(top.bcp[1].coordinate, c, rtol=0.0)
for c in bcp]) == 1
# check total number of CP
assert len(top.rcp) == 0
assert len(top.ccp) == 0
assert len(top.cps) == 5
assert top.poincare_hopf_equation
def test_condense_linear_from_molecule_fmr_h_ch4_fchk():
# expected populations of CH4 computed with HORTON
with path('chemtools.data', 'ch4_uhf_ccpvdz.fchk') as fname:
mol = Molecule.from_file(fname)
expected = np.array(
[6.11301651, 0.97175462, 0.97175263, 0.9717521, 0.97174353])
# check from_molecule
model = CondensedConceptualDFT.from_molecule(mol, "linear", "FMR", "h")
check_condensed_reactivity(model, "linear", expected, None, None, 10,
0.736396)
# check from_molecule given as a list
model = CondensedConceptualDFT.from_molecule([mol], "linear", "FMR", "h")
check_condensed_reactivity(model, "linear", expected, None, None, 10,
0.736396)
# check from_molecule & passing grid
grid = MolecularGrid(mol.coordinates, mol.numbers, mol.pseudo_numbesr,
'insane', 3, False)
model = CondensedConceptualDFT.from_molecule(mol,
"linear",
"FMR",
"h",
grid=grid)
check_condensed_reactivity(model, "linear", expected, None, None, 10,
0.736396)
# check from_molecule given as a list & passing grid
model = CondensedConceptualDFT.from_molecule([mol],
"linear",
"FMR",
"h",
grid=grid)
check_condensed_reactivity(model, "linear", expected, None, None, 10,
0.736396)
def test_populations_mulliken_h2o_anion():
# Test against Gaussian
with path("chemtools.data", "h2o_q-1_ub3lyp_ccpvtz.fchk") as fname:
mol = Molecule.from_file(str(fname))
assert_raises(ValueError, OrbPart.from_molecule, mol, 'muliken')
mot = OrbPart.from_molecule(mol)
mulliken = np.array([-2.64833827E-01, -3.67583325E-01, -3.67582849E-01])
assert np.allclose(mulliken, mot.charges, atol=1e-6)
def __init__(self, input_file):
self.input_file = input_file
# Initialize the molecule from a input_file
self.mol = Molecule.from_file(input_file)
self.coordinates = self.mol.coordinates
self.charges = self.mol.numbers
self.atoms = self.get_atom_list(self.charges)
self.geometry = list(zip(self.atoms, self.coordinates))
def test_kinetic_from_molecule_ch4_rhf_ccpvdz():
# load data computed with Fortran code
with path("chemtools.data",
"data_orbitalbased_fortran_ch4_uhf_ccpvdz.npz") as fname:
data = np.load(str(fname))
# test from_file initialization & check against Fortran code
with path("chemtools.data", "ch4_rhf_ccpvdz.fchk") as fname:
molecule = Molecule.from_file(fname)
tool = KED.from_molecule(molecule, data['points'])
check_kinetic_energy_density(tool, data)
def test_condense_quadratic_from_molecule_fmr_mbis_ch4_wfn():
# expected populations of CH4 computed with HORTON
with path('chemtools.data', 'ch4_uhf_ccpvdz.wfn') as fname:
molecule = Molecule.from_file(fname)
part = DensPart.from_molecule(molecule, scheme='mbis')
expected = np.array(
[6.46038055, 0.88489494, 0.88492901, 0.88493897, 0.88492396])
computed = part.numbers - part.charges
assert np.all(abs(expected - computed) < 1.e-2)
assert np.all(abs(part.condense_to_atoms(part.density) - computed) < 1.e-2)
def load_file(fnames):
"""Return `Molecule` instances corresponding to fnames.
Parameters
----------
fnames : str or Sequence of str
Strings specifying the path to molecule's file, or sequence of strings specifying
path to molecule files.
"""
if isinstance(fnames, (str, unicode, Path)):
# case of one file not given as a list
molecule = Molecule.from_file(fnames)
elif len(fnames) == 1 and isinstance(fnames[0], (str, unicode)):
# case of one file given as a list
molecule = Molecule.from_file(fnames[0])
else:
# case of multiple files
molecule = [Molecule.from_file(fname) for fname in fnames]
return molecule
def test_global_quadratic_fd_h2o_fchk():
ep, e0, en = -7.599493522312368E+01, -7.645980351270224E+01, -7.635212549312298E+01
ip, ea, energy = ep - e0, e0 - en, e0
# check quadratic global conceptual DFT model
with path("chemtools.data", "h2o_q+0_ub3lyp_ccpvtz.fchk") as file1:
with path("chemtools.data", "h2o_q-1_ub3lyp_ccpvtz.fchk") as file2:
with path("chemtools.data", "h2o_q+1_ub3lyp_ccpvtz.fchk") as file3:
fname = [file1, file2, file3]
model1 = GlobalConceptualDFT.from_file(fname, "quadratic")
molecule = [Molecule.from_file(item) for item in fname]
model2 = GlobalConceptualDFT.from_molecule(
molecule, "quadratic")
# cehck from_file
check_global_reactivity_quadratic(model1, ip, ea, energy, 10)
# check from_molecule
check_global_reactivity_quadratic(model2, ip, ea, energy, 10)
# rearrange input files
with path("chemtools.data", "h2o_q+1_ub3lyp_ccpvtz.fchk") as file1:
with path("chemtools.data", "h2o_q+0_ub3lyp_ccpvtz.fchk") as file2:
with path("chemtools.data", "h2o_q-1_ub3lyp_ccpvtz.fchk") as file3:
fname = [file1, file2, file3]
# check from_file
model1 = GlobalConceptualDFT.from_file(fname, "quadratic")
molecule = [Molecule.from_file(item) for item in fname]
model2 = GlobalConceptualDFT.from_molecule(
molecule, "quadratic")
check_global_reactivity_quadratic(model1, ip, ea, energy, 10)
# check from_molecule
check_global_reactivity_quadratic(model2, ip, ea, energy, 10)
# rearrange input files
with path("chemtools.data", "h2o_q-1_ub3lyp_ccpvtz.fchk") as file1:
with path("chemtools.data", "h2o_q+1_ub3lyp_ccpvtz.fchk") as file2:
with path("chemtools.data", "h2o_q+0_ub3lyp_ccpvtz.fchk") as file3:
fname = [file1, file2, file3]
model1 = GlobalConceptualDFT.from_file(fname, "quadratic")
molecule = [Molecule.from_file(item) for item in fname]
model2 = GlobalConceptualDFT.from_molecule(
molecule, "quadratic")
# check from_file
check_global_reactivity_quadratic(model1, ip, ea, energy, 10)
# check from_molecule
check_global_reactivity_quadratic(model2, ip, ea, energy, 10)
def test_condense_quadratic_from_molecule_fmr_mbis_ch4_wfn():
# expected populations of CH4 computed with HORTON
with path('chemtools.data', 'ch4_uhf_ccpvdz.wfn') as fname:
molecule = Molecule.from_file(fname)
expected = np.array([6.46038055, 0.88489494, 0.88492901, 0.88493897, 0.88492396])
# check from_molecule given as a string
model = CondensedConceptualDFT.from_molecule(molecule, "quadratic", "FMR", "mbis")
check_condensed_reactivity(model, "quadratic", expected, None, None, 10)
# check from_molecule given as a list
model = CondensedConceptualDFT.from_molecule([molecule], "quadratic", "FMR", "mbis")
check_condensed_reactivity(model, "quadratic", expected, None, None, 10)
def test_get_dict_energy_raises():
# check molecule
with path('chemtools.data', 'ch4_uhf_ccpvdz.fchk') as file1:
with path('chemtools.data', 'h2o_q+0_ub3lyp_ccpvtz.fchk') as file2:
fname = [file1, file2]
assert_raises(ValueError, get_dict_energy, fname)
assert_raises(ValueError, get_dict_energy, str(file1))
assert_raises(ValueError, get_dict_energy, "gibberish")
# check repeated molecules
with path('chemtools.data', 'ch4_uhf_ccpvdz.fchk') as fname:
molecule = [
Molecule.from_file(fname),
Molecule.from_file(fname),
]
assert_raises(ValueError, get_dict_energy, molecule)
# check molecules with the same number of molecules
with path('chemtools.data', 'ch4_uhf_ccpvdz.fchk') as file1:
with path('chemtools.data', 'h2o_q+0_ub3lyp_ccpvtz.fchk') as file2:
molecule = [Molecule.from_file(file1), Molecule.from_file(file2)]
assert_raises(ValueError, get_dict_energy, molecule)
def test_global_quadratic_from_molecule_fmo_h2o_anion_fchk():
# FMO: ip = -E(H**O) & ea = -E(LUMO)
ip, ea, energy = -1.93118022E-01, -2.69116912E-01, -7.635212549312298E+01
with path("chemtools.data", "h2o_q-1_ub3lyp_ccpvtz.fchk") as fname:
molecule = Molecule.from_file(fname)
# check quadratic global conceptual DFT model from a fname given as string
model = GlobalConceptualDFT.from_molecule(molecule, "quadratic")
check_global_reactivity_quadratic(model, ip, ea, energy, 11)
# check quadratic global conceptual DFT model from a fname given as a list of string
model = GlobalConceptualDFT.from_molecule([molecule], "quadratic")
check_global_reactivity_quadratic(model, ip, ea, energy, 11)
def from_file(cls, fname):
"""Initialize class from wave-function file.
Parameters
----------
fname : str
Path to molecule's wave-function file.
"""
molecule = Molecule.from_file(fname)
return cls.from_molecule(molecule)
def test_global_linear_from_molecule_fmo_h2o_anion_fchk():
# FMO: ip = -E(H**O) & ea = -E(LUMO)
ip, ea, energy = -1.93118022E-01, -2.69116912E-01, -7.635212549312298E+01
with path('chemtools.data', 'h2o_q-1_ub3lyp_ccpvtz.fchk') as fname:
molecule = Molecule.from_file(fname)
# check from_molecule
model = GlobalConceptualDFT.from_molecule(molecule, "linear")
check_global_reactivity_linear(model, ip, ea, energy, 11)
# check from_molecule given as a list
model = GlobalConceptualDFT.from_molecule([molecule], "linear")
check_global_reactivity_linear(model, ip, ea, energy, 11)
def from_file(cls, fname, scheme='mulliken'):
"""Initialize class from wave-function file.
Parameters
----------
fname : str
Path to molecule's wave-function file.
scheme : str
Type of population analysis scheme.
"""
return cls.from_molecule(Molecule.from_file(fname), scheme=scheme)
def from_file(cls, fname, points):
"""Initialize class from file.
Parameters
----------
fname : str
Path to molecule's files.
points : np.ndarray
Grid points, given as a 2D array with 3 columns, used for calculating local properties.
"""
molecule = Molecule.from_file(fname)
return cls(molecule, points)
def main_mot(args):
"""Build MOTBasedTool model and dump VMD script and cube files for visualizing MO."""
if args.info:
mol = Molecule.from_file(args.fname)
else:
mol, cube = load_molecule_and_grid(args.fname, args.cube)
hia, hib = np.array(mol.homo_index) - 1
lia, lib = np.array(mol.lumo_index) - 1
ea, eb = mol.energy
print("")
print(("File: {0}".format(args.fname)))
# print("Charge : % 5f" % np.sum(mol.numbers) - np.sum(ne))
# print("Multiplicity: % 5d" % np.max(ne) - np.min(ne) + 1)
print("")
print("Atomic number and coordinates:")
for index, num in enumerate(mol.numbers):
coord = mol.coordinates[index, :]
print(("% 2i %10.6f %10.6f %10.6f" %
(num, coord[0], coord[1], coord[2])))
print("")
print("Information on alpha & beta electrons:")
print(("# electrons : % 3.3f % 3.3f" % mol.mo.nelectrons))
print(("H**O index : % 3d % 5d" % mol.homo_index))
print("")
print(("LUMO+2 index : %10.6f %10.6f" % (ea[lia + 2], eb[lib + 2])))
print(("LUMO+1 energy: %10.6f %10.6f" % (ea[lia + 1], eb[lib + 1])))
print(("LUMO energy: %10.6f %10.6f" % mol.lumo_energy))
print(("H**O energy: %10.6f %10.6f" % mol.homo_energy))
print(("H**O-1 energy: %10.6f %10.6f" % (ea[hia - 1], eb[hib - 1])))
print(("H**O-2 energy: %10.6f %10.6f" % (ea[hia - 2], eb[hib - 2])))
print("")
if args.info:
return
index = args.index
if index is not None:
index = [int(item) for item in index.split(",")]
if len(index) == 1:
index = index[0]
# build model
mot = OrbPart.from_molecule(mol)
# dump files for visualization
if args.output is None:
args.output = args.fname.rsplit(".")[0]
mot.generate_scripts(args.output,
spin=args.spin,
index=index,
grid=cube,
isosurf=args.isosurface)
