def initialize_run_list(self): """sets self.vasp_run_list based on directories present""" self.vasp_run_list = [] for i in range(self.external_relaxation_count): run_path = self.get_extended_path(VaspRelaxation.external_relax_basename_string + str(i+1)) if Path.exists(run_path): self.vasp_run_list.append(VaspRun(run_path)) else: return static_path = self.get_extended_path(VaspRelaxation.static_basename_string) if Path.exists(static_path): self.vasp_run_list.append(VaspRun(static_path))
def create_next_run(self): run_path = self.get_next_run_path() structure = self.get_next_structure() kpoints = Kpoints(scheme_string=self.kpoint_schemes[self.run_count], subdivisions_list=self.kpoint_subdivisions_lists[self.run_count]) incar = self.get_next_incar() submission_script_file = None if self.submission_script_modification_keys_list: submission_script_file = QueueAdapter.modify_submission_script(QueueAdapter.get_submission_file(), self.submission_script_modification_keys_list[self.run_count]) input_set = VaspInputSet(structure, kpoints, incar, submission_script_file=submission_script_file, calculation_type=self.calculation_type) #Override node count in submission script over the auto generated count based on atom count if self.submission_node_count_list: input_set.set_node_count(self.submission_node_count_list[self.run_count]) input_set.set_npar_from_number_of_cores() #override npar if inputted for key in self.incar_modifier_lists_dictionary.keys(): if key.upper() == 'NPAR': input_set.incar['npar'] = self.incar_modifier_lists_dictionary['npar'][self.run_count] vasp_run = VaspRun(run_path, input_set=input_set, wavecar_path=self.get_wavecar_path()) #self.run_count += 1 #increment at end - this tracks how many runs have been created up to now self.vasp_run_list.append(vasp_run)
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 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 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'])
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 get_current_dos_count(self):
pre = 'hybrid_electronic_optimization_'
current = 0
while Path.exists(Path.join(self.dos_path, pre + str(current + 1))):
current += 1
if current == 0:
return 0
else:
run_path = Path.join(self.dos_path, pre + str(current))
current_dos_run = VaspRun(path=run_path)
if current_dos_run.complete:
return current + 1
else:
return current
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
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() guessed_minima_data_path = Path.join(base_path, 'guessed_chromosomes')
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 vasp_run_list(self):
return [
VaspRun(path=run_path) for run_path in self.get_run_paths_list()
]
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
class VaspPhonon(VaspRunSet):
"""
Represents a phonon run in vasp built on the phonopy finite differences framework.
This class takes as input an initial structure and parameters for the static force calculations
as well as phonopy parameters.
Upon finishing, the force constants file and (potentially) the BORN file are written out. These two files can be used to initialize
a phonopy instance for analysis of eigenvalues/vectors, dispersion relations, and so forth.
The file structure is:
path
|
----------------force_calculations--------------lepsilon_calculation-----------FORCE_CONSTANTS-------------BORN
| |
0----1----2---3----4----5---... INCAR---POSCAR---...
|
INCAR----POSCAR----...
"""
def __init__(self, path, initial_structure, phonopy_inputs_dictionary,
vasp_run_inputs_dictionary):
"""
path holds the main path of the calculation sets
initial_structure should be some small Structure instance for which one wishes to calculate phonons
phonopy_inputs should be a dictionary that looks like:
phonopy_inputs_dictionary = {
'supercell_dimensions': [2, 2, 2],
'symprec': 0.001,
'displacement_distance': 0.01,
'nac': True
...
}
vasp_run_inputs_dictionary should be a dictionary that looks like:
vasp_run_inputs_dictionary = {
'kpoint_scheme': 'Monkhorst',
'kpoint_subdivisions_list': [4, 4, 4], #***This is the kpoints of the supercell, not the primitive cell!!!***
'encut': 800
}
"""
self.path = path
self.initial_structure = initial_structure
self.phonopy_inputs = phonopy_inputs_dictionary
self.vasp_run_inputs = vasp_run_inputs_dictionary
self.forces_run_set = None #holds set of force calculations on distorted structures
self.lepsilon_calculation = None #calculates dielectric tensor and born effective charge if nac is needed
Path.make(path)
self.initialize_forces_run_set()
if self.has_nac():
self.initialize_vasp_lepsilon_calculation()
self.update()
def initialize_forces_run_set(self):
"""
Creates the set of force calculation vasp runs on the phonopy generated list of distorted structures.
"""
self.forces_run_set = VaspForcesRunSet(
path=self.get_forces_run_set_path(),
structures_list=self.get_distorted_structures_list(),
vasp_run_inputs_dictionary=self.vasp_run_inputs,
wavecar_path=None)
def get_distorted_structures_list(self):
"""
Returns list of Structure instances containing the distorted structures determined as necessary to calculate the forces of by phonopy.
"""
#########make sure we're using proper initial structure if there was reoptimization#####################################################################################
return phonopy_utility.get_distorted_structures_list(
initial_structure=self.initial_structure,
phonopy_inputs=self.phonopy_inputs)
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 update(self):
"""
Runs update on all force calculations (and potentially the lepsilon calculation) until they are all complete.
Once they are all complete, the force constants are generated and written to file, completing the phonon calculation.
"""
if not self.complete:
self.forces_run_set.update()
if self.has_nac():
self.lepsilon_calculation.update()
else:
#write the final results to file so that they can be used to initialize a phonopy instance
self.write_initial_structure()
self.write_force_constants()
if self.has_nac():
self.write_born_file()
@property
def complete(self):
if not self.forces_run_set.complete:
return False
if self.has_nac() and not self.lepsilon_calculation.complete:
return False
return True
def has_nac(self):
return self.phonopy_inputs.has_key(
'nac') and self.phonopy_inputs['nac']
def get_initial_structure_path(self):
return self.get_extended_path('initial_structure')
def get_force_constants_path(self):
return self.get_extended_path('FORCE_CONSTANTS')
def get_born_path(self):
return self.get_extended_path('BORN')
def get_lepsion_calculation_path(self):
return self.get_extended_path('lepsilon_calculation')
def get_forces_run_set_path(self):
return self.get_extended_path('force_calculations')
def write_initial_structure(self):
"""
Writes the initial structure used to generate displacements to a poscar file.
"""
#######make sure this is reoptimized structure
self.initial_structure.to_poscar_file_path(
self.get_initial_structure_path())
def write_force_constants(self):
"""
Writes the calculated force constants to file.
"""
phonopy_utility.write_force_constants_to_file_path(
initial_structure=self.initial_structure,
phonopy_inputs=self.phonopy_inputs,
vasp_xml_file_paths_list=self.forces_run_set.
get_xml_file_paths_list(),
file_path=self.get_force_constants_path())
def write_born_file(self):
"""
Writes born file necessary for NAC to file.
"""
if self.has_nac():
dielectric_tensor = self.lepsilon_calculation.outcar.get_dielectric_tensor(
)
born_effective_charge_tensor = self.lepsilon_calculation.outcar.get_born_effective_charge_tensor(
)
phonopy_utility.write_born_file(
initial_structure=self.initial_structure,
phonopy_inputs=self.phonopy_inputs,
dielectric_tensor=dielectric_tensor,
born_effective_charge_tensor=born_effective_charge_tensor,
file_path=self.get_born_path())
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()