def convert_computed_entry_to_job(self,entry):
"""
Convert ComputedStructureEntry into VaspJob object
Parameters
----------
entry :
ComputedStructureEntry.
Returns
-------
vaspjob :
VaspJob object.
"""
e = entry
path = e.data['dir_name']
inp = e.data['calculations'][0]['input']
incar = Incar(inp['incar'])
kpoints = Kpoints.from_dict(inp['kpoints'])
poscar = Poscar(e.structure)
potcar = Potcar(inp['potcar'])
inputs = VaspInput(incar, kpoints, poscar, potcar)
job_settings = e.data['job_settings']
job_script_filename = e.data['job_script_filename']
name = e.data['job_name']
outputs = {'ComputedStructureEntry':e}
vaspjob = VaspJob(path,inputs,job_settings,outputs,job_script_filename,name)
vaspjob._is_converged = e.data['is_converged']
vaspjob._band_structure = None
return vaspjob
def test_as_dict_from_dict(self):
k = Kpoints.monkhorst_automatic([2, 2, 2], [0, 0, 0])
d = k.as_dict()
k2 = Kpoints.from_dict(d)
self.assertEqual(k.kpts, k2.kpts)
self.assertEqual(k.style, k2.style)
self.assertEqual(k.kpts_shift, k2.kpts_shift)
def __init__(self, name, incar, poscar, potcar, kpoints,
qadapter=None, **kwargs ):
"""
default INCAR from config_dict
"""
self.name = name
self.incar = Incar.from_dict(incar.as_dict())
self.poscar = Poscar.from_dict(poscar.as_dict())
self.potcar = Potcar.from_dict(potcar.as_dict())
self.kpoints = Kpoints.from_dict(kpoints.as_dict())
self.extra = kwargs
if qadapter is not None:
self.qadapter = qadapter.from_dict(qadapter.to_dict())
else:
self.qadapter = None
config_dict = {}
config_dict['INCAR'] = self.incar.as_dict()
config_dict['POSCAR'] = self.poscar.as_dict()
#caution the key and the value are not always the same
config_dict['POTCAR'] = self.potcar.as_dict()
#dict(zip(self.potcar.as_dict()['symbols'],
#self.potcar.as_dict()['symbols']))
config_dict['KPOINTS'] = self.kpoints.as_dict()
#self.user_incar_settings = self.incar.as_dict()
DictVaspInputSet.__init__(self, name, config_dict,
ediff_per_atom=False, **kwargs)
def test_as_dict_from_dict(self):
k = Kpoints.monkhorst_automatic([2, 2, 2], [0, 0, 0])
d = k.as_dict()
k2 = Kpoints.from_dict(d)
self.assertEqual(k.kpts, k2.kpts)
self.assertEqual(k.style, k2.style)
self.assertEqual(k.kpts_shift, k2.kpts_shift)
def from_dict(d):
path = d['path']
inputs = {}
inputs["structures"] = [
Structure.from_dict(s) for s in d['inputs']['structures']
]
inputs["INCAR"] = Incar.from_dict(d['inputs']['INCAR'])
inputs["KPOINTS"] = Kpoints.from_dict(d['inputs']['KPOINTS'])
inputs["POTCAR"] = Potcar.from_dict(d['inputs']['POTCAR'])
job_settings = d['job_settings']
job_script_filename = d['job_script_filename']
name = d['name']
outputs = {}
vaspNEBjob = VaspNEBJob(path, inputs, job_settings, outputs,
job_script_filename, name)
vaspNEBjob._is_step_limit_reached = d['is_step_limit_reached']
vaspNEBjob._is_converged = d['is_converged']
vaspNEBjob._r = np.array(d['r'])
vaspNEBjob._energies = np.array(d['energies'])
vaspNEBjob._forces = np.array(d['forces'])
return vaspNEBjob
def __init__(self, name, incar, poscar, potcar, kpoints,
qadapter=None, script_name='submit_script',
vis_logger=None, **kwargs):
"""
default INCAR from config_dict
"""
self.name = name
self.incar = Incar.from_dict(incar.as_dict())
self.poscar = Poscar.from_dict(poscar.as_dict())
self.potcar = Potcar.from_dict(potcar.as_dict())
self.kpoints = Kpoints.from_dict(kpoints.as_dict())
self.extra = kwargs
if qadapter is not None:
self.qadapter = qadapter.from_dict(qadapter.to_dict())
else:
self.qadapter = None
self.script_name = script_name
config_dict = {}
config_dict['INCAR'] = self.incar.as_dict()
config_dict['POSCAR'] = self.poscar.as_dict()
# caution the key and the value are not always the same
config_dict['POTCAR'] = self.potcar.as_dict()
# dict(zip(self.potcar.as_dict()['symbols'],
# self.potcar.as_dict()['symbols']))
config_dict['KPOINTS'] = self.kpoints.as_dict()
# self.user_incar_settings = self.incar.as_dict()
DictVaspInputSet.__init__(self, name, config_dict,
ediff_per_atom=False, **kwargs)
if vis_logger:
self.logger = vis_logger
else:
self.logger = logger
def setup(self):
"""
Performs initial setup for VaspNEBJob, including overriding any settings
and backing up.
"""
neb_dirs = self.neb_dirs
if self.backup:
# Back up KPOINTS, INCAR, POTCAR
for f in VASP_NEB_INPUT_FILES:
shutil.copy(f, "{}.orig".format(f))
# Back up POSCARs
for path in neb_dirs:
poscar = os.path.join(path, "POSCAR")
shutil.copy(poscar, "{}.orig".format(poscar))
if self.half_kpts and os.path.exists("KPOINTS"):
kpts = Kpoints.from_file("KPOINTS")
kpts.kpts = np.maximum(np.array(kpts.kpts) / 2, 1)
kpts.kpts = kpts.kpts.astype(int).tolist()
if tuple(kpts.kpts[0]) == (1, 1, 1):
kpt_dic = kpts.as_dict()
kpt_dic["generation_style"] = "Gamma"
kpts = Kpoints.from_dict(kpt_dic)
kpts.write_file("KPOINTS")
if self.auto_npar:
try:
incar = Incar.from_file("INCAR")
import multiprocessing
# Try sge environment variable first
# (since multiprocessing counts cores on the current
# machine only)
ncores = os.environ.get(
"NSLOTS") or multiprocessing.cpu_count()
ncores = int(ncores)
for npar in range(int(math.sqrt(ncores)), ncores):
if ncores % npar == 0:
incar["NPAR"] = npar
break
incar.write_file("INCAR")
except Exception:
pass
if self.auto_continue and os.path.exists("STOPCAR") and not os.access(
"STOPCAR", os.W_OK):
# Remove STOPCAR
os.chmod("STOPCAR", 0o644)
os.remove("STOPCAR")
# Copy CONTCAR to POSCAR
for path in self.neb_sub:
contcar = os.path.join(path, "CONTCAR")
poscar = os.path.join(path, "POSCAR")
shutil.copy(contcar, poscar)
if self.settings_override is not None:
VaspModder().apply_actions(self.settings_override)
def get_kpoints(self):
"""
Create and return a :class:`pymatgen.io.vasp.inputs.Kpoints` instance
initialized from the node's stored k-point data contents.
:return: a pymatgen Kpoints instance
:rtype: :class:`pymatgen.io.vasp.inputs.Kpoints`
"""
return Kpoints.from_dict(self.get_dict())
def __init__(self,
name,
incar,
poscar,
kpoints,
potcar=None,
qadapter=None,
script_name='submit_script',
vis_logger=None,
reuse_path=None,
test=False,
**kwargs):
"""
default INCAR from config_dict
"""
self.name = name
self.test = test
#print (test)
self.incar_init = Incar.from_dict(incar.as_dict())
self.poscar_init = Poscar.from_dict(poscar.as_dict())
if not self.test:
self.potcar_init = Potcar.from_dict(potcar.as_dict())
if not isinstance(kpoints, str):
self.kpoints_init = Kpoints.from_dict(kpoints.as_dict())
#print (kpoints)
else:
self.kpoints_init = kpoints
self.reuse_path = reuse_path # complete reuse paths
self.extra = kwargs
if qadapter is not None:
self.qadapter = qadapter.from_dict(qadapter.to_dict())
else:
self.qadapter = None
self.script_name = script_name
config_dict = {}
config_dict['INCAR'] = self.incar_init.as_dict()
config_dict['POSCAR'] = self.poscar_init.as_dict()
# caution the key and the value are not always the same
if not self.test:
config_dict['POTCAR'] = self.potcar_init.as_dict()
# dict(zip(self.potcar.as_dict()['symbols'],
# self.potcar.as_dict()['symbols']))
if not isinstance(kpoints, str):
#print (self.kpoints_init)
config_dict['KPOINTS'] = self.kpoints_init.as_dict()
else:
# need to find a way to dictify this kpoints string more
# appropriately
config_dict['KPOINTS'] = {'kpts_hse': self.kpoints_init}
# self.user_incar_settings = self.incar.as_dict()
DictSet.__init__(self, poscar.structure, config_dict)
#**kwargs)
if vis_logger:
self.logger = vis_logger
else:
self.logger = logger
def from_dict(cls, d):
incar = Incar.from_dict(d["incar"])
poscar = Poscar.from_dict(d["poscar"])
potcar = Potcar.from_dict(d["potcar"])
kpoints = Kpoints.from_dict(d["kpoints"])
qadapter = None
if d["qadapter"] is not None:
qadapter = CommonAdapter.from_dict(d["qadapter"])
return MPINTVaspInputSet(d["name"], incar, poscar, potcar,
kpoints, qadapter, **d["kwargs"])
def test_kpt_bands_as_dict_from_dict(self):
file_name = os.path.join(test_dir, 'KPOINTS.band')
k = Kpoints.from_file(file_name)
d = k.as_dict()
import json
json.dumps(d)
# This doesn't work
k2 = Kpoints.from_dict(d)
self.assertEqual(k.kpts, k2.kpts)
self.assertEqual(k.style, k2.style)
self.assertEqual(k.kpts_shift, k2.kpts_shift)
self.assertEqual(k.num_kpts, k2.num_kpts)
def test_kpt_bands_as_dict_from_dict(self):
file_name = self.TEST_FILES_DIR / 'KPOINTS.band'
k = Kpoints.from_file(file_name)
d = k.as_dict()
import json
json.dumps(d)
# This doesn't work
k2 = Kpoints.from_dict(d)
self.assertEqual(k.kpts, k2.kpts)
self.assertEqual(k.style, k2.style)
self.assertEqual(k.kpts_shift, k2.kpts_shift)
self.assertEqual(k.num_kpts, k2.num_kpts)
def from_dict(cls, d):
incar = Incar.from_dict(d["incar"])
poscar = Poscar.from_dict(d["poscar"])
potcar = Potcar.from_dict(d["potcar"])
kpoints = Kpoints.from_dict(d["kpoints"])
qadapter = None
if d["qadapter"] is not None:
qadapter = CommonAdapter.from_dict(d["qadapter"])
script_name = d["script_name"]
return MPINTVaspInputSet(d["name"], incar, poscar, potcar,
kpoints, qadapter,
script_name=script_name,
vis_logger=logging.getLogger(d["logger"]),
**d["kwargs"])
def from_dict(cls, d):
incar = Incar.from_dict(d["incar"])
poscar = Poscar.from_dict(d["poscar"])
potcar = Potcar.from_dict(d["potcar"])
kpoints = Kpoints.from_dict(d["kpoints"])
cal = Calibrate(incar, poscar, potcar, kpoints,
system=d["system"], is_matrix = d["is_matrix"],
Grid_type = d["Grid_type"],
parent_job_dir=d["parent_job_dir"],
job_dir=d["job_dir"], qadapter=d.get("qadapter"),
job_cmd=d["job_cmd"], wait=d["wait"],
turn_knobs=d["turn_knobs"])
cal.job_dir_list = d["job_dir_list"]
cal.job_ids = d["job_ids"]
return cal
def from_dict(cls, d):
incar = Incar.from_dict(d["incar"])
poscar = Poscar.from_dict(d["poscar"])
potcar = Potcar.from_dict(d["potcar"])
kpoints = Kpoints.from_dict(d["kpoints"])
cal = Calibrate(incar, poscar, potcar, kpoints,
system=d["system"], is_matrix=d["is_matrix"],
Grid_type=d["Grid_type"],
parent_job_dir=d["parent_job_dir"],
job_dir=d["job_dir"], qadapter=d.get("qadapter"),
job_cmd=d["job_cmd"], wait=d["wait"],
turn_knobs=d["turn_knobs"])
cal.job_dir_list = d["job_dir_list"]
cal.job_ids = d["job_ids"]
return cal
def __init__(self, name, incar, poscar, kpoints, potcar=None,
qadapter=None, script_name='submit_script',
vis_logger=None, reuse_path=None, test=False,
**kwargs):
"""
default INCAR from config_dict
"""
self.name = name
self.test = test
self.incar_init = Incar.from_dict(incar.as_dict())
self.poscar_init = Poscar.from_dict(poscar.as_dict())
if not self.test:
self.potcar_init = Potcar.from_dict(potcar.as_dict())
if not isinstance(kpoints, str):
self.kpoints_init = Kpoints.from_dict(kpoints.as_dict())
else:
self.kpoints_init = kpoints
self.reuse_path = reuse_path # complete reuse paths
self.extra = kwargs
if qadapter is not None:
self.qadapter = qadapter.from_dict(qadapter.to_dict())
else:
self.qadapter = None
self.script_name = script_name
config_dict = {}
config_dict['INCAR'] = self.incar_init.as_dict()
config_dict['POSCAR'] = self.poscar_init.as_dict()
# caution the key and the value are not always the same
if not self.test:
config_dict['POTCAR'] = self.potcar_init.as_dict()
# dict(zip(self.potcar.as_dict()['symbols'],
# self.potcar.as_dict()['symbols']))
if not isinstance(kpoints, str):
config_dict['KPOINTS'] = self.kpoints_init.as_dict()
else:
# need to find a way to dictify this kpoints string more
# appropriately
config_dict['KPOINTS'] = {'kpts_hse':self.kpoints_init}
# self.user_incar_settings = self.incar.as_dict()
DictSet.__init__(self, poscar.structure, config_dict)
#**kwargs)
if vis_logger:
self.logger = vis_logger
else:
self.logger = logger
def set_kpoints(self, kpoint=None, poscar=None, ibzkpth=None):
"""
set the kpoint
"""
# useful to check if a poscar is supplied from setup_poscar_jobs (most often the case)
# or this is a single poscar use case
if not poscar:
poscar = self.poscar
# splitting into two if elif branches means fewer if statements to check on
# a run
# Most general method of setting the k-points for
# different grid types
# NOTE: requires that at least one k-points value be passed
# as a turn - knobs list value
# this is not true for values that may be caculated out of
# a database
# use this part only if this is a non-database run for example
# for k-points calibration
if not self.database:
if self.Grid_type == 'M':
self.kpoints = Kpoints.monkhorst_automatic(kpts=kpoint)
elif self.Grid_type == 'A':
self.kpoints = Kpoints.automatic(subdivisions=kpoint)
elif self.Grid_type == 'G':
self.kpoints = Kpoints.gamma_automatic(kpts=kpoint)
elif self.Grid_type == '3D_vol':
self.kpoints = Kpoints.automatic_density_by_vol(structure=poscar.structure,
kppvol=kpoint)
elif self.Grid_type == 'bulk_bands_pbe':
self.kpoints = Kpoints.automatic_linemode(divisions=kpoint,
ibz=HighSymmKpath(
poscar.structure))
elif self.Grid_type == 'D':
self.kpoints = Kpoints.automatic_density(structure=poscar.structure,kppa=kpoint)
elif self.Grid_type == 'Finer_G_Mesh':
# kpoint is the scaling factor and self.kpoints is the old kpoint mesh
self.logger.info('Setting Finer G Mesh for {0} by scale {1}'.format(kpoint, self.finer_kpoint))
self.kpoints = Kpoints.gamma_automatic(kpts = \
[i * self.finer_kpoint for i in kpoint])
self.logger.info('Finished scaling operation of k-mesh')
# applicable for database runs
# future constructs or settinsg can be activated via a yaml file
# database yaml file or better still the input deck from its speification
# decides what combination of input calibrate constructor settings to use
# one of them being the grid_type tag
elif self.database == 'twod':
# set of kpoints settings according to the 2D database profile
# the actual settings of k-points density
# will in future come from any database input file set
if self.Grid_type == 'hse_bands_2D_prep':
kpoint_dict = Kpoints.automatic_gamma_density(poscar.structure,
200).as_dict()
kpoint_dict['kpoints'][0][2] = 1 # remove z kpoints
self.kpoints = Kpoints.from_dict(kpoint_dict)
elif self.Grid_type == 'hse_bands_2D':
# can at most return the path to the correct kpoints file
# needs kpoints to be written out in instrument in a different way
# not using the Kpoints object
self.kpoints = get_2D_hse_kpoints(poscar.structure, ibzkpth)
elif self.Grid_type == 'bands_2D':
kpoint_dict = Kpoints.automatic_linemode(divisions=20,
ibz=HighSymmKpath(poscar.structure)).as_dict()
self.kpoints = Kpoints.from_dict(kpoint_dict)
elif self.Grid_type == 'relax_2D':
# general relaxation settings for 2D
kpoint_dict = Kpoints.automatic_gamma_density(poscar.structure,
1000).as_dict()
kpoint_dict['kpoints'][0][2] = 1
self.kpoints = Kpoints.from_dict(kpoint_dict)
elif self.Grid_type == 'relax_3D':
# general relaxation settings for 3D
kpoint_dict = Kpoints.automatic_gamma_density(
poscar.structure, 1000)
self.kpoints = Kpoints.from_dict(kpoint_dict)
from matgendb.creator import VaspToDbTaskDrone
drone = VaspToDbTaskDrone(collection='test')
for j in ds:
drone.assimilate(j.path)
#%%
from matgendb.query_engine import QueryEngine
qe = QueryEngine(collection='test')
# entries = qe.get_entries({'dir_name':'localhost:/home/lorenzo/tests/project-test/tutorials/Si-BS-dataset/3-PBE-BS'})
entries = qe.get_entries({'chemsys': 'Si'},
optional_data=['calculations'],
inc_structure=True)
#%%
e = entries[0]
inputs = e.data['calculations'][0]['input']
incar = Incar(inputs['incar'])
kpoints = Kpoints.from_dict(inputs['kpoints'])
poscar = Poscar(e.structure)
potcar = Potcar(inputs['potcar'])
vaspinput = VaspInput(incar, kpoints, poscar, potcar)
#%%
def make_vasp_defect_files(defects, path_base, user_settings={}, hse=False):
"""
Generates VASP files for defect computations
Args:
defect_structs:
the defects data as a dictionnary. Ideally this is generated
from core.defectsmaker.ChargedDefectsStructures.
path_base:
where we write the files
user_settings:
Settings in dict format to override the defaults used in
generating vasp files. The format of the dictionary is
{'defects:{'INCAR':{...},'KPOINTS':{...},
'bulk':{'INCAR':{...},'KPOINTS':{...}}
hse:
hse run or not
"""
bulk_sys = defects['bulk']['supercell']
comb_defs = functools.reduce(lambda x, y: x+y, [
defects[key] for key in defects if key != 'bulk'])
# User setting dicts
user_settings = deepcopy(user_settings)
user_incar = user_settings.pop('INCAR', {})
user_incar_blk_tmp = user_incar.pop('bulk', {})
user_incar_blk_def = user_incar.pop('defects', {})
user_incar.pop('dielectric', {})
user_incar_blk = deepcopy(user_incar)
user_incar_def = deepcopy(user_incar)
user_incar_blk.update(user_incar_blk_tmp)
user_incar_def.update(user_incar_blk_def)
user_kpoints = user_settings.pop('KPOINTS', {})
potcar_settings = user_settings.pop('POTCAR', {})
potcar_functional = potcar_settings.pop('functional', 'PBE')
for defect in comb_defs:
for charge in defect['charges']:
s = defect['supercell']
dict_transf = {
'defect_type': defect['name'],
'defect_site': defect['unique_site'],
'defect_supercell_site': defect['bulk_supercell_site'],
'defect_multiplicity': defect['site_multiplicity'],
'charge': charge, 'supercell': s['size']}
if 'substitution_specie' in defect:
dict_transf['substitution_specie'] = defect['substitution_specie']
defect_relax_set = DefectRelaxSet(
s['structure'], user_incar_settings=user_incar_def,
user_potcar_settings=potcar_settings,
potcar_functional=potcar_functional, charge=charge)
path = os.path.join(path_base, defect['name'],
"charge_"+str(charge))
try:
potcar = defect_relax_set.potcar
except:
potcar = None
if potcar or not charge:
defect_relax_set.write_input(path)
incar = defect_relax_set.incar if hse else {}
kpoints = Kpoints.from_dict(user_kpoints) if user_kpoints \
else None
write_additional_files(path, dict_transf, incar=incar,
kpoints=kpoints, hse=hse)
else:
os.makedirs(path)
with open(os.path.join(path, 'readme.txt'), 'w') as fp:
print("Vasp input files not generated for charged defects "
"due to unavailability of POTCAR. "
"If charged defects desired, please supply POTCAR file "
"path to .pmgrc.yaml file.", end="", file=fp)
# Generate bulk supercell inputs
s = bulk_sys
dict_transf = {'defect_type': 'bulk', 'supercell': s['size']}
#potcar_functional = user_potcar.get('functional', 'PBE')
blk_static_set = DefectStaticSet(s['structure'],
user_incar_settings=user_incar_blk,
user_potcar_settings=potcar_settings,
potcar_functional=potcar_functional)
path = os.path.join(path_base, 'bulk')
blk_static_set.write_input(path)
incar = blk_static_set.incar if hse else {}
kpoints = Kpoints.from_dict(user_kpoints) if user_kpoints else None
write_additional_files(path, dict_transf, incar=incar, kpoints=kpoints,
hse=hse)
