def test_continue(self):
# Test the continuation functionality
with cd(os.path.join(test_dir, 'postprocess')):
# Test default functionality
with ScratchDir('.', copy_from_current_on_enter=True) as d:
v = VaspJob("hello", auto_continue=True)
v.setup()
self.assertTrue(os.path.exists("continue.json"), "continue.json not created")
v.setup()
self.assertEqual(Poscar.from_file("CONTCAR").structure,
Poscar.from_file("POSCAR").structure)
self.assertEqual(Incar.from_file('INCAR')['ISTART'], 1)
v.postprocess()
self.assertFalse(os.path.exists("continue.json"),
"continue.json not deleted after postprocessing")
# Test explicit action functionality
with ScratchDir('.', copy_from_current_on_enter=True) as d:
v = VaspJob("hello", auto_continue=[{"dict": "INCAR",
"action": {"_set": {"ISTART": 1}}}])
v.setup()
v.setup()
self.assertNotEqual(Poscar.from_file("CONTCAR").structure,
Poscar.from_file("POSCAR").structure)
self.assertEqual(Incar.from_file('INCAR')['ISTART'], 1)
v.postprocess()
def _verify_inputs(self):
"""Validation of input files under user NEB directory."""
user_incar = Incar.from_file(os.path.join(self.user_dir, "INCAR"))
ref_incar = Incar.from_file(os.path.join(self.ref_dir_input, "INCAR"))
# Check INCAR
params_to_check = self.get("params_to_check", [])
defaults = {"ICHAIN": 0, "LCLIMB": True}
for p in params_to_check:
if user_incar.get(p, defaults.get(p)) != ref_incar.get(p, defaults.get(p)):
raise ValueError("INCAR value of {} is inconsistent!".format(p))
# Check KPOINTS
user_kpoints = Kpoints.from_file(os.path.join(self.user_dir, "KPOINTS"))
ref_kpoints = Kpoints.from_file(os.path.join(self.ref_dir_input, "KPOINTS"))
if user_kpoints.style != ref_kpoints.style or user_kpoints.num_kpts != ref_kpoints.num_kpts:
raise ValueError("KPOINT files are inconsistent! "
"Paths are:\n{}\n{} with kpts = {} {}".format(
self.user_dir, self.ref_dir_input, user_kpoints, ref_kpoints))
# Check POTCAR
user_potcar = Potcar.from_file(os.path.join(self.user_dir, "POTCAR"))
ref_potcar = Potcar.from_file(os.path.join(self.ref_dir_input, "POTCAR"))
if user_potcar.symbols != ref_potcar.symbols:
raise ValueError("POTCAR files are inconsistent! "
"Paths are:\n{}\n{}".format(self.user_dir, self.ref_dir_input))
# Check POSCARs
for u, r in zip(self.user_sdir, self.ref_sdir_input):
user_poscar = Poscar.from_file(os.path.join(u, "POSCAR"))
ref_poscar = Poscar.from_file(os.path.join(r, "POSCAR"))
if user_poscar.natoms != ref_poscar.natoms or \
user_poscar.site_symbols != ref_poscar.site_symbols:
raise ValueError("POSCAR files are inconsistent! Paths are:\n{}\n{}".format(u, r))
def poscar(self):
""" generating poscar for relaxation calculations """
print(
'--------------------------------------------------------------------------------------------------------'
)
print("Generation of VASP files for the cell relaxation:")
print(
'--------------------------------------------------------------------------------------------------------'
)
self.symData.structure = Structure.from_file(self.args.pos[0])
sym1 = float(self.args.sympre[0])
sym2 = float(self.args.symang[0])
aa = SpacegroupAnalyzer(self.symData.structure,
symprec=sym1,
angle_tolerance=sym2)
self.symData.space_group = aa.get_space_group_number()
print("Space group number =", self.symData.space_group)
spg = aa.get_space_group_symbol()
print("Space group symbol =", str(spg))
self.symData.number_of_species = len(self.symData.structure.species)
print("Number of atoms = {}".format(len(
self.symData.structure.species)))
pos_name = "POSCAR"
structure00 = Poscar(self.symData.structure)
structure00.write_file(filename=pos_name, significant_figures=16)
return self.symData
def write_to_file(invars, collect_structures):
f = open("{}/ORDERING_OUTPUT.txt".format(invars.run_dir), 'a')
f.write("Writing new structures to disk\n")
f.write("-------------------------------------------------------------------------------------\n\n")
f.close()
for entry in collect_structures:
f = open("{}/ORDERING_OUTPUT.txt".format(invars.run_dir), 'a')
folder_name = "space_group-No-{}".format(entry)
if os.path.isdir('{}/{}'.format(invars.run_dir, folder_name)):
f.write("{} directory is already present\n".format(folder_name))
f.write("Going in to look for files\n")
current_dir = '{}/{}'.format(invars.run_dir, folder_name)
else:
f.write("Creating {} directory\n".format(folder_name))
os.mkdir(folder_name)
current_dir = "{}/{}".format(invars.run_dir, folder_name)
f.close()
for i, new_strt in enumerate(collect_structures[entry]):
str_name = "{}-str-{}.vasp".format(folder_name, (i+1))
if os.path.isfile("{}/{}".format(current_dir, str_name)):
f = open("{}/ORDERING_OUTPUT.txt".format(invars.run_dir), 'a')
f.write("{} file is already present\n".format(str_name))
f.close()
pass
else:
w = Poscar(new_strt)
w.write_file("{}/{}".format(current_dir, str_name))
if invars.calc_distort == '.FASLE.':
pass
elif invars.calc_distort == '.TRUE.' \
and os.path.isdir('{}/distortions-str-{}'.format(current_dir, (i+1))) is False:
f = open("{}/ORDERING_OUTPUT.txt".format(invars.run_dir), 'a')
f.write("Evaluating distortions for {}\n".format(str_name))
f.write("-------------------------------------------------------------------------------------\n")
f.write('creating distortions-{} directory\n\n'.format(i+1))
os.mkdir('{}/distortions-str-{}'.format(current_dir,(i+1)))
dist_dir = '{}/distortions-str-{}'.format(current_dir,(i+1))
f.close()
#print distortion_files
match_atoms(new_strt, invars, dist_dir)
elif invars.calc_distort == '.TRUE.' \
and os.path.isdir('{}/distortions-str-{}'.format(current_dir, (i+1))) is True:
f = open("{}/ORDERING_OUTPUT.txt".format(invars.run_dir), 'a')
f.write('distortions-str-{} directory already present\nGoing in...\n\n'.format(i+1))
dist_dir = '{}/distortions-str-{}'.format(current_dir, (i+1))
f.close()
match_atoms(new_strt, invars, dist_dir)
def test_run_scale(self):
#raise SkipTest
ingdir = "%s/writedir/single_label1" % testdir
recipedir = "%s/writedir" % testdir
topmetad = MASTFile("files/top_metadata_single")
topmetad.data.append("origin_dir = %s/files\n" %
testdir) #give origin directory
topmetad.to_file("writedir/metadata.txt")
metad = MASTFile("files/metadata_single")
metad.data.append("defect_label = label1\n")
metad.data.append("scaling_size = [2,2,2]\n")
metad.to_file("%s/metadata.txt" % ingdir)
kdict = dict()
kdict['mast_program'] = 'vasp'
my_structure = Poscar.from_file("files/POSCAR_perfect").structure
myperf = MASTFile("files/POSCAR_perfect")
myperf.to_file("%s/POSCAR" % ingdir)
myri = ChopIngredient(name=ingdir,
program_keys=kdict,
structure=my_structure)
myri.run_scale()
my_scaled = Poscar.from_file("%s/CONTCAR" %
ingdir).structure.get_sorted_structure()
scaled_compare = Poscar.from_file(
"files/POSCAR_scaled").structure.get_sorted_structure()
self.assertEquals(my_scaled, scaled_compare)
def test_image_num(self):
os.path.dirname(os.path.abspath(__file__))
test_file_dir = os.path.join(PymatgenTest.TEST_FILES_DIR,
"path_finder")
start_s = Poscar.from_file(os.path.join(test_file_dir,
"LFP_POSCAR_s")).structure
end_s = Poscar.from_file(os.path.join(test_file_dir,
"LFP_POSCAR_e")).structure
chg = Chgcar.from_file(os.path.join(test_file_dir, "LFP_CHGCAR.gz"))
moving_cation_specie = Element("Li")
relax_sites = []
for site_i, site in enumerate(start_s.sites):
if site.specie == moving_cation_specie:
relax_sites.append(site_i)
pf = NEBPathfinder(
start_s,
end_s,
relax_sites=relax_sites,
v=ChgcarPotential(chg).get_v(),
n_images=(8 * 3),
)
images = []
for i, image in enumerate(pf.images):
if i % 3 == 0:
images.append(image)
self.assertEqual(len(images), 9)
moving_site = relax_sites[0]
dists = [
s1.sites[moving_site].distance(s2.sites[moving_site])
for s1, s2 in zip(pf.images[:-1], pf.images[1:])
]
# check that all the small distances are about equal
self.assertTrue(abs(min(dists) - max(dists)) / mean(dists) < 0.02)
def vac_antisite_def_struct_gen(c_size=15,
mpid="",
struct=None,
write_file=True):
"""
Vacancy, antisite generator
Args:
c_size: cell size
struct: Structure object or
mpid: materials project id
Returns:
def_str: defect structures in Poscar object format
"""
def_str = []
if struct == None:
with MPRester() as mp:
struct = mp.get_structure_by_material_id(mpid)
if mpid == "":
print("Provide structure")
c_size = c_size
prim_struct_sites = len(struct.sites)
struct = SpacegroupAnalyzer(struct).get_conventional_standard_structure()
dim1 = int((float(c_size) / float(max(abs(struct.lattice.matrix[0]))))) + 1
dim2 = int(float(c_size) / float(max(abs(struct.lattice.matrix[1])))) + 1
dim3 = int(float(c_size) / float(max(abs(struct.lattice.matrix[2])))) + 1
cellmax = max(dim1, dim2, dim3)
conv_struct_sites = len(struct.sites)
conv_prim_rat = int(conv_struct_sites / prim_struct_sites)
sc_scale = [dim1, dim2, dim3]
print("sc_scale", sc_scale)
tmp = struct.copy()
tmp.make_supercell(sc_scale)
sc_tmp = tmp # Poscar(tmp).structure .make_supercell(list(sc_scale))
scs = list(VacancyGenerator(struct))
supercell = Poscar(sc_tmp)
supercell.comment = str("bulk") + str("@") + str("cellmax") + str(cellmax)
def_str.append(supercell)
if write_file == True:
supercell.write_file("POSCAR-" + str("bulk") + str(".vasp"))
for i in range(len(scs)):
sc = scs[i].generate_defect_structure(sc_scale)
poscar = Poscar(sc) # mpvis.get_poscar(sc)
pmg_name = str(scs[i].name).split("_")
sitespecie = pmg_name[1]
mult = pmg_name[2].split("mult")[1]
name = (str("vacancy_") + str(i + 1) + str("_mult-") + str(mult) +
str("_sitespecie-") + str(sitespecie) + str("@cellmax") +
str(cellmax))
poscar.comment = str(name)
def_str.append(poscar)
if write_file == True:
filename = (str("POSCAR-") + str("vacancy_") + str(i + 1) +
str("_mult-") + str(mult) + str("_sitespecie-") +
str(sitespecie) + str(".vasp"))
poscar.write_file(filename)
return def_str
def _verify_inputs(self):
user_incar = Incar.from_file(os.path.join(os.getcwd(), "INCAR"))
ref_incar = Incar.from_file(os.path.join(self["ref_dir"], "inputs", "INCAR"))
# perform some BASIC tests
# check INCAR
params_to_check = self.get("params_to_check", [])
defaults = {"ISPIN": 1, "ISMEAR": 1, "SIGMA": 0.2}
for p in params_to_check:
if user_incar.get(p, defaults.get(p)) != ref_incar.get(p, defaults.get(p)):
raise ValueError("INCAR value of {} is inconsistent!".format(p))
# check KPOINTS
user_kpoints = Kpoints.from_file(os.path.join(os.getcwd(), "KPOINTS"))
ref_kpoints = Kpoints.from_file(os.path.join(self["ref_dir"], "inputs", "KPOINTS"))
if user_kpoints.style != ref_kpoints.style or user_kpoints.num_kpts != ref_kpoints.num_kpts:
raise ValueError("KPOINT files are inconsistent! Paths are:\n{}\n{}".format(
os.getcwd(), os.path.join(self["ref_dir"], "inputs")))
# check POSCAR
user_poscar = Poscar.from_file(os.path.join(os.getcwd(), "POSCAR"))
ref_poscar = Poscar.from_file(os.path.join(self["ref_dir"], "inputs", "POSCAR"))
if user_poscar.natoms != ref_poscar.natoms or user_poscar.site_symbols != ref_poscar.site_symbols:
raise ValueError("POSCAR files are inconsistent! Paths are:\n{}\n{}".format(
os.getcwd(), os.path.join(self["ref_dir"], "inputs")))
# check POTCAR
user_potcar = Potcar.from_file(os.path.join(os.getcwd(), "POTCAR"))
ref_potcar = Potcar.from_file(os.path.join(self["ref_dir"], "inputs", "POTCAR"))
if user_potcar.symbols != ref_potcar.symbols:
raise ValueError("POTCAR files are inconsistent! Paths are:\n{}\n{}".format(
os.getcwd(), os.path.join(self["ref_dir"], "inputs")))
logger.info("RunVaspFake: verified inputs successfully")
def _verify_inputs(self):
"""Validation of input files under user NEB directory."""
user_incar = Incar.from_file(os.path.join(self.user_dir, "INCAR"))
ref_incar = Incar.from_file(os.path.join(self.ref_dir_input, "INCAR"))
# Check INCAR
params_to_check = self.get("params_to_check", [])
defaults = {"ICHAIN": 0, "LCLIMB": True}
for p in params_to_check:
if user_incar.get(p, defaults.get(p)) != ref_incar.get(p, defaults.get(p)):
raise ValueError("INCAR value of {} is inconsistent!".format(p))
# Check KPOINTS
user_kpoints = Kpoints.from_file(os.path.join(self.user_dir, "KPOINTS"))
ref_kpoints = Kpoints.from_file(os.path.join(self.ref_dir_input, "KPOINTS"))
if user_kpoints.style != ref_kpoints.style or user_kpoints.num_kpts != ref_kpoints.num_kpts:
raise ValueError("KPOINT files are inconsistent! "
"Paths are:\n{}\n{} with kpts = {} {}".format(
self.user_dir, self.ref_dir_input, user_kpoints, ref_kpoints))
# Check POTCAR
user_potcar = Potcar.from_file(os.path.join(self.user_dir, "POTCAR"))
ref_potcar = Potcar.from_file(os.path.join(self.ref_dir_input, "POTCAR"))
if user_potcar.symbols != ref_potcar.symbols:
raise ValueError("POTCAR files are inconsistent! "
"Paths are:\n{}\n{}".format(self.user_dir, self.ref_dir_input))
# Check POSCARs
for u, r in zip(self.user_sdir, self.ref_sdir_input):
user_poscar = Poscar.from_file(os.path.join(u, "POSCAR"))
ref_poscar = Poscar.from_file(os.path.join(r, "POSCAR"))
if user_poscar.natoms != ref_poscar.natoms or \
user_poscar.site_symbols != ref_poscar.site_symbols:
raise ValueError("POSCAR files are inconsistent! Paths are:\n{}\n{}".format(u, r))
def write_structures(structures, file_name):
import tempfile
import zipfile
from os.path import basename, join
import os
if len(structures) > 1:
result_archive = zipfile.ZipFile(join(os.getcwd(),
basename(file_name) + '.zip'),
mode='w')
for name, structure in structures.items():
sorted_sites = list(
sorted(structure.sites.copy(),
key=lambda site: site.specie.symbol))
sorted_structure = Structure.from_sites(sorted_sites)
with tempfile.NamedTemporaryFile() as tmpfile:
Poscar(structure=sorted_structure).write_file(tmpfile.name)
result_archive.write(tmpfile.name,
arcname=basename(file_name) + '-' + name)
result_archive.close()
write_message('Archive file: {0}'.format(
join(os.getcwd(),
basename(file_name) + '.zip')),
level=DEBUG)
else:
#There is just one file write only that one
structure_key = list(structures.keys())[0]
sorted_sites = list(
sorted(structures[structure_key].sites.copy(),
key=lambda site: site.specie.symbol))
sorted_structure = Structure.from_sites(sorted_sites)
p = Poscar(structure=sorted_structure)
fname = join(os.getcwd(),
basename(file_name) + structure_key + '.vasp')
p.write_file(fname)
write_message('Output file: {0}'.format(fname), level=DEBUG)
def test_image_num(self):
module_dir = os.path.dirname(os.path.abspath(__file__))
test_file_dir = os.path.join(module_dir, "..", "..", "..", "test_files",
"path_finder")
start_s = Poscar.from_file(os.path.join(test_file_dir, 'LFP_POSCAR_s')).structure
end_s = Poscar.from_file(os.path.join(test_file_dir, 'LFP_POSCAR_e')).structure
mid_s = start_s.interpolate(end_s, nimages=2,
interpolate_lattices=False)[1]
chg = Chgcar.from_file(os.path.join(test_file_dir, 'LFP_CHGCAR.gz'))
moving_cation_specie = Element('Li')
relax_sites = []
for site_i, site in enumerate(start_s.sites):
if site.specie == moving_cation_specie:
relax_sites.append(site_i)
pf = NEBPathfinder(start_s, end_s, relax_sites=relax_sites,
v=ChgcarPotential(chg).get_v(), n_images=(8 * 3))
images = []
for i, image in enumerate(pf.images):
if i % 3 == 0:
images.append(image)
self.assertEqual(len(images), 9)
pf_mid = NEBPathfinder(start_s, end_s, relax_sites=relax_sites,
v=ChgcarPotential(chg).get_v(), n_images=10, mid_struct=mid_s)
moving_site = relax_sites[0]
dists = [s1.sites[moving_site].distance(s2.sites[moving_site])
for s1, s2 in zip(pf.images[:-1], pf.images[1:])]
# check that all the small distances are about equal
self.assertTrue(abs(min(dists)-max(dists))/mean(dists) < 0.02)
def mp_id(mpid):
"""
materials project の ID から POSCAR を作成
"""
mpr = MPRester("WTxsDhRV7g2Mcbqw")
strctr = mpr.get_structure_by_material_id(mpid)
poscar = Poscar(strctr)
poscar.write_file('POSCAR_{0}'.format(mpid))
def set_up_program_input(self):
image_structures = self.keywords['program_keys']['mast_neb_settings'][
'image_structures']
self.set_up_neb_folders(image_structures)
self._vasp_kpoints_setup()
mypotcar = self._vasp_potcar_setup(Poscar(image_structures[0]))
self._vasp_incar_setup(mypotcar, Poscar(image_structures[0]))
self._vasp_neb_incar_modify()
return
def std(src='POSCAR'):
"""
conventional standard cell に変換
"""
srcpos = Poscar.from_file(src)
finder = SpacegroupAnalyzer(srcpos.structure)
std_str = finder.get_conventional_standard_structure()
dstpos = Poscar(std_str)
dst = 'POSCAR_std'
Cabinet.reserve_file(dst)
dstpos.write_file(dst)
def refined(src):
"""
refined poscar を 作成する
"""
srcpos = Poscar.from_file(src)
finder = SpacegroupAnalyzer(srcpos.structure, symprec=5e-1, angle_tolerance=8)
scr_std = finder.get_refined_structure()
dstpos = Poscar(scr_std)
dst = "POSCAR_refined"
Cabinet.reserve_file(dst)
dstpos.write_file(dst)
def prim(src):
"""
primitive cell に変換
"""
srcpos = Poscar.from_file(src)
finder = SpacegroupAnalyzer(srcpos.structure)
prim_str = finder.get_primitive_standard_structure()
dstpos = Poscar(prim_str)
dst = 'POSCAR_prim'
Cabinet.reserve_file(dst)
dstpos.write_file(dst)
def vac_intl(cellmax=2, mpid='', struct=None):
"""
Vacancy and interstitial generator
Args:
cellmax: maximum cell size
struct: Structure object
Returns:
def_str: defect structures
"""
if struct == None:
with MPRester() as mp:
struct = mp.get_structure_by_material_id(mpid)
if mpid == '':
print("Provide structure")
sg_mat = SpacegroupAnalyzer(struct)
struct = sg_mat.get_conventional_standard_structure()
def_str = []
count = 0
cell_arr = [cellmax, cellmax, cellmax]
vac = Vacancy(struct, {}, {})
for el in list(struct.symbol_set):
scs = vac.make_supercells_with_defects(cell_arr, el)
for i in range(len(scs)):
if i == 0:
pos = Poscar(scs[i])
pos.comment = str('bulk') + str('.') + str('cellmax') + str(
cellmax)
if count == 0:
def_str.append(pos)
count = count + 1
else:
pos = Poscar(scs[i])
pos.comment = str('vac') + str('cellmax') + str(cellmax) + str(
'@') + str(vac.get_defectsite_multiplicity(i)) + str(
'Element') + str(el)
if pos not in def_str:
def_str.append(pos)
struct_valrad_eval = ValenceIonicRadiusEvaluator(struct)
val = struct_valrad_eval.valences
rad = struct_valrad_eval.radii
struct_val = val
struct_rad = rad
intl = Interstitial(struct, val, rad)
for el in struct.composition.elements:
scs = intl.make_supercells_with_defects(cell_arr, el)
for i in range(1, len(scs)):
pos = Poscar(scs[i])
pos.comment = str('intl') + str('cellmax') + str(cellmax) + str(
'@') + str(intl.get_defectsite_coordination_number(
i - 1)) + str('Element') + str(el)
if pos not in def_str:
def_str.append(pos)
print(len(def_str))
return def_str
def refined(src='POSCAR'):
"""
refined cell を 作成する
"""
srcpos = Poscar.from_file(src)
finder = SpacegroupAnalyzer(srcpos.structure,
symprec=5e-1, angle_tolerance=8)
std_str = finder.get_refined_structure()
dstpos = Poscar(std_str)
dst = 'POSCAR_refined'
Cabinet.reserve_file(dst)
dstpos.write_file(dst)
def _verify_inputs(self):
user_incar = Incar.from_file(os.path.join(os.getcwd(), "INCAR"))
# Carry out some BASIC tests.
# Check INCAR
if self.get("check_incar", True):
ref_incar = Incar.from_file(
os.path.join(self["ref_dir"], "inputs", "INCAR"))
params_to_check = self.get("params_to_check", [])
defaults = {"ISPIN": 1, "ISMEAR": 1, "SIGMA": 0.2}
for p in params_to_check:
if user_incar.get(p, defaults.get(p)) != ref_incar.get(
p, defaults.get(p)):
raise ValueError(
"INCAR value of {} is inconsistent!".format(p))
# Check KPOINTS
if self.get("check_kpoints", True):
user_kpoints = Kpoints.from_file(
os.path.join(os.getcwd(), "KPOINTS"))
ref_kpoints = Kpoints.from_file(
os.path.join(self["ref_dir"], "inputs", "KPOINTS"))
if user_kpoints.style != ref_kpoints.style or \
user_kpoints.num_kpts != ref_kpoints.num_kpts:
raise ValueError(
"KPOINT files are inconsistent! Paths are:\n{}\n{} with kpoints {} and {}"
.format(os.getcwd(), os.path.join(self["ref_dir"],
"inputs"), user_kpoints,
ref_kpoints))
# Check POSCAR
if self.get("check_poscar", True):
user_poscar = Poscar.from_file(os.path.join(os.getcwd(), "POSCAR"))
ref_poscar = Poscar.from_file(
os.path.join(self["ref_dir"], "inputs", "POSCAR"))
if user_poscar.natoms != ref_poscar.natoms or user_poscar.site_symbols != \
ref_poscar.site_symbols:
raise ValueError(
"POSCAR files are inconsistent! Paths are:\n{}\n{}".format(
os.getcwd(), os.path.join(self["ref_dir"], "inputs")))
# Check POTCAR
if self.get("check_potcar", True):
user_potcar = Potcar.from_file(os.path.join(os.getcwd(), "POTCAR"))
ref_potcar = Potcar.from_file(
os.path.join(self["ref_dir"], "inputs", "POTCAR"))
if user_potcar.symbols != ref_potcar.symbols:
raise ValueError(
"POTCAR files are inconsistent! Paths are:\n{}\n{}".format(
os.getcwd(), os.path.join(self["ref_dir"], "inputs")))
logger.info("RunVaspFake: verified inputs successfully")
def run_task(self, fw_spec):
structure_dict = fw_spec["structure"]
if self.get("rescale_volume", False):
spec_structure = Structure.from_dict(structure_dict)
scaling_volume = spec_structure.volume * self["rescale_volume"]
spec_structure.scale_lattice(scaling_volume)
structure_dict = spec_structure.as_dict()
_poscar = Poscar(structure_dict)
_poscar.write_file("POSCAR")
return FWAction()
def convert_fmt(args):
iformat = args.input_format[0]
oformat = args.output_format[0]
filename = args.input_filename[0]
out_filename = args.output_filename[0]
try:
if iformat == "POSCAR":
p = Poscar.from_file(filename)
structure = p.structure
elif iformat == "CIF":
r = CifParser(filename)
structure = r.get_structures()[0]
elif iformat == "CONVENTIONAL_CIF":
r = CifParser(filename)
structure = r.get_structures(primitive=False)[0]
elif iformat == "CSSR":
structure = Cssr.from_file(filename).structure
else:
structure = Structure.from_file(filename)
if oformat == "smart":
structure.to(filename=out_filename)
elif oformat == "POSCAR":
p = Poscar(structure)
p.write_file(out_filename)
elif oformat == "CIF":
w = CifWriter(structure)
w.write_file(out_filename)
elif oformat == "CSSR":
c = Cssr(structure)
c.write_file(out_filename)
elif oformat == "VASP":
ts = TransformedStructure(
structure, [],
history=[{"source": "file",
"datetime": str(datetime.datetime.now()),
"original_file": open(filename).read()}])
ts.write_vasp_input(MPRelaxSet, output_dir=out_filename)
elif oformat == "MITVASP":
ts = TransformedStructure(
structure, [],
history=[{"source": "file",
"datetime": str(datetime.datetime.now()),
"original_file": open(filename).read()}])
ts.write_vasp_input(MITRelaxSet, output_dir=out_filename)
except Exception as ex:
print("Error converting file. Are they in the right format?")
print(str(ex))
def surfer(mpid='',
vacuum=15,
layers=2,
mat=None,
max_index=1,
write_file=True):
"""
ASE surface bulder
Args:
vacuum: vacuum region
mat: Structure object
max_index: maximum miller index
min_slab_size: minimum slab size
Returns:
structures: list of surface Structure objects
"""
if mat == None:
with MPRester() as mp:
mat = mp.get_structure_by_material_id(mpid)
if mpid == '':
print('Provide structure')
sg_mat = SpacegroupAnalyzer(mat)
mat_cvn = sg_mat.get_conventional_standard_structure()
mat_cvn.sort()
indices = get_symmetrically_distinct_miller_indices(mat_cvn, max_index)
ase_atoms = AseAtomsAdaptor().get_atoms(mat_cvn)
structures = []
pos = Poscar(mat_cvn)
try:
pos.comment = str('sbulk') + str('@') + str('vac') + str(vacuum) + str(
'@') + str('layers') + str(layers)
except:
pass
structures.append(pos)
if write_file == True:
mat_cvn.to(fmt='poscar',
filename=str('POSCAR-') + str('cvn') + str('.vasp'))
for i in indices:
ase_slab = surface(ase_atoms, i, layers)
ase_slab.center(vacuum=vacuum, axis=2)
slab_pymatgen = AseAtomsAdaptor().get_structure(ase_slab)
slab_pymatgen.sort()
surf_name = '_'.join(map(str, i))
pos = Poscar(slab_pymatgen)
try:
pos.comment = str("Surf-") + str(surf_name) + str('@') + str(
'vac') + str(vacuum) + str('@') + str('layers') + str(layers)
except:
pass
if write_file == True:
pos.write_file(filename=str('POSCAR-') + str("Surf-") +
str(surf_name) + str('.vasp'))
structures.append(pos)
return structures
def poscar_direct_to_cart(self,
inputFilePath,
outputFilePath,
vasp4Compatible=False):
"""
TODO: replace default python file io with monty.io
"""
noDecimals = 6
direct = False
crystalStruc = Structure.from_file(inputFilePath)
poscarFile = Poscar(crystalStruc)
poscarString = poscarFile.get_string(direct, vasp4Compatible,
noDecimals)
with open(outputFilePath, "w") as f:
f.write(poscarString)
def setUpClass(cls):
if not os.environ.get("VASP_PSP_DIR"):
os.environ["VASP_PSP_DIR"] = os.path.join(module_dir,
"reference_files")
print(
'Note: This system is not set up to run VASP jobs. '
'Please set your VASP_PSP_DIR environment variable.')
cls.struct_si = PymatgenTest.get_structure("Si")
cls.ref_incar = Incar.from_file(
os.path.join(module_dir, "reference_files", "setup_test", "INCAR"))
cls.ref_poscar = Poscar.from_file(
os.path.join(module_dir, "reference_files", "setup_test",
"POSCAR"))
cls.ref_potcar = Potcar.from_file(
os.path.join(module_dir, "reference_files", "setup_test",
"POTCAR"))
cls.ref_kpoints = Kpoints.from_file(
os.path.join(module_dir, "reference_files", "setup_test",
"KPOINTS"))
cls.ref_incar_preserve = Incar.from_file(os.path.join(module_dir,
"reference_files",
"preserve_incar",
"INCAR"))
def run_task(self, fw_spec):
transformations = []
transformation_params = self.get("transformation_params",
[{} for i in range(len(self["transformations"]))])
for t in self["transformations"]:
found = False
for m in ["advanced_transformations", "defect_transformations",
"site_transformations", "standard_transformations"]:
mod = import_module("pymatgen.transformations.{}".format(m))
try:
t_cls = getattr(mod, t)
except AttributeError:
continue
t_obj = t_cls(**transformation_params.pop(0))
transformations.append(t_obj)
found = True
if not found:
raise ValueError("Could not find transformation: {}".format(t))
# TODO: @matk86 - should prev_calc_dir use CONTCAR instead of POSCAR? Note that if
# current dir, maybe it is POSCAR indeed best ... -computron
structure = self['structure'] if not self.get('prev_calc_dir', None) else \
Poscar.from_file(os.path.join(self['prev_calc_dir'], 'POSCAR')).structure
ts = TransformedStructure(structure)
transmuter = StandardTransmuter([ts], transformations)
final_structure = transmuter.transformed_structures[-1].final_structure.copy()
vis_orig = self["vasp_input_set"]
vis_dict = vis_orig.as_dict()
vis_dict["structure"] = final_structure.as_dict()
vis_dict.update(self.get("override_default_vasp_params", {}) or {})
vis = vis_orig.__class__.from_dict(vis_dict)
vis.write_input(".")
def __init__(self,
user_input,
make_supercell=False,
supercell_matrix=None,
isdope=False,
dopant=None):
"""
Args:
input: the POSCAR file of initial structure, or the material_id
"""
self.make_supercell = make_supercell
self.supercell_matrix = supercell_matrix
self.isdope = isdope
self.dopant = dopant
# if user_input is a path where store the POSCAR file
if (os.path.isfile(user_input)):
pos = Poscar.from_file(user_input)
struc = SpacegroupAnalyzer(pos.structure)
self.init_struc = struc.get_conventional_standard_structure()
# user_input is a mp_id
else:
prim_struc = mpr.get_structure_by_material_id(user_input)
struc = SpacegroupAnalyzer(prim_struc)
self.init_struc = struc.get_conventional_standard_structure()
self.formula = str(self.init_struc.composition.reduced_formula)
logging.info("self.formula: {}".format(self.formula))
def main():
parser = argparse.ArgumentParser(
description=
'Rotate a bond (Stone-Wales defect) of a fullerene stored in a POSCAR file.',
)
parser.add_argument(
'INPUT',
help='POSCAR where all atoms use an image from the same molecule.')
parser.add_argument('ATOM1',
type=int,
help='0-based index of first bonded atom')
parser.add_argument('ATOM2',
type=int,
help='0-based index of second bonded atom')
args = parser.parse_args()
from pymatgen.io.vasp import Poscar
from pymatgen.core import Structure
poscar = Poscar.from_file(args.INPUT)
structure = poscar.structure
cart_coords = structure.cart_coords
cart_coords = rotate_bond(cart_coords, args.ATOM1, args.ATOM2)
poscar.structure = Structure(structure.lattice,
structure.species,
cart_coords,
coords_are_cartesian=True)
print(poscar.get_string(significant_figures=16), end='')
def setUp(self):
struc = PymatgenTest.get_structure("VO2")
struc.make_supercell(3)
struc = struc
self.vac = Vacancy(struc, struc.sites[0], charge=-3)
abc = self.vac.bulk_structure.lattice.abc
axisdata = [np.arange(0.0, lattval, 0.2) for lattval in abc]
bldata = [np.array([1.0 for u in np.arange(0.0, lattval, 0.2)]) for lattval in abc]
dldata = [
np.array([(-1 - np.cos(2 * np.pi * u / lattval)) for u in np.arange(0.0, lattval, 0.2)]) for lattval in abc
]
self.frey_params = {
"axis_grid": axisdata,
"bulk_planar_averages": bldata,
"defect_planar_averages": dldata,
"dielectric": 15,
"initial_defect_structure": struc.copy(),
"defect_frac_sc_coords": struc.sites[0].frac_coords[:],
}
kumagai_bulk_struc = Poscar.from_file(
os.path.join(PymatgenTest.TEST_FILES_DIR, "defect", "CONTCAR_bulk")
).structure
bulk_out = Outcar(os.path.join(PymatgenTest.TEST_FILES_DIR, "defect", "OUTCAR_bulk.gz"))
defect_out = Outcar(os.path.join(PymatgenTest.TEST_FILES_DIR, "defect", "OUTCAR_vac_Ga_-3.gz"))
self.kumagai_vac = Vacancy(kumagai_bulk_struc, kumagai_bulk_struc.sites[0], charge=-3)
kumagai_defect_structure = self.kumagai_vac.generate_defect_structure()
self.kumagai_params = {
"bulk_atomic_site_averages": bulk_out.electrostatic_potential,
"defect_atomic_site_averages": defect_out.electrostatic_potential,
"site_matching_indices": [[ind, ind - 1] for ind in range(len(kumagai_bulk_struc))],
"defect_frac_sc_coords": [0.0, 0.0, 0.0],
"initial_defect_structure": kumagai_defect_structure,
"dielectric": 18.118 * np.identity(3),
"gamma": 0.153156, # not neccessary to load gamma, but speeds up unit test
}
v = Vasprun(os.path.join(PymatgenTest.TEST_FILES_DIR, "vasprun.xml"))
eigenvalues = v.eigenvalues.copy()
kptweights = v.actual_kpoints_weights
potalign = -0.1
vbm = v.eigenvalue_band_properties[2]
cbm = v.eigenvalue_band_properties[1]
self.bandfill_params = {
"eigenvalues": eigenvalues,
"kpoint_weights": kptweights,
"potalign": potalign,
"vbm": vbm,
"cbm": cbm,
}
self.band_edge_params = {
"hybrid_cbm": 1.0,
"hybrid_vbm": -1.0,
"vbm": -0.5,
"cbm": 0.6,
"num_hole_vbm": 1.0,
"num_elec_cbm": 1.0,
}
def test_run_subfolders(self):
#raise SkipTest
ingdir="%s/writedir/single_label1" % testdir
recipedir="%s/writedir" % testdir
topmetad = MASTFile("files/top_metadata_single")
topmetad.data.append("origin_dir = %s/files\n" % testdir) #give origin directory
topmetad.to_file("writedir/metadata.txt")
metad = MASTFile("files/metadata_single")
metad.to_file("%s/metadata.txt" % ingdir)
kdict=dict()
kdict['mast_program'] = 'vasp'
kdict['mast_kpoints'] = [2,2,2,"M"]
kdict['mast_xc'] = 'pw91'
my_structure = Poscar.from_file("files/perfect_structure").structure
for subfolder in ['sub1','sub2','sub3','sub4']:
subname = "%s/%s" % (ingdir, subfolder)
os.mkdir(subname)
shutil.copy("files/metadata_single","%s/metadata.txt" % subname)
mywr = ChopIngredient(name=subname, program_keys = kdict, structure=my_structure)
mywr.write_singlerun()
myri = ChopIngredient(name=ingdir,program_keys=kdict, structure=my_structure)
myri.run_subfolders()
self.assertFalse(myri.checker.is_ready_to_run())
for subfolder in ['sub1','sub2','sub3','sub4']:
subname = "%s/%s" % (ingdir, subfolder)
myri.checker.keywords['name'] = subname
self.assertTrue(myri.checker.is_ready_to_run())
mysubmit = MASTFile("%s/submitlist" % self.test_control)
self.assertEquals(mysubmit.data[0], "%s/sub1\n" % ingdir)
self.assertEquals(mysubmit.data[1], "%s/sub2\n" % ingdir)
self.assertEquals(mysubmit.data[2], "%s/sub3\n" % ingdir)
self.assertEquals(mysubmit.data[3], "%s/sub4\n" % ingdir)
def write_structure(structure, filename):
"""
Write a structure to a file based on file extension. For example, anything
ending in a "cif" is assumed to be a Crystallographic Information Format
file. Supported formats include CIF, POSCAR, CSSR and pymatgen's JSON
serialized structures.
Args:
structure (Structure/IStructure): Structure to write
filename (str): A filename to write to.
"""
fname = os.path.basename(filename)
if fnmatch(fname, "*.cif*"):
writer = CifWriter(structure)
elif fnmatch(fname, "POSCAR*") or fnmatch(fname, "CONTCAR*"):
writer = Poscar(structure)
elif fnmatch(fname.lower(), "*.cssr*"):
writer = Cssr(structure)
elif fnmatch(fname, "*.json*") or fnmatch(fname, "*.mson*"):
with zopen(filename, "wt") as f:
f.write(str2unicode(json.dumps(structure, cls=MontyEncoder)))
return
else:
raise ValueError("Unrecognized file extension!")
writer.write_file(filename)
def strout2poscar(src='str.out'):
"""
str.outをposcarの記述に変換し, Poscar objをreturn
"""
with open(src, 'r') as rfile:
lines = rfile.readlines()
latt_tmp = [[float(x) for x in y.split()] for y in lines[0:3]]
trans = [[float(x) for x in y.split()] for y in lines[3:6]]
sites_tmp = [[float(x) for x in y.split()[0:3]] for y in lines[6:]]
elements = [x.split()[3].split('+')[0].split('-')[0] for x in lines[6:]]
num_atoms = [elements.count(e)
for e in sorted(set(elements), key=elements.index)]
latt = np.dot(np.array(trans), np.array(latt_tmp))
sites = np.dot(np.array(sites_tmp), np.array(latt_tmp))
posc_str = "posc_orig\n"
posc_str += "1.00\n"
posc_str += "\n".join([" ".join([str(f) for f in l]) for l in latt])
posc_str += "\n"
posc_str += " ".join(sorted(set(elements), key=elements.index)) + "\n"
posc_str += " ".join([str(d) for d in num_atoms]) + "\n"
posc_str += "Cartesian\n"
posc_str += "\n".join([" ".join([str(f) for f in s]) for s in sites])
return Poscar.from_string(posc_str)
def run_task(self, fw_spec):
transformations = []
transformation_params = self.get("transformation_params", [{} for i in range(len(self["transformations"]))])
for t in self["transformations"]:
for m in [
"advanced_transformations",
"defect_transformations",
"site_transformations",
"standard_transformations",
]:
mod = import_module("pymatgen.transformations.{}".format(m))
try:
t_cls = getattr(mod, t)
except AttributeError:
continue
t_obj = t_cls(**transformation_params.pop(0))
transformations.append(t_obj)
structure = (
self["structure"]
if "prev_calc_dir" not in self
else Poscar.from_file(os.path.join(self["prev_calc_dir"], "POSCAR")).structure
)
ts = TransformedStructure(structure)
transmuter = StandardTransmuter([ts], transformations)
final_structure = transmuter.transformed_structures[-1].final_structure.copy()
vis_orig = self["vasp_input_set"]
vis_dict = vis_orig.as_dict()
vis_dict["structure"] = final_structure.as_dict()
vis_dict.update(self.get("override_default_vasp_params", {}) or {})
vis = vis_orig.__class__.from_dict(vis_dict)
vis.write_input(".")
def test_run_singlerun(self):
#raise SkipTest
ingdir = "%s/writedir/single_label1" % testdir
recipedir = "%s/writedir" % testdir
topmetad = MASTFile("files/top_metadata_single")
topmetad.data.append("origin_dir = %s/files\n" %
testdir) #give origin directory
topmetad.to_file("writedir/metadata.txt")
metad = MASTFile("files/metadata_single")
metad.to_file("%s/metadata.txt" % ingdir)
kdict = dict()
kdict['mast_program'] = 'vasp'
kdict['mast_kpoints'] = [2, 2, 2, "M"]
kdict['mast_xc'] = 'pw91'
my_structure = Poscar.from_file("files/perfect_structure").structure
mywr = ChopIngredient(name=ingdir,
program_keys=kdict,
structure=my_structure)
mywr.write_singlerun()
myri = ChopIngredient(name=ingdir,
program_keys=kdict,
structure=my_structure)
myri.run_singlerun()
self.assertTrue(myri.checker.is_ready_to_run())
mysubmit = MASTFile("%s/submitlist" % self.test_control)
self.assertEquals(mysubmit.data[0], "%s\n" % ingdir)
def parse_wf_for_latt_constants(wf_id):
lpad = LaunchPad().from_file(lpad_file_path)
wf = lpad.get_wf_by_fw_id(wf_id)
lattdata = {}
print('{} workflow retrieved with {} fws in it'.format(
wf.name, len(wf.fws)))
for fw in wf.fws:
print('\t{}'.format(fw.name))
if 'structure optimization' not in fw.name:
raise ValueError("Not a recognized firework!")
elif fw.state != 'COMPLETED':
print('\t\tstatus = {}, so skipping'.format(fw.state))
continue
pat = fw.launches[-1].launch_dir
s = Poscar.from_file(os.path.join(pat, 'CONTCAR.relax2.gz')).structure
nom = s.composition.reduced_formula
if nom in lattdata:
raise ValueError("{} already exists in lattdata??".format(nom))
elif (max(s.lattice.abc) - min(s.lattice.abc)) > 0.00001 or (
max(s.lattice.angles) - min(s.lattice.angles)) > 0.00001:
raise ValueError("Error occured with lattice relaxation??".format(
s.lattice))
else:
lattdata.update({nom: s.lattice.abc[0]})
print('\nFinalized lattice constant set:\n{}'.format(lattdata))
return lattdata
def hacky_struct2pmg(struct):
""" convert ASE structure to pymatgen structure
this is not natively implemented in ASE
"""
from ase.io import write
from pymatgen.io.cif import CifParser # this didn't give supercell structure
from pymatgen.io.vasp import Poscar
write("POSCAR.tmp",struct,format="vasp")
# fix formatting of the outputted vasp format, which has misplaced species labels
# this is a hacky way to insert it in the right line
f = open("POSCAR.tmp","r")
lines = []
for i,line in enumerate(f):
if i == 0:
species_line = line
elif i == 5:
lines.append(species_line)
lines.append(line)
f.close()
with open("POSCAR",'w') as f:
f.writelines(lines)
poscar = Poscar.from_file("POSCAR")
structure = poscar.structure
subprocess.call(["rm", "POSCAR","POSCAR.tmp"])
return structure
def testEntry(self):
entries = []
for i, f in enumerate(self.iter_path):
vi = VaspInput.from_directory(f)
ls = LabeledSystem(os.path.join(f, 'OUTCAR'))
attrib = loadfn(os.path.join(f, 'job.json'))
comp = vi['POSCAR'].structure.composition
entry = Entry(comp,
'vasp',
vi.as_dict(),
ls.as_dict(),
entry_id='pku-' + str(i),
attribute=attrib)
entries.append(entry)
self.assertEqual(len(entries), len(self.ref_entries))
ret0 = entries[0]
r0 = self.ref_entries[0]
self.assertEqual(Incar.from_dict(ret0.inputs['INCAR']),
Incar.from_dict(r0.inputs['INCAR']))
self.assertEqual(str(r0.inputs['KPOINTS']),
str(Kpoints.from_dict(ret0.inputs['KPOINTS'])))
self.assertEqual(ret0.inputs['POTCAR'], r0.inputs['POTCAR'].as_dict())
self.assertEqual(
Poscar.from_dict(ret0.inputs['POSCAR']).structure,
r0.inputs['POSCAR'].structure)
self.assertEqual(ret0.entry_id, 'pku-0')
def run_task(self, fw_spec):
transformations = []
transformation_params = self.get(
"transformation_params",
[{} for i in range(len(self["transformations"]))])
for t in self["transformations"]:
for m in [
"advanced_transformations", "defect_transformations",
"site_transformations", "standard_transformations"
]:
mod = __import__("pymatgen.transformations." + m, globals(),
locals(), [t], -1)
try:
t_cls = getattr(mod, t)
except AttributeError:
continue
t_obj = t_cls(**transformation_params.pop(0))
transformations.append(t_obj)
structure = self['structure'] if 'prev_calc_dir' not in self else \
Poscar.from_file(os.path.join(self['prev_calc_dir'], 'POSCAR')).structure
ts = TransformedStructure(structure)
transmuter = StandardTransmuter([ts], transformations)
final_structure = transmuter.transformed_structures[
-1].final_structure.copy()
vis_orig = self["vasp_input_set"]
vis_dict = vis_orig.as_dict()
vis_dict["structure"] = final_structure.as_dict()
vis_dict.update(self.get("override_default_vasp_params", {}) or {})
vis = vis_orig.__class__.from_dict(vis_dict)
vis.write_input(".")
def test_arrhenius(self):
poscar = Poscar.from_file(os.path.join(test_dir, 'arrhenius/POSCAR'))
struct = poscar.structure
aa = ArreheniusAnalyzer.from_csv(
os.path.join(test_dir, 'arrhenius/D_T.csv'))
temperature = 300
specie_string = 'Li+'
self.assertAlmostEqual(get_conversion_factor(struct, specie_string,
temperature),
158701249.73192352,
places=5)
self.assertAlmostEqual(aa.Ea, 0.258128283041, places=5)
self.assertAlmostEqual(aa.Ea_error, 0.0168320198494, places=5)
self.assertAlmostEqual(aa.predict_conductivity(temperature, struct,
specie_string)[0],
1.08036514392,
places=5)
self.assertAlmostEqual(aa.predict_conductivity(temperature, struct,
specie_string)[1][0],
0.54509683117599272,
places=5)
self.assertAlmostEqual(aa.predict_conductivity(temperature, struct,
specie_string)[1][1],
2.1412504667878154,
places=5)
self.assertAlmostEqual(aa.predict_diffusivity(temperature)[0],
6.80754024147e-09,
places=5)
def run_task(self, fw_spec):
transformations = []
transformation_params = self.get("transformation_params",
[{} for i in range(len(self["transformations"]))])
for t in self["transformations"]:
found = False
for m in ["advanced_transformations", "defect_transformations",
"site_transformations", "standard_transformations"]:
mod = import_module("pymatgen.transformations.{}".format(m))
try:
t_cls = getattr(mod, t)
except AttributeError:
continue
t_obj = t_cls(**transformation_params.pop(0))
transformations.append(t_obj)
found = True
if not found:
raise ValueError("Could not find transformation: {}".format(t))
# TODO: @matk86 - should prev_calc_dir use CONTCAR instead of POSCAR? Note that if
# current dir, maybe it is POSCAR indeed best ... -computron
structure = self['structure'] if not self.get('prev_calc_dir', None) else \
Poscar.from_file(os.path.join(self['prev_calc_dir'], 'POSCAR')).structure
ts = TransformedStructure(structure)
transmuter = StandardTransmuter([ts], transformations)
final_structure = transmuter.transformed_structures[-1].final_structure.copy()
vis_orig = self["vasp_input_set"]
vis_dict = vis_orig.as_dict()
vis_dict["structure"] = final_structure.as_dict()
vis_dict.update(self.get("override_default_vasp_params", {}) or {})
vis = vis_orig.__class__.from_dict(vis_dict)
vis.write_input(".")
dumpfn(transmuter.transformed_structures[-1], "transformations.json")
def full_opt_run(cls, vasp_cmd, auto_npar=True, vol_change_tol=0.05,
max_steps=10):
"""
Returns a generator of jobs for a full optimization run. Basically,
this runs an infinite series of geometry optimization jobs until the
% vol change in a particular optimization is less than vol_change_tol.
Args:
vasp_cmd (str): Command to run vasp as a list of args. For example,
if you are using mpirun, it can be something like
["mpirun", "pvasp.5.2.11"]
auto_npar (bool): Whether to automatically tune NPAR to be sqrt(
number of cores) as recommended by VASP for DFT calculations.
Generally, this results in significant speedups. Defaults to
True. Set to False for HF, GW and RPA calculations.
vol_change_tol (float): The tolerance at which to stop a run.
Defaults to 0.05, i.e., 5%.
max_steps (int): The maximum number of runs. Defaults to 10 (
highly unlikely that this limit is ever reached).
Returns:
Generator of jobs.
"""
for i in xrange(max_steps):
if i == 0:
settings = None
backup = True
else:
backup = False
initial = Poscar.from_file("POSCAR").structure
final = Poscar.from_file("CONTCAR").structure
vol_change = (final.volume - initial.volume) / initial.volume
logging.info("Vol change = %.1f %%!" % (vol_change * 100))
if abs(vol_change) < vol_change_tol:
logging.info("Stopping optimization!")
break
else:
settings = [
{"dict": "INCAR",
"action": {"_set": {"ISTART": 1}}},
{"file": "CONTCAR",
"action": {"_file_copy": {"dest": "POSCAR"}}}]
logging.info("Generating job = %d!" % (i+1))
yield VaspJob(vasp_cmd, final=False, backup=backup,
suffix=".relax%d" % (i+1), auto_npar=auto_npar,
settings_override=settings)
def data_from_outcars_in_folder(folder):
initLogging()
if not os.path.exists(config['data_load_file']):
different_energies = []
different_structures = []
poscar = Poscar.from_file(folder + '/POSCAR')
logging.info('Assigned Spin values Energy Unique energy FilePath')
for outcar_file in sorted(glob.glob(folder + '/OUTCAR*')):
structure = poscar.structure.copy()
magnetic_element_index = [
n for n, e in enumerate(structure)
if e.species_string in config['magnetic_elements']
]
magnetic_substructure = Structure.from_sites([
e for e in structure
if e.species_string in config['magnetic_elements']
])
outcar = Outcar(outcar_file)
try:
magnetization = np.array([
entry['tot'] for entry in outcar.magnetization
])[magnetic_element_index]
except IndexError:
logging.info(f'Bad OUTCAR: {outcar_file}')
continue
spins = np.zeros_like(magnetization)
for i, m in enumerate(magnetization):
spins[i] = np.sign(m) * config['spin_values'][i]
#if abs(m) > config['spin_threshold']:
# spins[i] = config['spin_value'] * np.sign(m)
magnetic_substructure.add_spin_by_site(spins)
magnetic_substructure.vasp_energy = outcar.final_energy
magnetic_substructure.name = outcar_file.split('/')[-1]
isUnique = False
if is_unique(different_energies, magnetic_substructure.vasp_energy,
1e-15):
different_energies.append(magnetic_substructure.vasp_energy)
isUnique = True
different_structures.append(magnetic_substructure)
#energy_checked = np.round(magnetic_substructure.vasp_energy, decimals=3)
#if not np.in1d(energy_checked, different_energies).any():
# different_energies.append(energy_checked)
# isUnique = True
# different_structures.append(magnetic_substructure)
logging.info((spins, magnetic_substructure.vasp_energy, isUnique,
outcar_file))
logging.info(
f'Data reading complete, saving to {config["data_load_file"]}')
with open(config['data_load_file'], 'wb') as f:
pickle.dump(different_structures, f)
logging.info('Data load complete. Rerun script')
import sys
sys.exit()
else:
with open(config['data_load_file'], 'rb') as f:
different_structures = pickle.load(f)
for s in different_structures:
logging.info(s.vasp_energy)
return different_structures
def five(src):
"""
VASP ver.5 のフォーマットに変換
元素名を 5 行目に追加
"""
srcpos = Poscar.from_file(src)
dst = "POSCAR_five"
srcpos.write_file(dst)
def ver5(src='POSCAR'):
"""
ver 5 の形式に変換
(POTCAR を読んで元素名を追加)
"""
srcpos = Poscar.from_file(src)
dst = 'POSCAR_five'
srcpos.write_file(dst)
def setUpClass(cls):
cls.struct_si = PymatgenTest.get_structure("Si")
cls.ref_incar = Incar.from_file(p_setup_test / "INCAR")
cls.ref_poscar = Poscar.from_file(p_setup_test / "POSCAR")
cls.ref_potcar = Potcar.from_file(p_setup_test / "POTCAR")
cls.ref_kpoints = Kpoints.from_file(p_setup_test / "KPOINTS")
cls.ref_incar_preserve = Incar.from_file(p_preserve_incar / "INCAR")
def _verify_files(self):
self.assertEqual(Incar.from_file(os.path.join(module_dir, "INCAR")), self.ref_incar)
self.assertEqual(str(Poscar.from_file(os.path.join(module_dir, "POSCAR"))),
str(self.ref_poscar))
self.assertEqual(Potcar.from_file(os.path.join(module_dir, "POTCAR")).symbols,
self.ref_potcar.symbols)
self.assertEqual(str(Kpoints.from_file(os.path.join(module_dir, "KPOINTS"))),
str(self.ref_kpoints))
def get_elements(src):
"""
元素ラベルを出力
"""
srcpos = Poscar.from_file(src)
elements = [x.symbol for x in srcpos.structure.species]
elem_counter = Counter(elements)
return elem_counter
def _parse_structure(self, structure_schema):
data = structure_schema['data']
format = structure_schema['format']
if format == 'cif':
structure = (CifParser.from_string(data)).get_structures()[0]
elif format == 'POSCAR':
structure = (Poscar.from_string(data)).structure
return structure
def check(self):
try:
oszicar = Oszicar(self.output_filename)
n = len(Poscar.from_file(self.input_filename).structure)
max_dE = max([s['dE'] for s in oszicar.ionic_steps[1:]]) / n
if max_dE > self.dE_threshold:
return True
except:
return False
def _verify_files(self, skip_kpoints=False, preserve_incar=False):
if not preserve_incar:
self.assertEqual(Incar.from_file(os.path.join(module_dir, "INCAR")), self.ref_incar)
self.assertEqual(str(Poscar.from_file(os.path.join(module_dir, "POSCAR"))), str(self.ref_poscar))
self.assertEqual((Potcar.from_file(os.path.join(module_dir, "POTCAR"))).symbols, self.ref_potcar.symbols)
if not skip_kpoints:
self.assertEqual(str(Kpoints.from_file(os.path.join(module_dir, "KPOINTS"))), str(self.ref_kpoints))
else:
self.assertEqual(Incar.from_file(os.path.join(module_dir, "INCAR")), self.ref_incar_preserve)
def cif(src):
"""
cifファイルを作成
"""
srcpos = Poscar.from_file(src)
finder = SpacegroupAnalyzer(srcpos.structure)
std_str = finder.get_conventional_standard_structure()
std_cif = CifWriter(std_str, symprec=0.1)
std_cif.write_file("poscar.cif")
def checkrelax_single(path, src_ini="posfinal", src_fin="posfinal3"):
"""
緩和で構造が歪んでいないかを check
"""
dirc = path
initial = Poscar.from_file(os.path.join(dirc, src_ini)).structure.as_dict()["lattice"]
final = Poscar.from_file(os.path.join(dirc, src_fin)).structure.as_dict()["lattice"]
length_a = final[u"a"] / initial[u"a"]
length_b = final[u"b"] / initial[u"b"]
length_c = final[u"c"] / initial[u"c"]
delta_length = ((length_b / length_a - 1) ** 2 + (length_c / length_a - 1) ** 2) ** 0.5
# print(delta_length)
angle_a = final["alpha"] / initial["alpha"] - 1
angle_b = final["beta"] / initial["beta"] - 1
angle_c = final["gamma"] / initial["gamma"] - 1
delta_angle = (angle_a ** 2 + angle_b ** 2 + angle_c ** 2) ** 0.5
# print(delta_angle)
return delta_length, delta_angle
def get_structure(filename):
if filename.lower().endswith('.cif'):
structure = CifParser(filename).get_structures()[0]
lattice = pmg.Lattice.from_parameters(*structure.lattice.abc, *structure.lattice.angles)
return pmg.Structure(lattice, structure.species, structure.frac_coords, coords_are_cartesian=False)
elif filename.lower().endswith('poscar'):
return Poscar.from_file(filename).structure
else:
raise ValueError('Cannot determine file type from filename [.cif, poscar]')
def cif(src='POSCAR'):
"""
cifファイルを作成
"""
srcpos = Poscar.from_file(src)
finder = SpacegroupAnalyzer(srcpos.structure)
std_str = finder.get_conventional_standard_structure()
cif_obj = CifWriter(std_str, symprec=0.1)
cif_obj.write_file('poscar.cif')
def print_spg(src):
"""
space group を表示する
"""
srcpos = Poscar.from_file(src)
finder = SpacegroupAnalyzer(srcpos.structure, symprec=5e-2, angle_tolerance=8)
spg = finder.get_spacegroup_symbol()
spg_num = finder.get_spacegroup_number()
print(spg)
print(spg_num)
def print_spg(src='POSCAR'):
"""
space group を return
"""
srcpos = Poscar.from_file(src)
finder = SpacegroupAnalyzer(srcpos.structure,
symprec=5e-2, angle_tolerance=8)
spg = finder.get_space_group_symbol()
spg_num = finder.get_space_group_number()
return spg, spg_num
def test_image_num(self):
module_dir = os.path.dirname(os.path.abspath(__file__))
test_file_dir = os.path.join(module_dir, "..", "..", "..", "test_files",
"path_finder")
start_s = Poscar.from_file(os.path.join(test_file_dir, 'LFP_POSCAR_s')).structure
end_s = Poscar.from_file(os.path.join(test_file_dir, 'LFP_POSCAR_e')).structure
chg = Chgcar.from_file(os.path.join(test_file_dir, 'LFP_CHGCAR.gz'))
moving_cation_specie = Element('Li')
relax_sites = []
for site_i, site in enumerate(start_s.sites):
if site.specie == moving_cation_specie:
relax_sites.append(site_i)
pf = NEBPathfinder(start_s, end_s, relax_sites=relax_sites,
v=ChgcarPotential(chg).get_v(), n_images=(8 * 3))
images = []
for i, image in enumerate(pf.images):
if i % 3 == 0:
images.append(image)
self.assertEqual(len(images), 9)
def of_poscar(cls, poscar_path, initial_pressure=0.0, initial_temperature=1000.0,
target_pressure=0.0, target_temperature=1000.0,
alpha=10e-5, beta=10e-7):
"""
Convenience constructor that accepts a poscar file as input
"""
poscar = Poscar.from_file(poscar_path)
return cls(poscar.structure, initial_pressure=initial_pressure, initial_temperature=initial_temperature,
target_pressure=target_pressure, target_temperature=target_temperature,
alpha=alpha, beta=beta, poscar=poscar)
def test_run_neb_subfolders(self):
#raise SkipTest
ingdir="%s/writedir/neb_labelinit-labelfin_stat" % testdir
recipedir="%s/writedir" % testdir
topmetad = MASTFile("files/top_metadata_neb")
topmetad.data.append("origin_dir = %s/files\n" % testdir) #give origin directory
topmetad.to_file("writedir/metadata.txt")
metad = MASTFile("files/metadata_neb")
metad.to_file("%s/metadata.txt" % ingdir)
kdict=dict()
kdict['mast_program'] = 'vasp'
kdict['mast_kpoints'] = [2,2,2,"M"]
kdict['mast_xc'] = 'pw91'
neblines = list()
neblines.append(["Cr","0.0 0.9 0.8","0.0 0.8 0.7"])
neblines.append(["Cr","0.4 0.2 0.1","0.3 0.3 0.2"])
neblines.append(["Cr","0.29 0.05 0.05","0.01 0.01 0.98"])
neblines.append(["Ni","0.61 0.99 0.98","0.25 0.01 0.97"])
kdict['mast_neb_settings']=dict()
kdict['mast_neb_settings']['lines']=neblines
kdict['mast_neb_settings']['images']=3
str_00 = MASTFile("files/POSCAR_00")
str_00.to_file("%s/parent_structure_labelinit" % ingdir)
str_04 = MASTFile("files/POSCAR_04")
str_04.to_file("%s/parent_structure_labelfin" % ingdir)
str_01 = MASTFile("files/POSCAR_01")
str_01.to_file("%s/parent_structure_labelinit-labelfin_01" % ingdir)
str_02 = MASTFile("files/POSCAR_02")
str_02.to_file("%s/parent_structure_labelinit-labelfin_02" % ingdir)
str_03 = MASTFile("files/POSCAR_03")
str_03.to_file("%s/parent_structure_labelinit-labelfin_03" % ingdir)
en_00 = MASTFile("files/OSZICAR_00")
en_00.to_file("%s/parent_energy_labelinit" % ingdir)
en_04 = MASTFile("files/OSZICAR_04")
en_04.to_file("%s/parent_energy_labelfin" % ingdir)
my_structure = Poscar.from_file("files/perfect_structure").structure
mywr = ChopIngredient(name=ingdir, program_keys = kdict, structure=my_structure)
mywr.write_neb_subfolders()
myri = ChopIngredient(name=ingdir,program_keys=kdict, structure=my_structure)
myri.run_neb_subfolders()
mysubmit = MASTFile("%s/submitlist" % self.test_control)
myri.checker.keywords['name'] = "%s/00" % ingdir
self.assertFalse(myri.checker.is_ready_to_run()) #do not run endpoints again
myri.checker.keywords['name'] = "%s/01" % ingdir
self.assertTrue(myri.checker.is_ready_to_run())
myri.checker.keywords['name'] = "%s/02" % ingdir
self.assertTrue(myri.checker.is_ready_to_run())
myri.checker.keywords['name'] = "%s/03" % ingdir
self.assertTrue(myri.checker.is_ready_to_run())
myri.checker.keywords['name'] = "%s/04" % ingdir
self.assertFalse(myri.checker.is_ready_to_run()) #do not run endpoints again
self.assertEquals(mysubmit.data[0], "%s/01\n" % ingdir)
self.assertEquals(mysubmit.data[1], "%s/02\n" % ingdir)
self.assertEquals(mysubmit.data[2], "%s/03\n" % ingdir)
def _parse_structure(self, structure_schema):
data = structure_schema['data']
format = structure_schema['format']
if format == 'cif':
# cif lattice can be weird non standard shape
structure = (CifParser.from_string(data)).get_structures()[0]
lattice = pmg.Lattice.from_parameters(*structure.lattice.abc, *structure.lattice.angles)
structure = pmg.Structure(lattice, structure.species, structure.frac_coords, coords_are_cartesian=False)
elif format == 'POSCAR':
structure = (Poscar.from_string(data)).structure
return structure
