def test_adf_mock(mocker: MockFixture):
"""Mock the ADF output."""
mol = Molecule(PATH_MOLECULES / "acetonitrile.xyz")
job = adf(templates.geometry, mol)
run_mocked = mocker.patch("qmflows.run")
jobname = "ADFjob"
dill_path = WORKDIR / jobname / "ADFjob.dill"
plams_dir = WORKDIR / jobname
run_mocked.return_value = ADF_Result(templates.geometry,
mol,
jobname,
dill_path=dill_path,
work_dir=plams_dir,
plams_dir=plams_dir)
rs = run_mocked(job)
assertion.isfinite(rs.energy)
assertion.isfinite(rs.h**o)
assertion.isfinite(rs.lumo)
# Array of runtime for each optimization
assertion.isfinite(rs.runtime[-1])
# 3-dimensional vector
assertion.len_eq(rs.dipole, 3)
# number of steps until convergence
assertion.eq(rs.optcycles, 8)
# Test molecule
# Molecule
mol = rs.molecule
assertion.isinstance(mol, Molecule)
assertion.len_eq(mol, 6) # there are 6 atoms
def example_partial_geometry_opt():
"""
Performa partial optimization freezing the Hydrogen atoms
"""
methanol = molkit.from_smiles('CO')
# optimize only H atoms
s = Settings()
s.freeze = [1, 2]
geom_job1 = adf(templates.geometry.overlay(s), methanol, job_name='geom_job1').molecule
# optimize only H atoms
s = Settings()
s.selected_atoms = ['H']
geom_job2 = adf(templates.geometry.overlay(s), methanol, job_name='geom_job2').molecule
geom1, geom2 = run(gather(geom_job1, geom_job2), n_processes=1)
return geom1, geom2
def iterate_over_jobs(promises, inp, prefix=None):
"""
Iterate over a list of `promised` jobs, calling adf
with input `inp` and the molecular geometry from previous jobs.
"""
return gather(*[
adf(inp,
job.molecule,
job_name='{}_{}'.format(prefix, get_job_name(job)))
for job in promises
])
def example_partial_geometry_opt():
"""Performa partial optimization freezing the Hydrogen atoms."""
methanol = molkit.from_smiles('CO')
# optimize only H atoms
s = Settings()
s.freeze = [1, 2]
geom_job1 = adf(templates.geometry.overlay(s),
methanol,
job_name='geom_job1').molecule
# optimize only H atoms
s = Settings()
s.selected_atoms = ['H']
geom_job2 = adf(templates.geometry.overlay(s),
methanol,
job_name='geom_job2').molecule
geom1, geom2 = run(gather(geom_job1, geom_job2), n_processes=1)
return geom1, geom2
def test_adf_props():
"""
Get properties from ADF freq calc
"""
mol = molkit.from_smiles('F[H]')
result = run(adf(templates.freq, mol, job_name='adf_FH'))
expected_energy = -0.30
assert abs(result.energy - expected_energy) < 0.01
assert len(result.dipole) == 3
expected_frequency = 3480.90
assert abs(result.frequencies[1] - expected_frequency) < 0.1
assert len(result.charges) == 2
assert abs(result.charges[0] + result.charges[1]) < 1e-6
def test_adf_props():
"""
Get properties from ADF freq calc
"""
mol = molkit.from_smiles('F[H]')
result = run(adf(templates.freq, mol, job_name='adf_FH'))
expected_energy = -0.30
assert abs(result.energy - expected_energy) < 0.01
assert len(result.dipole) == 3
expected_frequency = 3480.90
assert abs(result.frequencies[1] - expected_frequency) < 0.1
assert len(result.charges) == 2
assert abs(result.charges[0] + result.charges[1]) < 1e-6
name: dftb(templates.geometry, mol, job_name='dftb_{}'.format(name))
for name, mol in molecules.items()
}
optimized_mols = {name: job.molecule for name, job in dftb_jobs.items()}
# Settings for ADF SAOP single point calculation
s = Settings()
s.basis = 'DZP'
s.specific.adf.basis.core = None
s.specific.adf.xc.model = 'saop'
s.specific.adf.scf.converge = 1e-6
s.specific.adf.symmetry = 'nosym'
# single point calculations using the SAOP functional
singlepoints = [
adf(s, mol, job_name='adf_{}'.format(name))
for name, mol in optimized_mols.items()
]
# Filter results with H**O-LUMO gap lower than 3 eV
candidates = filter_homo_lumo_lower_than(gather(*singlepoints), 3)
# Optimize the selected candidates
inp = templates.geometry
inp.functional = 'pbe'
inp.basis = 'DZP'
inp.specific.adf.scf.converge = 1e-6
inp.specific.adf.symmetry = 'nosym'
# Optimize only the filter candidates
opt_jobs = iterate_over_jobs(candidates, inp, prefix='pbe')
}
# Check preoptimized molecules
opt_mols = {n: skip_dftb(job, molecules[n]) for n, job in dftb_jobs.items()}
# DFT optimization with Orca
s = templates.geometry
s.functional = 'BP86'
s.basis = 'def2TZVP'
dft_jobs = {
n: orca(s, mol, job_name='orca_{}'.format(n))
for n, mol in opt_mols.items()
}
# TD-DFT ADF with COSMO
s = templates.singlepoint
s.functional = 'camy-b3lyp'
s.basis = 'TZ2P'
s.specific.adf.Solvation.solvent = 'name=Dichloromethane emp=0.0 neql=2.028'
td_dft_jobs = {
n: adf(s, job.molecule, job_name='td_dft_{}'.format(n))
for n, job in dft_jobs.items()
}
energies = [gather(n, j.energy) for n, j in td_dft_jobs.items()]
result = run(gather(*energies), n_processes=4, folder='biphenyl')
print(result)
from scm.plams import Molecule
from qmflows import (adf, run, templates)
molecule = Molecule('files/uranyl.xyz')
inp = templates.geometry
# Generic Settings
inp.basis = 'TZ2P'
inp.functional = 'bp86'
# Specific
inp.specific.adf.charge = "2 0"
inp.specific.adf.relativistic = "scalar Zora"
inp.specific.adf.geometry.convergence = 'grad=1e-4'
result = run(adf(inp, molecule))
