os.mkdir(dir_name)
substrate_bulk.to(fmt='poscar',
filename=dir_name + os.sep +
item.replace('json', 'vasp'))
for direction in directions:
address = dir_name + os.sep + str(direction)
if not os.path.exists(address):
os.mkdir(address)
substrate_slab = Interface(substrate_bulk,
hkl=direction,
min_thick=10,
min_vac=15,
primitive=False,
from_ase=True)
sd_flags = CalibrateSlab.set_sd_flags(interface=substrate_slab,
n_layers=nlayers_substrate,
top=True,
bottom=False)
substrate_slab_aligned, mat2d_slab_aligned, mismatch = transformations.get_aligned_lattices(
substrate_slab,
mat2d_slab,
max_area=40,
max_mismatch=0.05,
max_angle_diff=20,
r1r2_tol=0.01)
substrate_slab_aligned.to(fmt='poscar',
filename=address + os.sep +
'POSCAR_substrate_aligned.vasp')
mat2d_slab_aligned.to(fmt='poscar',
filename=address + os.sep +
'POSCAR_mat2d_aligned.vasp')
# substrate_bulk = get_struct_from_mp('Ag')
sa_sub = SpacegroupAnalyzer(substrate_bulk)
substrate_bulk = sa_sub.get_conventional_standard_structure()
substrate_slab = Interface(substrate_bulk,
hkl=[1, 1, 1],
min_thick=10,
min_vac=25,
primitive=False, from_ase=True)
# substrate_slab = slab_from_file([0,0,1], 'POSCAR_substrate')
mat2d_slab = slab_from_file([0, 0, 1], 'POSCAR_2D')
# get the in-plane lattice aligned slabs
# substrate_slab.to(fmt='poscar', filename='POSCAR_substrate_slab.vasp')
mat2d_slab.to(fmt='poscar', filename='POSCAR_mat2d_slab.vasp')
# selective dynamics flag
sd_flags = CalibrateSlab.set_sd_flags(
interface=substrate_slab,
n_layers=nlayers_substrate,
top=True, bottom=False)
poscar = Poscar(substrate_slab, selective_dynamics=sd_flags)
poscar.write_file(filename='POSCAR_substrate_slab.vasp')
# get aligned lattices
substrate_slab_aligned, mat2d_slab_aligned = get_aligned_lattices(
substrate_slab,
mat2d_slab,
max_area=400,
max_mismatch=0.05,
max_angle_diff=1,
r1r2_tol=0.01)
substrate_slab_aligned.to(fmt='poscar',
filename='POSCAR_substrate_aligned.vasp')
mat2d_slab_aligned.to(fmt='poscar',
filename='POSCAR_mat2d_aligned.vasp')
poscar = Poscar(iface)
potcar = Potcar(poscar.site_symbols)
kpoints = Kpoints.automatic(20)
#set job list. if empty a single job will be run
encut_list = [] #range(400,800,100)
turn_knobs = OrderedDict(
[
('ENCUT', encut_list)
])
#job directory
job_dir = 'vasp_job'
# run settings
qadapter = None
job_cmd = None
nprocs = 16
nnodes = 1
walltime = '24:00:00'
mem = 1000
incar['NPAR'] = int(sqrt(nprocs))
job_bin = '/home/km468/Software/VASP/vasp.5.3.5/vasp'
qadapter, job_cmd = get_run_cmmnd(nnodes=nnodes, nprocs=nprocs,
walltime=walltime,
job_bin=job_bin, mem=mem)
# setup calibration jobs and run
cal = CalibrateSlab(incar, poscar, potcar, kpoints,
system=iface.as_dict(),
turn_knobs=turn_knobs, qadapter=qadapter,
job_cmd = job_cmd, job_dir=job_dir)
cal.setup()
cal.run()
encut_list = [] #range(400,800,100)
turn_knobs = OrderedDict([('ENCUT', encut_list)])
#job directory
job_dir = 'vasp_job'
# run settings
qadapter = None
job_cmd = None
nprocs = 16
nnodes = 1
walltime = '24:00:00'
mem = 1000
incar['NPAR'] = int(sqrt(nprocs))
job_bin = '/home/km468/Software/VASP/vasp.5.3.5/vasp'
qadapter, job_cmd = get_run_cmmnd(nnodes=nnodes,
nprocs=nprocs,
walltime=walltime,
job_bin=job_bin,
mem=mem)
# setup calibration jobs and run
cal = CalibrateSlab(incar,
poscar,
potcar,
kpoints,
system=iface.as_dict(),
turn_knobs=turn_knobs,
qadapter=qadapter,
job_cmd=job_cmd,
job_dir=job_dir)
cal.setup()
cal.run()
def upload_file():
stamp = ""
if request.method == 'POST':
#request.environ['REMOTE_ADDR']
if request.environ.get('HTTP_X_FORWARDED_FOR') is None:
ip = request.environ['REMOTE_ADDR']
else:
ip = request.environ['HTTP_X_FORWARDED_FOR'] # if behind a proxy
#substrate information#
f1 = request.files['POSCAR_sub']
stamp = time.strftime("%Y%m%d-%H%M%S") + '-' + ip
poscar_sub = stamp + '-' + f1.filename
f1.save(upload_dir + os.sep + secure_filename(poscar_sub))
h_sub = int(request.form["h_sub"])
k_sub = int(request.form["k_sub"])
l_sub = int(request.form["l_sub"])
nlayers_substrate = int(request.form["nlayers_substrate"])
min_thick_sub = float(request.form["min_thick_sub"])
min_vac_sub = float(request.form["min_vac_sub"])
#is_primitive = request.form.get["is_primitive"]
hkl_sub = [h_sub, k_sub, l_sub]
#2d information#
f2 = request.files['POSCAR_2d']
poscar_2d = stamp + '-' + f2.filename
f2.save(upload_dir + os.sep + secure_filename(poscar_2d))
h_2d = int(request.form["h_2d"])
k_2d = int(request.form["k_2d"])
l_2d = int(request.form["l_2d"])
nlayers_2d = int(request.form["nlayers_2d"])
hkl_2d = [h_2d, k_2d, l_2d]
#General information#
separation = float(request.form["separation"])
max_area = float(request.form["max_area"])
max_mismatch = float(request.form["max_mismatch"])
max_angle_diff = float(request.form["max_angle_diff"])
#Matching#
try:
substrate_bulk = pymatgen.Structure.from_file(upload_dir + os.sep +
poscar_sub)
sa_sub = pymatgen.symmetry.analyzer.SpacegroupAnalyzer(
substrate_bulk)
substrate_bulk = sa_sub.get_conventional_standard_structure()
substrate_slab = Interface(substrate_bulk,
hkl=hkl_sub,
min_thick=min_thick_sub,
min_vac=min_vac_sub,
primitive=False,
from_ase=True)
mat2d_slab = utils.slab_from_file(hkl_2d,
upload_dir + os.sep + poscar_2d)
operation_dir = "static" + os.sep + "operations" + os.sep + stamp
if not os.path.exists(operation_dir):
os.makedirs(operation_dir)
mat2d_slab.to(fmt="poscar",
filename=operation_dir + "POSCAR_mat2d_slab.vasp")
sd_flags = CalibrateSlab.set_sd_flags(interface=substrate_slab,
n_layers=nlayers_substrate,
top=True,
bottom=False)
poscar = pymatgen.io.vasp.inputs.Poscar(
substrate_slab, selective_dynamics=sd_flags)
poscar.write_file(filename=operation_dir + os.sep +
"POSCAR_substrate_slab.vasp")
substrate_slab_aligned, mat2d_slab_aligned, mismatch = transformations.get_aligned_lattices(
substrate_slab,
mat2d_slab,
max_area=max_area,
max_mismatch=max_mismatch,
max_angle_diff=max_angle_diff,
r1r2_tol=0.01)
substrate_slab_aligned.to(fmt="poscar",
filename=operation_dir + os.sep +
"POSCAR_substrate_aligned.vasp")
mat2d_slab_aligned.to(fmt="poscar",
filename=operation_dir + os.sep +
"POSCAR_mat2d_aligned.vasp")
hetero_interfaces = transformations.generate_all_configs(
mat2d_slab_aligned, substrate_slab_aligned, nlayers_2d,
nlayers_substrate, separation)
for i, iface in enumerate(hetero_interfaces):
sd_flags = CalibrateSlab.set_sd_flags(interface=iface,
n_layers=nlayers_2d +
nlayers_substrate,
top=True,
bottom=False)
poscar = pymatgen.io.vasp.inputs.Poscar(
iface, selective_dynamics=sd_flags)
poscar.write_file(filename=operation_dir + os.sep +
'POSCAR_final_{}.vasp'.format(i))
p = Poscar.from_file(operation_dir + os.sep +
'POSCAR_final_{}.vasp'.format(i))
w = CifWriter(p.structure)
w.write_file(operation_dir + os.sep +
'POSCAR_final_{}.cif'.format(i))
# st = pychemia.code.vasp.read_poscar(operation_dir+os.sep+'POSCAR_final_{}.vasp'.format(i))
#rf = open("testing")
#rf.write("reading succesful")
#rf.close()
# pychemia.io.cif.save(structure=st,filename=operation_dir+os.sep+'POSCAR_final_{}.xyz'.format(i))
except:
#redirect(url_for("error",_id="matching",stamp=stamp))
return ("Error")
return redirect(url_for('result', stamp=stamp))
return render_template("matching.html",
_id="matching",
test_var="test",
stamp=stamp)
def step3():
"""
put aligned & relaxed 2d materials in all possible ways on the
aligned & relaxed slab,
relax interface ionic positions(ISIF=2)
- uses info from step2_sub.json and step2_2d.json
- creates required input files and submits the jobs to the que
- 8(pairs) * 2(atoms in graphene basis) = 16 jobs
- returns: step3.json
"""
seperation = 3 # in angstroms
nlayers_2d = 1
nlayers_sub = 2
hkl_sub = [1,1,1]
hkl_2d = [0,0,1]
#job directory for the runs
name = 'step3'
job_dir = 'step3'
# incar
incar = Incar.from_dict(incar_dict)
incar['ISMEAR'] = 1
incar['ISIF'] = 2
# kpoints
kpoints = Kpoints.monkhorst_automatic(kpts=(18, 18, 1))
# load in previous jobs
relaxed_sub_jobs = Calibrate.jobs_from_file('step2_sub.json')
relaxed_2d_jobs = Calibrate.jobs_from_file('step2_2d.json')
# create list of all substrate poscars
all_poscars = []
# loop over aligned & relaxed substrates and 2d
for jsub, j2d in zip(relaxed_sub_jobs,relaxed_2d_jobs):
# substrate
job_dir_sub = os.path.join(jsub.parent_job_dir, jsub.job_dir)
contcar_file = os.path.join(job_dir_sub, 'CONTCAR')
# read in as structure object
substrate_slab_aligned = Structure.from_file(contcar_file)
species_sub = ''.join([tos.symbol for tos in substrate_slab_aligned.types_of_specie])
# 2d
job_dir_2d = os.path.join(j2d.parent_job_dir, j2d.job_dir)
contcar_file = os.path.join(job_dir_2d, 'CONTCAR')
# read in as structure object
mat2d_slab_aligned = Structure.from_file(contcar_file)
species_2d = ''.join([tos.symbol for tos in mat2d_slab_aligned.types_of_specie])
# position the aligned materials in all possible ways
hetero_interfaces = generate_all_configs(mat2d_slab_aligned,
substrate_slab_aligned,
nlayers_2d,
nlayers_sub,
seperation )
# loop over all hetero-interfaces
for i, iface in enumerate(hetero_interfaces):
sd_flags = CalibrateSlab.set_sd_flags(interface=iface,
n_layers=nlayers_2d+nlayers_sub,
top=True, bottom=False)
poscar = Poscar(iface, selective_dynamics=sd_flags)
poscar.comment = '_'.join([species_sub,species_2d,str(i)])
all_poscars.append(poscar)
# setup calibrate and run'em
turn_knobs = OrderedDict(
[
('POSCAR', all_poscars)
])
qadapter, job_cmd = get_run_cmmnd(nnodes=nnodes, nprocs=nprocs,
walltime=walltime,
job_bin=bin_sub, mem=mem)
run_cal(turn_knobs, qadapter, job_cmd, job_dir,
name, incar=incar, kpoints=kpoints)
return [name+'.json']
def step2():
"""
read in the realxed bulk substrates and relaxed 2d,
create substrate slab,
get aligned substrates and 2d,
relax the aligned structures seperatly(only ionic positions, ISIF=2)
- input from step1_sub.json and step1_2d.json
- 8(pairs) * 2 = 16 jobs
- returns step2.json
"""
nlayers_2d = 1
nlayers_sub = 2
hkl_sub = [1,1,1]
min_thick = 10.0
min_vac = 18.0
hkl_2d = [0,0,1]
#job directory for the runs
job_dir_sub = 'step2_sub'
job_dir_2d = 'step2_2d'
# isif = 2
incar_sub['ISIF'] = 2
incar_2d['ISIF'] = 2
# kpoints
kpoints_sub = Kpoints.monkhorst_automatic(kpts=(18, 18, 1))
kpoints_2d = Kpoints.monkhorst_automatic(kpts=(18, 18, 1))
# CSL settings for each substrate
alignment_settings = { 'Pt': [120, 0.10, 1, 0.5],
'Ag': [120, 0.10, 1, 0.5],
'Al': [120, 0.10, 1, 0.5],
'Au': [120, 0.10, 1, 0.5],
'Pd': [120, 0.10, 1, 0.5],
'Ir': [120, 0.10, 1, 0.5],
'Cu': [50, 0.06, 1, 0.5],
'Ni': [50, 0.06, 1, 0.5] }
# load in previous jobs
relaxed_sub_jobs = Calibrate.jobs_from_file('step1_sub.json')
relaxed_2d_jobs = Calibrate.jobs_from_file('step1_2d.json')
poscars_sub = []
poscars_2d = []
# create list of all aligned substrate and 2d slabs
for jsub in relaxed_sub_jobs:
jdir = os.path.join(jsub.parent_job_dir, jsub.job_dir)
contcar_file = os.path.join(jdir, 'CONTCAR')
relaxed_struct_sub = Structure.from_file(contcar_file)
# create slab
slab_sub = Interface(relaxed_struct_sub, hkl = hkl_sub,
min_thick = min_thick, min_vac = min_vac,
primitive = False, from_ase = True)
species_sub = ''.join([tos.symbol for tos in slab_sub.types_of_specie])
# loop over 2d
for j2d in relaxed_2d_jobs:
jdir = os.path.join(j2d.parent_job_dir, j2d.job_dir)
contcar_file = os.path.join(jdir, 'CONTCAR')
slab_2d = slab_from_file(hkl_2d, contcar_file)
species_2d = ''.join([tos.symbol for tos in slab_2d.types_of_specie])
# align
slab_sub_aligned, slab_2d_aligned = get_aligned_lattices(
slab_sub,
slab_2d,
*alignment_settings[species_sub])
# aligned sub poscar
sd_flags = CalibrateSlab.set_sd_flags(interface=slab_sub_aligned,
n_layers=nlayers_sub)
poscar = Poscar(slab_sub_aligned, selective_dynamics=sd_flags)
poscar.comment = '_'.join([species_sub,species_2d,'sub'])
poscars_sub.append(poscar)
# aligned 2d slab
sd_flags = CalibrateSlab.set_sd_flags(interface=slab_2d_aligned,
n_layers=nlayers_2d)
poscar = Poscar(slab_2d_aligned, selective_dynamics=sd_flags)
poscar.comment = '_'.join([species_sub,species_2d,'2d'])
poscars_2d.append(poscar)
# setup calibrate and run'em
turn_knobs_sub = OrderedDict(
[
('POSCAR', poscars_sub)
])
turn_knobs_2d = OrderedDict(
[
('POSCAR', poscars_2d)
])
qadapter, job_cmd = get_run_cmmnd(nnodes=nnodes, nprocs=nprocs,
walltime=walltime,
job_bin=bin_sub, mem=mem)
run_cal(turn_knobs_sub, qadapter, job_cmd, job_dir_sub,
'step2_sub', incar=incar_sub, kpoints=kpoints_sub)
run_cal(turn_knobs_2d, qadapter, job_cmd, job_dir_2d,
'step2_2d', incar=incar_2d, kpoints=kpoints_2d)
return ['step2_sub.json', 'step2_2d.json']