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()