def diamond_110_001(el, a0, n, crack_surface=[1,1,0], crack_front=[0,0,1],
skin_x=1.0, skin_y=1.0, vac=5.0):
nx, ny, nz = n
third_dir = np.cross(crack_surface, crack_front)
directions = [ third_dir, crack_surface, crack_front ]
if np.linalg.det(directions) < 0:
third_dir = -third_dir
directions = [ third_dir, crack_surface, crack_front ]
a = Diamond(el, latticeconstant = a0, size = [ nx,ny,nz ],
directions = directions)
sx, sy, sz = a.get_cell().diagonal()
a.translate([a0/100,a0/100,a0/100])
a.set_scaled_positions(a.get_scaled_positions())
a.center()
lx = skin_x*sx/nx
ly = skin_y*sy/ny
r = a.get_positions()
g = np.where(
np.logical_or(
np.logical_or(
np.logical_or(
r[:, 0] < lx, r[:, 0] > sx-lx),
r[:, 1] < ly),
r[:, 1] > sy-ly),
np.zeros(len(a), dtype=int),
np.ones(len(a), dtype=int))
a.set_array('groups', g)
a.set_cell([sx+2*vac, sy+2*vac, sz])
a.translate([vac, vac, 0.0])
a.set_pbc([False, False, True])
return a
def diamond_110_110(el, a0, n, crack_surface=[1,1,0],
crack_front=[1,-1,0],
skin_x=0.5, skin_y=1.0,
central_x=-1.0, central_y=-1.0,
vac=5.0):
nx, ny, nz = n
third_dir = np.cross(crack_surface, crack_front)
a = Diamond(el,
latticeconstant = a0,
size = [nx, ny, nz],
directions = [third_dir, crack_surface, crack_front]
)
sx, sy, sz = a.get_cell().diagonal()
a.translate([sx/(8*nx), sy/(4*ny), sz/(4*nz)])
a.set_scaled_positions(a.get_scaled_positions())
skin_x = skin_x*sx/nx
skin_y = skin_y*sy/ny
r = a.get_positions()
g = np.where(
np.logical_or(
np.logical_or(
np.logical_or(
r[:, 0] < skin_x, r[:, 0] > sx-skin_x),
r[:, 1] < skin_y),
r[:, 1] > sy-skin_y),
np.zeros(len(a), dtype=int),
np.ones(len(a), dtype=int))
g = np.where(
np.logical_or(
np.logical_or(
np.logical_or(
r[:, 0] < sx/2-central_x, r[:, 0] > sx/2+central_x),
r[:, 1] < sy/2-central_y),
r[:, 1] > sy/2+central_y),
g,
2*np.ones(len(a), dtype=int))
a.set_array('groups', g)
a.set_cell([sx+2*vac, sy+2*vac, sz])
a.translate([vac, vac, 0.0])
a.set_pbc([False, False, True])
return a
def test_pbc(self):
a = Diamond('Si', latticeconstant=5.432, size=[2,2,2])
sx, sy, sz = a.get_cell().diagonal()
a.set_calculator(Tersoff())
e1 = a.get_potential_energy()
a.set_pbc([True,True,False])
e2 = a.get_potential_energy()
a.set_pbc(True)
a.set_cell([sx,sy,2*sz])
e3 = a.get_potential_energy()
self.assertEqual(e2, e3)
# This should give the unrelaxed surface energy
esurf = (e2-e1)/(2*sx*sy) * Jm2
self.assertTrue(abs(esurf-2.309) < 0.001)
def test_pbc(self):
a = Diamond('Si', latticeconstant=5.432, size=[2,2,2])
sx, sy, sz = a.get_cell().diagonal()
a.set_calculator(Tersoff())
e1 = a.get_potential_energy()
a.set_pbc([True,True,False])
e2 = a.get_potential_energy()
a.set_pbc(True)
a.set_cell([sx,sy,2*sz])
e3 = a.get_potential_energy()
self.assertEqual(e2, e3)
# This should give the unrelaxed surface energy
esurf = (e2-e1)/(2*sx*sy) * Jm2
self.assertTrue(abs(esurf-2.309) < 0.001)
def test_calculator():
"""
Take ASE structure, PySCF object,
and run through ASE calculator interface.
This allows other ASE methods to be used with PySCF;
here we try to compute an equation of state.
"""
ase_atom=Diamond(symbol='C', latticeconstant=3.5668)
# Set up a cell; everything except atom; the ASE calculator will
# set the atom variable
cell = pbcgto.Cell()
cell.h=ase_atom.cell
cell.basis = 'gth-szv'
cell.pseudo = 'gth-pade'
cell.gs=np.array([8,8,8])
cell.verbose = 0
# Set up the kind of calculation to be done
# Additional variables for mf_class are passed through mf_dict
mf_class=pbcdft.RKS
mf_dict = { 'xc' : 'lda,vwn' }
# Once this is setup, ASE is used for everything from this point on
ase_atom.set_calculator(pyscf_ase.PySCF(molcell=cell, mf_class=mf_class, mf_dict=mf_dict))
print "ASE energy", ase_atom.get_potential_energy()
print "ASE energy (should avoid re-evaluation)", ase_atom.get_potential_energy()
# Compute equation of state
ase_cell=ase_atom.cell
volumes = []
energies = []
for x in np.linspace(0.95, 1.2, 5):
ase_atom.set_cell(ase_cell * x, scale_atoms = True)
print "[x: %f, E: %f]" % (x, ase_atom.get_potential_energy())
volumes.append(ase_atom.get_volume())
energies.append(ase_atom.get_potential_energy())
eos = EquationOfState(volumes, energies)
v0, e0, B = eos.fit()
print(B / kJ * 1.0e24, 'GPa')
eos.plot('eos.png')
import model
a0 = 5.44 # initial guess at lattice constant, cell will be relaxed below
fmax = 0.01 # maximum force following relaxtion [eV/A]
# set up the a
bulk = Diamond(symbol='Si', latticeconstant=a0, directions=[[1,-1,0],[0,0,1],[1,1,0]])
# specify that we will use model.calculator to compute forces, energies and stresses
bulk.set_calculator(model.calculator)
# flip coord system for ASE (precon minim?)
c = bulk.get_cell()
t_v = c[0,:].copy()
c[0,:] = c[1,:]
c[1,:] = t_v
bulk.set_cell(c)
# use one of the routines from utilities module to relax the initial
# unit cell and atomic positions
bulk = relax_atoms_cell(bulk, tol=fmax, traj_file=None)
# set up supercell
bulk *= (1, 1, 5)
ase.io.write(sys.stdout, bulk, format='extxyz')
def surface_energy(bulk, z_offset, opening):
Nat = bulk.get_number_of_atoms()
# shift so cut is through shuffle plane
bulk.positions[:,2] += z_offset
# Set up the kind of calculation to be done
# Additional variables for mf_class are passed through mf_dict
# E.g. gamma-point SCF calculation can be set to
mf_class = pbcdft.RKS
# SCF with k-point sampling can be set to
mf_class = lambda cell: pbcdft.KRKS(cell, kpts=cell.make_kpts([2, 2, 2]))
mf_dict = {'xc': 'lda,vwn'}
# Once this is setup, ASE is used for everything from this point on
ase_atom.set_calculator(
pyscf_ase.PySCF(molcell=cell, mf_class=mf_class, mf_dict=mf_dict))
print("ASE energy", ase_atom.get_potential_energy())
print("ASE energy (should avoid re-evaluation)",
ase_atom.get_potential_energy())
# Compute equation of state
ase_cell = ase_atom.cell
volumes = []
energies = []
for x in np.linspace(0.95, 1.2, 5):
ase_atom.set_cell(ase_cell * x, scale_atoms=True)
print "[x: %f, E: %f]" % (x, ase_atom.get_potential_energy())
volumes.append(ase_atom.get_volume())
energies.append(ase_atom.get_potential_energy())
eos = EquationOfState(volumes, energies)
v0, e0, B = eos.fit()
print(B / kJ * 1.0e24, 'GPa')
eos.plot('eos.png')
cell.verbose = 0
# Set up the kind of calculation to be done
# Additional variables for mf_class are passed through mf_dict
# E.g. gamma-point SCF calculation can be set to
mf_class = pbcdft.RKS
# SCF with k-point sampling can be set to
mf_class = lambda cell: pbcdft.KRKS(cell, kpts=cell.make_kpts([2,2,2]))
mf_dict = { 'xc' : 'lda,vwn' }
# Once this is setup, ASE is used for everything from this point on
ase_atom.set_calculator(pyscf_ase.PySCF(molcell=cell, mf_class=mf_class, mf_dict=mf_dict))
print("ASE energy", ase_atom.get_potential_energy())
print("ASE energy (should avoid re-evaluation)", ase_atom.get_potential_energy())
# Compute equation of state
ase_cell=ase_atom.cell
volumes = []
energies = []
for x in np.linspace(0.95, 1.2, 5):
ase_atom.set_cell(ase_cell * x, scale_atoms = True)
print "[x: %f, E: %f]" % (x, ase_atom.get_potential_energy())
volumes.append(ase_atom.get_volume())
energies.append(ase_atom.get_potential_energy())
eos = EquationOfState(volumes, energies)
v0, e0, B = eos.fit()
print(B / kJ * 1.0e24, 'GPa')
eos.plot('eos.png')
