def write_input_files(self, at, label):
global _chdir_lock
vasp = Vasp(**self.vasp_args)
vasp.initialize(at)
# chdir not thread safe, so acquire global lock before using it
orig_dir = os.getcwd()
try:
_chdir_lock.acquire()
os.chdir(self.subdir)
if os.path.exists('OUTCAR'):
n = 1
while os.path.exists('OUTCAR.%d' % n):
n += 1
shutil.copyfile('OUTCAR', 'OUTCAR.%d' % n)
shutil.copyfile('POSCAR', 'POSCAR.%d' % n)
write_vasp('POSCAR', vasp.atoms_sorted,
symbol_count=vasp.symbol_count,
vasp5='5' in self.exe)
vasp.write_incar(at)
vasp.write_potcar()
vasp.write_kpoints()
finally:
os.chdir(orig_dir)
_chdir_lock.release()
def get_calculator(self):
calc_paras = self.calc_paras
if self.calc_type == 'vasp':
from ase.calculators.vasp import Vasp
calc = Vasp(
xc=calc_paras.get('calculator', 'xc'), # for MD, coarse prec
prec=calc_paras.get('calculator', 'prec'),
istart=calc_paras.getint('calculator', 'istart'),
icharg=calc_paras.getint('calculator', 'icharg'),
ispin=calc_paras.getint('calculator', 'ispin'),
encut=calc_paras.getfloat('calculator', 'encut'),
ismear=calc_paras.getint('calculator', 'ismear'),
sigma=calc_paras.getfloat('calculator', 'sigma'),
nelm=calc_paras.getint('calculator', 'nelm'),
nelmin=calc_paras.getint('calculator', 'nelmin'),
ediff=calc_paras.getfloat('calculator', 'ediff'),
algo=calc_paras.get('calculator', 'algo'),
lwave=calc_paras.getboolean('calculator', 'lwave'),
lcharg=calc_paras.getboolean('calculator', 'lcharg'),
lreal=calc_paras.get('calculator', 'lreal'),
lplane=calc_paras.getboolean('calculator', 'lplane'),
npar=calc_paras.getint('calculator', 'npar'),
nsim=calc_paras.getint('calculator', 'nsim'))
return calc
from ase.build import molecule
from ase.calculators.vasp import Vasp
atoms = molecule('CO')
atoms.center(vacuum=10)
atoms.pbc=True
calc = Vasp(xc='PBE', #Level of theory (density functional)
encut=400, #plane-wave kinetic energy cutoff (convergence test; I usually use about 520)
kpts=[1,1,1], #number of k-points, e.g. [3,3,3] (convergence test; fewer kpoints are needed if lattice dimension is large)
isif=2, #relaxation method (2 = positions, 3 = positions+volume)
prec='Accurate', #accuracy (don't change this)
sigma=0.01, #don't need to change (smearing width)
ismear=0, #don't need to change (smearing method)
isym=0, #disables symmetry
ediffg=-0.03, #force tolerance, |ediffg| (eV/A) (I generally use 0.01 --> 0.03; lower is better but will take longer)
nsw=1000, #maximum number of steps
ivdw=12, #enable van der Waals interactions
setups='recommended',
ibrion=2) #geom opt algorithm (dont need change; default is conjugate gradient -- works fine)
atoms.set_calculator(calc)
atoms.get_potential_energy()
works.
"""
from ase.calculators.vasp import Vasp
def dict_is_subset(d1, d2):
"""True if all the key-value pairs in dict 1 are in dict 2"""
for key, value in d1.items():
if key not in d2:
return False
elif d2[key] != value:
return False
else:
return True
calc_vdw = Vasp(xc='optb86b-vdw')
assert dict_is_subset({'param1': 0.1234, 'param2': 1.0}, calc_vdw.float_params)
calc_hse = Vasp(xc='hse06', hfscreen=0.1, gga='RE', encut=400, sigma=0.5)
assert dict_is_subset({
'hfscreen': 0.1,
'encut': 400,
'sigma': 0.5
}, calc_hse.float_params)
assert dict_is_subset({'gga': 'RE'}, calc_hse.string_params)
from ase import Atom, Atoms
from ase.build import bulk, fcc100, add_adsorbate, add_vacuum
from ase.calculators.vasp import Vasp
from ase.calculators.kim.kim import KIM
from ase.calculators.qmmm import ForceQMMM, RescaledCalculator
from ase.constraints import StrainFilter
from ase.optimize import LBFGS
from ase.visualize import view
atoms = bulk("Pd", "fcc", a=3.5, cubic=True)
atoms.calc = KIM("MEAM_LAMMPS_JeongParkDo_2018_PdMo__MO_356501945107_000")
opt = LBFGS(StrainFilter(atoms), logfile=None)
opt.run(0.03, steps=30)
length = atoms.cell.cellpar()[0]
atoms = fcc100("Pd", (2,2,5), a=length, vacuum=10, periodic=True)
add_adsorbate(atoms, Atoms([Atom("Mo")]), 1.2)
qm_mask = [len(atoms)-1, len(atoms)-2]
qm_calc = Vasp(directory="./qmmm")
mm_calc = KIM("MEAM_LAMMPS_JeongParkDo_2018_PdMo__MO_356501945107_000")
mm_calc = RescaledCalculator(mm_calc, 1, 1, 1, 1)
qmmm = ForceQMMM(atoms, qm_mask, qm_calc, mm_calc, buffer_width=3)
qmmm.initialize_qm_buffer_mask(atoms)
atoms.pbc=True
atoms.calc = qmmm
print(atoms.get_forces())
"""
Check the unit cell is handled correctly
"""
from ase.calculators.vasp import Vasp
from ase.build import molecule
from ase.test import must_raise
# Molecules come with no unit cell
atoms = molecule('CH4')
calc = Vasp()
with must_raise(ValueError):
atoms.set_calculator(calc)
atoms.get_total_energy()
def test_vasp2_wdir(require_vasp):
"""
Run tests to ensure that the VASP txt and label arguments function correctly,
i.e. correctly sets the working directories and works in that directory.
This is conditional on the existence of the ASE_VASP_COMMAND, VASP_COMMAND
or VASP_SCRIPT environment variables
"""
import filecmp
import os
from ase.test.calculator.vasp import installed2 as installed
from ase import Atoms
from ase.calculators.vasp import Vasp2 as Vasp
assert installed()
def compare_paths(path1, path2):
assert os.path.abspath(path1) == os.path.abspath(path2)
# Test setup system, borrowed from vasp_co.py
d = 1.14
atoms = Atoms('CO', positions=[(0, 0, 0), (0, 0, d)], pbc=True)
atoms.center(vacuum=5.)
file1 = '_vasp_dummy_str.out'
file2 = '_vasp_dummy_io.out'
file3 = '_vasp_dummy_2.out'
testdir = '_dummy_txt_testdir'
label = os.path.join(testdir, 'vasp')
# Test
settings = dict(label=label,
xc='PBE',
prec='Low',
algo='Fast',
ismear=0,
sigma=1.,
istart=0,
lwave=False,
lcharg=False)
# Make 2 copies of the calculator object
calc = Vasp(**settings)
calc2 = Vasp(**settings)
# Check the calculator path is the expected path
compare_paths(calc.directory, testdir)
calc.set(txt=file1)
atoms.calc = calc
en1 = atoms.get_potential_energy()
# Check that the output files are in the correct directory
for fi in ['OUTCAR', 'CONTCAR', 'vasprun.xml']:
fi = os.path.join(testdir, fi)
assert os.path.isfile(fi)
# We open file2 in our current directory, so we don't want it to write
# in the label directory
with open(file2, 'w') as f:
calc2.set(txt=f)
atoms.calc = calc2
atoms.get_potential_energy()
# Make sure the two outputfiles are identical
assert filecmp.cmp(os.path.join(calc.directory, file1), file2)
# Test restarting from working directory in test directory
label2 = os.path.join(testdir, file3)
calc2 = Vasp(restart=label, label=label2)
# Check the calculator path is the expected path
compare_paths(calc2.directory, testdir)
assert not calc2.calculation_required(calc2.atoms, ['energy', 'forces'])
en2 = calc2.get_potential_energy()
# Check that the restarted calculation didn't run, i.e. write to output file
assert not os.path.isfile(os.path.join(calc.directory, file3))
# Check that we loaded energy correctly
assert en1 == en2
def test_vasp2_kpoints(require_vasp):
"""
Check the many ways of specifying KPOINTS
"""
import os
from ase.calculators.vasp import Vasp2 as Vasp
from ase.build import bulk
from ase.test.calculator.vasp import installed2 as installed
assert installed()
Al = bulk('Al', 'fcc', a=4.5, cubic=True)
def check_kpoints_line(n, contents):
"""Assert the contents of a line"""
with open('KPOINTS', 'r') as f:
lines = f.readlines()
assert lines[n] == contents
# Default to (1 1 1)
calc = Vasp(gamma=True)
calc.write_kpoints()
check_kpoints_line(2, 'Gamma\n')
check_kpoints_line(3, '1 1 1 \n')
calc.clean()
# 3-tuple prints mesh
calc = Vasp(gamma=False, kpts=(4, 4, 4))
calc.write_kpoints()
check_kpoints_line(2, 'Monkhorst-Pack\n')
check_kpoints_line(3, '4 4 4 \n')
calc.clean()
# Auto mode
calc = Vasp(kpts=20)
calc.write_kpoints()
check_kpoints_line(1, '0\n')
check_kpoints_line(2, 'Auto\n')
check_kpoints_line(3, '20 \n')
calc.clean()
# 1-element list ok, Gamma ok
calc = Vasp(kpts=[20], gamma=True)
calc.write_kpoints()
check_kpoints_line(1, '0\n')
check_kpoints_line(2, 'Auto\n')
check_kpoints_line(3, '20 \n')
calc.clean()
# KSPACING suppresses KPOINTS file
calc = Vasp(kspacing=0.23)
calc.initialize(Al)
calc.write_kpoints()
calc.write_incar(Al)
assert not os.path.isfile('KPOINTS')
with open('INCAR', 'r') as f:
assert ' KSPACING = 0.230000\n' in f.readlines()
calc.clean()
# Negative KSPACING raises an error
calc = Vasp(kspacing=-0.5)
try:
calc.write_kpoints()
except ValueError:
pass
else:
raise AssertionError("Negative KSPACING did not raise ValueError")
calc.clean()
# Explicit weighted points with nested lists, Cartesian if not specified
calc = Vasp(
kpts=[[0.1, 0.2, 0.3, 2], [0.0, 0.0, 0.0, 1], [0.0, 0.5, 0.5, 2]])
calc.write_kpoints()
with open('KPOINTS.ref', 'w') as f:
f.write("""KPOINTS created by Atomic Simulation Environment
3
Cartesian
0.100000 0.200000 0.300000 2.000000
0.000000 0.000000 0.000000 1.000000
0.000000 0.500000 0.500000 2.000000
""")
assert filecmp_ignore_whitespace('KPOINTS', 'KPOINTS.ref')
os.remove('KPOINTS.ref')
# Explicit points as list of tuples, automatic weighting = 1.
calc = Vasp(
kpts=[(0.1, 0.2, 0.3), (0.0, 0.0, 0.0), (0.0, 0.5, 0.5)], reciprocal=True)
calc.write_kpoints()
with open('KPOINTS.ref', 'w') as f:
f.write("""KPOINTS created by Atomic Simulation Environment
3
Reciprocal
0.100000 0.200000 0.300000 1.0
0.000000 0.000000 0.000000 1.0
0.000000 0.500000 0.500000 1.0
""")
assert filecmp_ignore_whitespace('KPOINTS', 'KPOINTS.ref')
os.remove('KPOINTS.ref')
d = 1.14
atoms = Atoms('CO', positions=[(0, 0, 0), (0, 0, d)],
pbc=True)
atoms.center(vacuum=5.)
# Test
settings = dict(xc='PBE',
prec='Low',
algo='Fast',
ismear=0,
sigma=1.,
istart=0,
lwave=False,
lcharg=False)
calc = Vasp(**settings)
atoms.set_calculator(calc)
en1 = atoms.get_potential_energy()
# Make a parameter change to the calculator
calc.set(sigma=0.5)
# Check that we capture a change for float params
assert calc.check_state(atoms) == ['float_params']
assert calc.calculation_required(atoms, ['energy', 'forces'])
en2 = atoms.get_potential_energy()
# The change in sigma should result in a small change in energy
def set_vasp(level=0, pstress=0.0000, setup=None):
default0 = {
'xc': 'pbe',
'npar': 8,
'kgamma': True,
'lcharg': False,
'lwave': False,
'ibrion': 2,
'pstress': pstress,
'setups': setup,
}
if level == 0:
default1 = {
'prec': 'low',
'algo': 'normal',
'kspacing': 0.4,
'isif': 4,
'ediff': 1e-2,
'nsw': 10,
'potim': 0.02,
}
elif level == 1:
default1 = {
'prec': 'normal',
'algo': 'normal',
'kspacing': 0.3,
'isif': 3,
'ediff': 1e-3,
'nsw': 25,
'potim': 0.05,
}
elif level == 2:
default1 = {
'prec': 'accurate',
'kspacing': 0.2,
'isif': 3,
'ediff': 1e-3,
'nsw': 50,
'potim': 0.1,
}
elif level == 3:
default1 = {
'prec': 'accurate',
'encut': 600,
'kspacing': 0.15,
'isif': 3,
'ediff': 1e-4,
'nsw': 50,
}
elif level == 4:
default1 = {
'prec': 'accurate',
'encut': 600,
'kspacing': 0.15,
'isif': 3,
'ediff': 1e-4,
'nsw': 0,
}
dict_vasp = dict(default0, **default1)
return Vasp(**dict_vasp)
kpd = 1000
kpts = kgrid_from_cell_volume(atoms, kpd)
if sum(kpts) == 3:
#os.environ['VASP_COMMAND'] ="srun -c4 --cpu_bind=cores vasp_gam"
os.environ['VASP_COMMAND'] = "srun --cpu_bind=cores vasp_gam"
else:
#os.environ['VASP_COMMAND'] ="srun -c4 --cpu_bind=cores vasp_std"
os.environ['VASP_COMMAND'] = "srun --cpu_bind=cores vasp_std"
#####
from numpy import loadtxt
temp = loadtxt('temperature.txt')
### minimal tags to run
from ase.calculators.vasp import Vasp
calc = Vasp(xc='PBE', setups='minimal', kpts=kpts)
### good tags to set
calc.set(prec='Accurate',
ediff=1E-8 * len(atoms),
encut=450,
algo='Fast',
ispin=1,
nelm=200,
lmaxmix=4)
calc.set(lreal='Auto')
################ molecular dynamics ###########
### vasp settings
calc.set(isym=0, ibrion=0) # turn on MD
#print("slab2", slab2)
#sys.exit()
if os.path.isfile(fname):
#print("\nfname:", fname)
#current position read in
slabatoms = read(fname)
#print("after read in")
slab.set_positions(slabatoms.get_positions())
#for atom in slab:
# print("atom:", atom)
#mask = [atom.tag > 2 for atom in slab] # MB: this needs to be adapted!!!
#slab.set_constraint(FixAtoms(mask=mask))
print "Now submit VASP",argv1,argv2
calc = Vasp(xc='PBE',lreal='Auto',kpts=[1,1,1],ispin=2,ismear=0,sigma=0.01,algo='fast',istart=0,ediff=0.00001,lwave = False,lcharg = False) #npar=8
slab.set_calculator(calc)
cwd = os.getcwd()
os.chdir(tmpDir)
if not os.path.exists(folder):
os.makedirs(folder)
os.chdir(folder)
energy = - slab.get_potential_energy()
grads = - slab.get_forces()
f = open('GRAD'+argv1, 'w')
f.write(str(energy))
f.write('\n')
f.write(str(grads))
def main():
arg = sys.argv
paras = readinputs(arg[1])
p1 = read('POSCAR')
#set calculator
#TODO: generate calculator with user-given parameters (user-friendly but less flexible)
#or keep both features
vasp1 = Vasp(xc='PBE', # for MD, coarse prec
prec='Med',
ediff=1e-3,
lplane=True,
npar=4,
lwave=True,
lcharg=True,
encut=200,
algo='Fast',
lreal='Auto',
istart=1,
icharg=1,
)
vasp2 = Vasp(xc='PBE', # for scf, prec normal prec
ediff=float(paras['EDIFF']),
lplane=paras['LPLANE'],
npar=int(paras['NPAR']),
lwave=paras['LWAVE'],
lcharg=paras['LCHARG'],
encut=float(paras['ENCUT']),
algo=paras['ALGO'],
lreal=paras['LREAL'],
istart=1,
icharg=1
)
#end of calculator
p1.set_calculator(vasp1)
md_structures, e_log = run_md(atoms=p1,
md_temperature = float(paras['md_temperature']) * kB,
md_step_size = float(paras['md_step_size']),
md_steps= int(paras['md_steps']),
md_interval= int(paras['md_interval'])
)
logfile = open(str(paras['output_file']), 'a+')
numb_structure = int(paras['record_frequency'])
for atoms in md_structures:
opt_traj, e_log, fs = opt_structure(atoms=atoms, interval=1, opt_calculator=vasp2, optimizer=FIRE)
if len(opt_traj) < numb_structure:
interval = 1
else:
interval = numb_structure #Chaged by Wanglai Cen at 16-02-2018
for i in range (len(opt_traj)):
if i % interval == 0 or i == len(opt_traj)-1:
if i == len(opt_traj)-1:
label = 'local minimum'
else:
label = 'nonstable'
logfile.write("%d\n"%(len(atoms)))
logfile.write("%s %s: %15.6f\n"%(label, 'Energy',e_log[i]))
for atom in opt_traj[i]:
j = atom.index
logfile.write("%s %15.6f %15.6f %15.6f %15.6f %15.6f %15.6f\n"%(atom.symbol, atom.x,
atom.y, atom.z, fs[i][j][0], fs[i][j][1], fs[i][j][2]))
logfile.flush() #Added by Wanglai Cen at 16-02-2018
logfile.close()
mode = 'a'
try:
sys = Trajectory(file_traj, 'r')[-1]
except (IOError, RuntimeError):
print "Creating molecule from scratch"
sys = molecule('H2')
sys.set_cell(np.array([20, 21, 22]))
sys.center()
#sys *= (2, 3, 1)
else:
print "Importing trajectory file from: %s" % file_traj
vasp_param = calc_dict['TiO2_step']
vasp_param['kpts'] = (1, 1, 1)
calc = Vasp(**vasp_param)
handle_restart(calc, sys)
print_vasp_param(calc)
sys.set_calculator(calc)
del sys.constraints
#print 'Constraints:'
#print '\tc1: Freezing bottom two layers (z < 15.)'
#c1 = FixAtoms(mask = [atom.z < 15 for atom in sys])
#sys.set_constraint(c1)
if testRun == True:
run_testRun(sys)
else:
geo_traj = Trajectory(file_traj, mode, sys)
dyn = LBFGS(sys, trajectory=geo_traj)
dyn.run(fmax=0.05)
from ase.build import fcc111
from ase.calculators.vasp import Vasp
Au = fcc111(
symbol='Au', a=4.15402, size=(2, 2, 5), vacuum=10
) # Using optimized lattice constant to build Au_fcc111 surface with 5 layers of Au
Au.pbc = True
calc4 = Vasp(
xc='PBE', #Level of theory (density functional)
encut=
280, #plane-wave kinetic energy cutoff (convergence test; I usually use about 520)
kpts=[
1, 1, 1
], #number of k-points, e.g. [3,3,3] (convergence test; fewer kpoints are needed if lattice dimension is large)
prec='Accurate', #accuracy (don't change this)
sigma=0.01, #don't need to change (smearing width)
ismear=0, #don't need to change (smearing method)
isym=0, #disables symmetry
ivdw=12, #enable van der Waals interactions
setups='recommended')
Au.set_calculator(calc4)
Au.get_potential_energy()
from ase.calculators.vasp import Vasp
from ase.build import bulk
Al = bulk('Al', 'fcc', a=4.5, cubic=True)
def check_kpoints_line(n, contents):
"""Assert the contents of a line"""
with open('KPOINTS', 'r') as f:
lines = f.readlines()
assert lines[n] == contents
# Default to (1 1 1)
calc = Vasp(gamma=True)
calc.write_kpoints()
check_kpoints_line(2, 'Gamma\n')
check_kpoints_line(3, '1 1 1 \n')
calc.clean()
# 3-tuple prints mesh
calc = Vasp(gamma=False, kpts=(4, 4, 4))
calc.write_kpoints()
check_kpoints_line(2, 'Monkhorst-Pack\n')
check_kpoints_line(3, '4 4 4 \n')
calc.clean()
# Auto mode
calc = Vasp(kpts=20)
calc.write_kpoints()
def main(name):
dft_calc = Vasp(prec='Normal',
algo='Normal',
ncore=4,
xc='PBE',
gga='RP',
lreal=False,
ediff=1e-4,
ispin=1,
nelm=100,
encut=400,
lwave=False,
lcharg=False,
nsw=0,
kpts=(4, 4, 1))
# Define initial set of images, can be as few as 1. If 1, make sure to
slab = ase.io.read("/home/mshuaibi/active-learning/slab_vasp.traj")
images = [slab]
# Define symmetry functions
Gs = {}
Gs["G2_etas"] = np.logspace(np.log10(0.05), np.log10(5.0), num=4)
Gs["G2_rs_s"] = [0] * 4
Gs["G4_etas"] = [0.005]
Gs["G4_zetas"] = [1.0, 4.0]
Gs["G4_gammas"] = [+1.0, -1]
Gs["cutoff"] = 6.0
fmax = 0.05
training_params = {
"al_convergence": {
"method": "final",
"force_tol": fmax
},
"samples_to_retrain": 1,
"Gs": Gs,
"morse": True,
"forcetraining": True,
"cores": 3,
"optimizer": torch.optim.LBFGS,
"batch_size": 1000,
"criterion": CustomMSELoss,
"num_layers": 3,
"num_nodes": 20,
"force_coefficient": 0.04,
"learning_rate": 1e-2,
"epochs": 200,
"test_split": 0,
"shuffle": False,
"verbose": 1,
"filename": name,
"file_dir": f"./",
"scheduler": {
"policy": "CosineAnnealingWarmRestarts",
"params": {
"T_0": 10,
"T_mult": 2
}
}
}
# Define AL calculator
learner = AtomisticActiveLearner(
training_data=images,
training_params=training_params,
parent_calc=dft_calc,
ensemble=5,
)
learner.learn(
atomistic_method=Relaxation(
initial_geometry=slab,
optimizer=BFGS,
fmax=fmax,
steps=200,
),
query_strategy=final_max_query,
)
os.system("rm -rf amp-* results*")
def preprocess_atoms(atoms):
if os.path.isfile('IMAG'):
imag = {}
for _line in open('IMAG'):
if '#' in _line:
line = _line[:_line.index('#')]
else:
line = _line
if len(line.split()) == 0:
continue
if '=' in line:
a, b = line.split('=')
else:
a, b = line.split()
imag[int(a)] = float(b)
m = [imag[z] if z in imag else 0. for z in atoms.numbers]
atoms.set_initial_magnetic_moments(m)
command = get_command()
calc = Vasp(command=command, setups=get_setups(), directory='vasp')
if os.path.isfile('INCAR'):
calc.read_incar('INCAR')
xc = get_xc(calc)
if xc is not None:
calc.set(xc=xc)
if os.path.isfile('KPOINTS'):
calc.read_kpoints('KPOINTS')
from ase.calculators.vasp import Vasp
def dict_is_subset(d1, d2):
"""True if all the key-value pairs in dict 1 are in dict 2"""
for key, value in d1.items():
if key not in d2:
return False
elif d2[key] != value:
return False
else:
return True
calc_vdw = Vasp(xc='optb86b-vdw')
assert dict_is_subset({'param1': 0.1234, 'param2': 1.0}, calc_vdw.float_params)
calc_hse = Vasp(xc='hse06', hfscreen=0.1, gga='RE', encut=400, sigma=0.5)
assert dict_is_subset({
'hfscreen': 0.1,
'encut': 400,
'sigma': 0.5
}, calc_hse.float_params)
assert dict_is_subset({'gga': 'RE'}, calc_hse.string_params)
calc_pw91 = Vasp(xc='pw91', kpts=(2, 2, 2), gamma=True, lreal='Auto')
assert dict_is_subset(
{
from amptorch.model import CustomMSELoss
import multiprocessing as mp
if __name__ == "__main__":
random.seed(1)
mp.set_start_method("spawn")
emt_calc = EMT()
dft_calc = Vasp(prec='Normal',
algo='Normal',
ncore=4,
xc='PBE',
gga='RP',
lreal=False,
ediff=1e-4,
ispin=1,
nelm=100,
encut=400,
lwave=False,
lcharg=False,
nsw=0,
kpts=(1, 1, 1))
# Define initial set of images, can be as few as 1. If 1, make sure to
slab = fcc100("Cu", size=(3, 3, 3))
ads = molecule("CO")
add_adsorbate(slab, ads, 3, offset=(1, 1))
cons = FixAtoms(indices=[atom.index for atom in slab if (atom.tag == 3)])
slab.set_constraint(cons)
slab.center(vacuum=13.0, axis=2)
slab.set_pbc(True)
# +
from ase.calculators.vasp import Vasp
calc = Vasp(
command="mpirun -n 6 vasp_std",
directory='vasp',
ispin=2,
kspacing=0.5,
)
def preprocess_atoms(atoms):
# optional: can be deleted
# this can be defined for setting the parameters
# that can not be set when defining the calculator.
#
# for instance:
# atoms.set_initial_magnetic_moments(len(atoms)*[1.])
pass
def postprocess_atoms(atoms):
# optional
pass
def calcs(calc_name):
"""
Define the default calculators for relaxations
Note: it should not include the kpts, gamma, or images keywords!
Args:
calc_name (string): name of calculator
Returns:
calc (dict): ASE Vasp calculator dictionary
"""
if calc_name == 'scf_test':
calc = Vasp(
xc=defaults['xc'],
setups=defaults['setups'],
ivdw=defaults['ivdw'],
prec=defaults['prec'],
algo=defaults['algo'],
ediff=defaults['ediff'],
nelm=defaults['nelm'],
nelmin=defaults['nelmin'],
lreal=defaults['lreal'],
ismear=defaults['ismear'],
sigma=defaults['sigma'],
lcharg=False,
lwave=True,
lorbit=defaults['lorbit'],
isym=defaults['isym'],
symprec=defaults['symprec'],
nsw=0,
istart=0,
ldau_luj=defaults['ldau_luj']
)
elif calc_name == 'ase_bfgs':
calc = Vasp(
xc=defaults['xc'],
setups=defaults['setups'],
ivdw=defaults['ivdw'],
prec=defaults['prec'],
algo=defaults['algo'],
ediff=defaults['ediff'],
nelm=defaults['nelm'],
nelmin=defaults['nelmin'],
lreal=defaults['lreal'],
ismear=defaults['ismear'],
sigma=defaults['sigma'],
lcharg=False,
lwave=True,
lorbit=defaults['lorbit'],
isym=defaults['isym'],
symprec=defaults['symprec'],
ldau_luj=defaults['ldau_luj']
)
elif calc_name == 'isif2_lowacc':
calc = Vasp(
xc=defaults['xc'],
setups=defaults['setups'],
ivdw=defaults['ivdw'],
prec=defaults['prec'],
algo=defaults['algo'],
ediff=defaults['ediff'],
nelm=defaults['nelm'],
nelmin=defaults['nelmin'],
lreal=defaults['lreal'],
ismear=defaults['ismear'],
sigma=defaults['sigma'],
lcharg=False,
lwave=True,
ibrion=2,
isif=2,
nsw=250,
ediffg=-0.05,
lorbit=defaults['lorbit'],
isym=defaults['isym'],
symprec=defaults['symprec'],
ldau_luj=defaults['ldau_luj']
)
elif calc_name == 'isif2_medacc':
calc = Vasp(
xc=defaults['xc'],
setups=defaults['setups'],
ivdw=defaults['ivdw'],
prec=defaults['prec'],
algo=defaults['algo'],
ediff=1e-6,
nelm=defaults['nelm'],
nelmin=8,
lreal=defaults['lreal'],
ismear=defaults['ismear'],
sigma=defaults['sigma'],
lcharg=False,
lwave=True,
ibrion=3,
iopt=7,
potim=0,
isif=2,
nsw=defaults['nsw'],
ediffg=-0.05,
lorbit=defaults['lorbit'],
isym=defaults['isym'],
symprec=defaults['symprec'],
ldau_luj=defaults['ldau_luj']
)
elif calc_name == 'isif2_highacc':
calc = Vasp(
xc=defaults['xc'],
setups=defaults['setups'],
encut=defaults['encut'],
ivdw=defaults['ivdw'],
prec=defaults['prec'],
algo=defaults['algo'],
ediff=1e-6,
nelm=defaults['nelm'],
nelmin=8,
lreal=defaults['lreal'],
ismear=defaults['ismear'],
sigma=defaults['sigma'],
lcharg=False,
lwave=True,
ibrion=3,
iopt=7,
potim=0,
isif=2,
nsw=defaults['nsw'],
ediffg=defaults['ediffg'],
lorbit=defaults['lorbit'],
isym=defaults['isym'],
symprec=defaults['symprec'],
ldau_luj=defaults['ldau_luj']
)
elif calc_name == 'isif3_lowacc':
calc = Vasp(
xc=defaults['xc'],
setups=defaults['setups'],
encut=defaults['encut'],
ivdw=defaults['ivdw'],
prec=defaults['prec'],
algo=defaults['algo'],
ediff=1e-6,
nelm=defaults['nelm'],
nelmin=defaults['nelmin'],
lreal=defaults['lreal'],
ismear=defaults['ismear'],
sigma=defaults['sigma'],
lcharg=False,
lwave=True,
ibrion=2,
isif=3,
nsw=30,
ediffg=defaults['ediffg'],
lorbit=defaults['lorbit'],
isym=defaults['isym'],
symprec=defaults['symprec'],
ldau_luj=defaults['ldau_luj']
)
elif calc_name == 'isif3_highacc':
calc = Vasp(
xc=defaults['xc'],
setups=defaults['setups'],
encut=defaults['encut'],
ivdw=defaults['ivdw'],
prec=defaults['prec'],
algo=defaults['algo'],
ediff=1e-6,
nelm=defaults['nelm'],
nelmin=defaults['nelmin'],
lreal=defaults['lreal'],
ismear=defaults['ismear'],
sigma=defaults['sigma'],
lcharg=False,
lwave=True,
ibrion=2,
isif=3,
nsw=30,
ediffg=defaults['ediffg'],
lorbit=defaults['lorbit'],
isym=defaults['isym'],
symprec=defaults['symprec'],
ldau_luj=defaults['ldau_luj']
)
elif calc_name == 'final_spe':
calc = Vasp(
xc=defaults['xc'],
setups=defaults['setups'],
encut=defaults['encut'],
ivdw=defaults['ivdw'],
prec=defaults['prec'],
algo=defaults['algo'],
ediff=1e-6,
nelm=defaults['nelm'],
lreal=False,
ismear=defaults['ismear'],
sigma=defaults['sigma'],
lcharg=True,
laechg=True,
lwave=True,
nsw=0,
lorbit=defaults['lorbit'],
isym=defaults['isym'],
symprec=defaults['symprec'],
addgrid=False,
ldau_luj=defaults['ldau_luj']
)
elif calc_name == 'cineb_lowacc':
calc = Vasp(
xc=defaults['xc'],
setups=defaults['setups'],
ivdw=defaults['ivdw'],
prec=defaults['prec'],
algo=defaults['algo'],
ediff=1e-6,
nelm=100,
nelmin=defaults['nelmin'],
lreal=defaults['lreal'],
ismear=defaults['ismear'],
sigma=defaults['sigma'],
lcharg=False,
lwave=False,
ibrion=3,
potim=0,
iopt=1,
nsw=defaults['nsw'],
ediffg=-1.0,
lclimb=True,
lorbit=defaults['lorbit'],
isym=defaults['isym'],
symprec=defaults['symprec'],
ichain=0,
ldau_luj=defaults['ldau_luj']
)
elif calc_name == 'dimer_lowacc':
calc = Vasp(
xc=defaults['xc'],
setups=defaults['setups'],
ivdw=defaults['ivdw'],
prec=defaults['prec'],
algo=defaults['algo'],
ediff=1e-8,
nelm=defaults['nelm'],
nelmin=defaults['nelmin'],
lreal=defaults['lreal'],
ismear=defaults['ismear'],
sigma=defaults['sigma'],
lcharg=False,
lwave=True,
ibrion=3,
potim=0,
iopt=7,
nsw=defaults['nsw']*4,
ediffg=-0.075,
lorbit=defaults['lorbit'],
isym=defaults['isym'],
symprec=defaults['symprec'],
ichain=2,
ldau_luj=defaults['ldau_luj']
)
elif calc_name == 'dimer_medacc':
calc = Vasp(
xc=defaults['xc'],
setups=defaults['setups'],
ivdw=defaults['ivdw'],
prec=defaults['prec'],
algo=defaults['algo'],
ediff=1e-8,
nelm=defaults['nelm'],
nelmin=defaults['nelmin'],
lreal=defaults['lreal'],
ismear=defaults['ismear'],
sigma=defaults['sigma'],
lcharg=False,
lwave=True,
ibrion=3,
potim=0,
iopt=7,
nsw=defaults['nsw']*2,
ediffg=-0.075,
lorbit=defaults['lorbit'],
isym=defaults['isym'],
symprec=defaults['symprec'],
ichain=2,
ldau_luj=defaults['ldau_luj']
)
elif calc_name == 'dimer_highacc':
calc = Vasp(
xc=defaults['xc'],
encut=defaults['encut'],
setups=defaults['setups'],
ivdw=defaults['ivdw'],
prec=defaults['prec'],
algo=defaults['algo'],
ediff=1e-8,
nelm=defaults['nelm'],
nelmin=defaults['nelmin'],
lreal=defaults['lreal'],
ismear=defaults['ismear'],
sigma=defaults['sigma'],
lcharg=False,
lwave=True,
ibrion=3,
potim=0,
iopt=7,
nsw=defaults['nsw']*2,
ediffg=defaults['ediffg'],
lorbit=defaults['lorbit'],
isym=defaults['isym'],
symprec=defaults['symprec'],
ichain=2,
ldau_luj=defaults['ldau_luj']
)
else:
raise ValueError('Out of range for calculators')
return calc
flipped signs and with checks that ensure FutureWarning is emitted.
Should be removed along with the net_charge parameter itself at some point.
"""
from ase.build import bulk
from ase.calculators.vasp import Vasp
from ase.test import must_raise, must_warn
from ase.test.vasp import installed
assert installed()
system = bulk('Al', 'fcc', a=4.5, cubic=True)
# Dummy calculation to let VASP determine default number of electrons
calc = Vasp(xc='LDA', nsw=-1, ibrion=-1, nelm=1, lwave=False, lcharg=False)
calc.calculate(system)
default_nelect_from_vasp = calc.get_number_of_electrons()
assert default_nelect_from_vasp == 12
# Compare VASP's output nelect from before + net charge to default nelect
# determined by us + net charge
with must_warn(FutureWarning):
net_charge = -2
calc = Vasp(xc='LDA',
nsw=-1,
ibrion=-1,
nelm=1,
lwave=False,
lcharg=False,
net_charge=net_charge)
from ase.constraints import FixAtoms
from ase.thermochemistry import HarmonicThermo
path = './'
cluster = read('POSCAR') #read geometry of the input file
calc = Vasp(ncore=4,
istart=0,
icharg=2,
ialgo=38,
ismear=0,
sigma=0.1,
ibrion=2,
nsw=300,
isif=2,
prec="Normal",
ediff=1E-4,
ediffg=-0.02,
xc="pbe",
ispin=2,
lcharg=True,
encut=470,
lorbit=11,
nelmin=6,
nelm=60,
ivdw=11,
isym=0,
lreal="Auto",
gamma=True)
cluster.calc = calc
cluster_energy = cluster.get_potential_energy()
print('Energy: ', cluster_energy
) #printing out optimized energy at zero sigma width to output file
import io, os
from ase.parallel import rank, size
# Read initial and final states:
initial = read('initial.traj')
final = read('final.traj')
numOfImages = 9
# Set calculators:
images = [initial]
constraint = FixAtoms(mask=[atom.tag > 2 for atom in initial])
calc = Vasp(xc='PBE',
lreal='Auto',
kpts=[1, 1, 1],
ismear=1,
sigma=0.2,
algo='fast',
istart=0,
npar=8,
encut=300)
n = size // numOfImages
#j = rank * numOfImages // size
j = (((2 * rank) + 2) // n) - 1
#calc = EMT()
for i in range(0, numOfImages): #determines the number of nodes
image = initial.copy()
if i == j:
image.set_calculator(calc)
image.set_constraint(constraint)
images.append(image)
images.append(final)
from ase import Atoms, Atom
from ase.calculators.vasp import Vasp
a = [6.5, 6.5, 7.7]
d = 2.3608
NaCl = Atoms([Atom('Na', [0, 0, 0], magmom=1.928),
Atom('Cl', [0, 0, d], magmom=0.75)],
cell=a)
calc = Vasp(prec='Accurate',
xc='PBE',
lreal=False)
NaCl.calc = calc
print(NaCl.get_magnetic_moment())
import os
import ase
from ase.calculators.vasp import Vasp
mof = ase.io.read('POSCAR.init')
calc_opt = Vasp(system="MOF-7",
istart=0,
iniwav=1,
icharg=0,
gamma=True,
reciprocal=True,
prec="Accurate",
lreal=False,
algo="Normal",
encut=500.00,
nelm=200,
ediff=1e-6,
gga="PS",
kpts=(1, 1, 1),
ediffg=1e-3,
nsw=100,
ibrion=1,
isif=3,
isym=2,
ismear=0)
mof.set_calculator(calc_opt)
energy = mof.get_potential_energy()
print("Energy: ", energy)
from ase.constraints import FixAtoms
adsorbedH = read('CONTCAR')
#c = FixAtoms(mask=[s == 'Cu' for s in adsorbedH.get_chemical_symbols()])
#adsorbedH.set_constraint(c)
calc = Vasp(
encut=500,
ispin=2,
prec="Accurate",
# ismear = -1,
sigma=0.1,
ediff=1e-8,
ediffg=-0.01,
algo="Fast",
gga="RP",
xc="PBE",
kpts=(4, 4, 1),
# isif = 0,
# ibrion = 5,
# nsw = 0,
# nfree = 2
)
adsorbedH.set_calculator(calc)
electronicenergy = adsorbedH.get_potential_energy()
print("electronic energy is %.5f" % electronicenergy)
vib = Vibrations(adsorbedH, indices=[23], delta=0.01, nfree=2)
from vibrations import Vibrations
from ase.calculators.vasp import Vasp
from ase.io import read
vasp_calc = Vasp(istart=0, # Start from scratch.
gga='PE', # Method.
kpts = (1,1,1), # k-points.
gamma = True, # Gamma-centered (defaults to Monkhorst-Pack)
encut=400, # Cutoff.
ismear=1, # Smearing
sigma = 0.1, # Smearing
ediffg=-0.015, # Convergence criteria.
ediff=1e-6, # Convergence criteria.
nsw=250, # Number of optimization steps.
nelmin=10, # Min. electronic steps.
nelm=250, # Max. electronic steps.
prec='Accurate', # Precision.
ibrion=2, # Optimization algorithm.
algo = 'Fast', # Optimization algorithm.
ispin=1, # Spin-polarization.
#npar=12, # Parallelization.
#ncore=4, # Parallelization.
lwave=False, # Output.
lcharg=False, # Output.
nfree=2, # Degrees of freedom.
isym=False, # Remove symmetry.
lreal=True # Reciprocal space.
)
vib = Vibrations(ase_calculator=vasp_calc,
anharmonic_correction=True)
files.sort()
atoms = read(files[0])
calc = Vasp(
prec='Normal',
xc='PBE',
gamma=True,
kpts=[4, 4, 1],
encut=400,
ediff=1E-4,
nelmin=4,
algo='Fast',
lreal='Auto',
ismear=1,
isym=0,
sigma=0.1,
ncore=8,
icharg=1,
lwave=False,
ibrion=2,
nsw=2000,
ediffg=-0.02,
luse_vdw=True,
zab_vdw=-1.8867,
aggac=0.0,
gga='MK',
param1=0.1234,
param2=0.7114,
)
atoms.set_calculator(calc)
atoms.get_potential_energy()
