def __init__(self,
rlxd_str,
nd=0.01,
ns=0.08,
num_norm=4,
num_shear=4,
symmetry=False):
"""
constructs the deformed geometries of a structure. Generates
m + n deformed structures according to the supplied parameters.
Args:
rlxd_str (structure): structure to undergo deformation, if
fitting elastic tensor is desired, should be a geometry
optimized structure
nd (float): maximum perturbation applied to normal deformation
ns (float): maximum perturbation applied to shear deformation
m (int): number of deformation structures to generate for
normal deformation, must be even
n (int): number of deformation structures to generate for
shear deformation, must be even
"""
if num_norm % 2 != 0:
raise ValueError("Number of normal deformations (num_norm)"
" must be even.")
if num_shear % 2 != 0:
raise ValueError("Number of shear deformations (num_shear)"
" must be even.")
norm_deformations = np.linspace(-nd, nd, num=num_norm + 1)
norm_deformations = norm_deformations[norm_deformations.nonzero()]
shear_deformations = np.linspace(-ns, ns, num=num_shear + 1)
shear_deformations = shear_deformations[shear_deformations.nonzero()]
self.undeformed_structure = rlxd_str
self.deformations = []
self.def_structs = []
# Generate deformations
for ind in [(0, 0), (1, 1), (2, 2)]:
for amount in norm_deformations:
defo = Deformation.from_index_amount(ind, amount)
self.deformations.append(defo)
for ind in [(0, 1), (0, 2), (1, 2)]:
for amount in shear_deformations:
defo = Deformation.from_index_amount(ind, amount)
self.deformations.append(defo)
# Perform symmetry reduction if specified
if symmetry:
self.deformations, self.sym_dict = \
symmetry_reduce(self.undeformed_structure, self.deformations)
self.def_structs = [
defo.apply_to_structure(rlxd_str) for defo in self.deformations
]
def generate_elastic_workflow(structure, tags=None):
"""
Generates a standard production workflow.
Notes:
Uses a primitive structure transformed into
the conventional basis (for equivalent deformations).
Adds the "minimal" category to the minimal portion
of the workflow necessary to generate the elastic tensor,
and the "minimal_full_stencil" category to the portion that
includes all of the strain stencil, but is symmetrically complete
"""
if tags == None:
tags = []
# transform the structure
ieee_rot = Tensor.get_ieee_rotation(structure)
if not SquareTensor(ieee_rot).is_rotation(tol=0.005):
raise ValueError("Rotation matrix does not satisfy rotation conditions")
symm_op = SymmOp.from_rotation_and_translation(ieee_rot)
ieee_structure = structure.copy()
ieee_structure.apply_operation(symm_op)
# construct workflow
wf = wf_elastic_constant(ieee_structure)
# Set categories, starting with optimization
opt_fws = get_fws_and_tasks(wf, fw_name_constraint="optimization")
wf.fws[opt_fws[0][0]].spec['elastic_category'] = "minimal"
# find minimal set of fireworks using symmetry reduction
fws_by_strain = {Strain(fw.tasks[-1]['pass_dict']['strain']): n
for n, fw in enumerate(wf.fws) if 'deformation' in fw.name}
unique_tensors = symmetry_reduce(list(fws_by_strain.keys()), ieee_structure)
for unique_tensor in unique_tensors:
fw_index = get_tkd_value(fws_by_strain, unique_tensor)
if np.isclose(unique_tensor, 0.005).any():
wf.fws[fw_index].spec['elastic_category'] = "minimal"
else:
wf.fws[fw_index].spec['elastic_category'] = "minimal_full_stencil"
# Add tags
if tags:
wf = add_tags(wf, tags)
wf = add_modify_incar(wf)
priority = 500 - structure.num_sites
wf = add_priority(wf, priority)
for fw in wf.fws:
if fw.spec.get('elastic_category') == 'minimal':
fw.spec['_priority'] += 2000
elif fw.spec.get('elastic_category') == 'minimal_full_stencil':
fw.spec['_priority'] += 1000
return wf
def __init__(self,
rlxd_str,
norm_strains=[-0.01, -0.005, 0.005, 0.01],
shear_strains=[-0.06, -0.03, 0.03, 0.06],
symmetry=False):
"""
constructs the deformed geometries of a structure. Generates
m + n deformed structures according to the supplied parameters.
Args:
rlxd_str (structure): structure to undergo deformation, if
fitting elastic tensor is desired, should be a geometry
optimized structure
norm_strains (list of floats): strain values to apply
to each normal mode.
shear_strains (list of floats): strain values to apply
to each shear mode.
symmetry (bool): whether or not to use symmetry reduction.
"""
self.undeformed_structure = rlxd_str
self.deformations = []
self.def_structs = []
# Generate deformations
for ind in [(0, 0), (1, 1), (2, 2)]:
for amount in norm_strains:
strain = Strain.from_index_amount(ind, amount)
self.deformations.append(strain.deformation_matrix)
for ind in [(0, 1), (0, 2), (1, 2)]:
for amount in shear_strains:
strain = Strain.from_index_amount(ind, amount)
self.deformations.append(strain.deformation_matrix)
# Perform symmetry reduction if specified
if symmetry:
self.sym_dict = symmetry_reduce(self.deformations,
self.undeformed_structure)
self.deformations = list(self.sym_dict.keys())
self.def_structs = [
defo.apply_to_structure(rlxd_str) for defo in self.deformations
]
def __init__(self, structure, norm_strains=None, shear_strains=None,
symmetry=False):
"""
constructs the deformed geometries of a structure. Generates
m + n deformed structures according to the supplied parameters.
Args:
structure (Structure): structure to undergo deformation
norm_strains (list of floats): strain values to apply
to each normal mode.
shear_strains (list of floats): strain values to apply
to each shear mode.
symmetry (bool): whether or not to use symmetry reduction.
"""
norm_strains = norm_strains or [-0.01, -0.005, 0.005, 0.01]
shear_strains = shear_strains or [-0.06, -0.03, 0.03, 0.06]
self.undeformed_structure = structure
self.deformations = []
self.def_structs = []
# Generate deformations
for ind in [(0, 0), (1, 1), (2, 2)]:
for amount in norm_strains:
strain = Strain.from_index_amount(ind, amount)
self.deformations.append(strain.deformation_matrix)
for ind in [(0, 1), (0, 2), (1, 2)]:
for amount in shear_strains:
strain = Strain.from_index_amount(ind, amount)
self.deformations.append(strain.deformation_matrix)
# Perform symmetry reduction if specified
if symmetry:
self.sym_dict = symmetry_reduce(self.deformations, structure)
self.deformations = list(self.sym_dict.keys())
self.deformed_structures = [defo.apply_to_structure(structure)
for defo in self.deformations]
def get_wf_elastic_constant(structure,
strain_states=None,
stencils=None,
db_file=None,
conventional=False,
order=2,
vasp_input_set=None,
analysis=True,
sym_reduce=False,
tag='elastic',
copy_vasp_outputs=False,
**kwargs):
"""
Returns a workflow to calculate elastic constants.
Firework 1 : write vasp input set for structural relaxation,
run vasp,
pass run location,
database insertion.
Firework 2 - number of total deformations: Static runs on the deformed structures
last Firework : Analyze Stress/Strain data and fit the elastic tensor
Args:
structure (Structure): input structure to be optimized and run.
strain_states (list of Voigt-notation strains): list of ratios of nonzero elements
of Voigt-notation strain, e. g. [(1, 0, 0, 0, 0, 0), (0, 1, 0, 0, 0, 0), etc.].
stencils (list of floats, or list of list of floats): values of strain to multiply
by for each strain state, i. e. stencil for the perturbation along the strain
state direction, e. g. [-0.01, -0.005, 0.005, 0.01]. If a list of lists,
stencils must correspond to each strain state provided.
db_file (str): path to file containing the database credentials.
conventional (bool): flag to convert input structure to conventional structure,
defaults to False.
order (int): order of the tensor expansion to be determined. Defaults to 2 and
currently supports up to 3.
vasp_input_set (VaspInputSet): vasp input set to be used. Defaults to static
set with ionic relaxation parameters set. Take care if replacing this,
default ensures that ionic relaxation is done and that stress is calculated
for each vasp run.
analysis (bool): flag to indicate whether analysis task should be added
and stresses and strains passed to that task
sym_reduce (bool): Whether or not to apply symmetry reductions
tag (str):
copy_vasp_outputs (bool): whether or not to copy previous vasp outputs.
kwargs (keyword arguments): additional kwargs to be passed to get_wf_deformations
Returns:
Workflow
"""
# Convert to conventional if specified
if conventional:
structure = SpacegroupAnalyzer(
structure).get_conventional_standard_structure()
uis_elastic = {
"IBRION": 2,
"NSW": 99,
"ISIF": 2,
"ISTART": 1,
"PREC": "High"
}
vis = vasp_input_set or MPStaticSet(structure,
user_incar_settings=uis_elastic)
strains = []
if strain_states is None:
strain_states = get_default_strain_states(order)
if stencils is None:
stencils = [np.linspace(-0.01, 0.01, 5 +
(order - 2) * 2)] * len(strain_states)
if np.array(stencils).ndim == 1:
stencils = [stencils] * len(strain_states)
for state, stencil in zip(strain_states, stencils):
strains.extend(
[Strain.from_voigt(s * np.array(state)) for s in stencil])
# Remove zero strains
strains = [strain for strain in strains if not (abs(strain) < 1e-10).all()]
vstrains = [strain.voigt for strain in strains]
if np.linalg.matrix_rank(vstrains) < 6:
# TODO: check for sufficiency of input for nth order
raise ValueError(
"Strain list is insufficient to fit an elastic tensor")
deformations = [s.deformation_matrix for s in strains]
if sym_reduce:
deformations = symmetry_reduce(deformations, structure)
wf_elastic = get_wf_deformations(structure,
deformations,
tag=tag,
db_file=db_file,
vasp_input_set=vis,
copy_vasp_outputs=copy_vasp_outputs,
**kwargs)
if analysis:
defo_fws_and_tasks = get_fws_and_tasks(
wf_elastic,
fw_name_constraint="deformation",
task_name_constraint="Transmuted")
for idx_fw, idx_t in defo_fws_and_tasks:
defo = wf_elastic.fws[idx_fw].tasks[idx_t][
'transformation_params'][0]['deformation']
pass_dict = {
'strain': Deformation(defo).green_lagrange_strain.tolist(),
'stress': '>>output.ionic_steps.-1.stress',
'deformation_matrix': defo
}
if sym_reduce:
pass_dict.update(
{'symmops': get_tkd_value(deformations, defo)})
mod_spec_key = "deformation_tasks->{}".format(idx_fw)
pass_task = pass_vasp_result(pass_dict=pass_dict,
mod_spec_key=mod_spec_key)
wf_elastic.fws[idx_fw].tasks.append(pass_task)
fw_analysis = Firework(ElasticTensorToDb(structure=structure,
db_file=db_file,
order=order,
fw_spec_field='tags'),
name="Analyze Elastic Data",
spec={"_allow_fizzled_parents": True})
wf_elastic.append_wf(Workflow.from_Firework(fw_analysis),
wf_elastic.leaf_fw_ids)
wf_elastic.name = "{}:{}".format(structure.composition.reduced_formula,
"elastic constants")
return wf_elastic