def test_dftb_relax_dimer():
import os
from ase import Atoms
from ase.test import require
from ase.test.testsuite import datafiles_directory
from ase.calculators.dftb import Dftb
from ase.optimize import BFGS
require('dftb')
os.environ['DFTB_PREFIX'] = datafiles_directory
calc = Dftb(
label='dftb',
Hamiltonian_SCC='No',
Hamiltonian_PolynomialRepulsive='SetForAll {Yes}',
)
atoms = Atoms('Si2',
positions=[[5., 5., 5.], [7., 5., 5.]],
cell=[12.] * 3,
pbc=False)
atoms.set_calculator(calc)
dyn = BFGS(atoms, logfile='-')
dyn.run(fmax=0.1)
e = atoms.get_potential_energy()
assert abs(e - -64.830901) < 1., e
def test_dftb_relax_bulk():
import os
from ase.test import require
from ase.test.testsuite import datafiles_directory
from ase.build import bulk
from ase.calculators.dftb import Dftb
from ase.optimize import QuasiNewton
from ase.constraints import ExpCellFilter
require('dftb')
os.environ['DFTB_PREFIX'] = datafiles_directory
calc = Dftb(label='dftb',
kpts=(3,3,3),
Hamiltonian_SCC='Yes')
atoms = bulk('Si')
atoms.set_calculator(calc)
ecf = ExpCellFilter(atoms)
dyn = QuasiNewton(ecf)
dyn.run(fmax=0.01)
e = atoms.get_potential_energy()
assert abs(e - -73.150819) < 1., e
def test_elk_cmdline():
from ase.test import cli, require
# warning! parameters are not converged - only an illustration!
require('elk')
cli("""ase build -x fcc -a 4.04 Al | \
ase run elk -p \
"tasks=0,kpts=1.5,rgkmax=5.0,tforce=True,smearing=(fermi-dirac,0.05)" """)
def installed():
require('vasp')
for env in ['VASP_COMMAND', 'VASP_SCRIPT']:
if os.getenv(env):
break
else:
raise unittest.SkipTest('Neither VASP_COMMAND nor VASP_SCRIPT defined')
return True
def test_aims_cmdline():
from ase.test import cli, require
require('aims')
# warning! parameters are not converged - only an illustration!
cli("""ase build -x bcc -a 3.6 Li | \
ase run aims -s 0.3 -p \
kpts=1.5,xc=LDA,sc_accuracy_rho=5.e-2,relativistic=none,compute_analytical_stress=True,sc_accuracy_forces=5.e-1"""
)
def installed2():
# Check if env variables exist for Vasp2
require('vasp')
for env in ['VASP_COMMAND', 'VASP_SCRIPT', 'ASE_VASP_COMMAND']:
if os.getenv(env):
break
else:
raise unittest.SkipTest(
'Neither ASE_VASP_COMMAND, VASP_COMMAND nor VASP_SCRIPT defined')
return True
def test_amber():
"""Test that amber calculator works.
This is conditional on the existence of the $AMBERHOME/bin/sander
executable.
"""
import subprocess
from ase import Atoms
from ase.calculators.amber import Amber
from ase.test import require
require('amber')
with open('mm.in', 'w') as outfile:
outfile.write("""\
zero step md to get energy and force
&cntrl
imin=0, nstlim=0, ntx=1 !0 step md
cut=100, ntb=0, !non-periodic
ntpr=1,ntwf=1,ntwe=1,ntwx=1 ! (output frequencies)
&end
END
""")
with open('tleap.in', 'w') as outfile:
outfile.write("""\
source leaprc.protein.ff14SB
source leaprc.gaff
source leaprc.water.tip3p
mol = loadpdb 2h2o.pdb
saveamberparm mol 2h2o.top h2o.inpcrd
quit
""")
subprocess.call('tleap -f tleap.in'.split())
atoms = Atoms(
'OH2OH2',
[[-0.956, -0.121, 0], [-1.308, 0.770, 0], [0.000, 0.000, 0],
[3.903, 0.000, 0], [4.215, -0.497, -0.759], [4.215, -0.497, 0.759]])
calc = Amber(amber_exe='sander -O ',
infile='mm.in',
outfile='mm.out',
topologyfile='2h2o.top',
incoordfile='mm.crd')
calc.write_coordinates(atoms, 'mm.crd')
atoms.calc = calc
e = atoms.get_potential_energy()
assert abs(e + 0.046799672) < 5e-3
def test_cmdline():
require('nwchem')
cli("""\
ase build O O.traj &&
ase run nwchem O.traj -o nwchem_cmdline.json &&
ase build O2 O2.traj &&
ase run nwchem O2.traj -o nwchem_cmdline.json""")
c = connect('nwchem_cmdline.json')
dct = read_json('nwchem_cmdline.json')
for name in ['O2', 'O']:
d = c.get([('formula', '=', name)])
id = d.id
e1 = d.energy
e2 = c.get_atoms(id).get_potential_energy()
e3 = read('{name}.nwo'.format(name=name)).get_potential_energy()
e4 = dct[id]['energy']
assert e1 == e2 == e3 == e4
print(e1)
ae = 2 * c.get('formula=O').energy - c.get('formula=O2').energy
assert_allclose(ae, 6.599194233179787, atol=1e-4, rtol=1e-4)
def test_gaussian_cmdline():
from ase.test import cli, require
from ase.db import connect
from ase.io import read
from ase.io.jsonio import read_json
require('gaussian')
cli("""\
ase build O O.xyz && ase run gaussian O.xyz -o gaussian_cmdline.json &&
ase build O2 O2.xyz && ase run gaussian O2.xyz -o gaussian_cmdline.json""")
c = connect('gaussian_cmdline.json')
dct = read_json('gaussian_cmdline.json')
for index, name in enumerate(['O', 'O2']):
d = c.get(index + 1)
id = d.id
e1 = d.energy
e2 = c.get_atoms(id).get_potential_energy()
e3 = read(name + '.log').get_potential_energy()
e4 = dct[id]['energy']
assert e1 == e2 == e3 == e4
print(e1)
ae = 2 * c.get(1).energy - c.get(2).energy
assert abs(ae - 0.65376) < 1e-3
def test_dftb_relax_surface():
import os
from ase.test import require
from ase.test.testsuite import datafiles_directory
from ase.build import diamond100
from ase.calculators.dftb import Dftb
from ase.optimize import BFGS
from ase.constraints import FixAtoms
require('dftb')
os.environ['DFTB_PREFIX'] = datafiles_directory
calc = Dftb(
label='dftb',
kpts=(2, 2, 1),
Hamiltonian_SCC='Yes',
Hamiltonian_Filling='Fermi {',
Hamiltonian_Filling_empty='Temperature [Kelvin] = 500.0',
)
a = 5.40632280995384
atoms = diamond100('Si', (1, 1, 6),
a=a,
vacuum=6.,
orthogonal=True,
periodic=True)
atoms.positions[-2:, 2] -= 0.2
atoms.set_constraint(FixAtoms(indices=range(4)))
atoms.set_calculator(calc)
dyn = BFGS(atoms, logfile='-')
dyn.run(fmax=0.1)
e = atoms.get_potential_energy()
assert abs(e - -214.036907) < 1., e
from ase.test import cli, require
require('aims')
# warning! parameters are not converged - only an illustration!
cli("""ase-build -x bcc -a 3.6 Li | \
ase-run aims -s 0.3 -p \
kpts=1.5,xc=LDA,sc_accuracy_rho=5.e-2,relativistic=none,compute_analytical_stress=True,sc_accuracy_forces=5.e-1""")
from ase.test import cli, require
from ase.db import connect
from ase.io.jsonio import read_json
from ase.calculators.gaussian import Gaussian
require('gaussian')
cli("""\
ase-build O | ase-run gaussian -d gaussian_cmdline.json &&
ase-build O2 | ase-run gaussian -d gaussian_cmdline.json""")
c = connect('gaussian_cmdline.json')
dct = read_json('gaussian_cmdline.json')
for name in ['O2', 'O']:
d = c.get([('name', '=', name)])
id = d.id
e1 = d.energy
e2 = c.get_atoms(id).get_potential_energy()
e3 = Gaussian.read_atoms(name).get_potential_energy()
e4 = dct[id]['energy']
assert e1 == e2 == e3 == e4
print(e1)
ae = 2 * c.get('name=O').energy - c.get('name=O2').energy
assert abs(ae - 1.060) < 1e-3
def test_Al_rmt():
import os
from ase.test import require
from ase.build import bulk
from ase.calculators.calculator import kpts2mp
from ase.calculators.elk import ELK
require('elk')
atoms = bulk('Al', 'bcc', a=4.0)
# save ELK_SPECIES_PATH
ELK_SPECIES_PATH = os.environ.get('ELK_SPECIES_PATH', None)
assert ELK_SPECIES_PATH is not None
# find rmt of the default species
sfile = os.path.join(os.environ['ELK_SPECIES_PATH'], 'elk.in')
assert os.path.exists(sfile)
slines = open(sfile, 'r').readlines()
rmt_orig = {}
for name in ['Al']:
found = False
for n, line in enumerate(slines):
if line.find("'" + name + "'") > -1:
begline = n - 1
for n, line in enumerate(slines[begline:]):
if not line.strip(): # first empty line
found = True
break
assert found
# split needed because H is defined with comments
rmt_orig[name] = float(slines[begline + 3].split()[0].strip())
assert rmt_orig['Al'] == 2.2 # 2.2 Bohr default
# test1
# generate species with custom rmt 2.1
rmt = {'Al': 2.1}
label = 'rmt2.1'
atomsrmt = atoms.copy()
os.environ['ELK_SPECIES_PATH'] = ELK_SPECIES_PATH
atomsrmt.calc = ELK(tasks=0, label=label, rmt=rmt) # minimal calc
atomsrmt.get_potential_energy()
del atomsrmt.calc
del atomsrmt
# hack ELK_SPECIES_PATH to use custom species
os.environ['ELK_SPECIES_PATH'] = os.path.abspath(label) + '/'
# run calculation
calc = ELK(tasks=0,
label=label,
rgkmax=4.0,
kpts=tuple(kpts2mp(atoms, 2.0, even=True)))
atoms.calc = calc
e1 = atoms.get_potential_energy()
# test2
# generate species with custom rmt 2.1
rmt = {'Al': -0.1}
label = 'rmt0.1m'
atomsrmt = atoms.copy()
os.environ['ELK_SPECIES_PATH'] = ELK_SPECIES_PATH
atomsrmt.calc = ELK(tasks=0, label=label, rmt=rmt) # minimal calc
atomsrmt.get_potential_energy()
del atomsrmt.calc
del atomsrmt
# hack ELK_SPECIES_PATH to use custom species
os.environ['ELK_SPECIES_PATH'] = os.path.abspath(label) + '/'
# run calculation
calc = ELK(tasks=0,
label=label,
rgkmax=4.0,
kpts=tuple(kpts2mp(atoms, 2.0, even=True)))
atoms.calc = calc
e2 = atoms.get_potential_energy()
# restore ELK_SPECIES_PATH
os.environ['ELK_SPECIES_PATH'] = ELK_SPECIES_PATH
assert abs(e1 - e2) < 1.0e-4
"""Test that amber calculator works.
This is conditional on the existence of the $AMBERHOME/bin/sander
executable.
"""
import subprocess
from ase import Atoms
from ase.calculators.amber import Amber
from ase.test import require
require('amber')
with open('mm.in', 'w') as outfile:
outfile.write("""\
zero step md to get energy and force
&cntrl
imin=0, nstlim=0, ntx=1 !0 step md
cut=100, ntb=0, !non-periodic
ntpr=1,ntwf=1,ntwe=1,ntwx=1 ! (output frequencies)
&end
END
""")
with open('tleap.in', 'w') as outfile:
outfile.write("""\
source leaprc.protein.ff14SB
source leaprc.gaff
source leaprc.water.tip3p
mol = loadpdb 2h2o.pdb
saveamberparm mol 2h2o.top h2o.inpcrd
from ase.test import cli, require
require('aims')
# warning! parameters are not converged - only an illustration!
cli("""ase-build -x bcc -a 3.6 Li | \
ase-run aims -s 0.3 -p \
kpts=1.5,xc=LDA,sc_accuracy_rho=5.e-2,relativistic=none,compute_analytical_stress=True,sc_accuracy_forces=5.e-1"""
)
"""Test that amber calculator works.
This is conditional on the existence of the $AMBERHOME/bin/sander
executable.
"""
import subprocess
from ase import Atoms
from ase.calculators.amber import Amber
from ase.test import require
require('amber')
with open('mm.in', 'w') as outfile:
outfile.write("""\
zero step md to get energy and force
&cntrl
imin=0, nstlim=0, ntx=1 !0 step md
cut=100, ntb=0, !non-periodic
ntpr=1,ntwf=1,ntwe=1,ntwx=1 ! (output frequencies)
&end
END
""")
with open('tleap.in', 'w') as outfile:
outfile.write("""\
source leaprc.protein.ff14SB
source leaprc.gaff
source leaprc.water.tip3p
mol = loadpdb 2h2o.pdb
from ase.test import cli, require
# warning! parameters are not converged - only an illustration!
require('elk')
cli("""ase build -x fcc -a 4.04 Al | \
ase run elk -p \
"tasks=0,kpts=1.5,rgkmax=5.0,tforce=True,smearing=(fermi-dirac,0.05)" """)
from ase.test import cli, require
require('fleur')
cli('ase build -x fcc -a 4.04 Al | ase run fleur -p kpts=3.0,xc=PBE')
def test_fleur_cmdline():
from ase.test import cli, require
require('fleur')
cli('ase build -x fcc -a 4.04 Al | ase run fleur -p kpts=3.0,xc=PBE')
from ase.test import cli, require
from ase.db import connect
from ase.io.jsonio import read_json
from ase.calculators.nwchem import NWChem
require('nwchem')
cli("""ase build O | ase run nwchem -d nwchem_cmdline.json &&
ase build O2 | ase run nwchem -d nwchem_cmdline.json""")
c = connect('nwchem_cmdline.json')
dct = read_json('nwchem_cmdline.json')
for name in ['O2', 'O']:
d = c.get([('name', '=', name)])
id = d.id
e1 = d.energy
e2 = c.get_atoms(id).get_potential_energy()
e3 = NWChem.read_atoms(name).get_potential_energy()
e4 = dct[id]['energy']
assert e1 == e2 == e3 == e4
print(e1)
ae = 2 * c.get('name=O').energy - c.get('name=O2').energy
assert abs(ae - 6.6053) < 1e-4
import os
from ase import Atoms
from ase.test import require
from ase.calculators.dftb import Dftb
from ase.optimize import BFGS
require('dftb')
p = os.path.dirname(__file__)
os.environ['DFTB_PREFIX'] = p if p else './'
calc = Dftb(
label='dftb',
Hamiltonian_SCC='No',
Hamiltonian_PolynomialRepulsive='SetForAll {Yes}',
)
atoms = Atoms('Si2',
positions=[[5., 5., 5.], [7., 5., 5.]],
cell=[12.] * 3,
pbc=False)
atoms.set_calculator(calc)
dyn = BFGS(atoms, logfile='-')
dyn.run(fmax=0.1)
e = atoms.get_potential_energy()
assert abs(e - -64.830901) < 1., e
from ase.test import cli, require
from ase.db import connect
from ase.db.jsondb import read_json
from ase.calculators.nwchem import NWChem
require('nwchem')
cli("""ase-build O | ase-run nwchem -d nwchem_cmdline.json &&
ase-build O2 | ase-run nwchem -d nwchem_cmdline.json""")
c = connect('nwchem_cmdline.json')
dct = read_json('nwchem_cmdline.json')
for name in ['O2', 'O']:
d = c.get([('name', '=', name)])
id = d.id
e1 = d.energy
e2 = c.get_atoms(id).get_potential_energy()
e3 = NWChem.read_atoms(name).get_potential_energy()
e4 = dct[id]['energy']
assert e1 == e2 == e3 == e4
print(e1)
ae = 2 * c.get('name=O').energy - c.get('name=O2').energy
assert abs(ae - 6.6053) < 1e-4
def test_dftb_bandstructure():
import os
import subprocess
from unittest import SkipTest
from ase.test import require
from ase.test.testsuite import datafiles_directory
from ase.calculators.dftb import Dftb
from ase.build import bulk
require('dftb')
os.environ['DFTB_PREFIX'] = datafiles_directory
# We need to get the DFTB+ version to know
# whether to skip this test or not.
# For this, we need to run DFTB+ and grep
# the version from the output header.
cmd = os.environ['ASE_DFTB_COMMAND'].split()[0]
proc = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)
lines = ''
for line in proc.stdout:
l = line.decode()
if 'DFTB+' in l and ('version' in l.lower() or 'release' in l.lower()):
version = l[l.index('DFTB+'):]
break
lines += l + '\n'
else:
raise RuntimeError('Could not parse DFTB+ version ' + lines)
if '17.1' not in version:
msg = 'Band structure properties not present in results.tag for ' + version
raise SkipTest(msg)
# The actual testing starts here
calc = Dftb(label='dftb',
kpts=(3, 3, 3),
Hamiltonian_SCC='Yes',
Hamiltonian_SCCTolerance=1e-5,
Hamiltonian_MaxAngularMomentum_Si='d')
atoms = bulk('Si')
atoms.set_calculator(calc)
atoms.get_potential_energy()
efermi = calc.get_fermi_level()
assert abs(efermi - -2.90086680996455) < 1.
# DOS does not currently work because of
# missing "get_k_point_weights" function
#from ase.dft.dos import DOS
#dos = DOS(calc, width=0.2)
#d = dos.get_dos()
#e = dos.get_energies()
#print(d, e)
calc = Dftb(atoms=atoms,
label='dftb',
kpts={
'path': 'WGXWLG',
'npoints': 50
},
Hamiltonian_SCC='Yes',
Hamiltonian_MaxSCCIterations=1,
Hamiltonian_ReadInitialCharges='Yes',
Hamiltonian_MaxAngularMomentum_Si='d')
atoms.set_calculator(calc)
calc.calculate(atoms)
calc.results['fermi_levels'] = [efermi]
calc.band_structure()