def energy(N, k, a=4.05): fcc = fcc100('Al', (1, 1, N), a=a, vacuum=7.5) fcc.center(axis=2) calc = GPAW(nbands=N * 3, kpts=(k, k, 1), h=0.25, txt='slab-%d.txt' % N) fcc.set_calculator(calc) e = fcc.get_potential_energy() calc.write('slab-%d.gpw' % N) return e
def energy(N, k, a=4.05): fcc = fcc100('Al', (1, 1, N), a=a, vacuum=7.5) fcc.center(axis=2) calc = GPAW(nbands=N * 5, kpts=(k, k, 1), h=0.25, txt='slab-%d.txt' % N) fcc.set_calculator(calc) e = fcc.get_potential_energy() calc.write('slab-%d.gpw' % N) return e
def asesurf2xxyz(symb, lattice, index, size=(1,1,3), vac=15.0, orthogonal=0): """ An interface function for ase.lattice.surface Usage: >>> atoms = asesurf2xxyz(symb, lattice, index, size, vac=15.0, orthogonal=0)) Parameters: symb: atomic symbol lattice: 'fcc', 'bcc', or 'hcp0001' index: '100', '111' or '110' (if lattice is 'hcp0001', this will not work.) size: the number of atoms per each vector Optional Parameters: vac (default: 15.0 angstron): the thickness of space normal to the surface orthogonal (default: False) : if True, two lateral cell vectors will be orthogonal. Example: >>> Fe_100_1x1 = asesurf2xxyz('Fe', 'bcc', '100', (1,1,2)) >>> Au_111_2x2 = asesurf2xxyz('Au', 'fcc', '111', (1,1,3)) """ if lattice == 'fcc': if index == '100': at_ase = AS.fcc100(symb, size, vacuum=vac) elif index == '111': at_ase = AS.fcc111(symb, size, orthogonal=orthogonal, vacuum=vac) elif index == '110': at_ase = AS.fcc110(symb, size, vacuum=vac) else: raise ValueError, "100, 111, or 110 surface is supported." elif lattice == 'bcc': if index == '100': at_ase = AS.bcc100(symb, size, vacuum=vac) elif index == '111': at_ase = AS.bcc111(symb, size, orthogonal=orthogonal, vacuum=vac) elif index == '110': at_ase = AS.bcc110(symb, size, orthogonal=orthogonal, vacuum=vac) else: raise ValueError, "100, 111, or 110 surface is supported." elif lattice == 'hcp0001': at_ase = AS.hcp0001(symb, size, orthogonal=orthogonal, vacuum=vac) else: raise ValueError, "fcc, bcc, or hcp0001 surface is supported." symbols = at_ase.get_chemical_symbols() posits = at_ase.get_positions() cell = at_ase.get_cell() pbc = at_ase.get_pbc() atoms = []; i=0 for sym in symbols: temp_at = Atom(sym, list(posits[i])) atoms.append(temp_at.copy()); i+=1 at_xxyz = AtomsSystem(atoms, cell=cell, pbc=pbc) return at_xxyz
def asesurf2xxyz(symb, lattice, index, size=(1,1,3), vac=15.0, orthogonal=0): """ An interface function for ase.lattice.surface Usage: >>> atoms = asesurf2xxyz(symb, lattice, index, size, vac=15.0, orthogonal=0)) Parameters: symb: atomic symbol lattice: 'fcc', 'bcc', or 'hcp0001' index: '100', '111' or '110' (if lattice is 'hcp0001', this will not work.) size: the number of atoms per each vector Optional Parameters: vac (default: 15.0 angstron): the thickness of space normal to the surface orthogonal (default: False) : if True, two lateral cell vectors will be orthogonal. Example: >>> Fe_100_1x1 = asesurf2xxyz('Fe', 'bcc', '100', (1,1,2)) >>> Au_111_2x2 = asesurf2xxyz('Au', 'fcc', '111', (1,1,3)) """ if lattice == 'fcc': if index == '100': at_ase = AS.fcc100(symb, size, vacuum=vac) elif index == '111': at_ase = AS.fcc111(symb, size, orthogonal=orthogonal, vacuum=vac) elif index == '110': at_ase = AS.fcc110(symb, size, vacuum=vac) else: raise ValueError("100, 111, or 110 surface is supported.") elif lattice == 'bcc': if index == '100': at_ase = AS.bcc100(symb, size, vacuum=vac) elif index == '111': at_ase = AS.bcc111(symb, size, orthogonal=orthogonal, vacuum=vac) elif index == '110': at_ase = AS.bcc110(symb, size, orthogonal=orthogonal, vacuum=vac) else: raise ValueError("100, 111, or 110 surface is supported.") elif lattice == 'hcp0001': at_ase = AS.hcp0001(symb, size, orthogonal=orthogonal, vacuum=vac) else: raise ValueError("fcc, bcc, or hcp0001 surface is supported.") symbols = at_ase.get_chemical_symbols() posits = at_ase.get_positions() cell = at_ase.get_cell() pbc = at_ase.get_pbc() atoms = []; i=0 for sym in symbols: temp_at = Atom(sym, list(posits[i])) atoms.append(temp_at.copy()); i+=1 at_xxyz = AtomsSystem(atoms, cell=cell, pbc=pbc) return at_xxyz
def get_atoms(): # 2x2-Al(001) surface with 3 layers and an # Au atom adsorbed in a hollow site: slab = fcc100('Al', size=(2, 2, 3)) add_adsorbate(slab, 'Au', 1.7, 'hollow') slab.center(axis=2, vacuum=4.0) # Fix second and third layers: mask = [atom.tag > 1 for atom in slab] slab.set_constraint(FixAtoms(mask=mask)) # Use EMT potential: slab.set_calculator(EMT()) # Initial state: qn = QuasiNewton(slab, logfile=None) qn.run(fmax=0.05) initial = slab.copy() # Final state: slab[-1].x += slab.get_cell()[0, 0] / 2 qn = QuasiNewton(slab, logfile=None) qn.run(fmax=0.05) final = slab.copy() # Setup a NEB calculation constraint = FixAtoms(mask=[atom.tag > 1 for atom in initial]) images = [initial] for i in range(3): image = initial.copy() image.set_constraint(constraint) images.append(image) images.append(final) neb = NEB(images, parallel=mpi.parallel) neb.interpolate() def set_calculator(calc): i = 0 for image in neb.images[1:-1]: if not mpi.parallel or mpi.rank // (mpi.size // 3) == i: image.set_calculator(calc) i += 1 neb.set_calculator = set_calculator return neb
def get_surface_slabs(symbol, surfacetype, surfacesize, layers, latticeconstants, vacuum=10.0): images = [] if surfacetype == 'fcc100' or surfacetype == 'fcc111': nlayeratoms = surfacesize[0] * surfacesize[1] if isinstance(latticeconstants, (list, tuple)): if not len(latticeconstants) == 1: raise ValueError("Too many latticeconstants") a = latticeconstants[0] else: a = latticeconstants elif surfacetype == 'hcp0001': nlayeratoms = surfacesize[0] * surfacesize[1] if isinstance(latticeconstants, (list, tuple)): if not len(latticeconstants) == 2: raise ValueError("Latticeconstants must be on the form [a, c]") a = latticeconstants[0] c = latticeconstants[1] else: raise ValueError("Latticeconstants must be on the form [a, c]") else: raise ValueError("Surface type '%s' is not supported" % (surfacetype, )) for n in layers: size = surfacesize + (n, ) if surfacetype == 'fcc100': images.append(fcc100(symbol=symbol, size=size, a=a, vacuum=vacuum)) elif surfacetype == 'fcc111': images.append( fcc111(symbol=symbol, size=size, a=a, vacuum=vacuum, orthogonal=True)) elif surfacetype == 'hcp0001': images.append( hcp0001(symbol=symbol, size=size, a=a, c=c, vacuum=vacuum, orthogonal=True)) return images, nlayeratoms
def facet_setup(host,fac,c,lat,root=None): if fac == 111: if root: atoms = fcc111_root(host, root=root, a=lat, size=(c[0],c[1],4), vacuum = 12.0) else: atoms = fcc111(host, a=lat, size=(c[0],c[1],4), vacuum=12.0) elif fac == 100: atoms = fcc100(host, a=lat, size=(c[0],c[1],4), vacuum=12.0) elif fac == 211: atoms = fcc211(host, a=lat, size=(c[0],c[1],4), vacuum=12.0) return atoms
def slabCalculation(): slab = fcc100("Al", size=(2, 2, 3)) add_adsorbate(slab, "Au", 1.7, "hollow") slab.center(axis=2, vacuum=4.0) # Make sure the structure is correct: # from ase.visualize import view # view(slab) # Fix second and third layers: mask = [atom.tag > 1 for atom in slab] # print mask fixlayers = FixAtoms(mask=mask) # Constrain the last atom (Au atom) to move only in the yz-plane: plane = FixedPlane(-1, (1, 0, 0)) slab.set_constraint([fixlayers, plane]) print(slab.cell / Bohr)
def slabCalculation(): slab = fcc100('Al', size=(2, 2, 3)) add_adsorbate(slab, 'Au', 1.7, 'hollow') slab.center(axis=2, vacuum=4.0) # Make sure the structure is correct: #from ase.visualize import view #view(slab) # Fix second and third layers: mask = [atom.tag > 1 for atom in slab] #print mask fixlayers = FixAtoms(mask=mask) # Constrain the last atom (Au atom) to move only in the yz-plane: plane = FixedPlane(-1, (1, 0, 0)) slab.set_constraint([fixlayers, plane]) print(slab.cell / Bohr)
def aual100(site, height, calc=None): slab = fcc100('Al', size=(2, 2, 1)) add_adsorbate(slab, 'Au', height, site) slab.center(axis=2, vacuum=3.0) mask = [atom.symbol == 'Al' for atom in slab] fixlayer = FixAtoms(mask=mask) slab.set_constraint(fixlayer) if calc is None: calc = GPAW(h=0.25, kpts=(2, 2, 1), xc='PBE', txt=site + '.txt') slab.set_calculator(calc) qn = QuasiNewton(slab, trajectory=site + '.traj') qn.run(fmax=0.05) if isinstance(calc, GPAW): calc.write(site + '.gpw') return slab.get_potential_energy()
def get_surface_slabs(symbol, surfacetype, surfacesize, layers, latticeconstants, vacuum=10.0): images = [] if surfacetype == 'fcc100' or surfacetype == 'fcc111': nlayeratoms = surfacesize[0] * surfacesize[1] if isinstance(latticeconstants, (list, tuple)): if not len(latticeconstants) == 1: raise ValueError("Too many latticeconstants") a = latticeconstants[0] else: a = latticeconstants elif surfacetype == 'hcp0001': nlayeratoms = surfacesize[0] * surfacesize[1] if isinstance(latticeconstants, (list, tuple)): if not len(latticeconstants) == 2: raise ValueError("Latticeconstants must be on the form [a, c]") a = latticeconstants[0] c = latticeconstants[1] else: raise ValueError("Latticeconstants must be on the form [a, c]") else: raise ValueError("Surface type '%s' is not supported" % (surfacetype,)) for n in layers: size = surfacesize + (n,) if surfacetype == 'fcc100': images.append(fcc100(symbol=symbol, size=size, a=a, vacuum=vacuum)) elif surfacetype == 'fcc111': images.append(fcc111(symbol=symbol, size=size, a=a, vacuum=vacuum, orthogonal=True)) elif surfacetype == 'hcp0001': images.append(hcp0001(symbol=symbol, size=size, a=a, c=c, vacuum=vacuum, orthogonal=True)) return images, nlayeratoms
from winak.curvilinear.Coordinates import DelocalizedCoordinates as DC from winak.globaloptimization.delocalizer import * from winak.curvilinear.InternalCoordinates import icSystem, Periodic_icSystem from winak.curvilinear.InternalCoordinates import ValenceCoordinateGenerator as VCG from winak.curvilinear.InternalCoordinates import PeriodicValenceCoordinateGenerator as PVCG from ase.lattice.cubic import FaceCenteredCubic as fcc from ase.lattice.surface import fcc100, fcc111 import cPickle as pickle import numpy as np i = 2 j = 2 k = 3 system = fcc100('Pd', (i,j,k), a=3.94, vacuum=10.) natoms =len(system) np.set_printoptions(threshold=np.nan) import time start=time.time() print start iclist = None iclist = pickle.load(open("iclist.p", "rb")) print 'delocalizer ' d = Delocalizer(system, icList=iclist, periodic=True, dense=False, \ weighted=False, add_cartesians = True) e1 = []
ncpus = 4 from ase.lattice.surface import fcc100 from gpaw import GPAW atoms = fcc100(symbol='Ni', size=(1, 1, 9), a=3.52, vacuum=5.5) atoms.set_initial_magnetic_moments([0.6] * len(atoms)) atoms.calc = GPAW(h=0.18, kpts=(8, 8, 1), xc='PBE')
l=options.lattice p=options.periods v=options.vaccuum e=options.element atoms = [] if(options.bravais == 'fcc'): if(options.hkl == '111'): #atoms = fcc111(e, size=p,a=l, vacuum=v, orthogonal=False) atoms = fcc111(e, size=p,a=l, vacuum=v, orthogonal=options.ortogonal) elif(options.hkl == '110'): atoms = fcc110(e, size=p,a=l, vacuum=v) elif(options.hkl == '100'): atoms = fcc100(e, size=p,a=l, vacuum=v) elif(options.bravais == 'MoS2'): atoms = mx2(formula='MoS2', kind='2H', a=3.18, thickness=3.19, size=(1, 1, 1), vacuum=7.5) #c=atoms.get_cell() #c[1][0] += l*math.sqrt(2)*0.5 #atoms.set_cell(c) #atoms.translate([0.0,0.0,-14.9999999999999982]) if(options.cell != None): to_remove = [] for i, atom in enumerate(atoms): r = atom.position.astype(float) print i, atom, r
from ase.visualize import view from ase.constraints import FixAtoms from ase.optimize import QuasiNewton from ase.lattice.surface import fcc100, add_adsorbate from gpaw import GPAW # Initial state: # 2x2-Al(001) surface with 1 layer and an # Au atom adsorbed in a hollow site: slab = fcc100("Al", size=(2, 2, 1)) add_adsorbate(slab, "Au", 1.6, "hollow") slab.center(axis=2, vacuum=3.0) # Make sure the structure is correct: view(slab) # Fix the Al atoms: mask = [atom.symbol == "Al" for atom in slab] print mask fixlayer = FixAtoms(mask=mask) slab.set_constraint(fixlayer) # Use GPAW: calc = GPAW(h=0.25, kpts=(2, 2, 1), xc="PBE", txt="hollow.txt") slab.set_calculator(calc) qn = QuasiNewton(slab, trajectory="hollow.traj") # Find optimal height. The stopping criterion is: the force on the # Au atom should be less than 0.05 eV/Ang qn.run(fmax=0.05)
from ase.lattice.surface import fcc100, add_adsorbate from gpaw import GPAW from gpaw.poisson import PoissonSolver from gpaw.dipole_correction import DipoleCorrection slab = fcc100('Al', (2, 2, 2), a=4.05, vacuum=7.5) add_adsorbate(slab, 'Na', 4.0) slab.center(axis=2) slab.calc = GPAW(txt='zero.txt', xc='PBE', setups={'Na': '1'}, kpts=(4, 4, 1)) e1 = slab.get_potential_energy() slab.calc.write('zero.gpw') slab.pbc = True slab.calc.set(txt='periodic.txt') e2 = slab.get_potential_energy() slab.calc.write('periodic.gpw') slab.pbc = (True, True, False) slab.calc.set(poissonsolver=DipoleCorrection(PoissonSolver(), 2), txt='corrected.txt') e3 = slab.get_potential_energy() slab.calc.write('corrected.gpw')
from ase.lattice.surface import fcc100, add_adsorbate from ase.constraints import FixAtoms from ase.calculators.emt import EMT from ase.dimer import DimerControl, MinModeAtoms, MinModeTranslate # Set up a small "slab" with an adatoms atoms = fcc100("Pt", size=(2, 2, 1), vacuum=10.0) add_adsorbate(atoms, "Pt", 1.611, "hollow") # Freeze the "slab" mask = [atom.tag > 0 for atom in atoms] atoms.set_constraint(FixAtoms(mask=mask)) # Calculate using EMT atoms.set_calculator(EMT()) relaxed_energy = atoms.get_potential_energy() # Set up the dimer d_control = DimerControl( initial_eigenmode_method="displacement", displacement_method="vector", logfile=None, mask=[0, 0, 0, 0, 1] ) d_atoms = MinModeAtoms(atoms, d_control) # Displace the atoms displacement_vector = [[0.0] * 3] * 5 displacement_vector[-1][1] = -0.1 d_atoms.displace(displacement_vector=displacement_vector) # Converge to a saddle point dim_rlx = MinModeTranslate(d_atoms, trajectory="dimer_method.traj", logfile=None) dim_rlx.run(fmax=0.001)
def get_structure(self, name, elements, a=None, c=None, l=None): # Check number of elements if name[:3] in ['fcc', 'hcp']: if len(elements) != 1: raise ValueError("Tuple of elements must be of length one") if name[:3] in ['l12', 'l10'] or name[:2] == 'B2': if len(elements) != 2: raise ValueError("Tuple of elements must be of length two") # Get lattice constants if a is None: if name[:2] == 'B2': a = self.get_lattice_constant_a(name[:2], elements) elif name[:3] in ['fcc', 'hcp', 'bcc', 'l12', 'l10']: a = self.get_lattice_constant_a(name[:3], elements) if c is None: if name[:3] in ['hcp', 'l10']: c = self.get_lattice_constant_c(name[:3], elements) # Get size if name in ['fcc', 'hcp', 'bcc', 'l12', 'l10', 'B2']: size = self.properties[name + '_size'] elif name in ['fcc100', 'fcc111', 'hcp0001']: size = self.properties[name + '_size'][:2] + (l, ) # Make structure if name == 'fcc': atoms = FaceCenteredCubic(symbol=elements[0], size=size, latticeconstant=a) elif name == 'hcp': atoms = HexagonalClosedPacked(symbol=elements[0], size=size, directions=[[2, -1, -1, 0], [0, 1, -1, 0], [0, 0, 0, 1]], latticeconstant=(a, c)) elif name == 'bcc': atoms = BodyCenteredCubic(symbol=elements[0], size=size, latticeconstant=a) elif name == 'B2': atoms = B2(symbol=elements, size=size, latticeconstant=a) elif name == 'l12': atoms = L1_2(symbol=elements, size=size, latticeconstant=a) elif name == 'l10': atoms = L1_0(symbol=elements, size=size, latticeconstant=(a, c)) elif name == 'fcc100': atoms = fcc100(symbol=elements[0], size=size, a=a, vacuum=10.0) elif name == 'fcc111': atoms = fcc111(symbol=elements[0], size=size, a=a, vacuum=10.0, orthogonal=True) elif name == 'hcp0001': atoms = hcp0001(symbol=elements[0], size=size, a=a, c=c, vacuum=10.0, orthogonal=True) elif name == 'hcp1010A': raise ValueError("Structure '%s' not supported" % (name, )) atoms = None elif name == 'hcp1010B': raise ValueError("Structure '%s' not supported" % (name, )) atoms = None elif name == 'l12100': n = (l + 1) / 2 atoms = L1_2(symbol=elements, size=(8, 8, n), latticeconstant=a) atoms.set_pbc([True, True, False]) # Remove layers atoms = atoms[atoms.get_positions()[:, 2] > 0.1 * a] # Set vacuum atoms.center(axis=2, vacuum=10.0) elif name == 'l12111': if l % 3 == 0: n = l / 3 c = 0 else: n = l / 3 + 1 c = 3 - l % 3 atoms = L1_2( symbol=elements, size=(8, 4, n), #directions=[[1,-1,0],[1,0,-1],[1,1,1]], latticeconstant=a) directions=[[1, -1, 0], [1, 1, -2], [1, 1, 1]], latticeconstant=a) atoms.set_pbc([True, True, False]) # Wrap positions scpos = atoms.get_scaled_positions() scpos[scpos > (1.0 - 1e-12)] = 0.0 atoms.set_scaled_positions(scpos) # Remove layers if c > 0: atoms = atoms[atoms.get_positions()[:, 2] > (c - 0.5) * a / np.sqrt(3.0)] # Set vacuum atoms.center(axis=2, vacuum=10.0) else: raise ValueError("Structure '%s' not supported" % (name, )) return atoms
import ase import ase.lattice.surface as surf from ase.visualize import view import jlgh as jl slab = surf.fcc100('Pd',[1,1,4],vacuum = 10) # view(slab*[2,2,1]) # raise SystemExit() h0 = max([at.position[2] for at in slab]) / slab.cell[2][2] sites = [ jl.Site(name='hollow', pos=[.5,.5,h0]), jl.Site(name='top', pos=[.0,.0,h0]), jl.Site(name='br1', pos=[.5,.0,h0]), jl.Site(name='br2', pos=[.0,.5,h0]), ] ucell = jl.SurfUnitCell(slab,sites_list=sites) COatoms = ase.Atoms('CO',positions=[[0.0,0.0,1.0],[0.0,0.0,2.0]]) Oatoms = ase.Atoms('O',positions=[[0.0,0.0,1.0],]) COads = jl.Adsorbate('CO',COatoms,center=[0.,0.,0.]) Oads = jl.Adsorbate('O',Oatoms,center=[0.,0.,0.]) # species_coords = [ 'O@hollow.(0,0,0)', 'O@hollow.(1,0,0)'] # species_coords = [ 'O@hollow.(0,0,0)', 'O@hollow.(1,0,0)','O@hollow.(1,1,0)'] species_coords = [ 'O@hollow.(0,0,0)', 'O@hollow.(1,0,0)','O@hollow.(1,1,0)','O@hollow.(0,1,0)'] species_coords = [ 'O@hollow.(0,0,0)', 'CO@br2.(1,1,0)'] species_coords = [ 'O@hollow.(0,0,0)', 'O@hollow.(1,0,0)','CO@br2.(1,1,0)'] conf = jl.Config(size = [2,2],species_coords = species_coords)
from winak.curvilinear.Coordinates import PeriodicCoordinates as PC from winak.curvilinear.Coordinates import DelocalizedCoordinates as DC from winak.globaloptimization.delocalizer import * from winak.curvilinear.InternalCoordinates import icSystem, Periodic_icSystem from winak.curvilinear.InternalCoordinates import ValenceCoordinateGenerator as VCG from winak.curvilinear.InternalCoordinates import PeriodicValenceCoordinateGenerator as PVCG from ase.lattice.cubic import FaceCenteredCubic as fcc from ase.lattice.surface import fcc100, fcc111 import numpy as np system = fcc100('Pd', (2,2,4), a=3.94, vacuum=10.) natoms =len(system) np.set_printoptions(threshold=np.nan) import time start=time.time() print start #constraints need to be satisfied on two levels #first we need to partition our active coordinate space #into constrained and unconstrained coordinates, this part #happens in the Delocalizer #secondly the backiteration needs to remove components of #constrained coordinates. For cartesian or lattice coordinates this #amounts to zeroing columns of the Bmatrix (passed to the backIteration # via biArgs col_constraints=[column1, column2] #For internal coordinates we zero the rows of the Bmatrix, passed by #row_constraints=[row1,row2] #pic example
from ase import Atoms, Atom from gpaw import GPAW, Mixer from ase.lattice.surface import fcc100 from gpaw.transport.jstm import dump_hs, dump_lead_hs calc = GPAW(h=0.2, mixer=Mixer(0.03, 5, weight=140.0), width=0.1, mode='lcao', basis='szp(dzp)', txt='dumphs.txt', usesymm=False) # surface calculation a = 4.0 srf = fcc100('Al', size=(2, 2, 10), vacuum=8.0) srf.translate([0, 0, -4]) srf.pbc= (1, 1, 0) srf += Atom('H', (a / 2**.5, a / 2**.5, srf.positions[-1][2] + 1.55)) srf.set_calculator(calc) srf.get_potential_energy() calc.write('srf') # Dump the overlap matrix and the Hamiltonian matrix to the local directory. # Here the keyword 'cvl' refers to the number of basis functions in the # in the convergence layer, i.e. for the present system four atomic layers are used. dump_hs(calc, 'srf', region='surface', cvl=4*4*9) # tip calculation a = 0.75 # lattice constant
from ase.lattice.surface import fcc100, add_adsorbate from ase.constraints import FixAtoms from ase.calculators.emt import EMT from ase.dimer import DimerControl, MinModeAtoms, MinModeTranslate # Set up a small "slab" with an adatoms atoms = fcc100('Pt', size = (2, 2, 1), vacuum = 10.0) add_adsorbate(atoms, 'Pt', 1.611, 'hollow') # Freeze the "slab" mask = [atom.tag > 0 for atom in atoms] atoms.set_constraint(FixAtoms(mask = mask)) # Calculate using EMT atoms.set_calculator(EMT()) relaxed_energy = atoms.get_potential_energy() # Set up the dimer d_control = DimerControl(initial_eigenmode_method = 'displacement', \ displacement_method = 'vector', logfile = None, \ mask = [0, 0, 0, 0, 1]) d_atoms = MinModeAtoms(atoms, d_control) # Dispalce the atoms displacement_vector = [[0.0]*3]*5 displacement_vector[-1][1] = -0.1 d_atoms.displace(displacement_vector = displacement_vector) # Converge to a saddle point dim_rlx = MinModeTranslate(d_atoms, trajectory = 'dimer_method.traj', \ logfile = None)
############ dimer ############################## path = os.path.dirname(os.path.abspath(__file__)) print(path) starttime = time.strftime("%y%m%d%H%M%S") a=3.9242 # Setting up the initial image: # initial = fcc111('Pt', size=(4, 4, 2), a=3.9242, vacuum=10.0) # add_adsorbate(initial, 'Pt', 1.611, 'hollow') """Pt_atoms = FaceCenteredCubic(directions=[[0,1,0], [0,0,1,], [1,0,0]], size=(4,4,1),latticeconstant=a, symbol='Pt', pbc=(1,1,1)) initial = surface(Pt_atoms, (0,0,1), 3) # [1,-1,0], [1,1,-2], [1,1,1]], # for 111 surface""" initial = fcc100('Pt', size=(4, 4, 5), a=a) add_adsorbate(initial, 'Pt', 1.611, 'hollow') #add adatom on surface at = initial[len(initial)-6] at_pos = at.position at_ind = at.index print(at) print(at_pos) print(at_ind) # del initial[len(initial)-7] # delete first atom ie create vacancy initial.center(vacuum=10.0, axis=2) # Save it # write('Molecule-%s-%s-start.xyz' % (str(11), str(1)), initial) N = len(initial) # number of atoms # Freeze the "slab" # Make a mask of zeros and ones that select fixed atoms - the two
def initlatticepositions(params, nlayers): """ Return nlayers of positions according to lattice type/plane and shift positions so that no atoms are on the edges of the box. """ lxsurf = params['lxsurf'] lysurf = params['lysurf'] alat = params['alat'] if params['surftype'] == 'fcc': if params['plane'] == '111': surf = ase.fcc111('O', a=alat, size=(lxsurf, lysurf, nlayers), orthogonal=True) positions = surf.positions positions[:, 0] = positions[:, 0] + (alat / 2.0**0.5) / 4.0 positions[:, 1] = (positions[:, 1] + (1.0 / 2.0) * (3.0**0.5) * (alat / 2.0**0.5) / 4.0) elif params['plane'] == '100': surf = ase.fcc100('O', a=alat, size=(lxsurf, lysurf, nlayers)) positions = surf.positions positions[:, 0] = positions[:, 0] + (alat / 2.0**0.5) / 4.0 positions[:, 1] = positions[:, 1] + (alat / 2.0**0.5) / 4.0 elif params['plane'] == '110': surf = ase.fcc110('O', a=alat, size=(lxsurf, lysurf, nlayers)) positions = surf.positions positions[:, 0] = positions[:, 0] + alat / 4.0 positions[:, 1] = positions[:, 1] + (alat / 2.0**0.5) / 4.0 elif params['surftype'] == 'bcc': if params['plane'] == '100': surf = ase.bcc100('O', a=alat, size=(lxsurf, lysurf, nlayers)) positions = surf.positions positions[:, 0] = positions[:, 0] + alat / 2.0 positions[:, 1] = positions[:, 1] + alat / 2.0 elif params['surftype'] == 'hcp': clat = params['clat'] if params['plane'] == '0001': surf = ase.hcp0001('O', a=alat, c=clat, size=(lxsurf, lysurf, nlayers), orthogonal=True) positions = surf.positions positions[:, 0] = positions[:, 0] + alat / 4.0 positions[:, 1] = positions[:, 1] + (1.0 / 2.0) * (3.0**0.5) * alat / 4.0 elif params['plane'] == '1010': surf = ase.hcp10m10('O', a=alat, c=clat, size=(lxsurf, lysurf, nlayers)) positions = surf.positions positions[:, 0] = positions[:, 0] + alat / 4.0 positions[:, 1] = positions[:, 1] + clat / 4.0 return positions
from ase import Atoms, Atom from gpaw import GPAW, Mixer from ase.lattice.surface import fcc100 from gpaw.transport.jstm import dump_hs, dump_lead_hs calc = GPAW(h=0.2, mixer=Mixer(0.03, 5, weight=140.0), width=0.1, mode='lcao', basis='szp(dzp)', txt='dumphs.txt', usesymm=False) # surface calculation a = 4.0 srf = fcc100('Al', size=(2, 2, 10), vacuum=8.0) srf.translate([0, 0, -4]) srf.pbc = (1, 1, 0) srf += Atom('H', (a / 2**.5, a / 2**.5, srf.positions[-1][2] + 1.55)) srf.set_calculator(calc) srf.get_potential_energy() calc.write('srf') # Dump the overlap matrix and the Hamiltonian matrix to the local directory. # Here the keyword 'cvl' refers to the number of basis functions in the # in the convergence layer, i.e. for the present system four atomic layers are used. dump_hs(calc, 'srf', region='surface', cvl=4 * 4 * 9) # tip calculation a = 0.75 # lattice constant
# *** An error occurred in MPI_Recv # *** on communicator MPI COMMUNICATOR 36 DUP FROM 28 # *** MPI_ERR_TRUNCATE: message truncated # *** MPI_ERRORS_ARE_FATAL (your MPI job will now abort) # works with 'sl_default': (2, 2, 32) from ase.lattice.surface import fcc100, add_adsorbate from gpaw import GPAW, ConvergenceError from gpaw.mpi import world from gpaw.utilities import compiled_with_sl assert world.size == 4 slab = fcc100('Cu', size=(2, 2, 4)) add_adsorbate(slab, 'O', 1.1, 'hollow') slab.center(vacuum=3.0, axis=2) calc = GPAW( mode='lcao', kpts=(2, 2, 1), txt='-', maxiter=1, ) if compiled_with_sl(): calc.set(parallel={'domain': (1, 1, 4), 'sl_default': (2, 2, 64)}) slab.set_calculator(calc) try: slab.get_potential_energy()
# { -1, -1}: On entry to PDLASRT parameter number 9 had an illegal value # works with 'sl_default': (2, 2, 32) from ase.lattice.surface import fcc100, add_adsorbate from gpaw import GPAW, ConvergenceError from gpaw.mpi import world from gpaw.utilities import compiled_with_sl assert world.size == 4 slab = fcc100('Cu', size=(2, 2, 2)) add_adsorbate(slab,'O', 1.1, 'hollow') slab.center(vacuum=3.0, axis=2) calc = GPAW(mode='lcao', kpts=(2, 2, 1), txt='-', maxiter=1,) if compiled_with_sl(): calc.set(parallel={'domain': (1, 1, 4), 'sl_default': (2, 2, 64)}) slab.set_calculator(calc) try: slab.get_potential_energy() except ConvergenceError: pass
from jlgh import * import numpy as np import ase.lattice.surface as surf from ase.constraints import FixAtoms from ase.utils.geometry import get_layers Pd_latconst = 3.937211 slab = surf.fcc100("Pd", a=Pd_latconst, size=[1, 1, 4], vacuum=10) slab.set_constraint(FixAtoms(indices=[il[0] for il in enumerate(get_layers(slab, (0, 0, 1))[0]) if il[1] < 2])) h0 = max([at.position[2] for at in slab]) / slab.cell[2][2] sites = [Site(name="hollow", pos=[0.5, 0.5, h0])] E_2x2 = -56199.75241886 base_cell = BaseCell(slab, site_list=sites, energy=E_2x2 / 4.0) Oatoms = ase.Atoms("O", positions=[[0.0, 0.0, 1.0]]) Oads = Adsorbate("O", Oatoms, center=[0.0, 0.0, 0.0], binding_energy=-439.4812229) V_O_O_1NN_defs = [("O@hollow.(0,0,0)", "O@hollow.(1,0,0)"), ("O@hollow.(0,0,0)", "O@hollow.(0,1,0)")] V_O_O_1NN = ClusterGroup("V_O_O_1NN", 0.3, V_O_O_1NN_defs) V_O_O_2NN_defs = [("O@hollow.(0,0,0)", "O@hollow.(1,1,0)"), ("O@hollow.(0,0,0)", "O@hollow.(1,-1,0)")] V_O_O_2NN = ClusterGroup("V_O_O_2NN", 0.07, V_O_O_2NN_defs) enes_defs = [ (-57077.82959288, ("O@hollow.(0,0,0)", "O@hollow.(1,0,0)")), (-57078.30630942, ("O@hollow.(0,0,0)", "O@hollow.(1,1,0)")),
from winak.curvilinear.Coordinates import PeriodicCoordinates as PC from winak.curvilinear.Coordinates import DelocalizedCoordinates as DC from winak.globaloptimization.delocalizer import * from winak.curvilinear.InternalCoordinates import icSystem, Periodic_icSystem from winak.curvilinear.InternalCoordinates import ValenceCoordinateGenerator as VCG from winak.curvilinear.InternalCoordinates import PeriodicValenceCoordinateGenerator as PVCG from ase.lattice.cubic import FaceCenteredCubic as fcc from ase.lattice.surface import fcc100, fcc111 import numpy as np system = fcc100('Pd', (3,3,4), a=3.94, vacuum=10.) natoms =len(system) np.set_printoptions(threshold=np.nan) import time start=time.time() print start d = Delocalizer(system, periodic=True, dense=False, weighted=False, \ add_cartesians = False) print 'timing 1 ',time.time() - start coords = PC(d.x_ref.flatten(),d.masses,unit=1.0,atoms=d.atoms,ic=d.ic, Li=d.get_U(), biArgs={'iclambda':1e-8, 'RIIS': True, 'maxiter': 900, 'eps': 1e-6, 'maxEps':1e-6}) #biArgs={'RIIS': True, 'maxiter': 900, 'eps': 1e-6, 'maxEps':1e-6}) print len(d.ww) print d.ww
from __future__ import print_function from ase.visualize import view from ase.constraints import FixAtoms from ase.optimize import QuasiNewton from ase.lattice.surface import fcc100, add_adsorbate from gpaw import GPAW, PW # Initial state: # 2x2-Al(001) surface with 1 layer and an # Au atom adsorbed in a hollow site: slab = fcc100('Al', size=(2, 2, 2)) slab.center(axis=2, vacuum=3.0) add_adsorbate(slab, 'Au', 1.6, 'hollow') # Make sure the structure is correct: view(slab) # Fix the Al atoms: mask = [atom.symbol == 'Al' for atom in slab] print(mask) fixlayer = FixAtoms(mask=mask) slab.set_constraint(fixlayer) # Use GPAW: calc = GPAW(mode=PW(200), kpts=(2, 2, 1), xc='PBE', txt='hollow.txt') slab.set_calculator(calc) qn = QuasiNewton(slab, trajectory='hollow.traj') # Find optimal height. The stopping criterion is: the force on the # Au atom should be less than 0.05 eV/Ang
from ase import * from ase.lattice.surface import fcc100, add_adsorbate from gpaw import * from gpaw import dscf from gpaw.utilities import equal atoms = fcc100('Pt', (1,1,2)) add_adsorbate(atoms, 'C', 2.00, 'ontop') add_adsorbate(atoms, 'O', 3.15, 'ontop') atoms.center(axis=2, vacuum=3) calc_1 = GPAW(h=0.24, nbands=20, xc='PBE', kpts=[4,4,1], convergence={'energy': 0.001, 'density': 0.001, 'eigenstates': 1.0e-7, 'bands': -3}) atoms.set_calculator(calc_1) E_gs = atoms.get_potential_energy() # Dscf calculation based on the MolecularOrbital class calc_1.set(nbands=25, spinpol=True) weights = {2: [0.,0.,0.,1.], 3: [0.,0.,0.,-1.]} lumo = dscf.MolecularOrbital(calc_1, weights=weights) dscf.dscf_calculation(calc_1, [[1.0, lumo, 1]], atoms) E_es1 = atoms.get_potential_energy() equal(E_es1, E_gs + 4.55, 0.1) # Dscf calculation based on the AEOrbital class. Two new calculators