def test_main():
atoms = bulk('C')
testname = 'stress_test'
calc = NWChem(
theory='pspw',
label=testname,
nwpw={
'lmbfgs': None,
'tolerances': '1e-9 1e-9'
},
)
atoms.set_calculator(calc)
assert_allclose(atoms.get_stress(),
calc.calculate_numerical_stress(atoms),
atol=1e-3,
rtol=1e-3)
# remove scratch files created by NWChem
os.remove(os.path.join(testname, 'junk.inp'))
os.remove(os.path.join(testname, testname + '.movecs'))
os.remove(os.path.join(testname, testname + '.db'))
for suffix in ['psp', 'vpp', 'vpp2']:
os.remove(os.path.join(testname, 'C.' + suffix))
def test_bands():
atoms = bulk('Si')
path = atoms.cell.bandpath('GXWK', density=10)
atoms.calc = NWChem(kpts=[2, 2, 2])
bs = calculate_band_structure(atoms, path)
print(bs)
bs.write('bs.json')
def minimise(self, cluster):
'''Minimise a cluster
parameters:
cluster- a Cluster object from bcga.cluster
Using this method will overwrite the coordinates and energy of the
supplied Cluster object.'''
# Fix overlapping atoms to avoid NWChem errors
cluster.fix_overlaps(1.5)
# Set up element labels for NWChem
atom_string = ""
for i in range(0, len(cluster.labels)):
atom_string += cluster.labels[i] + str(
get_composition(cluster.atom_types)[i])
print(atom_string)
# Set up an ASE Atoms object for the cluster
mol = Atoms(atom_string, positions=cluster._coords)
mol.center()
# Set up and runNWChem minimise
calc = NWChem(label=self.temp_files, **self.GPAWargs)
mol.set_calculator(calc)
opt = LBFGSLineSearch(mol)
try:
opt.run(fmax=0.25)
except:
sys.exit()
# Get back results from ASE
cluster.energy = mol.get_potential_energy()
cluster.quenched = True
return cluster
def main():
"""Perform C_{\inf v} calculation on Cr_2."""
# PBE from
# J. Chem. Phys. 112 , 5576 (2000)
# http://dx.doi.org/10.1063/1.481183
e_literature = -1.34
names = ['Cr2_sp_up.mos', 'Cr2_sp_down.mos']
fragment_energies = array([.0] * 2)
cr_atom = Atoms('Cr', positions=[(0, 0, 0)], pbc=False)
for orientation in range(2): # create two fragments
imm = 6 * (-1)**orientation
cr_atom.set_initial_magnetic_moments([imm])
calculator = NWChem(task='energy',
xc='PBE',
geometry='nocenter noautosym noautoz',
convergence={
'energy': 1e-3,
'density': 1e-2,
'gradient': 5e-2
},
basis='"DZVP2 (DFT Orbital)"',
vectors='input atomic output {0}'.format(
names[orientation]),
charge=0)
cr_atom.set_calculator(calculator)
fragment_energies[orientation] = cr_atom.get_potential_energy()
cr_dimer = Atoms('Cr2', positions=[(0, 0, 0), (0, 0, 1.93)], pbc=False)
cr_dimer.set_initial_magnetic_moments([0, 0])
calculator = NWChem(task='energy',
xc='PBE',
geometry='nocenter noautosym noautoz',
convergence={
'energy': 1e-3,
'density': 1e-2,
'gradient': 5e-2
},
odft=True,
basis='"DZVP2 (DFT Orbital)"',
vectors='input fragment {0} output Cr2_AF.mos'.format(
' '.join(names)),
charge=0)
cr_dimer.set_calculator(calculator)
e_dimer = cr_dimer.get_potential_energy()
e_tot = e_dimer - fragment_energies.sum()
assert abs(e_tot - e_literature) < 0.01
def test_main():
"""Perform C_{\\inf v} calculation on Cr_2."""
# PBE from
# J. Chem. Phys. 112 , 5576 (2000)
# https://doi.org/10.1063/1.481183
e_literature = -1.34
names = ['Cr2_sp_up.mos', 'Cr2_sp_down.mos']
fragment_energies = array([.0] * 2)
cr_atom = Atoms('Cr', positions=[(0, 0, 0)], pbc=False)
for orientation in range(2): # create two fragments
imm = 6 * (-1)**orientation
cr_atom.set_initial_magnetic_moments([imm])
calc = NWChem(task='energy',
xc='pbe',
theory='dft',
dft=dict(convergence=dict(energy=1e-3,
density=1e-2,
gradient=5e-2),
vectors='input atomic output {}'.format(
names[orientation])),
charge=0,
basis='"DZVP2 (DFT Orbital)"')
cr_atom.set_calculator(calc)
fragment_energies[orientation] = cr_atom.get_potential_energy()
cr_dimer = Atoms('Cr2', positions=[(0, 0, 0), (0, 0, 1.93)], pbc=False)
cr_dimer.set_initial_magnetic_moments([0, 0])
calc = NWChem(task='energy',
xc='pbe',
theory='dft',
dft=dict(
convergence=dict(energy=1e-3,
density=1e-2,
gradient=5e-2),
odft=None,
vectors='input fragment {} output Cr2_AF.mos'.format(
' '.join(names))),
basis='"DZVP2 (DFT Orbital)"',
charge=0)
cr_dimer.set_calculator(calc)
e_dimer = cr_dimer.get_potential_energy()
e_tot = e_dimer - fragment_energies.sum()
assert abs(e_tot - e_literature) < 0.01
def test_nwchem_eigenvalues(atoms, charge, eref):
atoms.calc = NWChem(charge=charge, dft=dict(mult=2))
energy = atoms.get_potential_energy()
assert abs(energy - eref) < 0.1
# Test fix for issue 575, which caused positive eigenvalues to not parse
# correctly. Make sure at least some of the eigenvalues are positive.
# (Actually they all should be positive, but let's be less strict)
evals = atoms.calc.calc.get_eigenvalues()
assert np.any(evals > 0)
assert len(evals) == 4
def _run_calc(atoms_in, theory, eref, forces=False, **kwargs):
atoms = atoms_in.copy()
calc = NWChem(label=theory, theory=theory, **kwargs)
atoms.calc = calc
assert_allclose(atoms.get_potential_energy(), eref, atol=1e-4, rtol=1e-4)
if forces:
assert_allclose(atoms.get_forces(),
calc.calculate_numerical_forces(atoms),
atol=1e-4,
rtol=1e-4)
# Delete all perm/scratch files to ensure tests are idempotent
for suffix in ['db', 'movecs', 'cfock', 'mp2nos', 't2']:
_try_delete(theory, theory, suffix)
for element in ['H', 'O']:
for suffix in ['psp', 'vpp', 'cpp', 'jpp']:
_try_delete(theory, element, suffix)
_try_delete(theory, element, 'basis', sep='_')
_try_delete(theory, 'junk', 'inp')
def main():
"""Check is independence of alignment is conserved"""
energies = []
cr_atom = Atoms('Cr', positions=[(0, 0, 0)], pbc=False)
for orientation in range(2):
imm = 6 * (-1)**orientation
cr_atom.set_initial_magnetic_moments([imm])
calculator = NWChem(
task='energy',
dft=dict(
convergence=dict(energy=1e-3, density=1e-2, gradient=5e-2)),
basis='m6-31g*',
basispar='"ao basis" spherical',
charge=0)
cr_atom.set_calculator(calculator)
energies.append(cr_atom.get_potential_energy())
assert abs(energies[0] - energies[1]) < 1e-9
def main():
"""The main routine for the prove of the warning."""
cr_atom = Atoms('Cr', positions=[(0, 0, 0)], pbc=False, magmoms=[5.0])
calculator = NWChem(task='energy',
geometry='nocenter noautosym noautoz',
convergence={
'energy': 1e-3,
'density': 1e-2,
'gradient': 5e-2
},
basis='Wachters+f',
charge=1)
cr_atom.set_calculator(calculator)
with catch_warnings(record=True) as thrown_warning:
simplefilter('always', RuntimeWarning)
cr_atom.get_potential_energy()
assert len(thrown_warning) == 1
assert 'levelshift' in str(thrown_warning[-1].message)
def calculate_target_repulsion(atoms, rc):
N = len(atoms)
pos = atoms.get_positions()
sym = atoms.get_chemical_symbols()
# First perform a regular SCF run
calc = NWChem(
#memory='1024mb',
#label='calc/nwchem',
dft=dict( #maxiter=2000,
xc=xc,
#mult=2,
odft=None,
convergence=dict(energy=1e-5, density=1e-4, gradient=5e-3),
),
basis=basis)
atoms.calc = calc
e, f = 0., np.zeros((N, 3))
e = atoms.get_potential_energy()
f = atoms.get_forces()
powers = np.arange(6)
#e, f = 0., np.zeros((N, 3))
#coeff = np.array([0., 0., 0., 14., -5., 2.])
#powers = np.arange(len(coeff))
#for i in range(N):
# for j in range(N):
# r = atoms.get_distance(i, j)
# if sym[i] == sym[j] or r > rc:
# continue
# e += 0.5 * (coeff * (rc - r) ** powers).sum()
# dedr = -coeff[1:] * powers[1:] * (rc - r) ** (powers[1:] - 1)
# drdx = (pos[i] - pos[j]) / r
# f[i] += -dedr.sum() * drdx
return e, f
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
import os, sys, re
import numpy as np
import ase
from ase import Atoms
from ase.calculators.nwchem import NWChem
from ase.db import connect
label = '{label}'
kwargs = {kwargs}
NWChem.command = 'mpirun -np {ppn} -path /usr/local/bin nwchem PREFIX.nw > PREFIX.out'
calc = NWChem(**kwargs)
atom = {atom}
geom = {geom}
mol = Atoms(symbols = atom, positions = geom)
mol.set_calculator(calc)
try:
e = mol.get_potential_energy() # use the NWChem optimizer (task optimize)
outfile = '{label}.out'
with open(outfile) as f:
lines = f.readlines()
for index, line in enumerate(reversed(lines)):
if re.search('Output coordinates in angstroms', line) != None:
def calc(self, **kwargs):
from ase.calculators.nwchem import NWChem
command = f'{self.executable} PREFIX.nwi > PREFIX.nwo'
return NWChem(command=command, **kwargs)
import sys
from ase.build import molecule
from ase.optimize import BFGS
from ase.calculators.nwchem import NWChem
from ase.calculators.socketio import SocketIOCalculator
atoms = molecule('H2O')
atoms.rattle(stdev=0.1)
unixsocket = 'ase_nwchem'
nwchem = NWChem(theory='scf',
task='optimize',
driver={'socket': {
'unix': unixsocket
}})
opt = BFGS(atoms, trajectory='opt.traj', logfile='opt.log')
with SocketIOCalculator(nwchem, log=sys.stdout, unixsocket=unixsocket) as calc:
atoms.calc = calc
opt.run(fmax=0.05)
if __name__ == '__main__':
import numpy as np
from ase import Atoms
from ase.calculators.nwchem import NWChem
from ase.optimize import BFGS
from numpy import cross, eye
from scipy.linalg import expm3, norm
def M(axis, theta):
return expm3(cross(eye(3), axis / norm(axis) * theta))
h2 = Atoms('H2', positions=[[0, 0, 0], [0, 0, 0.7]])
h2.calc = NWChem(xc='PBE')
opt = BFGS(h2)
opt.run(fmax=0.02)
h2.positions = np.dot(M(np.array([1., 1., 0.]), np.pi / 4.),
h2.positions.T).T
h2prime = ase.Atoms('H2')
h2prime.positions = np.copy(h2.positions)
# print h2.positions
angle = np.pi / 5.
axis = np.array([1., 0., 0.])
rotation = M(axis, angle)
soap = SOAP(1.)
for n in range(10):
h2prime.positions = np.dot(rotation, h2prime.positions.T).T
print(n + 1) * angle, soap.K(h2, h2prime)
def gaussianFreq(mol, lab, level):
level = level.split('_')
Trip = False
if len(level) == 4:
Trip = True
bas = level[1]
lev = level[0]
Igrid = level[2]
if len(level) == 3:
bas = level[1]
lev = level[0]
Igrid = level[2]
elif len(level) == 2:
bas = level[1]
lev = level[0]
Igrid = 'coarse'
else:
bas = basis
lev = level
Igrid = 'coarse'
sym = mol.get_chemical_symbols()
is_O = len(sym) == 1 and sym[0] == 'O'
is_OO = len(sym) == 2 and sym[0] == 'O' and sym[1] == 'O'
if is_O or is_OO or Trip == True:
mol.set_calculator(
NWChem(label=lab,
maxiter=60,
geometry='noautoz noautosym nocenter',
xc=lev,
basis=bas,
grid=Igrid,
raw='freq \nanimate \n end\n',
task='freq',
mult=3))
else:
atom_num = mol.get_atomic_numbers()
s = sum(atom_num)
if s % 2 == 0:
mol.set_calculator(
NWChem(label=lab,
maxiter=60,
geometry='noautoz noautosym nocenter',
xc=lev,
basis=bas,
grid=Igrid,
raw='freq \nanimate \n end\n',
CONVERGENCE='ncysh 5 ncydp 5 damp 50',
task=' freq',
mult=1))
else:
mol.set_calculator(
NWChem(label=lab,
maxiter=60,
geometry='noautoz noautosym nocenter',
xc=lev,
basis=bas,
grid=Igrid,
CONVERGENCE='ncysh 5 ncydp 5 damp 50',
mult=2,
raw='freq \nanimate \n end\n',
task=' freq'))
return mol
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 ase.db
from ase.structure import molecule
from ase.optimize.bfgs import BFGS
from ase.calculators.nwchem import NWChem
from ase.data.g2_1 import molecule_names, atom_names
c = ase.db.connect('g2-1.db')
for name in molecule_names + atom_names:
id = c.reserve(name=name, calculator='nwchem')
if id is None:
continue
atoms = molecule(name)
atoms.calc = NWChem(command='mpiexec -np 4 nwchem PREFIX.nw > PREFIX.out',
geometry='noautosym nocenter noautoz',
task='gradient',
xc='PBE',
grid='nodisk',
tolerances='tight',
basis='def2-qzvppd',
basispar='spherical',
direct='noio',
label=name)
atoms.get_forces()
c.write(atoms, name=name, relaxed=False)
if len(atoms) > 1:
opt = BFGS(atoms, logfile=name + '.nwchem.log')
opt.run(0.01)
c.write(atoms, name=name, relaxed=True)
del c[id]
from ase.build import bulk
from ase.calculators.nwchem import NWChem
from ase.utils import workdir
from ase.dft.band_structure import calculate_band_structure
atoms = bulk('Si')
with workdir('files', mkdir=True):
path = atoms.cell.bandpath('GXWK', density=10)
atoms.calc = NWChem(kpts=[2, 2, 2])
bs = calculate_band_structure(atoms, path)
print(bs)
bs.write('bs.json')
"""Checks that writing and reading of NWChem input files is consistent."""
from ase.build import molecule
from ase.calculators.nwchem import NWChem
from ase import io
atoms = molecule('CH3COOH')
calc = NWChem()
calc.write_input(atoms)
atoms2 = io.read('nwchem.nw')
tol = 1e-8
check = sum(abs((atoms.positions - atoms2.positions).ravel()) > tol)
assert check == 0
def calculator():
return NWChem(task='gradient', theory='scf', charge=-1)
files_to_optimize = []
for mol in mols_of_interest:
list_dir = os.listdir(path.format(mol))
for f in list_dir:
if f.endswith(".xyz"):
files_to_optimize.append(os.path.join(path.format(mol), f))
file_of_interest = files_to_optimize[i]
atoms = read(file_of_interest)
scratch = "/projects/CPOX/northeastern_comocheng/conformers/optimizing_others/"
os.chdir(scratch)
calc = NWChem(label=file_of_interest[20:-4].replace("/", "_"),
scratch=scratch,
method="m06-2x",
basis="6-311++G(2D,2P)",
multiplicity=1)
atoms.set_calculator(calc)
opt = BFGS(atoms=atoms)
opt.run()
print
print "The potential energy of {} is:".format(file_of_interest[20:-4].replace(
"/", "_"))
print atoms.get_potential_energy()
def calculator():
return NWChem(task='gradient',
geometry='nocenter noautosym noautoz',
charge=-1)
def gaussian2(mol, lab, level):
level = level.split('_')
Trip = False
if len(level) == 4:
Trip = True
bas = level[1]
lev = level[0]
Igrid = level[2]
if len(level) == 3:
bas = level[1]
lev = level[0]
Igrid = level[2]
elif len(level) == 2:
bas = level[1]
lev = level[0]
Igrid = 'coarse'
else:
bas = basis
lev = level
Igrid = 'coarse'
sym = mol.get_chemical_symbols()
is_O = len(sym) == 1 and sym[0] == 'O'
is_OO = len(sym) == 2 and sym[0] == 'O' and sym[1] == 'O'
if is_O or is_OO or Trip == True:
mol.set_calculator(
NWChem(
label=lab,
maxiter=60,
geometry='noautoz noautosym nocenter',
xc=lev,
basis=bas,
vectors='output mo.movecs',
grid=Igrid,
task=
'energy ignore \nset dft:converged true \ntask dft gradient',
mult=3))
else:
atom_num = mol.get_atomic_numbers()
s = sum(atom_num)
if s % 2 == 0:
mol.set_calculator(
NWChem(
label=lab,
maxiter=60,
geometry='noautoz noautosym nocenter',
xc=lev,
basis=bas,
vectors='output mo.movecs',
grid=Igrid,
task=
'energy ignore \nset dft:converged true \ntask dft gradient',
mult=1))
else:
mol.set_calculator(
NWChem(
label=lab,
maxiter=60,
geometry='noautoz noautosym nocenter',
xc=lev,
basis=bas,
vectors='output mo.movecs',
grid=Igrid,
CONVERGENCE='ncysh 5 ncydp 5 damp 50',
mult=2,
task=
'energy ignore \nset dft:converged true \ntask dft gradient'
))
return mol
