def create_new_vasp_run(self, path, structure):
"""
Creates a static force calculation at path using structure as the initial structure and self.vasp_run_inputs as the run inputs.
"""
run_inputs = copy.deepcopy(self.vasp_run_inputs)
if 'submission_node_count' in run_inputs:
node_count = run_inputs.pop('submission_node_count')
else:
node_count = None
kpoints = Kpoints(
scheme_string=run_inputs.pop('kpoint_scheme'),
subdivisions_list=run_inputs.pop('kpoint_subdivisions_list'))
incar = IncarMaker.get_static_incar(run_inputs)
input_set = VaspInputSet(structure,
kpoints,
incar,
auto_change_lreal=('lreal' not in run_inputs),
auto_change_npar=('npar' not in run_inputs))
if node_count != None:
input_set.set_node_count(node_count)
if 'npar' not in run_inputs:
input_set.set_npar_from_number_of_cores()
vasp_run = VaspRun(path=path,
input_set=input_set,
wavecar_path=self.wavecar_path)
def get_next_incar(self):
"""
Returns the incar corresponding to the next run in the relaxation set
"""
incar_modifications_dict = {} #will look like {'ediff':base_ediff, 'encut':encut, ...}
for key, value_list in self.incar_modifier_lists_dictionary.items():
incar_modifications_dict[key] = value_list[self.run_count]
if self.run_count < self.external_relaxation_count:
incar = IncarMaker.get_external_relaxation_incar(incar_modifications_dict)
else:
incar = IncarMaker.get_static_incar(incar_modifications_dict)
if self.static_lwave:
incar['lwave'] = True
return incar
def create_new_vasp_run(self, path, structure): """ Creates a static force calculation at path using structure as the initial structure and self.vasp_run_inputs as the run inputs. """ kpoints = Kpoints(scheme_string=self.vasp_run_inputs['kpoint_scheme'], subdivisions_list=self.vasp_run_inputs['kpoint_subdivisions_list']) incar = IncarMaker.get_accurate_forces_incar() incar['encut'] = self.vasp_run_inputs['encut'] if 'npar' in self.vasp_run_inputs: incar['npar'] = self.vasp_run_inputs['npar'] auto_change_npar = False else: auto_change_npar = True input_set = VaspInputSet(structure, kpoints, incar, auto_change_lreal=False, auto_change_npar=auto_change_npar) vasp_run = VaspRun(path=path, input_set=input_set, wavecar_path=self.wavecar_path)
def encut_converger(base_path, structure, encut_list, base_kpoints_scheme, base_kpoints_subdivisions_list, base_ediff):
"""Takes in a structure, set of encuts, and base params and runs set in base_path"""
encut_convergence_set_path = Path.clean(base_path)
Path.make(encut_convergence_set_path)
for encut in encut_list:
run_path = Path.join(encut_convergence_set_path, str(encut))
kpoints = Kpoints(scheme_string=base_kpoints_scheme, subdivisions_list=base_kpoints_subdivisions_list)
incar = IncarMaker.get_static_incar({'ediff':base_ediff, 'encut':encut})
input_set = VaspInputSet(structure, kpoints, incar)
vasp_run = VaspRun(run_path, input_set=input_set, verbose=False)
if vasp_run.update():
print encut, round(vasp_run.outcar.energy_per_atom, 5), round(vasp_run.outcar.get_calculation_time_in_core_hours(), 2)
else:
pass
def get_energy_of_eigen_chromosome(self, path, eigen_chromosome):
# print "chrom " + str(eigen_chromosome)
structure = self.get_distorted_structure_from_eigen_chromosome(
eigen_chromosome)
run_inputs = copy.deepcopy(self.vasp_run_inputs_dictionary)
if 'submission_node_count' in run_inputs:
node_count = run_inputs.pop('submission_node_count')
else:
node_count = None
kpoints = Kpoints(
scheme_string=run_inputs.pop('kpoint_scheme'),
subdivisions_list=run_inputs.pop('kpoint_subdivisions_list'))
incar = IncarMaker.get_static_incar(run_inputs)
input_set = VaspInputSet(structure,
kpoints,
incar,
auto_change_lreal=('lreal' not in run_inputs),
auto_change_npar=('npar' not in run_inputs))
if node_count != None:
input_set.set_node_count(node_count)
if 'npar' not in run_inputs:
input_set.set_npar_from_number_of_cores()
vasp_run = VaspRun(
path=path,
input_set=input_set,
wavecar_path=self.reference_completed_vasp_relaxation_run.
get_wavecar_path())
vasp_run.update()
if vasp_run.complete:
vasp_run.delete_wavecar_if_complete()
return vasp_run.get_final_energy(per_atom=False)
else:
return None
def initialize_vasp_lepsilon_calculation(self):
"""
Sets up a run for the calculation of dielectric and born effective charge tensors. This is necessary if the Non-Analytical correction is used (for polar materials).
"""
kpoints = Kpoints(
scheme_string=self.vasp_run_inputs['kpoint_scheme'],
subdivisions_list=[
self.vasp_run_inputs['kpoint_subdivisions_list'][i] *
self.phonopy_inputs['supercell_dimensions'][i]
for i in range(3)
])
incar = IncarMaker.get_lepsilon_incar()
incar['encut'] = self.vasp_run_inputs['encut']
input_set = VaspInputSet(self.initial_structure,
kpoints,
incar,
auto_change_npar=False)
self.lepsilon_calculation = VaspRun(
path=self.get_lepsion_calculation_path(), input_set=input_set)
def kpoints_converger(base_path, structure, kpoints_lists, base_kpoints_scheme, base_encut, base_ediff, incar_modification_dictionary=None):
convergence_set_path = Path.clean(base_path)
Path.make(convergence_set_path)
for kpoints_list in kpoints_lists:
run_path = Path.join(convergence_set_path, "_".join(str(kpoints) for kpoints in kpoints_list))
kpoints = Kpoints(scheme_string=base_kpoints_scheme, subdivisions_list=kpoints_list)
incar_mod = {'ediff':base_ediff, 'encut':base_encut}
if incar_modification_dictionary:
for key, value in incar_modification_dictionary.items():
incar_mod[key] = value
incar = IncarMaker.get_static_incar(incar_mod)
input_set = VaspInputSet(structure, kpoints, incar)
vasp_run = VaspRun(run_path, input_set=input_set, verbose=False)
if vasp_run.update():
print "_".join(str(kpoints) for kpoints in kpoints_list), round(vasp_run.outcar.energy_per_atom, 5), round(vasp_run.outcar.get_calculation_time_in_core_hours(), 2)
else:
vasp_run.view(['kpoints','_job_output.txt'])
relaxation = VaspRelaxation(path=Path.join(base_path, 'relaxation'), initial_structure=initial_structure, input_dictionary=initial_relaxation_input_dictionary) if not relaxation.complete: relaxation.update() else: relaxed_structure = relaxation.final_structure force_calculation_path = Path.join(base_path, 'dfpt_force_calculation') kpoints = Kpoints(scheme_string=kpoint_scheme, subdivisions_list=kpoint_subdivisions_list) incar = IncarMaker.get_dfpt_hessian_incar(dfpt_incar_settings) input_set = VaspInputSet(relaxed_structure, kpoints, incar, auto_change_lreal=False, auto_change_npar=False) dfpt_force_run = VaspRun(path=force_calculation_path, input_set=input_set) if not dfpt_force_run.complete: dfpt_force_run.update() else: hessian = Hessian(dfpt_force_run.outcar) #hessian.print_eigen_components() hessian.print_eigenvalues()
def term_acceptance_function(expansion_term):
variables = expansion_term.get_active_variables()
if not expansion_term.is_pure_type('strain')
#remove all terms with in-plane strain variables in them - these are fixed to 0 for (100) epitaxy
for variable in variables:
if variable.type_string == 'strain' and variable.index in [0, 1, 5]:
return False
#assume no forces or stresses on the cell
if expansion_term.order == 1:
return False
#only expand to second order w.r.t. strain
if expansion_term.is_pure_type('strain') and expansion_term.order > 2:
return False
#for perovskite structure under arbitrary homogeneous strain, displacement terms are centrosymmetric
if expansion_term.is_centrosymmetric():
return False
#only go to fourth order in single variable dsiplacement terms - don't do fourth order cross terms
if expansion_term.order == 4 and not expansion_term.has_single_variable():
return False
return True
taylor_expansion = TaylorExpansion(variables_list=variables, term_acceptance_function=term_acceptance_function)
print
print "Number of terms:", len(taylor_expansion)
print '\n\t\t',
print taylor_expansion
print '\n'*3
base_path = "./"
perturbation_magnitudes_dictionary = {'strain': 0.01, 'displacement': 0.2}
a = 3.79
Nx = 1
Ny = 1
Nz = 1
vasp_run_inputs_dictionary = {
'kpoint_scheme': 'Monkhorst',
'kpoint_subdivisions_list': [8, 8, 8],
'encut': 900,
'addgrid': True
}
relaxation_input_dictionary= {
'external_relaxation_count': 3,
'isif': [6],
'kpoint_schemes_list': [vasp_run_inputs_dictionary['kpoint_scheme']],
'kpoint_subdivisions_lists': [vasp_run_inputs_dictionary['kpoint_subdivisions_list']],
'ediff': [0.00001, 1e-7, 1e-9],
'encut': [vasp_run_inputs_dictionary['encut']],
'submission_script_modification_keys_list': ['100'],
'lwave': [True]
}
initial_structure=Perovskite(supercell_dimensions=[Nx, Ny, Nz], lattice=[[a*Nx, 0.0, 0.0], [0.0, a*Ny, 0.0], [0.0, 0.0, a*Nz*1.02]], species_list=['Sr', 'Ti', 'O'])
relaxation = VaspRelaxation(path=Path.join(base_path, 'relaxation'), initial_structure=initial_structure, input_dictionary=relaxation_input_dictionary)
if not relaxation.complete:
relaxation.update()
else:
relaxed_structure = relaxation.final_structure
force_calculation_path = Path.join(base_path, 'dfpt_force_calculation')
kpoints = Kpoints(scheme_string=vasp_run_inputs_dictionary['kpoint_scheme'], subdivisions_list=vasp_run_inputs_dictionary['kpoint_subdivisions_list'])
incar = IncarMaker.get_dfpt_hessian_incar({'encut': vasp_run_inputs_dictionary['encut']})
input_set = VaspInputSet(relaxed_structure, kpoints, incar, auto_change_lreal=False, auto_change_npar=False)
dfpt_force_run = VaspRun(path=force_calculation_path, input_set=input_set)
if not dfpt_force_run.complete:
dfpt_force_run.update()
else:
hessian = Hessian(dfpt_force_run.outcar)
eigen_structure = EigenStructure(reference_structure=relaxed_structure, hessian=hessian)
eigen_structure.print_eigen_components()
de_path = Path.join(base_path, 'term_coefficient_calculations')
derivative_evaluator = DerivativeEvaluator(path=de_path, reference_structure=relaxed_structure, hessian=hessian, taylor_expansion=taylor_expansion,
reference_completed_vasp_relaxation_run=relaxation, vasp_run_inputs_dictionary=vasp_run_inputs_dictionary, perturbation_magnitudes_dictionary=perturbation_magnitudes_dictionary)
derivative_evaluator.update()
print derivative_evaluator.taylor_expansion
def run_misfit_strain(path, misfit_strain, input_dictionary,
initial_relaxation_input_dictionary, dfpt_incar_settings,
derivative_evaluation_vasp_run_inputs_dictionary,
minima_relaxation_input_dictionary,
epitaxial_relaxation_input_dictionary):
Path.make(path)
guessed_minima_data_path = Path.join(path, 'guessed_chromosomes')
species_list = input_dictionary['species_list']
reference_lattice_constant = input_dictionary['reference_lattice_constant']
Nx = input_dictionary['supercell_dimensions_list'][0]
Ny = input_dictionary['supercell_dimensions_list'][1]
Nz = input_dictionary['supercell_dimensions_list'][2]
displacement_finite_differences_step_size = input_dictionary[
'displacement_finite_differences_step_size']
perturbation_magnitudes_dictionary = input_dictionary[
'perturbation_magnitudes_dictionary']
a = reference_lattice_constant * (1.0 + misfit_strain)
initial_structure = Perovskite(
supercell_dimensions=[Nx, Ny, Nz],
lattice=[[a * Nx, 0.0, 0.0], [0.0, a * Ny, 0.0],
[
0.0, 0.0, reference_lattice_constant * Nz *
(1.0 + 0.3 * (1.0 - (a / reference_lattice_constant)))
]],
species_list=species_list)
relaxation = VaspRelaxation(
path=Path.join(path, 'relaxation'),
initial_structure=initial_structure,
input_dictionary=initial_relaxation_input_dictionary)
if not relaxation.complete:
relaxation.update()
return False
relaxed_structure = relaxation.final_structure
relaxed_structure_path = Path.join(path, 'output_relaxed_structure')
relaxed_structure.to_poscar_file_path(relaxed_structure_path)
force_calculation_path = Path.join(path, 'dfpt_force_calculation')
kpoints = Kpoints(scheme_string=kpoint_scheme,
subdivisions_list=kpoint_subdivisions_list)
incar = IncarMaker.get_dfpt_hessian_incar(dfpt_incar_settings)
input_set = VaspInputSet(relaxed_structure,
kpoints,
incar,
auto_change_lreal=False,
auto_change_npar=False)
input_set.incar['lepsilon'] = True
dfpt_force_run = VaspRun(path=force_calculation_path, input_set=input_set)
if not dfpt_force_run.complete:
dfpt_force_run.update()
return False
hessian = Hessian(dfpt_force_run.outcar)
if input_dictionary['write_hessian_data']:
hessian.print_eigenvalues_to_file(
Path.join(path, 'output_eigen_values'))
hessian.print_eigen_components_to_file(
Path.join(path, 'output_eigen_components'))
hessian.print_mode_effective_charge_vectors_to_file(
Path.join(path, 'output_mode_effective_charge_vectors'),
relaxed_structure)
eigen_structure = EigenStructure(reference_structure=relaxed_structure,
hessian=hessian)
mode_structures_path = Path.join(path, 'mode_rendered_structures')
Path.make(mode_structures_path)
mode_charge_file = File(
Path.join(path, 'output_mode_effective_charge_vectors'))
sorted_eigen_pairs = hessian.get_sorted_hessian_eigen_pairs_list()
for i, structure in enumerate(
eigen_structure.get_mode_distorted_structures_list(
amplitude=0.6)):
if i > 30:
break
structure.to_poscar_file_path(
Path.join(
mode_structures_path, 'u' + str(i + 1) + '_' +
str(round(sorted_eigen_pairs[i].eigenvalue, 2)) + '.vasp'))
structure.lattice = Lattice([[8.0, 0.0, 0.0], [0.0, 8.0, 0.0],
[0.0, 0.0, 8.0]])
mode_charge_file[i] += ' ' + structure.get_spacegroup_string(
symprec=0.2) + ' ' + structure.get_spacegroup_string(
symprec=0.1) + ' ' + structure.get_spacegroup_string(
symprec=0.001)
mode_charge_file.write_to_path()
#sys.exit()
################################################### random structure searcher
if True:
rand_path = Path.join(path, 'random_trials')
Path.make(rand_path)
num_guesses = 1
num_modes = 12
max_amplitude = 0.6
if misfit_strain == 0.02:
eigen_structure = EigenStructure(
reference_structure=relaxed_structure, hessian=hessian)
for i in range(num_guesses):
trial_path = Path.join(rand_path, str(i))
if not Path.exists(trial_path):
initial_structure_trial = eigen_structure.get_random_structure(
mode_count_cutoff=num_modes,
max_amplitude=max_amplitude)
trial_relaxation = VaspRelaxation(
path=trial_path,
initial_structure=initial_structure_trial,
input_dictionary=minima_relaxation_input_dictionary)
else:
trial_relaxation = VaspRelaxation(path=trial_path)
print "Updating random trial relaxation at " + trial_relaxation.path + " Status is " + trial_relaxation.get_status_string(
)
trial_relaxation.update()
if trial_relaxation.complete:
print "Trial " + str(i)
print trial_relaxation.get_data_dictionary()
return None
###################################################
if not Path.exists(guessed_minima_data_path):
variable_specialty_points_dictionary = input_dictionary[
'variable_specialty_points_dictionary_set'][
misfit_strain] if input_dictionary.has_key(
misfit_strain) else {}
derivative_evaluation_path = Path.join(
path, 'expansion_coefficient_calculations')
derivative_evaluator = DerivativeEvaluator(
path=derivative_evaluation_path,
reference_structure=relaxed_structure,
hessian=hessian,
reference_completed_vasp_relaxation_run=relaxation,
vasp_run_inputs_dictionary=
derivative_evaluation_vasp_run_inputs_dictionary,
perturbation_magnitudes_dictionary=
perturbation_magnitudes_dictionary,
displacement_finite_differences_step_size=
displacement_finite_differences_step_size,
status_file_path=Path.join(path, 'output_derivative_plot_data'),
variable_specialty_points_dictionary=
variable_specialty_points_dictionary,
max_displacement_variables=input_dictionary[
'max_displacement_variables'])
derivative_evaluator.update()
else:
minima_path = Path.join(path, 'minima_relaxations')
minima_relaxer = MinimaRelaxer(
path=minima_path,
reference_structure=relaxed_structure,
reference_completed_vasp_relaxation_run=relaxation,
hessian=hessian,
vasp_relaxation_inputs_dictionary=
minima_relaxation_input_dictionary,
eigen_chromosome_energy_pairs_file_path=guessed_minima_data_path,
log_base_path=path,
max_minima=input_dictionary['max_minima'])
minima_relaxer.update()
minima_relaxer.print_status_to_file(
Path.join(path, 'output_minima_relaxations_status'))
if minima_relaxer.complete:
print "Minima relaxer complete: sorting the relaxations to find the lowest energy structure."
#minima_relaxer.print_selected_uniques_to_file(file_path=Path.join(path, 'output_selected_unique_minima_relaxations'))
sorted_uniques = minima_relaxer.get_sorted_unique_relaxation_data_list(
)
return sorted_uniques
def __init__(self, vasp_calculation_input_dictionary):
vasp_calculation_input_dictionary = copy.deepcopy(
vasp_calculation_input_dictionary)
vasp_calculation_input_dictionary = {
k.lower(): v
for k, v in vasp_calculation_input_dictionary.items()
} #enforce all keys lowercase
path = Path.clean(vasp_calculation_input_dictionary.pop('path'))
information_structure = None #used for number of nodes and potcar
if isinstance(vasp_calculation_input_dictionary['structure'],
Structure):
initial_structure = vasp_calculation_input_dictionary.pop(
'structure')
information_structure = initial_structure
contcar_path = None
else:
initial_structure = None
contcar_path = vasp_calculation_input_dictionary.pop('structure')
information_structure = Structure(contcar_path)
wavecar_path = vasp_calculation_input_dictionary.pop(
'wavecar_path'
) if 'wavecar_path' in vasp_calculation_input_dictionary else None
chargecar_path = vasp_calculation_input_dictionary.pop(
'chargecar_path'
) if 'chargecar_path' in vasp_calculation_input_dictionary else None
incar_template = vasp_calculation_input_dictionary.pop(
'incar_template'
) if 'incar_template' in vasp_calculation_input_dictionary else None
kpoints_scheme = vasp_calculation_input_dictionary.pop(
'kpoints_scheme'
) if 'kpoints_scheme' in vasp_calculation_input_dictionary else None
kpoints_list = [
int(x) for x in vasp_calculation_input_dictionary.pop(
'kpoints_list').split(' ')
] if ('kpoints_list' in vasp_calculation_input_dictionary
and vasp_calculation_input_dictionary['kpoints_list'] != None
) else None
potcar_type = vasp_calculation_input_dictionary.pop(
'potcar_type'
) if 'potcar_type' in vasp_calculation_input_dictionary else 'lda_paw'
vasp_code_type = vasp_calculation_input_dictionary.pop(
'vasp_code_type'
) if 'vasp_code_type' in vasp_calculation_input_dictionary else 'standard'
node_count = vasp_calculation_input_dictionary.pop(
'node_count'
) if 'node_count' in vasp_calculation_input_dictionary else None
use_mp_hubbard_u = vasp_calculation_input_dictionary.pop(
'use_mp_hubbard_u'
) if 'use_mp_hubbard_u' in vasp_calculation_input_dictionary else None
for file_path in [wavecar_path, chargecar_path]:
if file_path != None and not Path.exists(file_path):
print "Warning: Path " + str(
file_path) + " specified does not exist. Not using."
#raise Exception("Path " + str(file_path) + " specified does not exist.")
if kpoints_scheme != None and kpoints_list != None:
kpoints = Kpoints(scheme_string=kpoints_scheme,
subdivisions_list=kpoints_list)
if 'kspacing' in vasp_calculation_input_dictionary:
raise Exception(
"kpoints are being specified by more than one method.")
elif 'kspacing' not in vasp_calculation_input_dictionary:
raise Exception(
"If kpoints aren't explicitly defined through a scheme and a list, the kspacing tag must be present in the incar."
)
else:
kpoints = None
potcar = Potcar(elements_list=information_structure.get_species_list(),
calculation_type=potcar_type)
submission_script_file = QueueAdapter.get_submission_file()
if os.environ['QUEUE_ADAPTER_HOST'] != 'Savio':
if node_count == None:
submission_script_file = QueueAdapter.modify_number_of_cores_from_num_atoms(
submission_script_file, information_structure.site_count)
else:
submission_script_file = QueueAdapter.set_number_of_nodes(
submission_script_file, node_count)
submission_script_file = QueueAdapter.modify_submission_script(
submission_script_file, modification_key=vasp_code_type)
incar_modifiers = vasp_calculation_input_dictionary #whatever is left should only be incar modifiers - we popped all other keys
for key, value in incar_modifiers.items(
): #make sure there are no None values - these should not be put in INCAR
if value in [None, 'None']:
del incar_modifiers[key]
if 'encut' in incar_modifiers and (
0.1 < incar_modifiers['encut']) and (
incar_modifiers['encut'] <
10.0): #Should use this as a multiplier times enmax
enmax = potcar.get_enmax()
incar_modifiers['encut'] = int(incar_modifiers['encut'] * enmax)
if incar_template == 'static':
incar = IncarMaker.get_static_incar(
custom_parameters_dictionary=incar_modifiers)
elif incar_template == 'external_relaxation':
incar = IncarMaker.get_external_relaxation_incar(
custom_parameters_dictionary=incar_modifiers)
elif incar_template != None:
raise Exception("Incar template " + str(incar_template) +
" not valid")
else:
incar = Incar()
incar.modify_from_dictionary(incar_modifiers)
if 'lreal' not in incar:
if information_structure.site_count > 20:
incar['lreal'] = 'Auto'
else:
incar['lreal'] = False
if 'npar' not in incar:
if os.environ['QUEUE_ADAPTER_HOST'] == 'Savio':
incar['npar'] = 4
else:
incar['npar'] = QueueAdapter.get_optimal_npar(
submission_script_file)
elif incar['npar'] in ['Remove', 'remove']:
del incar['npar']
###################TEMPORARILY HARDCODED FOR PEROVSKITES##########################################
if use_mp_hubbard_u:
u_species = initial_structure.get_species_list()[1]
mp_hubbard_u_values = {
'Co': 3.32,
'Cr': 3.7,
'Fe': 5.3,
'Mn': 3.9,
'Mo': 4.38,
'Ni': 6.2,
'V': 3.25,
'W': 6.2
}
if u_species in mp_hubbard_u_values.keys():
u_value = mp_hubbard_u_values[u_species]
incar['LDAU'] = True
incar['LDAUJ'] = '0 0 0'
incar['LDAUL'] = '0 2 0'
incar['LDAUPRINT'] = 1
incar['LDAUTYPE'] = 2
incar['LDAUU'] = '0 ' + str(u_value) + ' 0'
incar['LMAXMIX'] = 4
incar['LORBIT'] = 11
super(VaspCalculationGenerator,
self).__init__(path=path,
initial_structure=initial_structure,
incar=incar,
kpoints=kpoints,
potcar=potcar,
submission_script_file=submission_script_file,
contcar_path=contcar_path,
wavecar_path=wavecar_path,
chargecar_path=chargecar_path)
Nx = 2
Ny = 2
Nz = 2
vasp_run_inputs = {
'kpoint_scheme': 'Monkhorst',
'kpoint_subdivisions_list': [2, 2, 2],
}
custom_incar_inputs = {
'encut': 800
}
initial_structure=Perovskite(supercell_dimensions=[Nx, Ny, Nz], lattice=[[a*Nx, 0.0, 0.0], [0.0, a*Ny, 0.0], [0.0, 0.0, a*Nz]], species_list=['Sr', 'Ti', 'O'])
force_calculation_path = './dfpt_force_calculation'
kpoints = Kpoints(scheme_string=vasp_run_inputs['kpoint_scheme'], subdivisions_list=vasp_run_inputs['kpoint_subdivisions_list'])
incar = IncarMaker.get_dfpt_hessian_incar(custom_incar_inputs)
input_set = VaspInputSet(initial_structure, kpoints, incar, auto_change_lreal=False, auto_change_npar=False)
dfpt_force_run = VaspRun(path=force_calculation_path, input_set=input_set)
dfpt_force_run.update()
def run_misfit_strain(path, misfit_strain, input_dictionary,
initial_relaxation_input_dictionary, dfpt_incar_settings,
derivative_evaluation_vasp_run_inputs_dictionary,
minima_relaxation_input_dictionary,
epitaxial_relaxation_input_dictionary):
Path.make(path)
species_list = input_dictionary['species_list']
reference_lattice_constant = input_dictionary['reference_lattice_constant']
Nx = input_dictionary['supercell_dimensions_list'][0]
Ny = input_dictionary['supercell_dimensions_list'][1]
Nz = input_dictionary['supercell_dimensions_list'][2]
displacement_finite_differrences_step_size = input_dictionary[
'displacement_finite_differrences_step_size']
perturbation_magnitudes_dictionary = input_dictionary[
'perturbation_magnitudes_dictionary']
a = reference_lattice_constant * (1.0 + misfit_strain)
initial_structure = Perovskite(
supercell_dimensions=[Nx, Ny, Nz],
lattice=[[a * Nx, 0.0, 0.0], [0.0, a * Ny, 0.0],
[
0.0, 0.0, reference_lattice_constant * Nz *
(1.0 + 0.3 * (1.0 - (a / reference_lattice_constant)))
]],
species_list=species_list)
relaxation = VaspRelaxation(
path=Path.join(path, 'relaxation'),
initial_structure=initial_structure,
input_dictionary=initial_relaxation_input_dictionary)
if not relaxation.complete:
relaxation.update()
return False
relaxed_structure = relaxation.final_structure
relaxed_structure_path = Path.join(path, 'output_relaxed_structure')
relaxed_structure.to_poscar_file_path(relaxed_structure_path)
force_calculation_path = Path.join(path, 'dfpt_force_calculation')
kpoints = Kpoints(scheme_string=kpoint_scheme,
subdivisions_list=kpoint_subdivisions_list)
incar = IncarMaker.get_dfpt_hessian_incar(dfpt_incar_settings)
input_set = VaspInputSet(relaxed_structure,
kpoints,
incar,
auto_change_lreal=False,
auto_change_npar=False)
dfpt_force_run = VaspRun(path=force_calculation_path, input_set=input_set)
if not dfpt_force_run.complete:
dfpt_force_run.update()
return False
hessian = Hessian(dfpt_force_run.outcar)
hessian.print_eigenvalues_to_file(Path.join(path, 'output_eigen_values'))
hessian.print_eigen_components_to_file(
Path.join(path, 'output_eigen_components'))
variable_specialty_points_dictionary = input_dictionary[
'variable_specialty_points_dictionary_set'][
misfit_strain] if input_dictionary.has_key(misfit_strain) else {}
derivative_evaluation_path = Path.join(
path, 'expansion_coefficient_calculations')
derivative_evaluator = DerivativeEvaluator(
path=derivative_evaluation_path,
reference_structure=relaxed_structure,
hessian=hessian,
reference_completed_vasp_relaxation_run=relaxation,
vasp_run_inputs_dictionary=
derivative_evaluation_vasp_run_inputs_dictionary,
perturbation_magnitudes_dictionary=perturbation_magnitudes_dictionary,
displacement_finite_differrences_step_size=
displacement_finite_differrences_step_size,
status_file_path=Path.join(path, 'output_derivative_plot_data'),
variable_specialty_points_dictionary=
variable_specialty_points_dictionary)
derivative_evaluator.update()
guessed_minima_data_path = Path.join(path, 'guessed_chromosomes')
minima_path = Path.join(path, 'minima_relaxations')
if Path.exists(guessed_minima_data_path):
minima_relaxer = MinimaRelaxer(
path=minima_path,
reference_structure=relaxed_structure,
reference_completed_vasp_relaxation_run=relaxation,
hessian=hessian,
vasp_relaxation_inputs_dictionary=
minima_relaxation_input_dictionary,
eigen_chromosome_energy_pairs_file_path=guessed_minima_data_path)
minima_relaxer.update()
minima_relaxer.print_status_to_file(
Path.join(path, 'output_minima_relaxations_status'))
if minima_relaxer.complete:
minima_relaxer.print_selected_uniques_to_file(file_path=Path.join(
path, 'output_selected_unique_minima_relaxations'))
sorted_uniques = minima_relaxer.get_sorted_unique_relaxation_data_list(
)
return sorted_uniques
def update(self):
if not self.relaxation.complete:
self.relaxation.update()
else:
Path.make(self.dos_path)
dos_runs_count = self.get_current_dos_count()
incar_modifications = {}
for key, value_list in self.relaxation.incar_modifier_lists_dictionary.items(
):
incar_modifications[key] = value_list[1000]
incar = IncarMaker.get_static_incar(incar_modifications)
if 'submission_node_count' in self.extra_dos_inputs:
node_count = self.extra_dos_inputs.pop('submission_node_count')
else:
node_count = None
structure = self.relaxation.final_structure
kpoint_schemes = ParameterList(
self.extra_dos_inputs.pop('kpoint_schemes_list'))
kpoint_subdivisions_lists = ParameterList(
self.extra_dos_inputs.pop('kpoint_subdivisions_lists'))
kpoints = Kpoints(
scheme_string=kpoint_schemes[dos_runs_count],
subdivisions_list=kpoint_subdivisions_lists[dos_runs_count])
incar = IncarMaker.get_static_incar(incar_modifications)
for key, value in self.extra_dos_inputs.items():
incar[key] = value
if node_count != None:
input_set.set_node_count(node_count)
incar['lhfcalc'] = True
incar['hfscreen'] = 0.2
incar['lorbit'] = 11
chargecar_path = None
if dos_runs_count == 0:
run_path = Path.join(self.dos_path,
'hybrid_electronic_optimization_1')
Path.make(run_path)
wavecar_path = Path.join(self.relaxation.path, 'static',
'WAVECAR')
incar['algo'] = 'All'
incar['time'] = 0.4
incar['precfock'] = 'Fast'
incar['nkred'] = 2
incar['ismear'] = 0
incar['sigma'] = 0.02
incar['lwave'] = True
elif dos_runs_count == 1:
run_path = Path.join(self.dos_path,
'hybrid_electronic_optimization_2')
Path.make(run_path)
wavecar_path = Path.join(self.dos_path,
'hybrid_electronic_optimization_1',
'WAVECAR')
incar['ialgo'] = 53
incar['time'] = 0.4
incar['precfock'] = 'Fast'
incar['nkred'] = 2
incar['ismear'] = -5
incar['sigma'] = 0.02
incar['lwave'] = True
incar['lcharg'] = True
elif dos_runs_count >= 2:
run_path = Path.join(self.dos_path,
'hybrid_electronic_optimization_3')
Path.make(run_path)
wavecar_path = Path.join(self.dos_path,
'hybrid_electronic_optimization_2',
'WAVECAR')
chargecar_path = Path.join(self.dos_path,
'hybrid_electronic_optimization_2',
'CHARGECAR')
incar['ialgo'] = 53
incar['time'] = 0.4
incar['precfock'] = 'Fast'
incar['nkred'] = 2
incar['ismear'] = -5
incar['sigma'] = 0.02
incar['lwave'] = True
incar['lcharg'] = True
incar['icharge'] = 11
input_set = VaspInputSet(structure,
kpoints,
incar,
calculation_type='gga')
current_dos_run = VaspRun(path=run_path,
input_set=input_set,
wavecar_path=wavecar_path,
chargecar_path=None)
current_dos_run.update()