def calc_gap():
oraxis = '0,0,1'
pot_param = PotentialParameters()
ener_per_atom = pot_param.gs_ener_per_atom()
selected_grains = GrainBoundary.select().where(
GrainBoundary.orientation_axis == oraxis).where(
GrainBoundary.boundary_plane != oraxis)
f = open('./locenviron/gap_energies.dat', 'a')
for gb in selected_grains.order_by(GrainBoundary.angle)[2:]:
subgbs = (gb.subgrains.select(
GrainBoundary,
SubGrainBoundary).where(SubGrainBoundary.potential ==
'PotBH.xml').join(GrainBoundary).dicts())
subgbs = [
(16.02 * (subgb['E_gb'] -
float(subgb['n_at'] * ener_per_atom['PotBH.xml'])) /
(2.0 * subgb['area']), subgb) for subgb in subgbs
]
subgbs.sort(key=lambda x: x[0])
try:
print subgbs[0][1]['path']
continue
target_dir = os.path.join('./grain_boundaries',
subgbs[0][1]['path'])
struct_file = os.path.join(target_dir,
subgbs[0][1]['gbid']) + '_traj.xyz'
print struct_file
ats = AtomsReader(struct_file)[-1]
pot = Potential('IP GAP', param_filename='gp33b.xml')
ats.set_calculator(pot)
print subgbs[0][1]['n_at'], subgbs[0][1]['area']
strain_mask = [0, 0, 1, 0, 0, 0]
ucf = UnitCellFilter(ats, strain_mask)
opt = FIRE(ucf)
FORCE_TOL = 0.1
opt.run(fmax=FORCE_TOL)
gap_en = ats.get_potential_energy()
print gap_en
print round(gb.angle * (180.0 / 3.14159), 3), round(
subgbs[0][0], 3), 16.02 * (gap_en - float(
subgbs[0][1]['n_at'] * ener_per_atom['gp33b.xml'])) / (
2.0 * subgbs[0][1]['area'])
print >> f, round(gb.angle * (180.0 / 3.14159), 3), round(
subgbs[0][0], 3), 16.02 * (gap_en - float(
subgbs[0][1]['n_at'] * ener_per_atom['gp33b.xml'])) / (
2.0 * subgbs[0][1]['area'])
ats.write('./locenviron/{}.xyz'.format(subgbs[0][1]['gbid']))
except IndexError:
print '\t', round(gb.angle * (180.0 / 3.14159), 3), subgbs
def calc_chemoelast(input_file):
"""Adds the structure type using an ovitos script to the :py:class:`Atoms` object
and calculates the breakdown of the energy contributions.
Args:
input_file(str):Relaxed grain boundary structure file.
Returns:
list(float):[(chemical_energy/total_energy)*gb_energy, (elastic_energy/total_energy)*gb_energy, gb_energy]
"""
potparam = PotentialParameters()
ener_bulk_dict = potparam.gs_ener_per_atom()
r_scale_dict = potparam.eam_rscale()
r_scale = r_scale_dict['PotBH.xml']
E_bulk = ener_bulk_dict['PotBH.xml']
try:
POT_DIR = os.environ['POTDIR']
except KeyError:
sys.exit("PLEASE SET export POTDIR='path/to/potfiles/'")
eam_pot = 'PotBH.xml'
eam_pot = os.path.join(POT_DIR, eam_pot)
pot = Potential(
'IP EAM_ErcolAd do_rescale_r=T r_scale={0}'.format(r_scale),
param_filename=eam_pot)
ats = AtomsReader(input_file)[-1]
ats.set_calculator(pot)
gb_energy = potparam.calc_e_gb(ats, E_bulk)
print gb_energy, 'J/^2m'
ats.write('full.xyz')
elastic_energy = strain_energy(ats)
with open('elast.dat', 'w') as f:
for x in elastic_energy:
print >> f, x[0], x[1]
#generates output.xyz
imeall_root = os.path.join(app.root_path, 'ovito_scripts/attach_cna.py')
args_str = 'ovitos {imeall_root} -i {input_file}'.format(
imeall_root=app.root_path, input_file='full.xyz').split()
job = subprocess.Popen(args_str)
job.wait()
ats = Atoms('output.xyz')
#print the three contributions
x = calc_chemomechanical(ats)
try:
assert round(gb_energy, 2) == round(x[2], 2)
except AssertionError:
print "WARNING ENERGIES DON'T MATCH", gb_energy, x[2]
return x
def calc_elast_dipole_eam(input_file, force_tol, relax_cell):
"""
Calculate elastic dipole using an Embedded Atom Potential.
Args:
input_file (str): Name of .xyz file contains unitcell with defect.
force_tol (float): Force tolerance to stop relaxation.
relax_cell (bool): Relax lattice vectors.
Returns:
Elastic Dipole Tensor 3x3 numpy array.
"""
try:
POT_DIR = os.environ['POTDIR']
except KeyError:
sys.exit("PLEASE SET export POTDIR='path/to/potfiles/'")
elastic = ElasticDipole()
eam_pot = os.path.join(POT_DIR, 'PotBH.xml')
pot = Potential(
'IP EAM_ErcolAd do_rescale_r=T r_scale={0}'.format(1.00894848312),
param_filename=eam_pot)
ats = Atoms(input_file)
ats.set_calculator(pot)
init_vol = ats.get_volume()
print 'Initial Vol.', init_vol
elastic.relax_defect_cell(ats, force_tol=force_tol, relax_cell=relax_cell)
final_vol = ats.get_volume()
print 'Final Vol.', final_vol
print 'Volume Diff.', final_vol - init_vol
ats = Atoms('defect_cell_relaxed.xyz')
defect = find_h_atom(ats)
print 'Defect index', defect.index, 'Position', defect.position, 'Type: ', defect.number
ats.set_calculator(pot)
return elastic.compute_vacancy_dipole(defect, ats.copy(), pot)
def build_h_nebpath(self, struct_path="fe_bcc.xyz", neb_path=np.array([0.25, 0.0, -0.25]),
alat=2.8297, knots=5, sup_cell=5, fmax=1.e-4):
"""
Takes a vector neb_path, and generates n intermediate images along the minimum energy path.
the struct path should point to the relaxed structure.
"""
POT_DIR = os.path.join(app.root_path, 'potentials')
eam_pot = os.path.join(POT_DIR, 'PotBH.xml')
r_scale = 1.00894848312
mm_pot = Potential('IP EAM_ErcolAd do_rescale_r=T r_scale={0}'.format(r_scale), param_filename=eam_pot)
ats_ini = AtomsReader(struct_path)[-1]
#Pick the top tetrahedral H position in the cell [[1,0,0],[0,1,0],[0,0,1]]
tetra_pos = alat*np.array([0.5, 0.0, 0.75])
mid_point = 0.5*(np.diag(ats_ini.get_cell()))
mid_point = [((sup_cell-1)/2.)*alat for sp in range(3)]
h_pos = tetra_pos + mid_point
disloc_ini = ats_ini.copy()
h_tmp = h_pos
disloc_ini.add_atoms(np.array(h_tmp), 1)
disloc_fin = ats_ini.copy()
h_tmp = h_pos + neb_path*alat
disloc_fin.add_atoms(h_tmp,1)
#Relax images at the start and end of trajectory.
disloc_ini.set_calculator(mm_pot)
opt = FIRE(disloc_ini)
opt.run(fmax=fmax)
disloc_fin.set_calculator(mm_pot)
opt = FIRE(disloc_fin)
opt.run(fmax=fmax)
return disloc_ini, disloc_fin
print 'Initializing crack_cell from Info File.'
crack = CrackCell(**crack_info)
f.close()
except IOError:
print 'no crack dictionary found.'
sys.exit()
Grain_Boundary = False
if not Grain_Boundary:
unit_slab = crack.build_unit_slab()
pot_dir = os.environ['POTDIR']
pot_file = os.path.join(pot_dir, crack_info['param_file'])
mm_pot = Potential('IP EAM_ErcolAd do_rescale_r=T r_scale=1.00894848312',
param_filename=pot_file,
cutoff_skin=2.0)
# gb_frac.py will generate the frac_cell.xyz file which contains
# a crack_cell:
if Grain_Boundary:
unit_slab = Atoms('frac_cell.xyz')
unit_slab.set_calculator(mm_pot)
#calculate the elasticity tensor:
crack.calculate_c(mm_pot)
surface = crack.build_surface(mm_pot)
E_surf = surface.get_potential_energy()
bulk = bcc(2.82893)
bulk.set_atoms(26)
bulk.info['adsorbate_info'] = None
if z1 != 8:
raise ValueError('all IN term atoms must be O')
r_ij = (b.positions[j] + np.dot(o, b.cell) - b.positions[i])
t = Atoms('H')
d = r_ij / (eqm_bond_lengths[min(z1, z2), max(z1, z2)] *
eqm_bond_lengths[min(z1, 1), max(z1, 1)])
t.translate(b.positions[i] + d)
term += t
cryst = b[mask] + term
# calculator
from quippy import Potential
calc = Potential('IP TS', param_filename='ts_params.xml')
cryst.set_calculator(calc)
cryst.get_potential_energy() # obtain reference dipole moments
cryst.set_scaled_positions(cryst.get_scaled_positions())
cryst.positions[:, 0] += cryst.cell[0, 0] / 2. - cryst.positions[:, 0].mean()
cryst.positions[:, 1] += cryst.cell[1, 1] / 2. - cryst.positions[:, 1].mean()
cryst.set_scaled_positions(cryst.get_scaled_positions())
cryst.center(vacuum, axis=0)
cryst.center(vacuum, axis=1)
# fix atoms near outer boundaries
r = cryst.get_positions()
minx = r[:, 0].min() + skin
import __builtin__
orig_dir = os.getcwd()
model_dir = os.path.dirname(__file__)
if model_dir != '':
os.chdir(model_dir)
if os.path.exists(
'gp_iter6_sparse9k.xml.sparseX.GAP_2017_6_17_60_4_3_56_1651.bz2'):
os.system(
'bunzip2 gp_iter6_sparse9k.xml.sparseX.GAP_2017_6_17_60_4_3_56_1651.bz2'
)
try:
if hasattr(__builtin__, 'mpi_glob'):
calculator = Potential(
init_args='Potential xml_label="GAP_2017_6_17_60_4_3_56_165"',
param_filename='gp_iter6_sparse9k.xml',
mpi_obj=mpi_glob)
else:
calculator = Potential(
init_args='Potential xml_label="GAP_2017_6_17_60_4_3_56_165"',
param_filename='gp_iter6_sparse9k.xml')
Potential.__str__ = lambda self: '<GAP Potential>'
finally:
os.chdir(orig_dir)
no_checkpoint = True
name = 'GAP'
sim_T = sim_T*units.kB
calc_elastic_constants = False
dyn_type = 'eam'
print '\tDislocation Type: ', dis_type, ' dislocation.'
print '\tCalculate Dynamics: ', run_dyn
print '\tCalculate Nye Tensor: ', calc_nye
print '\tInput File: ', input_file
print '\tPotential: ', pot_type
if pot_type == 'EAM':
global potdir
potdir = os.environ['POTDIR']
eam_pot = os.path.join(potdir, 'PotBH.xml')
r_scale = 1.00894848312
pot = Potential('IP EAM_ErcolAd do_rescale_r=T r_scale={0}'.format(r_scale), param_filename=eam_pot)
elif pot_type == 'TB':
tb = TightBindingPot(alat= 1.00, nk=12)
screw_slab_unit = Atoms(screw_slab_unit)
center_cell = np.diag(screw_slab_unit.get_cell())/2.
screw_slab_unit.add_atoms(center_cell,1)
#screw_slab_unit.add_atoms(center_cell*0.76, 6)
screw_slab_unit.set_atoms(screw_slab_unit.Z)
print len(screw_slab_unit)
tb.write_control_file('ctrl.fe', screw_slab_unit)
pot = Potential('IP LMTO_TBE', param_str="""
<params>
<LMTO_TBE_params n_types="2" control_file="ctrl.fe">
<per_type_data type="1" atomic_num="26"/>
<per_type_data type="2" atomic_num="1"/>
def calc_bulk_dissolution(args):
"""Calculate the bulk dissolution energy for hydrogen
in a tetrahedral position in bcc iron.
Args:
args(list): determine applied strain to unit cell.
"""
POT_DIR = os.path.join(app.root_path, 'potentials')
eam_pot = os.path.join(POT_DIR, 'PotBH.xml')
r_scale = 1.00894848312
pot = Potential(
'IP EAM_ErcolAd do_rescale_r=T r_scale={0}'.format(r_scale),
param_filename=eam_pot)
alat = 2.83
gb = BodyCenteredCubic(directions=[[1, 0, 0], [0, 1, 0], [0, 0, 1]],
size=(6, 6, 6),
symbol='Fe',
pbc=(1, 1, 1),
latticeconstant=alat)
cell = gb.get_cell()
print 'Fe Cell', cell
e1 = np.array([1, 0, 0])
e2 = np.array([0, 1, 0])
e3 = np.array([0, 0, 1])
if args.hydrostatic != 0.0:
strain_tensor = np.eye(3) + args.hydrostatic * np.eye(3)
cell = cell * strain_tensor
gb.set_cell(cell, scale_atoms=True)
print 'Hydrostatic strain', args.hydrostatic
print 'strain tensor', strain_tensor
print gb.get_cell()
elif args.stretch != 0.0:
strain_tensor = np.tensordot(e2, e2, axes=0)
strain_tensor = np.eye(3) + args.stretch * strain_tensor
cell = strain_tensor * cell
print 'Stretch strain'
print 'Cell:', cell
gb.set_cell(cell, scale_atoms=True)
elif args.shear != 0.0:
strain_tensor = np.tensordot(e1, e2, axes=0)
strain_tensor = np.eye(3) + args.shear * strain_tensor
cell = strain_tensor.dot(cell)
print 'Shear Strain', strain_tensor
print 'Cell:', cell
gb.set_cell(cell, scale_atoms=True)
gb.write('sheared.xyz')
else:
print 'No strain applied.'
tetra_pos = alat * np.array([0.25, 0.0, 0.5])
h2 = aseAtoms('H2', positions=[[0, 0, 0], [0, 0, 0.7]])
h2 = Atoms(h2)
gb = Atoms(gb)
gb_h = gb.copy()
gb_h.add_atoms(tetra_pos, 1)
#caclulators
gb.set_calculator(pot)
h2.set_calculator(pot)
gb_h.set_calculator(pot)
gb_h.write('hydrogen_bcc.xyz')
#Calc Hydrogen molecule energy
opt = BFGS(h2)
opt.run(fmax=0.0001)
E_h2 = h2.get_potential_energy()
h2.write('h2mol.xyz')
#strain_mask = [1,1,1,0,0,0]
strain_mask = [0, 0, 0, 0, 0, 0]
ucf = UnitCellFilter(gb_h, strain_mask)
#opt = BFGS(gb_h)
opt = FIRE(ucf)
opt.run(fmax=0.0001)
E_gb = gb.get_potential_energy()
E_gbh = gb_h.get_potential_energy()
E_dis = E_gbh - E_gb - 0.5 * E_h2
print 'E_gb', E_gb
print 'E_gbh', E_gbh
print 'H2 Formation Energy', E_h2
print 'Dissolution Energy', E_dis
import os
from quippy import Potential
import __builtin__
orig_dir = os.getcwd()
model_dir = os.path.dirname(__file__)
os.chdir(model_dir)
try:
if hasattr(__builtin__, 'mpi_glob'):
calculator = Potential(init_args='TB DFTB use_k_density k_density=4.0 Fermi_T=0.05',
param_filename='tightbind.parms.DFTB.pbc-0-1.xml', mpi_obj=mpi_glob)
else:
calculator = Potential(init_args='TB DFTB use_k_density k_density=4.0 Fermi_T=0.05',
param_filename='tightbind.parms.DFTB.pbc-0-1.xml')
finally:
os.chdir(orig_dir)
no_checkpoint = True
name = 'DFTB.1'
def gamma_surf(h_pos=np.array([1.41, 1.500, 22.48])):
"""
:method:`gamma_surf` generates a set of directories with the upper
half unit cell displaced along a certain distance
along a particular lattice vector. Hydrogens can be added by
setting vector in h_pos.
TODO:
h_pos should be a list of vectors and atom type for this to be more general.
"""
vasp_exe = '/projects/SiO2_Fracture/iron/vasp.bgq'
crack_geom = {
'cleavage_plane': (1, 1, 0),
'crack_front': (1, -1, 0),
'crack_direction': (0, 0, 1)
}
crack_direction = crack_geom['crack_direction']
crack_front = crack_geom['crack_front']
cleavage_plane = crack_geom['cleavage_plane']
fe_unit = BodyCenteredCubic(
directions=[crack_direction, crack_front, cleavage_plane],
size=(1, 1, 1),
symbol='Fe',
pbc=(1, 1, 1),
latticeconstant=2.83)
nunits = 8
fe_bulk = BodyCenteredCubic(
directions=[crack_direction, crack_front, cleavage_plane],
size=(2, 2, nunits),
symbol='Fe',
pbc=(1, 1, 1),
latticeconstant=2.83)
fe_unit = Atoms(fe_unit)
fe_bulk = Atoms(fe_bulk)
ycut = 5.0 + float(nunits) / 2.0 * fe_unit.lattice[2, 2]
fe_bulk.center(vacuum=5.0, axis=2)
print 'lattice', fe_bulk.lattice[1, 1]
print 'ycut', ycut
a1 = fe_unit.lattice[0, 0]
a2 = fe_unit.lattice[1, 1]
POT_DIR = os.environ['POTDIR']
eam_pot = os.path.join(POT_DIR, 'PotBH.xml')
r_scale = 1.00894848312
#eam_pot = os.path.join(POT_DIR, 'iron_mish.xml')
#r_scale = 1.0129007626
pot = Potential(
'IP EAM_ErcolAd do_rescale_r=T r_scale={0}'.format(r_scale),
param_filename=eam_pot)
fe_bulk.set_calculator(pot)
print 'Bulk Energy', fe_bulk.get_potential_energy()
refen = fe_bulk.get_potential_energy()
A = fe_bulk.get_volume() / fe_bulk.lattice[2, 2]
vasp_args = dict(
xc='PBE',
amix=0.01,
amin=0.001,
bmix=0.001,
amix_mag=0.01,
bmix_mag=0.001,
kpts=[8, 8, 1],
kpar=32,
lreal='auto',
ibrion=2,
nsw=40,
nelmdl=-15,
ispin=2,
nelm=100,
algo='VeryFast',
npar=8,
lplane=False,
lwave=False,
lcharg=False,
istart=0,
voskown=1,
ismear=1,
sigma=0.1,
isym=2) # possibly try iwavpr=12, should be faster if it works
dir_name = 'b111shiftsym'
#dir_name = 'b001shiftsym'
f = open('_patdon123{0}H1.dat'.format(dir_name), 'w')
WRITEVASP = True
a0 = 2.83
for inum, ashift in enumerate(np.arange(0, 1.10, 0.10)):
try:
os.mkdir('{0}{1}'.format(dir_name, ashift))
except:
pass
print 'Directory already exists'
os.chdir('{0}{1}'.format(dir_name, ashift))
fe_shift = fe_bulk.copy()
fe_shift.set_calculator(pot)
for at in fe_shift:
if at.position[2] > ycut:
#[00-1](110)
# at.position += ashift*np.array([-a1,0,0])
#[1-11](110)
at.position += 0.5 * ashift * np.array([a1, a2, 0])
# print >> fil1, ashift, (units.m**2/units.J)*(fe_shift.get_potential_energy()-refen)/A
line = []
for at in fe_shift:
line.append(FixedLine(at.index, (0, 0, 1)))
#Now add Hydrogen
# fe_shift.add_atoms(np.array([0.53*a0, 0.53*a0, 21.0+a0/2]),1)
# at relaxed position:
fe_shift.add_atoms(h_pos, 1)
fix_atoms_mask = [at.number == 1 for at in fe_shift]
fixedatoms = FixAtoms(mask=fix_atoms_mask)
fe_shift.set_constraint(line + [fixedatoms])
opt = LBFGS(fe_shift)
opt.run(fmax=0.1, steps=1000)
if inum == 0:
print 'Setting Reference Energy'
refen = fe_shift.get_potential_energy()
print >> f, ashift, (units.m**2 / units.J) * (
fe_shift.get_potential_energy() - refen) / A
fe_shift.write('feb{0}.xyz'.format(ashift))
if WRITEVASP:
vasp = Vasp(**vasp_args)
vasp.initialize(fe_shift)
write_vasp('POSCAR',
vasp.atoms_sorted,
symbol_count=vasp.symbol_count,
vasp5=True)
vasp.write_incar(fe_shift)
vasp.write_potcar()
vasp.write_kpoints()
os.chdir('../')
f.close()
relax_slab = True # If True, relax notched slab with calculator
relax_fmax = 0.025*units.eV/units.Ang # Maximum force criteria for relaxation
# ******* Molecular dynamics parameters ***********
sim_T = 300.0*units.kB # Simulation temperature
nsteps = 10000 # Total number of timesteps to run for
timestep = 1.0*units.fs # Timestep (NB: time base units are not fs!)
cutoff_skin = 2.0*units.Ang # Amount by which potential cutoff is increased
# for neighbour calculations
tip_move_tol = 10.0 # Distance tip has to move before crack
# is taken to be running
strain_rate = 1e-5*(1/units.fs) # Strain rate
traj_file = 'traj.nc' # Trajectory output file (NetCDF format)
traj_interval = 10 # Number of time steps between
# writing output frames
# ********** Setup calculator ************
# Stillinger-Weber (SW) classical interatomic potential, from QUIP
from quippy import Potential
calc = Potential('IP SW', 'params.xml')
# Screened Kumagai potential, from Atomistica
#import atomistica
#calc = atomistica.KumagaiScr()
potparam = PotentialParameters()
ener_bulk = potparam.gs_ener_per_atom()
POT_DIR = '/Users/lambert/pymodules/imeall/imeall/potentials'
at = AtomsReader(sys.argv[1])
at = at[-1]
pot_string = 'iron_mish.xml'
print ''
print '\t POTENTIAL: ', pot_string
print ''
eam_pot = os.path.join(POT_DIR, pot_string)
pot_1 = Potential(
'IP EAM_ErcolAd do_rescale_r=T r_scale={0}'.format(1.0129007626),
param_filename=eam_pot)
at.set_calculator(pot_1)
calc_e_gb(at, ener_bulk[pot_string])
pot_string = 'Fe_Mendelev.xml'
print ''
print 'POTENTIAL: ', pot_string
print ''
eam_pot = os.path.join(POT_DIR, pot_string)
pot_2 = Potential(
'IP EAM_ErcolAd do_rescale_r=T r_scale={0}'.format(1.00894848312),
param_filename=eam_pot)
at.set_calculator(pot_2)
calc_e_gb(at, ener_bulk[pot_string])
from quippy import Potential
import os
model_dir = os.path.dirname(os.path.realpath(__file__))
filename = os.path.join(
model_dir,
'16x16x16k_mesh_param_file_tightbind.parms.NRL_TB.Ti_spline.xml')
calculator = Potential('TB NRL-TB', param_filename=filename, Fermi_T=0.1)
no_checkpoint = True
name = 'DFTB'
sc = SumCalculator(pot, cc)
atoms.set_constraint(FixAtoms(mask=fix_line_mask))
atoms.set_calculator(sc)
LBFGS(atoms, use_armijo=False).run(fmax=0.2)
fix_line = [FixedLine(i, np.array([0, 1, 0])) for i in fix_line_idx]
atoms.set_array('fix_line_mask', fix_line_mask)
atoms.set_constraint(fix_line + springs)
atoms.set_calculator(pot)
opt = vanillaLBFGS(atoms)
else:
print("Method not understood")
return
opt.attach(trajectory_write, interval=5)
opt.run(fmax=fmax)
return
if __name__ == '__main__':
pot = Potential('IP TS', param_filename="../ts_params.xml")
in_file = sys.argv[1]
out_file = os.path.splitext(in_file)[0] + '_relaxed.xyz'
atoms = Atoms(in_file)
minim_precon(atoms)
atoms.write(out_file)
# A module defining a module needs to define only one variable,
# named `calculator`, which should be an instance of the ase.calculator.Calculator,
# a subclass of this, or a compatible class implementing the calculator interface.
calculator = Potential('IP Tersoff',
param_str="""
<Tersoff_params n_types="3" label="PRB_39">
<comment> Tersoff, Phys. Rev. B v 39, p 5566 (1989) </comment>
<per_type_data type="1" atomic_num="6"
A="1393.6" B="346.7" lambda="3.4879" mu="2.2119" beta="0.00000015724"
n="0.72751" c="38049" d="4.384" h="-0.57058" R="1.8" S="2.1" />
<per_type_data type="2" atomic_num="14"
A="1830.8" B="471.18" lambda="2.4799" mu="1.7322" beta="0.0000011"
n="0.78734" c="100390" d="16.217" h="-0.59825" R="2.7" S="3.0" />
<per_type_data type="3" atomic_num="32"
A="1769" B="419.23" lambda="2.4451" mu="1.7047" beta="0.00000090166"
n="0.75627" c="106430" d="15.652" h="-0.43884" R="2.8" S="3.1" />
<per_pair_data type1="1" type2="1" chi="1.0" />
<per_pair_data type1="2" type2="1" chi="0.9776" />
<per_pair_data type1="2" type2="2" chi="1.0" />
<per_pair_data type1="3" type2="1" chi="1.0" />
<per_pair_data type1="3" type2="2" chi="1.00061" />
<per_pair_data type1="3" type2="3" chi="1.0" />
</Tersoff_params>
""")
no_checkpoint = True
name = 'Tersoff'
import os
import numpy as np
from ase.units import GPa, J, m, kB, fs, Ang
import quippy
from matscipy.neighbours import neighbour_list
from quippy import Potential
k_spring = 1.00
initial_strain = 0.10
crack_seed_length = 1. / 3 # fraction of total length
strain_ramp_length = 15
vacuum = 20
relax_fmax = 0.01
pre_optim = True
relax_slab = True
calc = Potential("IP TS", param_filename='ts_params.xml')
import os
from quippy import Potential
import __builtin__
orig_dir = os.getcwd()
model_dir = os.path.dirname(__file__)
if model_dir != '':
os.chdir(model_dir)
if os.path.exists('gp_iter5_with111adatom_with3x3das_sparse2x.xml.sparseX.GAP_2017_5_20_60_4_23_20_5121.bz2'):
os.system('bunzip2 gp_iter5_with111adatom_with3x3das_sparse2x.xml.sparseX.GAP_2017_5_20_60_4_23_20_5121.bz2')
try:
if hasattr(__builtin__, 'mpi_glob'):
calculator = Potential(init_args='Potential xml_label="GAP_2017_5_20_60_4_23_20_512"',
param_filename='gp_iter5_with111adatom_with3x3das_sparse2x.xml', mpi_obj=mpi_glob)
else:
calculator = Potential(init_args='Potential xml_label="GAP_2017_5_20_60_4_23_20_512"',
param_filename='gp_iter5_with111adatom_with3x3das_sparse2x.xml')
Potential.__str__ = lambda self: '<GAP Potential>'
finally:
os.chdir(orig_dir)
no_checkpoint = True
name = 'GAP-ScienceAdvances'
# Model for Stillinger-Weber with original parameters for Si (Z=14)
from quippy import Potential
# A module defining a module needs to define only one variable,
# named `calculator`, which should be an instance of the ase.calculator.Calculator,
# a subclass of this, or a compatible class implementing the calculator interface.
calculator = Potential('IP SW',
param_str="""
<SW_params n_types="1">
<per_type_data type="1" atomic_num="14" />
<per_pair_data atnum_i="14" atnum_j="14" AA="7.049556277" BB="0.6022245584"
p="4" q="0" a="1.80" sigma="2.0951" eps="2.1675" />
<per_triplet_data atnum_c="14" atnum_j="14" atnum_k="14"
lambda="21.0" gamma="1.20" eps="2.1675" />
</SW_params>
""")
no_checkpoint = True
name = 'SW'
calc_elastic_constants = False
dyn_type = 'eam'
print '\tDislocation Type: ', dis_type, ' dislocation.'
print '\tCalculate Dynamics: ', run_dyn
print '\tCalculate Nye Tensor: ', calc_nye
print '\tInput File: ', input_file
print '\tPotential: ', pot_type
if pot_type == 'EAM':
global potdir
potdir = os.environ['POTDIR']
eam_pot = os.path.join(potdir, 'PotBH.xml')
r_scale = 1.00894848312
pot = Potential(
'IP EAM_ErcolAd do_rescale_r=T r_scale={0}'.format(r_scale),
param_filename=eam_pot)
elif pot_type == 'TB':
tb = TightBindingPot(alat=1.00, nk=12)
screw_slab_unit = Atoms(screw_slab_unit)
center_cell = np.diag(screw_slab_unit.get_cell()) / 2.
screw_slab_unit.add_atoms(center_cell, 1)
#screw_slab_unit.add_atoms(center_cell*0.76, 6)
screw_slab_unit.set_atoms(screw_slab_unit.Z)
print len(screw_slab_unit)
tb.write_control_file('ctrl.fe', screw_slab_unit)
pot = Potential('IP LMTO_TBE',
param_str="""
<params>
<LMTO_TBE_params n_types="2" control_file="ctrl.fe">
try:
pot_dir = os.environ['POTDIR']
except:
print 'POTDIR not defined in os environment.'
raise
nqx = 24
nqy = 24
nqz = 24
n_sup_x = 8
n_sup_y = 8
n_sup_z = 8
pot_file = os.path.join(pot_dir, 'PotBH.xml')
pot = Potential('IP EAM_ErcolAd', param_filename=pot_file)
#Set paths for phonon band structures:
#paths = [np.array([0,0,-0.5]), np.array([0,0,0]), np.array([0,0,0.5]), np.array([0,0.5,0.5])]
b1 = 1.0
#Nice plot for phonon:
paths = [np.array([0,0,0.0]), np.array([b1/2.0, b1/2.0, 0.0]), np.array([b1/2.0,b1/2.0,b1])]
paths = calc_band_paths(paths)
unit_cell = BodyCenteredCubic(directions = [[1,0,0], [0,1,0],[0,0,1]],
size = (1,1,1), symbol='Fe', pbc=(1,1,1),
latticeconstant = 2.83)
symbols = unit_cell.get_chemical_symbols()
cell = unit_cell.get_cell()
scaled_positions = unit_cell.get_scaled_positions()
THZ_to_mev = 4.135665538536
def relax_gb(gb_file='file_name',
traj_steps=120,
total_steps=1200,
force_tol=0.05):
"""Method to relax a grain_boundary bicrystal structure. Requires a .json
file with at a minimum the 'param_file' variable specified.
Args:
gb_file(str): gbid.
traj_steps(int): number of steps between print trajectories.
total_steps(int): total number of force relaxation steps.
force_tol(float): Force relaxation criterion in ev/A.
Returns:
:class:`ase.Atoms` Object
"""
def converged(grain, smax, fmax):
maxstress = max(grain.get_stress().ravel())
rmsforces = np.sum(grain.get_forces()**2, axis=1)**0.5
maxforce = max(rmsforces)
if maxforce < fmax and maxstress < smax:
return True
return False
with open('subgb.json', 'r') as outfile:
j_dict = json.load(outfile)
try:
POT_DIR = os.path.join(app.root_path, 'potentials')
except KeyError:
sys.exit(
"Please set POTDIR in os environment. `export POTDIR='path/to/potfiles/`"
)
try:
param_file = j_dict['param_file']
if param_file == 'iron_mish.xml':
eam_pot = os.path.join(POT_DIR, 'iron_mish.xml')
r_scale = 1.0129007626
elif param_file == 'Fe_Mendelev.xml':
eam_pot = os.path.join(POT_DIR, 'Fe_Mendelev.xml')
r_scale = 1.00894848312
elif param_file == 'PotBH.xml':
eam_pot = os.path.join(POT_DIR, 'PotBH.xml')
r_scale = 1.00894848312
elif param_file == 'Fe_Ackland.xml':
eam_pot = os.path.join(POT_DIR, 'Fe_Ackland.xml')
r_scale = 1.00894185389
elif param_file == 'Fe_Dudarev.xml':
eam_pot = os.path.join(POT_DIR, 'Fe_Dudarev.xml')
r_scale = 1.01279093417
elif param_file == 'gp33b.xml':
eam_pot = os.path.join(POT_DIR, 'gp33b.xml')
sparse_file = 'gp33b.xml.sparseX.GAP_2016_10_3_60_19_29_10_8911'
eam_pot_sparse = os.path.join(POT_DIR, sparse_file)
shutil.copy(eam_pot, './')
shutil.copy(eam_pot_sparse, './')
else:
print 'No paramfile found!'
sys.exit()
except KeyError:
print 'No EAM potential file with that name. Relax failed.'
sys.exit()
print 'Using: ', eam_pot
pot_file = eam_pot.split('/')[-1]
print '{0}.xyz'.format(gb_file)
print os.getcwd()
grain = io.read('{0}.xyz'.format(gb_file), index='-1')
if param_file != 'gp33b.xml':
pot = Potential(
'IP EAM_ErcolAd do_rescale_r=T r_scale={0}'.format(r_scale),
param_filename=eam_pot)
else:
pot = Potential('IP GAP', param_filename=eam_pot)
grain.set_calculator(pot)
grain.info['adsorbate_info'] = None
E_gb_init = grain.get_potential_energy()
traj_file = gb_file
if 'traj' in traj_file:
out = AtomsWriter('{0}'.format('{0}.xyz'.format(traj_file)))
else:
out = AtomsWriter('{0}'.format('{0}_traj.xyz'.format(traj_file)))
strain_mask = [0, 0, 1, 0, 0, 0]
ucf = UnitCellFilter(grain, strain_mask)
opt = FIRE(ucf)
cell = grain.get_cell()
A = cell[0][0] * cell[1][1]
H = cell[2][2]
#Calculation dumps total energyenergy and grainboundary area data to json file.
with open('subgb.json', 'r') as f:
gb_dict = json.load(f)
#Write an initial dict so we know if the system has been initialized but the calculation is not finished.
with open('subgb.json', 'w') as outfile:
for key, value in gb_dict.items():
j_dict[key] = value
json.dump(j_dict, outfile, indent=2)
CONVERGED = False
FORCE_TOL = force_tol
#default to 5 if traj_steps = 120, otherwise increases
num_iters = int(float(total_steps) / float(traj_steps))
logging.debug('num_iters: {}'.format(num_iters))
for i in range(num_iters):
opt.run(fmax=FORCE_TOL, steps=traj_steps)
out.write(grain)
force_array = grain.get_forces()
max_force_II = max([max(f) for f in force_array])
max_forces = [
np.sqrt(fx**2 + fy**2 + fz**2) for fx, fy, fz in zip(
grain.properties['force'][0], grain.properties['force'][1],
grain.properties['force'][2])
]
if max(max_forces) <= FORCE_TOL:
CONVERGED = True
break
out.close()
gb_dict['converged'] = CONVERGED
E_gb = grain.get_potential_energy()
gb_dict['E_gb'] = E_gb
gb_dict['E_gb_init'] = E_gb_init
gb_dict['area'] = A
with open('subgb.json', 'w') as outfile:
for key, value in gb_dict.items():
j_dict[key] = value
json.dump(j_dict, outfile, indent=2)
if param_file == 'gp33b.xml':
os.remove(param_file)
os.remove(sparse_file)
else:
pass
return grain
sym_tilt_110 = [[np.pi*(93.37/180.), np.array([-3., 3., 4.])]]
gbid = '1109337334'
or_axis = [1,1,0]
bp = [-1,1,12]
##########################################
##First calculate surface energetics: ##
##########################################
bulk = BodyCenteredCubic(directions = [[1,0,0],[0,1,0], [0,0,1]],
size = (1,1,1), symbol='Fe', pbc=(1,1,1),
latticeconstant = 2.85)
eam_pot = './Fe_Mendelev.xml'
gb_frac = GBFracture()
surf_cell = gb_frac.build_surface(bp = sym_tilt_110[0][1])
pot = Potential('IP EAM_ErcolAd', param_filename=eam_pot)
bulk.set_calculator(pot)
ener_per_atom = bulk.get_potential_energy()/len(bulk)
surf_cell.set_calculator(pot)
surf_ener = surf_cell.get_potential_energy()
cell = surf_cell.get_cell()
A = cell[0][0]*cell[1][1]
gamma = (surf_ener- len(surf_cell)*ener_per_atom)/A
print '2*gamma ev/A2', gamma
print '2*gamma J/m2', gamma/(units.J/units.m**2)
j_dict = {'or_axis':or_axis, 'bp':bp, 'gamma':gamma}
with open('gbfrac.json','w') as f:
json.dump(j_dict, f)
out = AtomsWriter('{0}'.format('{0}_surf.xyz'.format(gbid)))
out.write(Atoms(surf_cell))
at.calc_connect()
print 'Delete atoms'
at = gbr.delete_atoms(grain=at, rcut=1.5)
at.info['OrigHeight'] = at.positions[:, 1].max() - at.positions[:, 1].min()
r_scale = 1.00894848312
rem = []
for atom in at:
if atom.position[0] <= 0.00 and atom.position[1] <= 100.0:
rem.append(atom.index + 1)
print 'Removing ', len(rem), ' atoms.'
if len(rem) > 0:
at.remove_atoms(rem)
else:
print 'No atoms displaced from unitcell'
pot = Potential('IP EAM_ErcolAd do_rescale_r=T r_scale={0}'.format(r_scale),
param_filename=eam_pot)
at.set_calculator(pot)
at.write('unrelaxed.xyz')
print 'Running Relaxation'
opt = FIRE(at)
opt.run(fmax=0.1)
print 'Calculating connectivity and Nye Tensor'
ref_slab = Atoms('ref_slab.xyz')
ref_slab.set_cutoff(3.0)
ref_slab.calc_connect()
at.set_cutoff(3.0)
at.calc_connect()
alpha = calc_nye_tensor(at, ref_slab, 3, 3, at.n)
MOL=mol GAMMA=F PAIR=pair SCALE={scale}
UL={ul} IODEL={io} OVLP={ovlp} TBU={tbu} NOUAVG={nav} U1={u1}
EWALD TOL=ewtol NKDMX=1999 NKRMX=1999
OPTIONS ASA[ADNF[0] NSPH[0] TWOC[0] CCOR[1]]"""
# generate a control file from template for this atomic config
write_control_file('ctrl.fe', ctrl_template, atoms, alat, nk=nk)
# setup QUIP Potential interfacing to LMTO TBE library
# control file is the one written above from template
# NB: order of types must match order in control file
tb_pot = Potential('IP LMTO_TBE',
param_str="""
<params>
<LMTO_TBE_params n_types="3" control_file="ctrl.fe">
<per_type_data type="1" atomic_num="26"/>
<per_type_data type="2" atomic_num="6"/>
<per_type_data type="3" atomic_num="1"/>
</LMTO_TBE_params>
</params>""")
print tb_pot
# compute energies and forces for a range of lattice constants
if True:
a = np.linspace(2.5, 3.0, 5)
e = []
f = []
configs = []
for aa in a:
atoms = BodyCenteredCubic(symbol='Fe', latticeconstant=aa)
parser.add_argument("--use_gap", "-g", action="store_true")
parser.add_argument("--relax", "-r", action="store_true", help='If true relaxes initial and final positions of the NEB calculation.')
args = parser.parse_args()
#only one qmpot specifed at command line
use_eampot = not(args.use_gap or args.use_socket)
#assert sum(args.use_gap + args.use_socket + use_mmpot) == 1
print (args, file=(open('output.txt','w')))
buff = args.buff
qm_radius = args.qm_radius
POT_DIR = os.path.join(app.root_path, 'potentials')
eam_pot = os.path.join(POT_DIR, 'PotBH.xml')
r_scale = 1.00894848312
mm_pot = Potential('IP EAM_ErcolAd do_rescale_r=T r_scale={0}'.format(r_scale), param_filename=eam_pot)
if args.auto_gen:
gb_cell = AtomsReader(args.input_file)[-1]
else:
gb_cell = AtomsReader("disloc_0.xyz")[-1]
# defect = find_h_atom(gb_cell)
# h_pos = defect.position
qm_center = gb_cell.info['CrackPos']
x, y, z = gb_cell.positions.T
radius1 = np.sqrt((x -qm_center[0])**2 + (y-qm_center[1])**2 + (z-qm_center[2])**2)
qm_region_mask = (radius1 < qm_radius)
qm_buffer_mask = (radius1 < qm_radius + buff)
distances.append(v['distance'])
if j % npoints == 0:
special_points.append(v['distance'])
special_points.append(data['phonon'][-1]['distance'])
return special_points, distances, frequencies
write_yaml = 1 # save results to band.yaml file
read_yaml = 0 # set to 1 to add a plot loaded from YAML file
# Define unit cell and potential to be used for calculating forces
a = 5.44
bulk = diamond(a, 14)
pot = Potential('IP SW')
bulk.set_calculator(pot)
# Phonopy pre-process
print "------"
print "Phonon"
print "------"
# 1st arg. is the input unit cell.
# 2nd arg. is the supercell lattice relative to the unit cell.
# 'distance' is the distance of displacements.
# Default symmetry tolerance is 1e-5 in fractional coordinates.
phonon = Phonopy(bulk, [[1, 0, 0], [0, 1, 0], [0, 0, 1]],
distance=0.01,
factor=VaspToTHz)
phonon.print_displacements()
supercells = phonon.get_supercells_with_displacements()
env=os.environ)
sock_calc = SocketCalculator(quip_client)
el = 'Si'
a0 = 5.43
n = [6, 4, 1]
crack_surface = [1, 1, 1]
crack_front = [1, -1, 0]
cryst = diamond(el, a0, n, crack_surface, crack_front)
cryst.pbc = [True, True, True] # QUIP doesn't handle open BCs
cryst.rattle(0.01)
cryst.set_calculator(sock_calc)
sock_e = cryst.get_potential_energy()
sock_f = cryst.get_forces()
sock_s = cryst.get_stress()
sock_calc.shutdown()
# compare to results from quippy
quippy_calc = Potential('IP SW', param_filename='params.xml')
cryst.set_calculator(quippy_calc)
quippy_e = cryst.get_potential_energy()
quippy_f = cryst.get_forces()
quippy_s = cryst.get_stress()
print 'energy difference', sock_e - quippy_e
print 'force difference', abs((sock_f - quippy_f).max())
print 'stress difference', abs((sock_s - quippy_s).max())
calculator = Potential('IP Si_MEAM',
param_str="""
<Si_MEAM_params n_types="1" label="">
<!-- Thomas J Lenosky, Babak Sadigh, Eduardo Alonso, Vasily V Bulatov, Tomas Diaz de la Rubia -->
<!-- Jeongnim Kim, Arthur F Voter and Joel D Kress -->
<!-- Highly optimized empirical potential model of silicon -->
<!-- Modelling Simul. Mater. Sci. Eng. 8 (2000) 825-841 -->
<per_type_data atomic_num="14" type="1">
<spline spline_function="U" n_spline="8" yp1="0.73514" ypn="0.61652">
<point x="-1.7709300000" y="-1.0749300000" />
<point x="-0.3881514286" y="-0.2004500000" />
<point x=" 0.9946271429" y=" 0.4142200000" />
<point x=" 2.3774057143" y=" 0.8793900000" />
<point x=" 3.7601842857" y=" 1.2668900000" />
<point x=" 5.1429628571" y=" 1.6299800000" />
<point x=" 6.5257414286" y=" 1.9773800000" />
<point x=" 7.9085200000" y=" 2.3961800000" />
</spline>
</per_type_data>
<per_pair_data atomic_num_i="14" atomic_num_j="14" r_cut_phi="4.5" r_cut_rho="3.5" r_cut_f="3.5">
<spline spline_function="phi" n_spline="10" yp1="-42.66967" ypn="0.00000">
<point x="1.5000000000" y=" 6.9299400000" />
<point x="1.8333333333" y="-0.4399500000" />
<point x="2.1666666667" y="-1.7012300000" />
<point x="2.5000000000" y="-1.6247300000" />
<point x="2.8333333333" y="-0.9969600000" />
<point x="3.1666666667" y="-0.2739100000" />
<point x="3.5000000000" y="-0.0249900000" />
<point x="3.8333333333" y="-0.0178400000" />
<point x="4.1666666667" y="-0.0096100000" />
<point x="4.5000000000" y=" 0.0000000000" />
</spline>
<spline spline_function="rho" n_spline="11" yp1="-1.00000" ypn="0.00000">
<point x="1.5000000000" y=" 0.1374700000" />
<point x="1.7000000000" y="-0.1483100000" />
<point x="1.9000000000" y="-0.5597200000" />
<point x="2.1000000000" y="-0.7311000000" />
<point x="2.3000000000" y="-0.7628300000" />
<point x="2.5000000000" y="-0.7291800000" />
<point x="2.7000000000" y="-0.6662000000" />
<point x="2.9000000000" y="-0.5732800000" />
<point x="3.1000000000" y="-0.4069000000" />
<point x="3.3000000000" y="-0.1666200000" />
<point x="3.5000000000" y=" 0.0000000000" />
</spline>
<spline spline_function="f" n_spline="10" yp1="-3.61894" ypn="0.00000">
<point x="1.5000000000" y="1.2503100000" />
<point x="1.7222222222" y="0.8682100000" />
<point x="1.9444444444" y="0.6084600000" />
<point x="2.1666666667" y="0.4875600000" />
<point x="2.3888888889" y="0.4416300000" />
<point x="2.6111111111" y="0.3761000000" />
<point x="2.8333333333" y="0.2714500000" />
<point x="3.0555555556" y="0.1481400000" />
<point x="3.2777777778" y="0.0485500000" />
<point x="3.5000000000" y="0.0000000000" />
</spline>
</per_pair_data>
<per_triplet_data atomic_num_i="14" atomic_num_j="14" atomic_num_k="14">
<spline spline_function="g" n_spline="8" yp1="-13.95042" ypn="1.13462">
<point x="-1.0000000000" y="5.2541600000" />
<point x="-0.7428371429" y="2.3591500000" />
<point x="-0.4856742857" y="1.1959500000" />
<point x="-0.2285114286" y="1.2299500000" />
<point x=" 0.0286514286" y="2.0356500000" />
<point x=" 0.2858142857" y="3.4247400000" />
<point x=" 0.5429771429" y="4.9485900000" />
<point x=" 0.8001400000" y="5.6179900000" />
</spline>
</per_triplet_data>
</Si_MEAM_params>
""")
