|
1 | 1 | # coding: utf-8 |
2 | 2 | # Copyright (c) Max-Planck-Institut für Eisenforschung GmbH - Computational Materials Design (CM) Department |
3 | 3 | # Distributed under the terms of "New BSD License", see the LICENSE file. |
| 4 | +import os |
| 5 | +from typing import Optional, Union |
4 | 6 |
|
| 7 | +from ase.atoms import Atoms |
| 8 | +from pyiron_base import Project, ProjectHDFio |
| 9 | + |
| 10 | +from pyiron_atomistics.atomistics.structure.atoms import ase_to_pyiron |
5 | 11 | from pyiron_atomistics.vasp.interactive import VaspInteractive |
6 | 12 |
|
7 | 13 | __author__ = "Sudarsan Surendralal" |
@@ -54,3 +60,200 @@ def __init__(self, project, job_name): |
54 | 60 | None # Reset the version number to the executable is set automatically |
55 | 61 | ) |
56 | 62 | self._executable_activate(enforce=True) |
| 63 | + |
| 64 | + |
| 65 | +def vasp_function( |
| 66 | + working_directory: str, |
| 67 | + structure: Atoms, |
| 68 | + plane_wave_cutoff: Optional[Union[float, int]] = None, |
| 69 | + exchange_correlation_functional: Optional[str] = None, |
| 70 | + spin_constraints: Optional[str] = None, |
| 71 | + write_electrostatic_potential: Optional[bool] = None, |
| 72 | + write_charge_density: Optional[bool] = None, |
| 73 | + write_wave_funct: Optional[bool] = None, |
| 74 | + write_resolved_dos: Optional[bool] = None, |
| 75 | + sorted_indices: Optional[list] = None, |
| 76 | + fix_spin_constraint: Optional[bool] = None, |
| 77 | + fix_symmetry: Optional[bool] = None, |
| 78 | + eddrmm_handling: str = "ignore", |
| 79 | + coulomb_interactions_kwargs: Optional[dict] = None, |
| 80 | + algorithm_kwargs: Optional[dict] = None, |
| 81 | + calc_mode: str = "static", |
| 82 | + calc_kwargs: Optional[dict] = None, |
| 83 | + band_structure_calc_kwargs: Optional[dict] = None, |
| 84 | + convergence_precision_kwargs: Optional[dict] = None, |
| 85 | + dipole_correction_kwargs: Optional[dict] = None, |
| 86 | + electric_field_kwargs: Optional[dict] = None, |
| 87 | + occupancy_smearing_kwargs: Optional[dict] = None, |
| 88 | + fft_mesh_kwargs: Optional[dict] = None, |
| 89 | + mixing_parameters_kwargs: Optional[dict] = None, |
| 90 | + n_empty_states: Optional[int] = None, |
| 91 | + rwigs_kwargs: Optional[dict] = None, |
| 92 | + spin_constraint_kwargs: Optional[dict] = None, |
| 93 | + kpoints_kwargs: Optional[dict] = None, |
| 94 | + server_kwargs: Optional[dict] = None, |
| 95 | + executable_version: Optional[str] = None, |
| 96 | + executable_path: Optional[str] = None, |
| 97 | + incar_file: Optional[Union[str, list, dict]] = None, |
| 98 | + kpoints_file: Optional[Union[str, list, dict]] = None, |
| 99 | +): |
| 100 | + """ |
| 101 | +
|
| 102 | + Args: |
| 103 | + working_directory: |
| 104 | + structure: |
| 105 | + plane_wave_cutoff: |
| 106 | + exchange_correlation_functional: |
| 107 | + spin_constraints: |
| 108 | + write_electrostatic_potential: |
| 109 | + write_charge_density: |
| 110 | + write_wave_funct: |
| 111 | + write_resolved_dos: |
| 112 | + sorted_indices: |
| 113 | + fix_spin_constraint: |
| 114 | + fix_symmetry: |
| 115 | + eddrmm_handling: |
| 116 | + coulomb_interactions_kwargs: |
| 117 | + algorithm_kwargs: |
| 118 | + calc_mode: |
| 119 | + calc_kwargs: |
| 120 | + band_structure_calc_kwargs: |
| 121 | + convergence_precision_kwargs: |
| 122 | + dipole_correction_kwargs: |
| 123 | + electric_field_kwargs: |
| 124 | + occupancy_smearing_kwargs: |
| 125 | + fft_mesh_kwargs: |
| 126 | + mixing_parameters_kwargs: |
| 127 | + n_empty_states: |
| 128 | + rwigs_kwargs: |
| 129 | + spin_constraint_kwargs: |
| 130 | + kpoints_kwargs: |
| 131 | + server_kwargs: |
| 132 | + executable_version: |
| 133 | + executable_path: |
| 134 | + incar_file: |
| 135 | + kpoints_file: |
| 136 | +
|
| 137 | + Returns: |
| 138 | + str, dict, bool: Tuple consisting of the shell output (str), the parsed output (dict) and a boolean flag if |
| 139 | + the execution raised an accepted error. |
| 140 | + """ |
| 141 | + if coulomb_interactions_kwargs is None: |
| 142 | + coulomb_interactions_kwargs = {} |
| 143 | + if algorithm_kwargs is None: |
| 144 | + algorithm_kwargs = {} |
| 145 | + if calc_kwargs is None: |
| 146 | + calc_kwargs = {} |
| 147 | + if band_structure_calc_kwargs is None: |
| 148 | + band_structure_calc_kwargs = {} |
| 149 | + if convergence_precision_kwargs is None: |
| 150 | + convergence_precision_kwargs = {} |
| 151 | + if dipole_correction_kwargs is None: |
| 152 | + dipole_correction_kwargs = {} |
| 153 | + if electric_field_kwargs is None: |
| 154 | + electric_field_kwargs = {} |
| 155 | + if occupancy_smearing_kwargs is None: |
| 156 | + occupancy_smearing_kwargs = {} |
| 157 | + if fft_mesh_kwargs is None: |
| 158 | + fft_mesh_kwargs = {} |
| 159 | + if mixing_parameters_kwargs is None: |
| 160 | + mixing_parameters_kwargs = {} |
| 161 | + if rwigs_kwargs is None: |
| 162 | + rwigs_kwargs = {} |
| 163 | + if spin_constraint_kwargs is None: |
| 164 | + spin_constraint_kwargs = {} |
| 165 | + if kpoints_kwargs is None: |
| 166 | + kpoints_kwargs = {} |
| 167 | + if server_kwargs is None: |
| 168 | + server_kwargs = {} |
| 169 | + |
| 170 | + os.makedirs(working_directory, exist_ok=True) |
| 171 | + job = Vasp( |
| 172 | + project=ProjectHDFio( |
| 173 | + project=Project(working_directory), |
| 174 | + file_name="lmp_funct_job", |
| 175 | + h5_path=None, |
| 176 | + mode=None, |
| 177 | + ), |
| 178 | + job_name="lmp_funct_job", |
| 179 | + ) |
| 180 | + job.structure = ase_to_pyiron(structure) |
| 181 | + if plane_wave_cutoff is not None: |
| 182 | + job.plane_wave_cutoff = plane_wave_cutoff |
| 183 | + if exchange_correlation_functional is not None: |
| 184 | + job.exchange_correlation_functional = exchange_correlation_functional |
| 185 | + if spin_constraints is not None: |
| 186 | + job.spin_constraints = spin_constraints |
| 187 | + if write_electrostatic_potential is not None: |
| 188 | + job.write_electrostatic_potential = write_electrostatic_potential |
| 189 | + if write_charge_density is not None: |
| 190 | + job.write_charge_density = write_charge_density |
| 191 | + if write_wave_funct is not None: |
| 192 | + job.write_wave_funct = write_wave_funct |
| 193 | + if write_resolved_dos is not None: |
| 194 | + job.write_resolved_dos = write_resolved_dos |
| 195 | + if sorted_indices is not None: |
| 196 | + job.sorted_indices = sorted_indices |
| 197 | + if fix_spin_constraint is not None: |
| 198 | + job.fix_spin_constraint = fix_spin_constraint |
| 199 | + if fix_symmetry is not None: |
| 200 | + job.fix_symmetry = fix_symmetry |
| 201 | + job.set_eddrmm_handling(status=eddrmm_handling) |
| 202 | + if len(coulomb_interactions_kwargs) > 0: |
| 203 | + job.set_coulomb_interactions(**coulomb_interactions_kwargs) |
| 204 | + if len(algorithm_kwargs) > 0: |
| 205 | + job.set_algorithm(**algorithm_kwargs) |
| 206 | + if len(band_structure_calc_kwargs) > 0: |
| 207 | + job.set_for_band_structure_calc(**band_structure_calc_kwargs) |
| 208 | + if len(convergence_precision_kwargs) > 0: |
| 209 | + job.set_convergence_precision(**convergence_precision_kwargs) |
| 210 | + if len(dipole_correction_kwargs) > 0: |
| 211 | + job.set_dipole_correction(**dipole_correction_kwargs) |
| 212 | + if len(electric_field_kwargs) > 0: |
| 213 | + job.set_electric_field(**electric_field_kwargs) |
| 214 | + if len(occupancy_smearing_kwargs) > 0: |
| 215 | + job.set_occupancy_smearing(**occupancy_smearing_kwargs) |
| 216 | + if len(fft_mesh_kwargs) > 0: |
| 217 | + job.set_fft_mesh(**fft_mesh_kwargs) |
| 218 | + if len(mixing_parameters_kwargs) > 0: |
| 219 | + job.set_mixing_parameters(**mixing_parameters_kwargs) |
| 220 | + job.set_empty_states(n_empty_states=n_empty_states) |
| 221 | + if len(rwigs_kwargs) > 0: |
| 222 | + job.set_rwigs(rwigs_dict=rwigs_kwargs) |
| 223 | + if len(spin_constraint_kwargs) > 0: |
| 224 | + job.set_spin_constraint(**spin_constraint_kwargs) |
| 225 | + if len(kpoints_kwargs) > 0: |
| 226 | + job.set_kpoints(**kpoints_kwargs) |
| 227 | + server_dict = job.server.to_dict() |
| 228 | + server_dict.update(server_kwargs) |
| 229 | + job.server.from_dict(server_dict=server_dict) |
| 230 | + if calc_mode == "static": |
| 231 | + job.calc_static() |
| 232 | + elif calc_mode == "md": |
| 233 | + job.calc_md(**calc_kwargs) |
| 234 | + elif calc_mode == "minimize": |
| 235 | + job.calc_minimize(**calc_kwargs) |
| 236 | + else: |
| 237 | + raise ValueError() |
| 238 | + if incar_file is not None and isinstance(incar_file, dict): |
| 239 | + for k, v in incar_file.items(): |
| 240 | + job.input.incar[k] = v |
| 241 | + elif incar_file is not None and ( |
| 242 | + isinstance(incar_file, str) or isinstance(incar_file, list) |
| 243 | + ): |
| 244 | + job.input.incar.load_string(input_str=incar_file) |
| 245 | + if kpoints_file is not None and isinstance(kpoints_file, dict): |
| 246 | + for k, v in kpoints_file.items(): |
| 247 | + job.input.kpoints[k] = v |
| 248 | + elif kpoints_file is not None and ( |
| 249 | + isinstance(kpoints_file, str) or isinstance(kpoints_file, list) |
| 250 | + ): |
| 251 | + job.input.kpoints.load_string(input_str=kpoints_file) |
| 252 | + if executable_path is not None: |
| 253 | + job.executable = executable_path |
| 254 | + if executable_version is not None: |
| 255 | + job.version = executable_version |
| 256 | + |
| 257 | + calculate_kwargs = job.calculate_kwargs |
| 258 | + calculate_kwargs["working_directory"] = working_directory |
| 259 | + return job.get_calculate_function()(**calculate_kwargs) |
0 commit comments