def test_combine(testdir): dirname = 'subdir' vibname = 'ir' with workdir(dirname, mkdir=True): atoms = molecule('C2H6') ir = Infrared(atoms) assert ir.name == vibname ir.calc = RandomCalculator() ir.run() freqs = ir.get_frequencies() ints = ir.intensities assert ir.combine() == 49 ir = Infrared(atoms) assert (freqs == ir.get_frequencies()).all() assert (ints == ir.intensities).all() vib = Vibrations(atoms, name=vibname) assert (freqs == vib.get_frequencies()).all() # Read the data from other working directory with workdir('..'): ir = Infrared(atoms, name=f'{dirname}/{vibname}') assert (freqs == ir.get_frequencies()).all() ir = Infrared(atoms) assert ir.split() == 1 assert (freqs == ir.get_frequencies()).all() assert (ints == ir.intensities).all() vib = Vibrations(atoms, name=vibname) assert (freqs == vib.get_frequencies()).all() assert ir.clean() == 49
def test_combine(): import os from numpy.random import RandomState from ase.build import molecule from ase.vibrations import Vibrations from ase.vibrations import Infrared class RandomCalculator(): """Fake Calculator class. """ def __init__(self): self.rng = RandomState(42) def get_forces(self, atoms): return self.rng.rand(len(atoms), 3) def get_dipole_moment(self, atoms): return self.rng.rand(3) atoms = molecule('C2H6') ir = Infrared(atoms) ir.calc = RandomCalculator() ir.run() freqs = ir.get_frequencies() ints = ir.intensities assert ir.combine() == 49 ir = Infrared(atoms) assert (freqs == ir.get_frequencies()).all() assert (ints == ir.intensities).all() vib = Vibrations(atoms, name='ir') assert (freqs == vib.get_frequencies()).all() # Read the data from other working directory dirname = os.path.basename(os.getcwd()) os.chdir('..') # Change working directory ir = Infrared(atoms, name=os.path.join(dirname, 'ir')) assert (freqs == ir.get_frequencies()).all() os.chdir(dirname) ir = Infrared(atoms) assert ir.split() == 1 assert (freqs == ir.get_frequencies()).all() assert (ints == ir.intensities).all() vib = Vibrations(atoms, name='ir') assert (freqs == vib.get_frequencies()).all() assert ir.clean() == 49
def test_vib(): import os from ase import Atoms from ase.calculators.emt import EMT from ase.optimize import QuasiNewton from ase.vibrations import Vibrations from ase.thermochemistry import IdealGasThermo n2 = Atoms('N2', positions=[(0, 0, 0), (0, 0, 1.1)], calculator=EMT()) QuasiNewton(n2).run(fmax=0.01) vib = Vibrations(n2) vib.run() freqs = vib.get_frequencies() print(freqs) vib.summary() print(vib.get_mode(-1)) vib.write_mode(n=None, nimages=20) vib_energies = vib.get_energies() for image in vib.iterimages(): assert len(image) == 2 thermo = IdealGasThermo(vib_energies=vib_energies, geometry='linear', atoms=n2, symmetrynumber=2, spin=0) thermo.get_gibbs_energy(temperature=298.15, pressure=2 * 101325.) assert vib.clean(empty_files=True) == 0 assert vib.clean() == 13 assert len(list(vib.iterimages())) == 13 d = dict(vib.iterdisplace(inplace=False)) for name, atoms in vib.iterdisplace(inplace=True): assert d[name] == atoms vib = Vibrations(n2) vib.run() assert vib.combine() == 13 assert (freqs == vib.get_frequencies()).all() vib = Vibrations(n2) assert vib.split() == 1 assert (freqs == vib.get_frequencies()).all() assert vib.combine() == 13 # Read the data from other working directory dirname = os.path.basename(os.getcwd()) os.chdir('..') # Change working directory vib = Vibrations(n2, name=os.path.join(dirname, 'vib')) assert (freqs == vib.get_frequencies()).all() assert vib.clean() == 1
def test_vibrations_restart_dir(self, testdir, random_dimer): vib = Vibrations(random_dimer) vib.run() freqs = vib.get_frequencies() assert freqs is not None # write/read the data from another working directory atoms = random_dimer.copy() # This copy() removes the Calculator with ase.utils.workdir('run_from_here', mkdir=True): vib = Vibrations(atoms, name=str(Path.cwd().parent / 'vib')) assert_array_almost_equal(freqs, vib.get_frequencies()) assert vib.clean() == 13
def characteriseTSinternal(self, mol): os.chdir((self.workingDir + '/Raw/' + self.procNum)) if (self.lowMeth == 'nwchem'): mol = tl.setCalc(mol, self.lowString, 'nwchem2', self.lowLev) self.Reac.get_forces() else: mol = tl.setCalc(mol, self.lowString, self.lowMeth, self.lowLev) vib = Vibrations(mol) vib.clean() vib.run() viblist = vib.get_frequencies() print("getting vibs") TSFreqs, zpe = tl.getVibString(viblist, False, True) print("vibs done " + str(zpe)) imaginaryFreq = tl.getImageFreq(viblist) vib.clean() os.chdir((self.workingDir)) # Finally get single point energy mol = tl.setCalc(mol, self.singleString, self.singleMeth, self.singleLev) print("Getting single point energy for TS = " + str(mol.get_potential_energy()) + "zpe = " + str(zpe) + "reactant energy = " + str(self.reactantEnergy)) energy = mol.get_potential_energy() + zpe return TSFreqs, imaginaryFreq, zpe, energy
def test_Ag_Cu100(): from math import sqrt from ase import Atom, Atoms from ase.neb import NEB from ase.constraints import FixAtoms from ase.vibrations import Vibrations from ase.calculators.emt import EMT from ase.optimize import QuasiNewton, BFGS # Distance between Cu atoms on a (100) surface: d = 3.6 / sqrt(2) initial = Atoms('Cu', positions=[(0, 0, 0)], cell=(d, d, 1.0), pbc=(True, True, False)) initial *= (2, 2, 1) # 2x2 (100) surface-cell # Approximate height of Ag atom on Cu(100) surfece: h0 = 2.0 initial += Atom('Ag', (d / 2, d / 2, h0)) # Make band: images = [initial.copy() for i in range(6)] neb = NEB(images, climb=True) # Set constraints and calculator: constraint = FixAtoms(range(len(initial) - 1)) for image in images: image.calc = EMT() image.set_constraint(constraint) # Displace last image: images[-1].positions[-1] += (d, 0, 0) # Relax height of Ag atom for initial and final states: dyn1 = QuasiNewton(images[0]) dyn1.run(fmax=0.01) dyn2 = QuasiNewton(images[-1]) dyn2.run(fmax=0.01) # Interpolate positions between initial and final states: neb.interpolate() for image in images: print(image.positions[-1], image.get_potential_energy()) dyn = BFGS(neb, trajectory='mep.traj') dyn.run(fmax=0.05) for image in images: print(image.positions[-1], image.get_potential_energy()) a = images[0] vib = Vibrations(a, [4]) vib.run() print(vib.get_frequencies()) vib.summary() print(vib.get_mode(-1)) vib.write_mode(-1, nimages=20)
def characteriseFreqInternal(self, mol): os.chdir((self.workingDir + '/' + '/Raw/' + self.procNum)) vib = Vibrations(mol) vib.clean() vib.run() viblist = vib.get_frequencies() freqs, zpe = tl.getVibString(viblist, False, False) vib.clean() os.chdir((self.workingDir)) return freqs, zpe
def test_vibrations_on_surface(self, testdir): atoms = self.n2_on_ag.copy() atoms.calc = EMT() vibs = Vibrations(atoms, indices=[-2, -1]) vibs.run() freqs = vibs.get_frequencies() vib_data = vibs.get_vibrations() assert_array_almost_equal(freqs, vib_data.get_frequencies())
def test_gs_minimum(): """Test ground state minimum distance, energy and vibrational frequency""" atoms = H2Morse() assert atoms.get_distance(0, 1) == pytest.approx(Re[0], 1.e-12) assert atoms.get_potential_energy() == -De[0] # check ground state vibrations vib = Vibrations(atoms) vib.run() assert (vib.get_frequencies().real[-1] == pytest.approx(ome[0], 1e-2))
def VibScript(): from ase.vibrations import Vibrations import glob, json, cPickle, ase, os ####################### print "Initializing..." #---------------------- params, atoms = initialize( ) # Remove old .out/.err files, load from fw_spec, and write 'init.traj' prev = glob.glob( '*.pckl') #delete incomplete pckls - facilitating restarted jobs if rank() == 0: for p in prev: if os.stat(p).st_size < 100: os.remove(p) atoms.set_calculator(makeCalc(params)) vib = Vibrations(atoms, delta=params['delta'], indices=json.loads(params['vibids_json'])) vib.run() vib.write_jmol() ########################## print "Storing Results..." #------------------------- vib.summary(log='vibrations.txt') with open('vibrations.txt', 'r') as f: vibsummary = f.read() ase.io.write('final.traj', atoms) optAtoms = ase.io.read('final.traj') vib_energies, vib_frequencies = vib.get_energies(), vib.get_frequencies() resultDict = mergeDicts([ params, trajDetails(optAtoms), { 'vibfreqs_pckl': cPickle.dumps(vib_frequencies), 'vibsummary': vibsummary, 'vibengs_pckl': cPickle.dumps(vib_energies) } ]) with open('result.json', 'w') as outfile: outfile.write(json.dumps(resultDict)) with open('result.json', 'r') as outfile: json.loads(outfile.read()) #test that dictionary isn't 'corrupted' if rank() == 0: log(params, optAtoms) return 0
def get_modes(self,atm,freqname="vib."): for f in [f for f in os.listdir(".") if freqname in f and '.pckl' in f]: os.remove(f) new_target = open(os.devnull, "w") old_target, sys.stdout = sys.stdout, new_target atm.set_calculator(ANIENS(self.ens)) vib = Vibrations(atm, nfree=2, name=freqname) vib.run() freq = vib.get_frequencies() modes = np.stack(vib.get_mode(i) for i in range(freq.size)) vib.clean() sys.stdout = old_target return modes
def __init__(self, atoms, vibname, minfreq=None, maxfreq=None): """Input is a atoms object and the corresponding vibrations. With minfreq and maxfreq frequencies can be excluded from the calculation""" self.atoms = atoms # V = a * v is the combined atom and xyz-index self.mm05_V = np.repeat(1.0 / np.sqrt(atoms.get_masses()), 3) self.minfreq = minfreq self.maxfreq = maxfreq self.shape = (len(self.atoms), 3) vib = Vibrations(atoms, name=vibname) self.energies = np.real(vib.get_energies(method="frederiksen")) # [eV] self.frequencies = np.real(vib.get_frequencies(method="frederiksen")) # [cm^-1] self.modes = vib.modes self.H = vib.H
def __init__(self, atoms, vibname, minfreq=-np.inf, maxfreq=np.inf): """Input is a atoms object and the corresponding vibrations. With minfreq and maxfreq frequencies can be excluded from the calculation""" self.atoms = atoms # V = a * v is the combined atom and xyz-index self.mm05_V = np.repeat(1. / np.sqrt(atoms.get_masses()), 3) self.minfreq = minfreq self.maxfreq = maxfreq self.shape = (len(self.atoms), 3) vib = Vibrations(atoms, name=vibname) self.energies = np.real(vib.get_energies(method='frederiksen')) # [eV] self.frequencies = np.real( vib.get_frequencies(method='frederiksen')) # [cm^-1] self.modes = vib.modes self.H = vib.H
def run_task(self,fw_spec): """ONLY WORKS FOR QUANTUM ESPRESSO""" from ase.vibrations import Vibrations jobID = fw_spec['jobID'] job = db2object(jobID) t0 = time.time() atoms = job.atoms() atoms.set_calculator(job.vibCalc()) vib = Vibrations(atoms,delta=job.delta(),indicies=job.vibids) vib.run() vib.summary(log='vibrations.txt') vib.write_jmol() vibs = vib.get_frequencies() t = (time.time()-t0)/60.0 #min return FWAction(stored_data= {'vibs':vibs,'avgtime':t},mod_spec=[{'_push': {'vibs':vibs,'time':t}}])
def test_vibrations_on_surface(self, testdir): atoms = self.n2_on_ag.copy() atoms.calc = EMT() vibs = Vibrations(atoms, indices=[-2, -1]) vibs.run() freqs = vibs.get_frequencies() assert len(freqs) == 6 vib_data = vibs.get_vibrations() assert_array_almost_equal(freqs, vib_data.get_frequencies()) # These should blow up if the vectors don't match number of atoms vibs.summary() vibs.write_jmol() for i in range(6): # Frozen atoms should have zero displacement assert_array_almost_equal(vibs.get_mode(i)[0], [0., 0., 0.]) # At least one of the N atoms should have finite displacement # (It's a strange test system, the N aren't interacting.) assert np.any(vibs.get_mode(i)[-2:, :])
def run_task(self,fw_spec): """ONLY WORKS FOR QUANTUM ESPRESSO""" from ase.vibrations import Vibrations job,params,atoms = initialize(fw_spec) prev = g.glob('*.pckl') #delete incomplete pckls - facilitating restarted jobs for p in prev: if os.stat(p).st_size < 100: os.remove(p) atoms.set_calculator(job.vibCalc()) vib = Vibrations(atoms,delta=job.delta(),indices=job.vibids()) vib.run(); vib.write_jmol() vib.summary(log='vibrations.txt') with open('vibrations.txt','r') as f: vibsummary = f.read() vib_energies,vib_frequencies = vib.get_energies(),vib.get_frequencies() resultDict = misc.mergeDicts([params, {'vibfreqs_pckl': pickle.dumps(vib_frequencies) ,'vibsummary':vibsummary ,'vibengs_pckl':pickle.dumps(vib_energies)}]) with open('result.json', 'w') as outfile: json.dumps(resultDict, outfile) return fireworks.core.firework.FWAction(stored_data=resultDict)
def characteriseMinInternal(self, mol): os.chdir((self.workingDir + '/' + '/Raw/' + self.procNum)) if (self.lowMeth == 'nwchem'): mol = tl.setCalc(mol, self.lowString, 'nwchem2', self.lowLev) self.Reac.get_forces() else: mol = tl.setCalc(mol, self.lowString, self.lowMeth, self.lowLev) min = BFGS(mol) min.run(fmax=0.05, steps=50) vib = Vibrations(mol) vib.clean() vib.run() viblist = vib.get_frequencies() Freqs, zpe = tl.getVibString(viblist, False, False) vib.clean() os.chdir((self.workingDir)) # Finally get single point energy mol = tl.setCalc(mol, self.singleString, self.singleMeth, self.singleLev) print("Getting single point energy for TS = " + str(mol.get_potential_energy()) + "zpe = " + str(zpe) + "reactant energy = " + str(self.reactantEnergy)) energy = mol.get_potential_energy() + zpe return Freqs, energy, mol
from __future__ import print_function from ase import Atoms from ase.calculators.emt import EMT from ase.optimize import QuasiNewton from ase.vibrations import Vibrations from ase.thermochemistry import IdealGasThermo n2 = Atoms('N2', positions=[(0, 0, 0), (0, 0, 1.1)], calculator=EMT()) QuasiNewton(n2).run(fmax=0.01) vib = Vibrations(n2) vib.run() freqs = vib.get_frequencies() print(freqs) vib.summary() print(vib.get_mode(-1)) vib.write_mode(n=None, nimages=20) vib_energies = vib.get_energies() for image in vib.iterimages(): assert len(image) == 2 thermo = IdealGasThermo(vib_energies=vib_energies, geometry='linear', atoms=n2, symmetrynumber=2, spin=0) thermo.get_gibbs_energy(temperature=298.15, pressure=2 * 101325.) assert vib.clean(empty_files=True) == 0 assert vib.clean() == 13 assert len(list(vib.iterimages())) == 13
def calculate(element, ref_data, p): values_dict = {} values_dict[p['xc']] = {} for XY, data in ref_data[p['xc']].items(): X = XY.split('-')[0] Y = XY.split('-')[1] if (X == Y and X == element) or (X != Y and (X == element or Y == element)): # compound contains the requested element re_ref = data['re'] we_ref = data['we'] m0_ref = data.get('m0', 0.0) # compound = Atoms(X+Y, [ (0, 0, 0.5 ), (0, 0, 0.5+re_ref/a), ], pbc=0) compound.set_cell([a, b, c], scale_atoms=1) compound.center() # calculation on the reference geometry calc = Calculator(**p) compound.set_calculator(calc) e_compound = compound.get_potential_energy() finegd = calc.density.finegd dip = finegd.calculate_dipole_moment(calc.density.rhot_g)*calc.a0 vib = Vibrations(compound) vib.run() vib_compound = vib.get_frequencies(method='frederiksen').real[-1] world.barrier() vib_pckl = glob('vib.*.pckl') if rank == 0: for file in vib_pckl: remove(file) # calculation on the relaxed geometry qn = QuasiNewton(compound) #qn.attach(PickleTrajectory('compound.traj', 'w', compound).write) qn.run(fmax=0.05) e_compound_r = compound.get_potential_energy() dist_compound_r = compound.get_distance(0,1) dip_r = finegd.calculate_dipole_moment(calc.density.rhot_g)*calc.a0 vib = Vibrations(compound) vib.run() vib_compound_r = vib.get_frequencies(method='frederiksen').real[-1] world.barrier() vib_pckl = glob('vib.*.pckl') if rank == 0: for file in vib_pckl: remove(file) del compound e = e_compound we = vib_compound m0 = dip e_r = e_compound_r we_r = vib_compound_r re_r = dist_compound_r m0_r = dip_r # values_dict[p['xc']][XY] = {'re': re_r, 'we': (we_r, we), 'm0': (m0_r, m0)} # return values_dict
maxiter=777, convergence={'lshift': 0.0}, basis=basis, basispar='spherical', direct='noio', raw='set int:txs:limxmem 134217728\nmemory total 8000 Mb noverify\n', label=label) atoms.set_calculator(calc) t = time.time() if len(atoms) > 1: # need a copy of atoms for calculation of vibrations vibatoms = atoms.copy() vibatoms.set_calculator(calc) vib = Vibrations(vibatoms, name=label + '_fixed') vib.run() f = vib.get_frequencies()[-1].real # clean nwchem restart if os.path.exists(name + '_' + code + '.db'): os.remove(name + '_' + code + '.db') atoms.get_potential_energy() c.write(atoms, name=name, relaxed=False, basis=basis, frequency=f, time=time.time()-t) else: atoms.get_potential_energy() c.write(atoms, name=name, relaxed=False, basis=basis, time=time.time()-t) if len(atoms) > 1: opt = BFGS(atoms, logfile=name + '_' + code + '.log', trajectory=name + '_' + code + '.traj')
Analysis_CalculateForces = 'Yes') # Mixing calculators QMMMcalc = ase.calculators.mixing.SumCalculator([DFTBcalc,SchNetcalc], atoms) atoms.set_calculator(QMMMcalc) # Optmizing geometry qn = BFGS(atoms, trajectory='mol.traj') qn.run(fmax=0.0001) write('final.xyz', atoms) # Computing vibrational modes vib = Vibrations(atoms, delta=0.01,nfree=4) vib.run() vib.summary() vb_ev = vib.get_energies() vb_cm = vib.get_frequencies() ENE = float(atoms.get_total_energy()) o1 = open('info-modes.dat', 'w') o1.write("# Potential energy: " + "{: >24}".format(ENE) + "\n") for i in range(0, len(vb_ev)): o1.write("{: >24}".format(vb_ev.real[i]) + "{: >24}".format(vb_ev.imag[i]) + "{: >24}".format(vb_cm.real[i]) + "{: >24}".format(vb_cm.imag[i]) + "\n") vib.write_jmol() o1.close() chdir(odir)
# Relax structure dyn = BFGS(atoms, trajectory=f'traj/Al{N}.traj') dyn.run(fmax=0.05) # Get vibrational spectrum str1 = f'-------- N={N}' str2 = ' ---------' print(str1 + str2.ljust(40 - len(str1))) ##### Using Vibrations module v = Vibrations(atoms, name=f'./vibs/vib_{N}') if not p.isfile(f'./vibs/vib_{N}.all.pckl'): print('Running vibration calculation') v.run() v.combine() # Combine pickle files # Get frequencies and DOS - i.e # of states per frequency all_freq = v.get_frequencies() # if N==38: # print(v.summary()) # print(all_freq) (freq, counts) = np.unique(all_freq, return_counts=True) fold_freq = v.fold(np.real(freq), np.real(counts), start=0, end=np.real(freq.max()), width=12, normalize=False) f_freq = np.array(fold_freq[0]) f_dos = np.array(fold_freq[1]) freq = np.array(freq) dos = np.array(counts)
def calculate(element, ref_data, p): values_dict = {} values_dict[p['xc']] = {} for XY, data in ref_data[p['xc']].items(): X = XY.split('-')[0] Y = XY.split('-')[1] if (X == Y and X == element) or (X != Y and (X == element or Y == element)): # compound contains the requested element re_ref = data['re'] we_ref = data['we'] m0_ref = data.get('m0', 0.0) # compound = Atoms(X + Y, [ (0, 0, 0.5), (0, 0, 0.5 + re_ref / a), ], pbc=0) compound.set_cell([a, b, c], scale_atoms=1) compound.center() # calculation on the reference geometry calc = Calculator(**p) compound.set_calculator(calc) e_compound = compound.get_potential_energy() finegd = calc.density.finegd dip = finegd.calculate_dipole_moment(calc.density.rhot_g) * calc.a0 vib = Vibrations(compound) vib.run() vib_compound = vib.get_frequencies(method='frederiksen').real[-1] world.barrier() vib_pckl = glob('vib.*.pckl') if rank == 0: for file in vib_pckl: remove(file) # calculation on the relaxed geometry qn = QuasiNewton(compound) #qn.attach(PickleTrajectory('compound.traj', 'w', compound).write) qn.run(fmax=0.05) e_compound_r = compound.get_potential_energy() dist_compound_r = compound.get_distance(0, 1) dip_r = finegd.calculate_dipole_moment( calc.density.rhot_g) * calc.a0 vib = Vibrations(compound) vib.run() vib_compound_r = vib.get_frequencies(method='frederiksen').real[-1] world.barrier() vib_pckl = glob('vib.*.pckl') if rank == 0: for file in vib_pckl: remove(file) del compound e = e_compound we = vib_compound m0 = dip e_r = e_compound_r we_r = vib_compound_r re_r = dist_compound_r m0_r = dip_r # values_dict[p['xc']][XY] = { 're': re_r, 'we': (we_r, we), 'm0': (m0_r, m0) } # return values_dict
def test_vibrations(self, testdir, n2_emt, n2_optimized): atoms = n2_emt vib = Vibrations(atoms) vib.run() freqs = vib.get_frequencies() vib.write_mode(n=None, nimages=5) vib.write_jmol() vib_energies = vib.get_energies() for image in vib.iterimages(): assert len(image) == 2 thermo = IdealGasThermo(vib_energies=vib_energies, geometry='linear', atoms=atoms, symmetrynumber=2, spin=0) thermo.get_gibbs_energy(temperature=298.15, pressure=2 * 101325., verbose=False) vib.summary(log=self.logfile) with open(self.logfile, 'rt') as f: log_txt = f.read() assert log_txt == vibrations_n2_log mode1 = vib.get_mode(-1) assert_array_almost_equal(mode1, [[0., 0., -0.188935], [0., 0., 0.188935]]) assert_array_almost_equal( vib.show_as_force(-1, show=False).get_forces(), [[0., 0., -2.26722e-1], [0., 0., 2.26722e-1]]) for i in range(3): assert not os.path.isfile('vib.{}.traj'.format(i)) mode_traj = ase.io.read('vib.3.traj', index=':') assert len(mode_traj) == 5 assert_array_almost_equal(mode_traj[0].get_all_distances(), atoms.get_all_distances()) with pytest.raises(AssertionError): assert_array_almost_equal(mode_traj[4].get_all_distances(), atoms.get_all_distances()) with open('vib.xyz', 'rt') as f: jmol_txt = f.read() assert jmol_txt == jmol_txt_ref assert vib.clean(empty_files=True) == 0 assert vib.clean() == 13 assert len(list(vib.iterimages())) == 13 d = dict(vib.iterdisplace(inplace=False)) for name, image in vib.iterdisplace(inplace=True): assert d[name] == atoms atoms2 = n2_emt vib2 = Vibrations(atoms2) vib2.run() assert_array_almost_equal(freqs, vib.get_frequencies()) # write/read the data from another working directory atoms3 = n2_optimized.copy() # No calculator needed! workdir = os.path.abspath(os.path.curdir) try: os.mkdir('run_from_here') os.chdir('run_from_here') vib = Vibrations(atoms3, name=os.path.join(os.pardir, 'vib')) assert_array_almost_equal(freqs, vib.get_frequencies()) assert vib.clean() == 13 finally: os.chdir(workdir) if os.path.isdir('run_from_here'): os.rmdir('run_from_here')
dw=8000, # density cutoff nbands=-10, # number of bands kpts=(8, 8, 8), # k points xc='rpbe', # exchange correlation method sigma=0.2, # Fermi temperature dipole={'status': False}, spinpol=False, convergence={ 'energy': 0.0005, 'mixing': 0.1, 'nmix': 10, 'maxsteps': 500, 'diag': 'david' }, outdirprefix='vibdir') atoms.set_calculator(calc) vib = Vibrations(atoms, delta=0.04, indices=vib_atoms) vib.run() vib.summary(log='vibrations.txt') vib.write_jmol() realFreq = [ x * 0.00012 for x in vib.get_frequencies() if not isinstance(x, complex) ] #eV S = HarmonicThermo(realFreq).get_entropy(300) with open('vibrations.txt', 'a') as f: f.write('\nTS at 300K: ' + str(S))
from ase import Atoms from ase.calculators.emt import EMT from ase.optimize import QuasiNewton from ase.vibrations import Vibrations from ase.thermochemistry import IdealGasThermo n2 = Atoms('N2', positions=[(0, 0, 0), (0, 0, 1.1)], calculator=EMT()) QuasiNewton(n2).run(fmax=0.01) vib = Vibrations(n2) vib.run() print vib.get_frequencies() vib.summary() print vib.get_mode(-1) vib.write_mode(-1, nimages=20) vib_energies = vib.get_energies() thermo = IdealGasThermo(vib_energies=vib_energies, geometry='linear', atoms=n2, symmetrynumber=2, spin=0) thermo.get_free_energy(temperature=298.15, pressure=2*101325.)
from ase import Atoms from ase.calculators.emt import EMT from ase.optimize import QuasiNewton from ase.vibrations import Vibrations from ase.thermochemistry import IdealGasThermo n2 = Atoms('N2', positions=[(0, 0, 0), (0, 0, 1.1)], calculator=EMT()) QuasiNewton(n2).run(fmax=0.01) vib = Vibrations(n2) vib.run() print(vib.get_frequencies()) vib.summary() print(vib.get_mode(-1)) vib.write_mode(n=None, nimages=20) vib_energies = vib.get_energies() thermo = IdealGasThermo(vib_energies=vib_energies, geometry='linear', atoms=n2, symmetrynumber=2, spin=0) thermo.get_gibbs_energy(temperature=298.15, pressure=2 * 101325.)
from __future__ import print_function from ase import Atoms from ase.calculators.emt import EMT from ase.optimize import QuasiNewton from ase.vibrations import Vibrations from ase.thermochemistry import IdealGasThermo n2 = Atoms('N2', positions=[(0, 0, 0), (0, 0, 1.1)], calculator=EMT()) QuasiNewton(n2).run(fmax=0.01) vib = Vibrations(n2) vib.run() print(vib.get_frequencies()) vib.summary() print(vib.get_mode(-1)) vib.write_mode(n=None, nimages=20) vib_energies = vib.get_energies() for image in vib.iterimages(): assert len(image) == 2 thermo = IdealGasThermo(vib_energies=vib_energies, geometry='linear', atoms=n2, symmetrynumber=2, spin=0) thermo.get_gibbs_energy(temperature=298.15, pressure=2 * 101325.) assert vib.clean(empty_files=True) == 0 assert vib.clean() == 13 assert len(list(vib.iterimages())) == 13 d = dict(vib.iterdisplace(inplace=False))
from ase import * from ase.vibrations import Vibrations n2 = Atoms('N2', positions=[(0, 0, 0), (0, 0, 1.1)], calculator=EMT()) QuasiNewton(n2).run(fmax=0.01) vib = Vibrations(n2) vib.run() print vib.get_frequencies() vib.summary() print vib.get_mode(-1) vib.write_mode(-1, nimages=20)
# Using optimal lattice parameter from task 2 a = 4.043 # A atoms = bulk('Al', 'fcc', a) # view(atoms) # DEBUG #### Calculate vibrational spectrum # Attach EAM calculator to atoms mishin = EAM(potential='../CourseGitRepo/HA5_al_potential.alloy') # Set up EAM atoms.set_calculator(mishin) # Get vibrational spectrum v = Vibrations(atoms, name='./vibs/vib_bulk') v.run() v.summary() # Get frequencies and DOS - i.e # of states per frequency (freq, counts) = np.unique(v.get_frequencies(), return_counts=True) freq = np.array(freq) dos = np.array(counts) # Save to db vibDB.write(atoms, data={'frequency': freq, 'DOS': dos}) #### Calculate band structure N = 7 # Use a supercell of size 7x7x7 ph = Phonons(atoms, mishin, name='./phonons/ph_bulk', supercell=(N, N, N), delta=0.05) ph.run() # Read the results from the run and obtain the bandpath and DOS ph.read(acoustic=True)
# Calc minimized energies e = geometry.get_potential_energy() print('Total energy', e, 'eV') # Get the forces again print('Forces:') print(geometry.get_forces()) # Run the vibrational analysis vib = Vibrations(geometry, nfree=2) vib.run() print(vib.summary()) print(vib.get_zero_point_energy()) # Get freqs f = vib.get_frequencies() # Print modes + freq for i in range(0, len(f)): print('Mode(' + str(i) + ') Freq: ' + "{:.7e}".format(f[i])) print(vib.get_mode(i)) ''' # We will alse need to use these functions to get thermo-chem data thermo = IdealGasThermo(vib_energies=vib_energies, potentialenergy=potentialenergy, atoms=atoms, geometry='linear', symmetrynumber=2, spin=0) G = thermo.get_gibbs_energy(temperature=298.15, pressure=101325.) '''