def main_func(mpid='',mat=None,parameters={}):
if mpid !='':
json_dat=parameters['json_dat']
data = loadfn(json_dat, cls=MontyDecoder)
for d in data:
mmpid= str(d['mpid'])
if mmpid==mpid:
fin= (d['structure'])
break
strt = fin#mp.get_structure_by_material_id(mpid)
sg_mat = SpacegroupAnalyzer(strt)
mat_cvn = sg_mat.get_conventional_standard_structure()
mat_cvn.sort()
if int(strt.composition._natoms)==int(mat_cvn.composition._natoms):
mat= Poscar(mat_cvn)
else:
mat=Poscar(strt)
mpid=mpid.replace('-','_')
mpid=str('bulk@')+str(mpid)
mat.comment=mpid
main(p=mat,parameters=parameters)
def get_chem_pot(s1=None,s2=None,parameters= {}):
#def get_chem_pot(s1=None,s2=None,parameters= {'pair_style':'eam/alloy','pair_coeff':'/scratch/lfs/kamal/POSMAT/Automatic2/Al03.eam.alloy','atom_style': 'charge' ,'control_file':'/home/kamal/inelast.mod'}):
s1.sort()
s2.sort()
s3=(set(s2)).symmetric_difference(set(s1))#list(set(s1)-set(s2))
#s3=[]
#for el1 in s1:
# for el2 in s2:
# if el1 !=el2 and el1 not in s3:
# s3.append(el1)
# if el1 !=el2 and el2 not in s3:
# s3.append(el2)
#
#from pymatgen.analysis.structure_matcher import StructureMatcher
#print "Mather",StructureMatcher().fit(s1, s2)
print "s3 is ",type(s1),type(s2),s3
uniq=[]
for q in s3:
el=q._species.elements
for j in el:
print "j is ",j
if j not in uniq:
uniq.append(j)
a,b= get_struct_from_mp(j)
p=Poscar(b)
p.comment=str(a)
enp,strt,forces=run_job(mat=p,parameters = parameters)
if len(uniq)>1:
print "uniq problem",uniq
print "uniqqqqqqqqqqqqqqqqqqq=",uniq
return enp
def do_phonons(strt=None, parameters=None, c_size=25):
"""
Setting up phonopy job using LAMMPS
Args:
strt: Structure object
parameters: LAMMPS input file parameters
c_size: cell-size
"""
p = get_phonopy_atoms(mat=strt)
bulk = p
dim1 = int((float(c_size) / float(max(abs(strt.lattice.matrix[0]))))) + 1
dim2 = int(float(c_size) / float(max(abs(strt.lattice.matrix[1])))) + 1
dim3 = int(float(c_size) / float(max(abs(strt.lattice.matrix[2])))) + 1
Poscar(strt).write_file("POSCAR")
tmp = strt.copy()
tmp.make_supercell([dim1, dim2, dim3])
Poscar(tmp).write_file("POSCAR-Super.vasp")
phonon = Phonopy(bulk, [[dim1, 0, 0], [0, dim2, 0], [0, 0, dim3]]) # ,
print("[Phonopy] Atomic displacements:")
disps = phonon.get_displacements()
for d in disps:
print("[Phonopy]", d[0], d[1:])
supercells = phonon.get_supercells_with_displacements()
# Force calculations by calculator
set_of_forces = []
disp = 0
for scell in supercells:
cell = Atoms(
symbols=scell.get_chemical_symbols(),
scaled_positions=scell.get_scaled_positions(),
cell=scell.get_cell(),
pbc=True,
)
disp = disp + 1
mat = Poscar(AseAtomsAdaptor().get_structure(cell))
mat.comment = str("disp-") + str(disp)
parameters["min"] = "skip"
parameters["control_file"] = "/users/knc6/in.phonon"
# a,b,forces=run_job(mat=mat,parameters={'min':'skip','pair_coeff': '/data/knc6/JARVIS-FF-NEW/ALLOY4/Mishin-Ni-Al-2009.eam.alloy', 'control_file': '/users/knc6/in.phonon', 'pair_style': 'eam/alloy', 'atom_style': 'charge'})
a, b, forces = run_job(mat=mat, parameters=parameters)
print("forces=", forces)
drift_force = forces.sum(axis=0)
print("drift forces=", drift_force)
print("[Phonopy] Drift force:", "%11.5f" * 3 % tuple(drift_force))
# Simple translational invariance
for force in forces:
force -= drift_force / forces.shape[0]
set_of_forces.append(forces)
phonon.produce_force_constants(forces=set_of_forces)
write_FORCE_CONSTANTS(phonon.get_force_constants(), filename="FORCE_CONSTANTS")
print()
print("[Phonopy] Phonon frequencies at Gamma:")
def main(p=None,vac_cal=True,surf_cal=True,phon_cal=True, parameters={}):
#p=Poscar.from_file("POSCAR")
c_size=parameters['c_size']
vac_size=parameters['vac_size']
surf_size=parameters['surf_size']
phon_size=parameters['phon_size']
sg_mat = SpacegroupAnalyzer(p.structure)
mat_cvn = sg_mat.get_conventional_standard_structure()
dim1=int((float(c_size)/float( max(abs(mat_cvn.lattice.matrix[0])))))+1
dim2=int(float(c_size)/float( max(abs(mat_cvn.lattice.matrix[1]))))+1
dim3=int(float(c_size)/float( max(abs(mat_cvn.lattice.matrix[2]))))+1
cellmax=max(dim1,dim2,dim3)
tmp=mat_cvn.copy()
mat_cvn.make_supercell([dim1,dim2,dim3])
#print "dim1 dim2 dim3",dim1,dim2,dim3
#mat_cvn.make_supercell([dim1,dim2,dim3])
mat_pos=Poscar(mat_cvn)
mat_pos.comment=str(p.comment)
#print ('execcccccc',parameters['exec'])
#print mat_pos
#toten,final_str,forces=run_job(mat=mat_pos,parameters = parameters)
#do_phonons(strt=final_str,parameters=parameters)
try:
print ('in elastic calc')
toten,final_str,forces=run_job(mat=mat_pos,parameters = parameters)
print ('done elastic calc')
except:
pass
vac=vac_antisite_def_struct_gen(c_size=vac_size,struct=final_str)
def_list,header_list=def_energy(vac=vac,parameters = parameters)
#print def_list,header_list
try:
if vac_cal==True:
print ('in defect calc')
vac=vac_antisite_def_struct_gen(c_size=vac_size,struct=final_str)
def_list,header_list=def_energy(vac=vac,parameters = parameters)
print ('done defect calc',def_list,header_list)
except:
pass
try:
if surf_cal==True:
print ('in surf calc')
surf=pmg_surfer(mat=final_str, min_slab_size=surf_size,vacuum=25,max_index=3)
surf_list,surf_header_list=surf_energy(surf=surf,parameters = parameters)
print ('done surf calc',surf_list,surf_header_list)
except:
pass
try:
if phon_cal==True:
print ('in phon calc')
cwd=str(os.getcwd())
if not os.path.exists("Phonon"):
os.mkdir("Phonon")
os.chdir("Phonon")
do_phonons(strt=final_str,parameters=parameters)
print ('done phon calc')
os.chdir(cwd)
except:
pass
def main_func(mpid='',mat=None,parameters={}):
if mpid !='':
with MPRester() as mp:
strt = mp.get_structure_by_material_id(mpid)
mat=Poscar(strt)
mpid=mpid.replace('-','_')
mpid=str('bulk@')+str(mpid)
mat.comment=mpid
main(p=mat,parameters=parameters)
def do_phonons(strt=None,parameters=None):
p= get_phonopy_atoms(mat=strt)
bulk =p
c_size=parameters['phon_size']
dim1=int((float(c_size)/float( max(abs(strt.lattice.matrix[0])))))+1
dim2=int(float(c_size)/float( max(abs(strt.lattice.matrix[1]))))+1
dim3=int(float(c_size)/float( max(abs(strt.lattice.matrix[2]))))+1
Poscar(strt).write_file("POSCAR")
tmp=strt.copy()
tmp.make_supercell([dim1,dim2,dim3])
Poscar(tmp).write_file("POSCAR-Super.vasp")
print ('supercells',dim1,dim2,dim3)
phonon = Phonopy(bulk,[[dim1,0,0],[0,dim2,0],[0,0,dim3]])
print ("[Phonopy] Atomic displacements:")
disps = phonon.get_displacements()
for d in disps:
print ("[Phonopy]", d[0], d[1:])
supercells = phonon.get_supercells_with_displacements()
# Force calculations by calculator
set_of_forces = []
disp=0
for scell in supercells:
cell = Atoms(symbols=scell.get_chemical_symbols(),
scaled_positions=scell.get_scaled_positions(),
cell=scell.get_cell(),
pbc=True)
disp=disp+1
mat = Poscar(AseAtomsAdaptor().get_structure(cell))
mat.comment=str("disp-")+str(disp)
parameters['min']='skip'
parameters['control_file']= parameters['phonon_control_file'] #'/users/knc6/in.phonon'
#a,b,forces=run_job(mat=mat,parameters={'min':'skip','pair_coeff': '/data/knc6/JARVIS-FF-NEW/ALLOY4/Mishin-Ni-Al-2009.eam.alloy', 'control_file': '/users/knc6/in.phonon', 'pair_style': 'eam/alloy', 'atom_style': 'charge'})
a,b,forces=run_job(mat=mat,parameters=parameters)
#print "forces=",forces
drift_force = forces.sum(axis=0)
#print "drift forces=",drift_force
#print "[Phonopy] Drift force:", "%11.5f"*3 % tuple(drift_force)
# Simple translational invariance
for force in forces:
force -= drift_force / forces.shape[0]
set_of_forces.append(forces)
phonon.produce_force_constants(forces=set_of_forces)
write_FORCE_CONSTANTS(phonon.get_force_constants(),
filename="FORCE_CONSTANTS")
#print
#print "[Phonopy] Phonon frequencies at Gamma:"
for i, freq in enumerate(phonon.get_frequencies((0, 0, 0))):
print ("[Phonopy] %3d: %10.5f THz" % (i + 1, freq)) # THz
def main_func(mpid="", mat=None, parameters={}):
"""
Call master job function either using mpid or Poscar object
"""
if mpid != "":
with MPRester() as mp:
strt = mp.get_structure_by_material_id(mpid)
mat = Poscar(strt)
mpid = mpid.replace("-", "_")
mpid = str("bulk@") + str(mpid)
mat.comment = mpid
main(p=mat, parameters=parameters)
def make_big(poscar=None,size=11.0):
"""
Helper function to make supercell
Args:
poscar: Poscar object
size: simulation size in Angstrom
Returns:
big: Poscar supercell object
"""
struct=poscar.structure
comm=poscar.comment
a, b, c = struct.lattice.abc
struct.make_supercell([int(float(size)/float(a))+1,int(float(size)/float(b))+1,int(float(size)/float(c))+1])
big=Poscar(struct)
big.comment=str(comm)
return big
def main_func(mpid='', jid='', mat=None, enforc_cvn=False):
"""
Main function to carry out property calculations
Args:
mpid: materialsproject id
jid: jarvis-dft id
mat: Poscar object
enforc_cvn: whether or not enforce conventional cell input structure
Returns:
en: final energy
final: final structure
"""
if mpid != '' or jid != '':
data = loadfn(json_dat, cls=MontyDecoder)
for d in data:
mmpid = str(d['mpid'])
jjid = str(d['mpid'])
if mmpid == mpid:
fin = (d['structure'])
break
if jjpid == jid:
fin = (d['structure'])
break
strt = fin
sg_mat = SpacegroupAnalyzer(strt)
mat_cvn = sg_mat.get_conventional_standard_structure()
mat_cvn.sort()
if int(strt.composition._natoms) == int(
mat_cvn.composition._natoms) and enforc_cvn == True:
mat = Poscar(mat_cvn)
else:
mat = Poscar(strt)
mpid = mpid.replace('-', '_')
mpid = str('bulk@') + str(mpid)
mat.comment = mpid
en, final = smart_converge(mat=mat)
print(en, final)
def get_chem_pot(s1=None,s2=None,parameters= {}):
#def get_chem_pot(s1=None,s2=None,parameters= {'pair_style':'eam/alloy','pair_coeff':'/scratch/lfs/kamal/POSMAT/Automatic2/Al03.eam.alloy','atom_style': 'charge' ,'control_file':'/home/kamal/inelast.mod'}):
s1.sort()
s2.sort()
s3=(set(s2)).symmetric_difference(set(s1))#list(set(s1)-set(s2))
uniq=[]
for q in s3:
el=q._species.elements
for j in el:
j=str(j.symbol)
if j not in uniq:
uniq.append(j)
a,b= get_struct_from_mp(j)
p=Poscar(b)
p.comment=str(a)
enp,strt,forces=run_job(mat=p,parameters = parameters)
if len(uniq)>1:
print ("uniq problem",uniq)
print ("uniq=",uniq)
return enp
def get_chem_pot(s1=None, s2=None, parameters={}):
"""
Get chemical potential given perfect and defect structures
Args:
s1: perfect Structure object
s2: defect Structure object
parameters: LAMMPS input parameter
Returns:
enp: energy per atom
"""
# def get_chem_pot(s1=None,s2=None,parameters= {'pair_style':'eam/alloy','pair_coeff':'/scratch/lfs/kamal/POSMAT/Automatic2/Al03.eam.alloy','atom_style': 'charge' ,'control_file':'/home/kamal/inelast.mod'}):
s1.sort()
s2.sort()
s3 = (set(s2)).symmetric_difference(set(s1)) # list(set(s1)-set(s2))
# s3=[]
# for el1 in s1:
# for el2 in s2:
# if el1 !=el2 and el1 not in s3:
# s3.append(el1)
# if el1 !=el2 and el2 not in s3:
# s3.append(el2)
#
# from pymatgen.analysis.structure_matcher import StructureMatcher
# print "Mather",StructureMatcher().fit(s1, s2)
print("s3 is ", type(s1), type(s2), s3)
uniq = []
for q in s3:
el = q._species.elements
for j in el:
print("j is ", j)
if j not in uniq:
uniq.append(j)
a, b = chempot_struct(j.symbol)
# a, b = get_struct_from_jv(j)
p = Poscar(b)
p.comment = str(a)
enp, strt, forces = run_job(mat=p, parameters=parameters)
if len(uniq) > 1:
print("uniq problem", uniq)
return enp
bg_arr.append(bg)
tm_arr.append(tm)
ucf_arr.append(ucf)
ehull_arr.append(ehull)
comment = str("bulk@") + str(x)
folder2 = str(
os.getcwd()) + str("/") + str(comment) + str("_fold")
if not os.path.exists(folder2):
os.makedirs(str(folder2))
print("folder2=", folder2)
cwd2 = str(os.getcwd())
os.chdir(str(folder2))
p = Poscar(structure)
p.comment = comment
p.write_file("POSCAR")
poscar_file = str(os.getcwd()) + str("/POSCAR")
pair_coeff = str(cwd1) + str("/") + str(file)
# pair_coeff=str('/data/knc6/JARVIS-FF-NEW/ALLOY')+str("/")+str(file)
parameters = {
"pair_style": "eam/fs",
"pair_coeff": pair_coeff,
"atom_style": "charge",
"control_file": "/users/knc6/inelast.mod",
}
main_file = open("setup.py", "w")
line = str("from NEW_LAMMPS10 import main_func") + "\n"
main_file.write(line)
line = str(
def main_alloy():
"""
Run alloy FFs job
"""
for file in glob.glob("*.alloy"):
try:
folder1 = str(os.getcwd()) + str("/") + str(file) + str("_nist")
if not os.path.exists(folder1):
os.makedirs(str(folder1))
cwd1 = str(os.getcwd())
print("folder1=", folder1)
ff = str(file)
element_ff = []
f = open(ff, "r")
os.chdir(str(folder1))
list_el = []
lines = f.readlines()
content = (lines[3]).split(" ")
# content=(lines[3]).split("' '|\n|\r\n")
for val in content:
if val != "" and val != "\n" and val != "\r\n":
list_el.append(val)
for i in range(0, len(list_el)):
if i != 0:
element_ff.append(list_el[i])
# print ff,' ',element_ff
with MPRester(MAPI_KEY) as m:
data = m.get_entries_in_chemsys(
element_ff,
inc_structure="final",
property_data=[
"unit_cell_formula",
"material_id",
"icsd_id",
"spacegroup",
"energy_per_atom",
"formation_energy_per_atom",
"pretty_formula",
"band_gap",
"total_magnetization",
"e_above_hull",
],
)
if len(element_ff) > 1:
try:
entries = m.get_entries_in_chemsys(element_ff)
pd = PhaseDiagram(entries)
plotter = PDPlotter(pd, show_unstable=True)
image = str(ff) + str("_DFT") + str(".jpg")
plotter.write_image(image)
except:
pass
structures = []
structures_cvn = []
icsd_arr = []
mp_arr = []
sg_arr = []
enp_arr = []
fenp_arr = []
pf_arr = []
ucf_arr = []
bg_arr = []
tm_arr = []
ehull_arr = []
for d in data:
x = d.data["material_id"]
sg = d.data["spacegroup"]
enp = d.data["energy_per_atom"]
fenp = d.data["formation_energy_per_atom"]
pf = d.data["pretty_formula"]
ucf = d.data["unit_cell_formula"]
bg = d.data["band_gap"]
tm = d.data["total_magnetization"]
ehull = d.data["e_above_hull"]
icsd = d.data["icsd_id"]
structure = m.get_structure_by_material_id(x)
structures.append(structure)
icsd_arr.append(icsd)
mp_arr.append(x)
sg_arr.append(sg)
enp_arr.append(enp)
fenp_arr.append(fenp)
pf_arr.append(pf)
bg_arr.append(bg)
tm_arr.append(tm)
ucf_arr.append(ucf)
ehull_arr.append(ehull)
comment = str("bulk@") + str(x)
folder2 = str(os.getcwd()) + str("/") + str(comment) + str("_fold")
if not os.path.exists(folder2):
os.makedirs(str(folder2))
print("folder2=", folder2)
cwd2 = str(os.getcwd())
os.chdir(str(folder2))
p = Poscar(structure)
p.comment = comment
p.write_file("POSCAR")
poscar_file = str(os.getcwd()) + str("/POSCAR")
pair_coeff = str(cwd1) + str("/") + str(file)
# pair_coeff=str('/data/knc6/JARVIS-FF-NEW/ALLOY')+str("/")+str(file)
parameters = {
"pair_style": "eam/alloy",
"exec": lammps_exec,
"pair_coeff": pair_coeff,
"atom_style": "charge",
"control_file": input_box,
}
main_file = open("setup.py", "w")
line = str("from jlammps import main_func") + "\n"
main_file.write(line)
line = str("from pymatgen.io.vasp.inputs import Poscar") + "\n"
main_file.write(line)
# line=str("try:")+'\n'
# main_file.write(line)
line = (
str("p=Poscar.from_file(")
+ str('"')
+ str(poscar_file)
+ str('"')
+ str(")")
+ "\n"
)
main_file.write(line)
line = (
str("main_func(mat=p")
+ str(",")
+ str("parameters=")
+ str(parameters)
+ str(")")
+ "\n"
)
main_file.write(line)
# line=str("except:")+'\n'
# main_file.write(line)
# line=str(" pass")+'\n'
# main_file.write(line)
main_file.close()
# try:
# p=Poscar.from_file(poscar_file)
# main_func(mat=p,parameters=parameters)
# except:
# pass
os.chdir(cwd2) # =str(os.getcwd())
os.chdir(cwd1) # =str(os.getcwd())
except:
pass
def main(p=None, parameters={}, c_size=35):
"""
Master function to run LAMMPS job
Args:
p: Poscar object
parameters: LAMMPS input parameters
c_size:cell size
"""
# p=Poscar.from_file("POSCAR")
c_size = 35
sg_mat = SpacegroupAnalyzer(p.structure)
mat_cvn = sg_mat.get_conventional_standard_structure()
dim1 = int((float(c_size) / float(max(abs(mat_cvn.lattice.matrix[0]))))) + 1
dim2 = int(float(c_size) / float(max(abs(mat_cvn.lattice.matrix[1])))) + 1
dim3 = int(float(c_size) / float(max(abs(mat_cvn.lattice.matrix[2])))) + 1
cellmax = max(dim1, dim2, dim3)
# print "dim1 dim2 dim3",dim1,dim2,dim3
# mat_cvn.make_supercell([dim1,dim2,dim3])
mat_pos = Poscar(mat_cvn)
mat_pos.comment = str(p.comment)
print(mat_pos)
try:
toten, final_str, forces = run_job(mat=mat_pos, parameters=parameters)
except:
pass
print("p.comment issssss", p.comment)
vac = vac_antisite_def_struct_gen(c_size=c_size, struct=final_str)
def_list, header_list = def_energy(vac=vac, parameters=parameters)
print(def_list, header_list)
try:
print("p.comment issssss", p.comment)
vac = vac_antisite_def_struct_gen(c_size=c_size, struct=final_str)
def_list, header_list = def_energy(vac=vac, parameters=parameters)
print(def_list, header_list)
except:
pass
try:
surf = pmg_surfer(mat=final_str, min_slab_size=35, vacuum=35, max_index=3)
surf_list, surf_header_list = surf_energy(surf=surf, parameters=parameters)
print(surf_list, surf_header_list)
except:
pass
try:
cwd = str(os.getcwd())
if not os.path.exists("Phonon"):
os.mkdir("Phonon")
os.chdir("Phonon")
do_phonons(strt=final_str, parameters=parameters)
os.chdir(cwd)
except:
pass
sub_files = []
calc = 0
for a in glob.glob("*.json"):
fold = a.split(".json")[0]
cwd = os.getcwd()
target_file = str(cwd) + str("/") + str(fold)
dest_file = str(cwd) + str("/") + str(fold) + str(".zip")
sub_files.append(dest_file)
ZipDir(
target_file,
dest_file,
contents=[
"init.mod",
"potential.mod",
"in.elastic",
"data",
"log.lammps",
"restart.equil",
"data0",
],
)
calc = calc + 1
target_file = str(cwd)
dest_file = str(cwd) + str("/") + str("Calc-") + str(calc) + str(".zip")
ZipDir(target_file, dest_file, contents=sub_files)
for a in glob.glob("*.json"):
fold = a.split(".json")[0]
cwd = os.getcwd()
dest_file = str(cwd) + str("/") + str(fold) + str(".zip")
line = str("rm ") + str(dest_file)
os.system(line)
from jarvis.vasp.joptb88vdw import smart_converge
from pymatgen.io.vasp.inputs import Poscar
from pymatgen.core.structure import Structure
import os, time
s = Structure.from_file('POSCAR')
p = Poscar(s)
p.comment = 'bulk@ATAT'
en, final = smart_converge(mat=p, elast_prop=False)
print "en,finel", en, final
def smart_converge(mat=None,encut='',leng='',band_str=True,elast_prop=True,optical_prop=True,mbj_prop=True,spin_orb=False,phonon=False,surf_en=False,def_en=False):
"""
Main function to converge k-points/cut-off
optimize structure, and run subsequent property calculations
Args:
mat: Poscar object with structure information
encut: if '' then automataic convergence, else use defined fixed-cutoff
leng: if '' then automataic convergence, else use defined fixed-line density
band_str: if True then do band-structure calculations along high-symmetry points
elast_prop: if True then do elastic property calculations using finite-difference
optical_prop: if True do frequency dependent dielectric function calculations using he independent-particle (IP) approximation
mbj_prop: if True do METAGGA-TBmBJ optical property calculations with IP approximation
spin_orb: if True do spin-orbit calculations
phonon: if True do phonon calculations using DFPT
surf_en: if True do surface enrgy calculations
def_en: if True do defect enrgy calculations
Returns:
en2: final energy
mat_f: final structure
"""
if encut=="":
encut=converg_encut(encut=500,mat=mat)
if leng=="":
leng= converg_kpoints(length=0,mat=mat)
kpoints=Auto_Kpoints(mat=mat,length=leng)
isif=2
commen=str(mat.comment)
lcharg='.FALSE.'
if commen.split('@')[0] =='bulk' :
isif=3
lcharg='.TRUE.'
if commen.split('@')[0] == 'sbulk':
isif=3
incar_dict = use_incar_dict
incar_dict.update({"ENCUT":encut,"EDIFFG":-1E-3,"ISIF":3,"NEDOS":5000,"NSW":500,"NELM":500,"LORBIT":11,"LVTOT":'.TRUE.',"LVHAR":'.TRUE.',"ISPIN":2,"LCHARG":'.TRUE.'})
incar = Incar.from_dict(incar_dict)
try:
if mat.comment.startswith('Mol'):
incar.update({"ISIF": '2'})
except:
print ("Mol error")
pass
#if commen.startswith('Surf-') :
# pol=check_polar(mat_f.structure)
# if pol==True:
# ase_atoms = AseAtomsAdaptor().get_atoms(mat_f.structure)
# COM=ase_atoms.get_center_of_mass(scaled=True)
# incar.update({"LDIPOL": '.TRUE.',"IDIPOL":4,"ISYM": 0,"DIPOL":COM})
print ("running smart_converge for",str(mat.comment)+str('-')+str('MAIN-RELAX'))
cwd=str(os.getcwd())
en2,contc=run_job(mat=mat,incar=incar,kpoints=kpoints,jobname=str('MAIN-RELAX')+str('-')+str(mat.comment))
os.chdir(cwd)
path=str(contc.split('/CONTCAR')[0])+str('/vasprun.xml')
v=open(path,"r").readlines()
for line in v:
if "NBANDS" in line:
nbands=int(line.split(">")[1].split("<")[0])
print ("nbands=",nbands)
break
strt=Structure.from_file(contc)
mat_f=Poscar(strt)
mat_f.comment=str(mat.comment)
if band_str==True:
incar_dict = use_incar_dict
incar_dict.update({"ISPIN":2,"NEDOS":5000,"LORBIT":11,"IBRION":1,"ENCUT":encut,"NBANDS":int(nbands)+10})
incar = Incar.from_dict(incar_dict)
kpath = HighSymmKpath(mat_f.structure)
frac_k_points, k_points_labels = kpath.get_kpoints(line_density=20,coords_are_cartesian=False)
kpoints = Kpoints(comment="Non SCF run along symmetry lines",style=Kpoints.supported_modes.Reciprocal,num_kpts=len(frac_k_points),kpts=frac_k_points, labels=k_points_labels,kpts_weights=[1] * len(frac_k_points))
try:
print ("running MAIN-BAND")
kpoints=mpvis.get_kpoints(mat_f.structure)
en2B,contcB=run_job(mat=mat_f,incar=incar,kpoints=kpoints,jobname=str('MAIN-BAND')+str('-')+str(mat_f.comment))
# kpoints=mpvis.get_kpoints(mat_f.structure)
# en2B,contcB=run_job(mat=mat_f,incar=incar,kpoints=kpoints,jobname=str('MAIN-BAND')+str('-')+str(mat_f.comment))
except:
print ("No band str calc.")
if str(os.getcwd)!=cwd:
print ("Changing directory")
line=str("cd ")+str(cwd)
os.chdir(cwd)
print (os.getcwd())
pass
os.chdir(cwd)
if surf_en==True:
incar_dict = use_incar_dict
incar_dict.update({"ENCUT":encut,"NEDOS":5000,"IBRION":1,"NSW":500,"LORBIT":11})
incar = Incar.from_dict(incar_dict)
surf=surfer(mat=mat_f.structure,layers=3)
for i in surf:
try:
print ("running MAIN-BAND")
#NSCF
#chg_file=str(contc).replace('CONTCAR','CHGCAR')
#print ('chrfile',chg_file)
#shutil.copy2(chg_file,'./')
kpoints=Auto_Kpoints(mat=i,length=leng)
en2s,contcs=run_job(mat=i,incar=incar,kpoints=kpoints,jobname=str('Surf_en-')+str(i.comment)+str('-')+str(mat_f.comment))
#kpoints=mpvis.get_kpoints(mat_f.structure)
#en2B,contcB=run_job(mat=mat_f,incar=incar,kpoints=kpoints,jobname=str('MAIN-BAND')+str('-')+str(mat_f.comment))
except:
pass
os.chdir(cwd)
if def_en==True:
incar_dict = use_incar_dict
incar_dict.update({"ENCUT":encut,"NEDOS":5000,"IBRION":1,"NSW":500,"LORBIT":11})
incar = Incar.from_dict(incar_dict)
#surf=surfer(mat=mat_f.structure,layers=3)
vac=vac_antisite_def_struct_gen(cellmax=3,struct=mat_f.structure)
for i in vac:
try:
print ("running MAIN-vac")
kpoints=Auto_Kpoints(mat=i,length=leng)
en2d,contcd=run_job(mat=i,incar=incar,kpoints=kpoints,jobname=str('Def_en-')+str(i.comment)+str('-')+str(mat_f.comment))
# kpoints=mpvis.get_kpoints(mat_f.structure)
# en2B,contcB=run_job(mat=mat_f,incar=incar,kpoints=kpoints,jobname=str('MAIN-BAND')+str('-')+str(mat_f.comment))
except:
pass
os.chdir(cwd)
#surf=surfer(mat=strt,layers=layers)
#surf=surfer(mat=strt,layers=layers)
if spin_orb==True:
#chg_file=str(contc).replace('CONTCAR','CHGCAR')
#print ('chrfile',chg_file)
#shutil.copy2(chg_file,'./')
incar_dict = use_incar_dict
incar_dict.update({"ENCUT":encut,"NPAR":ncores,"GGA_COMPAT":'.FALSE.',"LSORBIT":'.TRUE.',"IBRION":1,"ISYM":0,"NEDOS":5000,"IBRION":1,"NSW":500,"LORBIT":11})
incar = Incar.from_dict(incar_dict)
sg_mat = SpacegroupAnalyzer(mat_f.structure)
mat_cvn = sg_mat.get_conventional_standard_structure()
mat_cvn.sort()
kpoints=Auto_Kpoints(mat=Poscar(mat_cvn),length=leng/2)
try:
en2S,contcS=run_job(mat=Poscar(mat_cvn),incar=incar,kpoints=kpoints,jobname=str('MAIN-SOC')+str('-')+str(mat_f.comment))
except:
pass
os.chdir(cwd)
if optical_prop==True:
incar_dict = use_incar_dict
incar_dict.update({"NEDOS":5000,"LORBIT":11,"IBRION":1,"ENCUT":encut,"NBANDS":3*int(nbands),"LOPTICS":'.TRUE.'})
incar = Incar.from_dict(incar_dict)
kpoints=Auto_Kpoints(mat=mat_f,length=leng)
try:
en2OP,contcOP=run_job(mat=mat_f,incar=incar,kpoints=kpoints,jobname=str('MAIN-OPTICS')+str('-')+str(mat_f.comment))
except:
pass
os.chdir(cwd)
if mbj_prop==True:
incar_dict = use_incar_dict
incar_dict.update({"NEDOS":5000,"LORBIT":11,"IBRION":1,"ENCUT":encut,"NBANDS":3*int(nbands),"LOPTICS":'.TRUE.','METAGGA':'MBJ','ISYM':0,"SIGMA":0.1})
incar = Incar.from_dict(incar_dict)
kpoints=Auto_Kpoints(mat=mat_f,length=leng)
try:
en2OP,contcOP=run_job(mat=mat_f,incar=incar,kpoints=kpoints,jobname=str('MAIN-MBJ')+str('-')+str(mat_f.comment))
except:
pass
os.chdir(cwd)
if elast_prop==True:
incar_dict = use_incar_dict
incar_dict.update({"NEDOS":5000,"IBRION":6,"ENCUT":1.3*float(encut),"ISIF":3,"POTIM":0.015,"NPAR":ncores,"ISPIN":2})
incar = Incar.from_dict(incar_dict)
sg_mat = SpacegroupAnalyzer(mat_f.structure)
mat_cvn = sg_mat.get_conventional_standard_structure()
mat_cvn.sort()
kpoints=Auto_Kpoints(mat=Poscar(mat_cvn),length=leng)
try:
en2E,contcE=run_job(mat=Poscar(mat_cvn),incar=incar,kpoints=kpoints,jobname=str('MAIN-ELASTIC')+str('-')+str(mat_f.comment))
except:
pass
os.chdir(cwd)
if phonon==True:
incar_dict = use_incar_dict
incar_dict.update({"IBRION":8,"ENCUT":float(encut),"ISYM":0,"ADDGRID":'.TRUE.','EDIFF': 1e-09,'LORBIT': 11})
incar = Incar.from_dict(incar_dict)
kpoints=Auto_Kpoints(mat=mat_f,length=leng)
mat_pho=make_big(poscar=mat_f,size=11.0)
try:
en2P,contcP=run_job(mat=mat_pho,incar=incar,kpoints=kpoints,jobname=str('MAIN-PHO8')+str('-')+str(mat_f.comment))
except:
pass
os.chdir(cwd)
#if Raman_calc==True:
# Raman(strt=mat_f,encut=encut,length=leng)
os.chdir(cwd)
return en2,mat_f
dim1 = int((float(c_size) / float(max(abs(mat_cvn.lattice.matrix[0]))))) + 1
dim2 = int(float(c_size) / float(max(abs(mat_cvn.lattice.matrix[1])))) + 1
dim3 = int(float(c_size) / float(max(abs(mat_cvn.lattice.matrix[2])))) + 1
p.make_supercell([dim1, dim2, dim3])
write_lammps_data(p, file='dat.dat') #can be visulaized using Ovito
"""
Step-2: writing LAMMPS input file
Adjust parameters according to LAMMPS executable, force-field file, main input file that you'll be using, pair style and atom style
"""
parameters = {
'exec': 'mpirun /cluster/bin/lmp_ctcms-14439-knc6 <in.elastic >out',
'pair_coeff':
'/users/knc6/Software/jarvis/jarvis/lammps/examples/Mishin-Ni-Al-2009.eam.alloy',
'control_file': '/users/knc6/inelast.mod',
'pair_style': 'eam/alloy',
'atom_style': 'charge',
'cluster': 'pbs'
}
write_lammps_in(structure=p,
lammps_in="init.mod",
lammps_in1="potential.mod",
lammps_in2="in.elastic",
parameters=parameters)
"""
Step-3
If you survive the above two steps, lets submit job to computer-cluster
"""
pos = Poscar(p)
pos.comment = 'bulk@Al'
main_func(mat=pos, parameters=parameters)
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']
from jarvis.vasp.joptb88vdw import smart_converge
from pymatgen.io.vasp.inputs import Poscar
from pymatgen.core.structure import Structure
import os, time
s = Structure.from_file("POSCAR")
p = Poscar(s)
p.comment = "bulk@ATAT"
en, final = smart_converge(mat=p, elast_prop=False)
print("en,finel", en, final)
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']
