Full Defect Workflow Example (w/GGA) — doped (2024)

import os# Load your MP_API_KEY from your environment variablesMP_API_KEY = os.environ.get("MP_API_KEY")# Or set it directly# MP_API_KEY="your-api-key"

# Note that this syntax will only work if you have set the legacy API key!from pymatgen.ext.matproj import MPRester # Legacy API used by doped# from mp_api.client import MPRester# Here we query with the explicit formulampr = MPRester() # MP_API_KEYresults = mpr.query( criteria={"pretty_formula": "MgO", "e_above_hull": {"$lte": 0.01}}, properties=["material_id", "pretty_formula", "e_above_hull", "structure", "spacegroup"])print(f"Number of parsed structures: {len(results)}")

/home/ireaml/miniconda3/envs/doped/lib/python3.11/site-packages/pymatgen/ext/matproj_legacy.py:164: UserWarning: You are using the legacy MPRester. This version of the MPRester will no longer be updated. To access the latest data with the new MPRester, obtain a new API key from https://materialsproject.org/api and consult the docs at https://docs.materialsproject.org/ for more information. warnings.warn(

Number of parsed structures: 1

results

[{'material_id': 'mp-1265', 'pretty_formula': 'MgO', 'e_above_hull': 0, 'structure': Structure Summary Lattice abc : 3.0097887004120407 3.0097887004120407 3.0097887004120407 angles : 60.00000000000001 60.00000000000001 60.00000000000001 volume : 19.2793782653415 A : 0.0 2.128242 2.128242 B : 2.128242 0.0 2.128242 C : 2.128242 2.128242 0.0 pbc : True True True PeriodicSite: Mg (0.0, 0.0, 0.0) [0.0, 0.0, 0.0] PeriodicSite: O (2.128, 2.128, 2.128) [0.5, 0.5, 0.5], 'spacegroup': {'symprec': 0.1, 'source': 'spglib', 'symbol': 'Fm-3m', 'number': 225, 'point_group': 'm-3m', 'crystal_system': 'cubic', 'hall': '-F 4 2 3'}}]

prim_struc = results[0]["structure"]

prim_struc

Structure SummaryLattice abc : 3.0097887004120407 3.0097887004120407 3.0097887004120407 angles : 60.00000000000001 60.00000000000001 60.00000000000001 volume : 19.2793782653415 A : 0.0 2.128242 2.128242 B : 2.128242 0.0 2.128242 C : 2.128242 2.128242 0.0 pbc : True True TruePeriodicSite: Mg (0.0, 0.0, 0.0) [0.0, 0.0, 0.0]PeriodicSite: O (2.128, 2.128, 2.128) [0.5, 0.5, 0.5]

# Save to Input_files for reproducibilityprim_struc.to(filename="MgO/Input_files/prim_struc_POSCAR")

'Mg1 O1\n1.0\n 0.0000000000000000 2.1282420000000002 2.1282420000000002\n 2.1282420000000002 0.0000000000000000 2.1282420000000002\n 2.1282420000000002 2.1282420000000002 0.0000000000000000\nMg O\n1 1\ndirect\n 0.0000000000000000 0.0000000000000000 0.0000000000000000 Mg\n 0.5000000000000000 0.5000000000000000 0.5000000000000000 O\n'

import osfrom pymatgen.core.structure import Structureif not os.path.exists("./MgO/Bulk_relax/CONTCAR"): print("Please run the bulk relaxation first!")else: prim_struc = Structure.from_file("./MgO/Bulk_relax/CONTCAR")

from doped.generation import DefectsGenerator# generate all intrinsic defects, enforcing the use of a cubic supercell in this example case:defect_gen = DefectsGenerator(structure=prim_struc, supercell_gen_kwargs={"force_cubic":True})

Generating DefectEntry objects: 100.0%|██████████| [00:08, 11.75it/s]

Vacancies Guessed Charges Conv. Cell Coords Wyckoff----------- ----------------- ------------------- ---------v_Mg [+1,0,-1,-2] [0.000,0.000,0.000] 4av_O [+2,+1,0,-1] [0.500,0.500,0.500] 4bSubstitutions Guessed Charges Conv. Cell Coords Wyckoff--------------- ----------------- ------------------- ---------Mg_O [+4,+3,+2,+1,0] [0.500,0.500,0.500] 4bO_Mg [0,-1,-2,-3,-4] [0.000,0.000,0.000] 4aInterstitials Guessed Charges Conv. Cell Coords Wyckoff--------------- ----------------- ------------------- ---------Mg_i_Td [+2,+1,0] [0.250,0.250,0.250] 8cO_i_Td [0,-1,-2] [0.250,0.250,0.250] 8cThe number in the Wyckoff label is the site multiplicity/degeneracy of that defect in the conventional ('conv.') unit cell, which comprises 4 formula unit(s) of MgO.Note that Wyckoff letters can depend on the ordering of elements in the conventional standard structure, for which doped uses the spglib convention.

from doped.generation import DefectsGeneratorDefectsGenerator?

Init signature:DefectsGenerator( structure: pymatgen.core.structure.Structure, extrinsic: Union[str, List, Dict, NoneType] = None, interstitial_coords: Optional[List] = None, generate_supercell: bool = True, charge_state_gen_kwargs: Optional[Dict] = None, supercell_gen_kwargs: Optional[Dict] = None, interstitial_gen_kwargs: Optional[Dict] = None, target_frac_coords: Optional[List] = None, processes: Optional[int] = None,)Docstring: Class for generating doped DefectEntry objects.Init docstring:Generates doped DefectEntry objects for defects in the input hoststructure. By default, generates all intrinsic defects, but extrinsicdefects (impurities) can also be created using the ``extrinsic``argument.Interstitial sites are generated using Voronoi tessellation by default (foundto be the most reliable), which can be controlled using the``interstitial_gen_kwargs`` argument (passed as keyword arguments to the``VoronoiInterstitialGenerator`` class). Alternatively, a list of interstitialsites (or single interstitial site) can be manually specified using the``interstitial_coords`` argument.By default, supercells are generated for each defect using the doped``get_ideal_supercell_matrix()`` function (see docstring), with default settingsof ``min_image_distance = 10`` (minimum distance between periodic images of 10 Å),``min_atoms = 50`` (minimum 50 atoms in the supercell) and ``ideal_threshold = 0.1``(allow up to 10% larger supercell if it is a diagonal expansion of the primitiveor conventional cell). This uses a custom algorithm in ``doped`` to efficientlysearch over possible supercell transformations and identify that with the minimumnumber of atoms (hence computational cost) that satisfies the minimum image distance,number of atoms and ``ideal_threshold`` constraints. These settings can be controlledby specifying keyword arguments with ``supercell_gen_kwargs``, which are passed to``get_ideal_supercell_matrix()`` (e.g. for a minimum image distance of 15 Å with atleast 100 atoms, use:``supercell_gen_kwargs = {'min_image_distance': 15, 'min_atoms': 100}``). If theinput structure already satisfies these constraints (for the same number of atoms asthe ``doped``-generated supercell), then it will be used.Alternatively if ``generate_supercell = False``, then no supercell is generatedand the input structure is used as the defect & bulk supercell. (Note thismay give a slightly different (but fully equivalent) set of coordinates).The algorithm for determining defect entry names is to use the pymatgen defectname (e.g. ``v_Cd``, ``Cd_Te`` etc.) for vacancies/antisites/substitutions, unlessthere are multiple inequivalent sites for the defect, in which case the pointgroup of the defect site is appended (e.g. ``v_Cd_Td``, ``Cd_Te_Td`` etc.), and ifthis is still not unique, then element identity and distance to the nearestneighbour of the defect site is appended (e.g. ``v_Cd_Td_Te2.83``, ``Cd_Te_Td_Cd2.83``etc.). For interstitials, the same naming scheme is used, but the point groupis always appended to the pymatgen defect name.Possible charge states for the defects are estimated using the probability ofthe corresponding defect element oxidation state, the magnitude of the chargestate, and the maximum magnitude of the host oxidation states (i.e. how'charged' the host is), with large (absolute) charge states, low probabilityoxidation states and/or greater charge/oxidation state magnitudes than that ofthe host being disfavoured. This can be controlled using the``probability_threshold`` (default = 0.0075) or ``padding`` (default = 1) keys inthe ``charge_state_gen_kwargs`` parameter, which are passed to the``_charge_state_probability()`` function. The input and computed values used toguess charge state probabilities are provided in the``DefectEntry.charge_state_guessing_log`` attributes. See docs for examples ofmodifying the generated charge states.Args: structure (Structure): Structure of the host material (as a pymatgen Structure object). If this is not the primitive unit cell, it will be reduced to the primitive cell for defect generation, before supercell generation. extrinsic (Union[str, List, Dict]): List or dict of elements (or string for single element) to be used for extrinsic defect generation (i.e. dopants/impurities). If a list is provided, all possible substitutional defects for each extrinsic element will be generated. If a dict is provided, the keys should be the host elements to be substituted, and the values the extrinsic element(s) to substitute in; as a string or list. In both cases, all possible extrinsic interstitials are generated. interstitial_coords (List): List of fractional coordinates (corresponding to the input structure), or a single set of fractional coordinates, to use as interstitial defect site(s). Default (when interstitial_coords not specified) is to automatically generate interstitial sites using Voronoi tessellation. The input interstitial_coords are converted to DefectsGenerator.prim_interstitial_coords, which are the corresponding fractional coordinates in DefectsGenerator.primitive_structure (which is used for defect generation), along with the multiplicity and equivalent coordinates, sorted according to the doped convention. generate_supercell (bool): Whether to generate a supercell for the output defect entries (using the custom algorithm in ``doped`` which efficiently searches over possible supercell transformations and identifies that with the minimum number of atoms (hence computational cost) that satisfies the minimum image distance, number of atoms and ``ideal_threshold`` constraints - which can be controlled with ``supercell_gen_kwargs``). If False, then the input structure is used as the defect & bulk supercell. (Note this may give a slightly different (but fully equivalent) set of coordinates). charge_state_gen_kwargs (Dict): Keyword arguments to be passed to the ``_charge_state_probability`` function (such as ``probability_threshold`` (default = 0.0075, used for substitutions and interstitials) and ``padding`` (default = 1, used for vacancies)) to control defect charge state generation. supercell_gen_kwargs (Dict): Keyword arguments to be passed to the ``get_ideal_supercell_matrix`` function (such as ``min_image_distance`` (default = 10), ``min_atoms`` (default = 50), ``ideal_threshold`` (default = 0.1), ``force_cubic`` - which enforces a (near-)cubic supercell output (default = False), or ``force_diagonal`` (default = False)). interstitial_gen_kwargs (Dict, bool): Keyword arguments to be passed to the ``VoronoiInterstitialGenerator`` class (such as ``clustering_tol``, ``stol``, ``min_dist`` etc), or to ``InterstitialGenerator`` if ``interstitial_coords`` is specified. If set to False, interstitial generation will be skipped entirely. target_frac_coords (List): Defects are placed at the closest equivalent site to these fractional coordinates in the generated supercells. Default is [0.5, 0.5, 0.5] if not set (i.e. the supercell centre, to aid visualisation). processes (int): Number of processes to use for multiprocessing. If not set, defaults to one less than the number of CPUs available.Attributes: defect_entries (Dict): Dictionary of {defect_species: DefectEntry} for all defect entries (with charge state and supercell properties) generated. defects (Dict): Dictionary of {defect_type: [Defect, ...]} for all defect objects generated. primitive_structure (Structure): Primitive cell structure of the host used to generate defects. supercell_matrix (Matrix): Matrix to generate defect/bulk supercells from the primitive cell structure. bulk_supercell (Structure): Supercell structure of the host (equal to primitive_structure * supercell_matrix). conventional_structure (Structure): Conventional cell structure of the host according to the Bilbao Crystallographic Server (BCS) definition, used to determine defect site Wyckoff labels and multiplicities. ``DefectsGenerator`` input parameters are also set as attributes.File: ~/Library/CloudStorage/OneDrive-ImperialCollegeLondon/Bread/Projects/Packages/doped/doped/generation.pyType: typeSubclasses: 

defect_gen.bulk_supercell.lattice

Lattice abc : 12.599838 12.599838 12.599838 angles : 90.0 90.0 90.0 volume : 2000.298843632019 A : 12.599838 0.0 0.0 B : 0.0 12.599838 0.0 C : 0.0 0.0 12.599838 pbc : True True True

defect_gen.supercell_matrix

array([[-3, 3, 3], [ 3, -3, 3], [ 3, 3, -3]])

defect_gen.defects

{'vacancies': [v_Mg vacancy defect at site [0.000,0.000,0.000] in structure, v_O vacancy defect at site [0.500,0.500,0.500] in structure], 'substitutions': [Mg_O substitution defect at site [0.500,0.500,0.500] in structure, O_Mg substitution defect at site [0.000,0.000,0.000] in structure], 'interstitials': [Mg_i interstitial defect at site [0.250,0.250,0.250] in structure, O_i interstitial defect at site [0.250,0.250,0.250] in structure]}

# Names of generated defects with their chargesdefect_gen.defect_entries.keys()

dict_keys(['v_Mg_-2', 'v_Mg_-1', 'v_Mg_0', 'v_Mg_+1', 'v_O_-1', 'v_O_0', 'v_O_+1', 'v_O_+2', 'Mg_O_0', 'Mg_O_+1', 'Mg_O_+2', 'Mg_O_+3', 'Mg_O_+4', 'O_Mg_-4', 'O_Mg_-3', 'O_Mg_-2', 'O_Mg_-1', 'O_Mg_0', 'Mg_i_Td_0', 'Mg_i_Td_+1', 'Mg_i_Td_+2', 'O_i_Td_-2', 'O_i_Td_-1', 'O_i_Td_0'])

defect_gen.defects = { "substitutions": [ defect for defect in defect_gen.defects["substitutions"] if defect.name == "Mg_O"], # select Mg_O}defect_gen.defect_entries = { k: v for k, v in defect_gen.defect_entries.items() if "Mg_O" in k}

# Check that now we only have the O interstitialdefect_gen.defect_entries.keys()

dict_keys(['Mg_O_0', 'Mg_O_+1', 'Mg_O_+2', 'Mg_O_+3', 'Mg_O_+4'])

defect_gen.to_json("MgO/defect_gen.json")

from doped.generation import DefectsGenerator# Load from JSONdefect_gen = DefectsGenerator.from_json("MgO/defect_gen.json")

from doped.generation import DefectsGeneratordefect_gen = DefectsGenerator.from_json("MgO/defect_gen.json")

from pymatgen.core.structure import Structureimport numpy as npprim_struc = Structure.from_file("MgO/Bulk_relax/CONTCAR")supercell = defect_gen.bulk_supercellconverged_kgrid = (7, 7, 7)ratio = np.array(supercell.lattice.abc) / np.array(prim_struc.lattice.abc)print(f"Ratio of supercell lattice to primitive lattice: {ratio}")kgrid = tuple(np.array(converged_kgrid) / ratio) # Divide by supercell expansion to get kgrid for supercellprint(f"Kgrid for supercell:", kgrid)# Round kgrid to next highest integerprint(f"Rounded kgrid for supercell:", [int(np.ceil(k)) for k in kgrid])

Ratio of supercell lattice to primitive lattice: [4.24264027 4.24264027 4.24264027]Kgrid for supercell: (1.6499159830969252, 1.6499159830969252, 1.6499159830969252)Rounded kgrid for supercell: [2, 2, 2]

from doped.vasp import DefectsSet # append "?" to function/class to see the help docstrings:DefectsSet?

Init signature:DefectsSet( defect_entries: Union[doped.generation.DefectsGenerator, Dict[str, doped.core.DefectEntry], List[doped.core.DefectEntry], doped.core.DefectEntry], soc: Optional[bool] = None, user_incar_settings: Optional[dict] = None, user_kpoints_settings: Union[dict, pymatgen.io.vasp.inputs.Kpoints, NoneType] = None, user_potcar_functional: Optional[Literal['PBE', 'PBE_52', 'PBE_54', 'LDA', 'LDA_52', 'LDA_54', 'PW91', 'LDA_US', 'PW91_US']] = 'PBE', user_potcar_settings: Optional[dict] = None, **kwargs,)Docstring: An object for generating input files for VASP defect calculations fromdoped/pymatgen ``DefectEntry`` objects.Init docstring:Creates a dictionary of: {defect_species: DefectRelaxSet}.DefectRelaxSet has the attributes:- ``DefectRelaxSet.vasp_gam``: ``DefectDictSet`` for Gamma-point only relaxation. Usually not needed if ShakeNBreak structure searching has been performed (recommended), unless only Γ-point `k`-point sampling is required (converged) for your system, and no vasp_std calculations with multiple `k`-points are required (determined from kpoints settings).- ``DefectRelaxSet.vasp_nkred_std``: ``DefectDictSet`` for relaxation with a kpoint mesh and using ``NKRED``. Not generated for GGA calculations (if ``LHFCALC`` is set to ``False`` in ``user_incar_settings``) or if only Gamma kpoint sampling is required.- ``DefectRelaxSet.vasp_std``: ``DefectDictSet`` for relaxation with a kpoint mesh, not using ``NKRED``. Not generated if only Gamma kpoint sampling is required.- ``DefectRelaxSet.vasp_ncl``: ``DefectDictSet`` for singlepoint (static) energy calculation with SOC included. Generated if ``soc=True``. If ``soc`` is not set, then by default is only generated for systems with a max atomic number (Z) >= 31 (i.e. further down the periodic table than Zn).where ``DefectDictSet`` is an extension of ``pymatgen``'s ``DictSet`` class fordefect calculations, with ``incar``, ``poscar``, ``kpoints`` and ``potcar``attributes for the corresponding VASP defect calculations (see docstring).Also creates the corresponding ``bulk_vasp_...`` attributes for singlepoint(static) energy calculations of the bulk (pristine, defect-free) supercell.This needs to be calculated once with the same settings as the final defectcalculations, for the later calculation of defect formation energies.See the ``RelaxSet.yaml`` and ``DefectSet.yaml`` files in the``doped/VASP_sets`` folder for the default ``INCAR`` settings, and``PotcarSet.yaml`` for the default ``POTCAR`` settings.Note that any changes to the default ``INCAR``/``POTCAR`` settings shouldbe consistent with those used for all defect and competing phase (chemicalpotential) calculations.Args: defect_entries (``DefectsGenerator``, dict/list of ``DefectEntry``\s, or ``DefectEntry``): Either a ``DefectsGenerator`` object, or a dictionary/list of ``DefectEntry``\s, or a single ``DefectEntry`` object, for which to generate VASP input files. If a ``DefectsGenerator`` object or a dictionary (-> {defect_species: DefectEntry}), the defect folder names will be set equal to ``defect_species``. If a list or single ``DefectEntry`` object is provided, the defect folder names will be set equal to ``DefectEntry.name`` if the ``name`` attribute is set, otherwise generated according to the ``doped`` convention (see doped.generation). Defect charge states are taken from ``DefectEntry.charge_state``. soc (bool): Whether to generate ``vasp_ncl`` DefectDictSet attribute for spin-orbit coupling singlepoint (static) energy calculations. If not set, then by default is set to True if the max atomic number (Z) in the structure is >= 31 (i.e. further down the periodic table than Zn). user_incar_settings (dict): Dictionary of user INCAR settings (AEXX, NCORE etc.) to override default settings. Highly recommended to look at output INCARs or the ``RelaxSet.yaml`` and ``DefectSet.yaml`` files in the ``doped/VASP_sets`` folder, to see what the default INCAR settings are. Note that any flags that aren't numbers or True/False need to be input as strings with quotation marks (e.g. ``{"ALGO": "All"}``). (default: None) user_kpoints_settings (dict or Kpoints): Dictionary of user KPOINTS settings (in pymatgen DictSet() format) e.g. {"reciprocal_density": 123}, or a Kpoints object, to use for the ``vasp_std``, ``vasp_nkred_std`` and ``vasp_ncl`` DefectDictSets (Γ-only for ``vasp_gam``). Default is Gamma-centred, reciprocal_density = 100 [Å⁻³]. user_potcar_functional (str): POTCAR functional to use. Default is "PBE" and if this fails, tries "PBE_52", then "PBE_54". user_potcar_settings (dict): Override the default POTCARs, e.g. {"Li": "Li_sv"}. See ``doped/VASP_setsPotcarSet.yaml`` for the default ``POTCAR`` set. **kwargs: Additional kwargs to pass to each ``DefectRelaxSet()``.Attributes: defect_sets (Dict): Dictionary of {defect_species: ``DefectRelaxSet``}. defect_entries (Dict): Dictionary of {defect_species: DefectEntry} for the input defect species, for which to generate VASP input files. bulk_vasp_gam (DefectDictSet): DefectDictSet for a `bulk` Γ-point-only singlepoint (static) supercell calculation. Often not used, as the bulk supercell only needs to be calculated once with the same settings as the final defect calculations, which may be with ``vasp_std`` or ``vasp_ncl``. bulk_vasp_nkred_std (DefectDictSet): DefectDictSet for a singlepoint (static) `bulk` ``vasp_std`` supercell calculation (i.e. with a non-Γ-only kpoint mesh) and ``NKRED(X,Y,Z)`` INCAR tag(s) to downsample kpoints for the HF exchange part of the hybrid DFT calculation. Not generated for GGA calculations (if ``LHFCALC`` is set to ``False`` in user_incar_settings) or if only Gamma kpoint sampling is required. bulk_vasp_std (DefectDictSet): DefectDictSet for a singlepoint (static) `bulk` ``vasp_std`` supercell calculation with a non-Γ-only kpoint mesh, not using ``NKRED``. Not generated if only Gamma kpoint sampling is required. bulk_vasp_ncl (DefectDictSet): DefectDictSet for singlepoint (static) energy calculation of the `bulk` supercell with SOC included. Generated if ``soc=True``. If ``soc`` is not set, then by default is only generated for systems with a max atomic number (Z) >= 31 (i.e. further down the periodic table than Zn). json_obj (Union[Dict, DefectsGenerator]): Either the DefectsGenerator object if input ``defect_entries`` is a ``DefectsGenerator`` object, otherwise the ``defect_entries`` dictionary, which will be written to file when ``write_files()`` is called, to aid calculation provenance. json_name (str): Name of the JSON file to save the ``json_obj`` to. Input parameters are also set as attributes.File: ~/Library/CloudStorage/OneDrive-ImperialCollegeLondon/Bread/Projects/Packages/doped/doped/vasp.pyType: typeSubclasses: 

from doped.vasp import DefectsSet # append "?" to function/class to see the help docstrings:from pymatgen.io.vasp.inputs import Kpointsdefect_set = DefectsSet( defect_gen, # our DefectsGenerator object, can also input individual DefectEntry objects if desired user_incar_settings={ "ENCUT": 450, "GGA": "PS", # Functional (PBEsol for this tutorial) "LHFCALC": False, # Disable Hybrid functional "NCORE": 8, # Parallelisation, might need updating for your HPC! }, # custom INCAR settings, any that aren't numbers or True/False need to be input as strings with quotation marks! user_kpoints_settings=Kpoints(kpts=[(2,2,2)]),)# We can also customise the POTCAR settings (and others), see the docstrings above for more info

defect_set.defect_sets

{'v_Mg_+1': doped DefectRelaxSet for bulk composition MgO, and defect entry v_Mg_+1. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'v_Mg_0': doped DefectRelaxSet for bulk composition MgO, and defect entry v_Mg_0. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'v_Mg_-1': doped DefectRelaxSet for bulk composition MgO, and defect entry v_Mg_-1. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'v_Mg_-2': doped DefectRelaxSet for bulk composition MgO, and defect entry v_Mg_-2. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'v_O_+2': doped DefectRelaxSet for bulk composition MgO, and defect entry v_O_+2. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'v_O_+1': doped DefectRelaxSet for bulk composition MgO, and defect entry v_O_+1. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'v_O_0': doped DefectRelaxSet for bulk composition MgO, and defect entry v_O_0. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'v_O_-1': doped DefectRelaxSet for bulk composition MgO, and defect entry v_O_-1. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'Mg_O_+4': doped DefectRelaxSet for bulk composition MgO, and defect entry Mg_O_+4. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'Mg_O_+3': doped DefectRelaxSet for bulk composition MgO, and defect entry Mg_O_+3. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'Mg_O_+2': doped DefectRelaxSet for bulk composition MgO, and defect entry Mg_O_+2. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'Mg_O_+1': doped DefectRelaxSet for bulk composition MgO, and defect entry Mg_O_+1. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'Mg_O_0': doped DefectRelaxSet for bulk composition MgO, and defect entry Mg_O_0. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'O_Mg_0': doped DefectRelaxSet for bulk composition MgO, and defect entry O_Mg_0. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'O_Mg_-1': doped DefectRelaxSet for bulk composition MgO, and defect entry O_Mg_-1. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'O_Mg_-2': doped DefectRelaxSet for bulk composition MgO, and defect entry O_Mg_-2. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'O_Mg_-3': doped DefectRelaxSet for bulk composition MgO, and defect entry O_Mg_-3. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'O_Mg_-4': doped DefectRelaxSet for bulk composition MgO, and defect entry O_Mg_-4. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'Mg_i_Td_+2': doped DefectRelaxSet for bulk composition MgO, and defect entry Mg_i_Td_+2. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'Mg_i_Td_+1': doped DefectRelaxSet for bulk composition MgO, and defect entry Mg_i_Td_+1. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'Mg_i_Td_0': doped DefectRelaxSet for bulk composition MgO, and defect entry Mg_i_Td_0. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'O_i_Td_0': doped DefectRelaxSet for bulk composition MgO, and defect entry O_i_Td_0. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'O_i_Td_-1': doped DefectRelaxSet for bulk composition MgO, and defect entry O_i_Td_-1. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}, 'O_i_Td_-2': doped DefectRelaxSet for bulk composition MgO, and defect entry O_i_Td_-2. Available attributes: {'defect_entry', 'user_potcar_settings', 'bulk_vasp_std', 'poscar_comment', 'vasp_nkred_std', 'bulk_supercell', 'vasp_gam', 'defect_supercell', 'soc', 'vasp_ncl', 'bulk_vasp_nkred_std', 'dict_set_kwargs', 'user_kpoints_settings', 'user_incar_settings', 'bulk_vasp_gam', 'bulk_vasp_ncl', 'user_potcar_functional', 'charge_state', 'vasp_std'} Available methods: {'validate_monty_v1', 'validate_monty_v2', 'write_all', 'write_std', 'unsafe_hash', 'as_dict', 'from_dict', 'write_nkred_std', 'write_ncl', 'to_json', 'write_gam'}}

# for example, let's look at the generated inputs for a `vasp_std` calculation for Mg_O_0:print(f"INCAR:\n{defect_set.defect_sets['Mg_O_0'].vasp_std.incar}")print(f"KPOINTS:\n{defect_set.defect_sets['Mg_O_0'].vasp_std.kpoints}")print(f"POTCAR (symbols):\n{defect_set.defect_sets['Mg_O_0'].vasp_std.potcar_symbols}")

INCAR:# May want to change NCORE, KPAR, AEXX, ENCUT, IBRION, LREAL, NUPDOWN, ISPIN = Typical variable parametersALGO = Normal # change to all if zhegv, fexcp/f or zbrent errors encounteredEDIFF = 4e-05EDIFFG = -0.01ENCUT = 450GGA = PsIBRION = 2ICHARG = 1ICORELEVEL = 0 # needed if using the kumagai-oba (efnv) anisotropic charge correction schemeISIF = 2ISMEAR = 0ISPIN = 2ISYM = 0 # symmetry breaking extremely likely for defectsKPAR = 2LASPH = TrueLHFCALC = FalseLORBIT = 11LREAL = AutoLVHAR = TrueNCORE = 8NEDOS = 2000NELECT = 860.0NSW = 200NUPDOWN = 0PREC = AccurateSIGMA = 0.05KPOINTS:KPOINTS from doped, with reciprocal_density = 100/Å⁻³0Gamma2 2 2POTCAR (symbols):['Mg', 'O']

defect_set.write_files?

Signature:defect_set.write_files( output_path: str = '.', unperturbed_poscar: bool = False, vasp_gam: bool = False, bulk: Union[bool, str] = True, processes: Optional[int] = None, **kwargs,)Docstring:Write VASP input files to folders for all defects in`self.defect_entries`. Folder names are set to the key of theDefectRelaxSet in `self.defect_sets` (same as self.defect_entries keys,see `DefectsSet` docstring).For each defect folder, the following subfolders are generated:- vasp_nkred_std -> Defect relaxation with a kpoint mesh and using `NKRED`. Not generated for GGA calculations (if `LHFCALC` is set to `False` in user_incar_settings) or if only Γ-point sampling required.- vasp_std -> Defect relaxation with a kpoint mesh, not using `NKRED`. Not generated if only Γ-point sampling required.- vasp_ncl -> Singlepoint (static) energy calculation with SOC included. Generated if `soc=True`. If `soc` is not set, then by default is only generated for systems with a max atomic number (Z) >= 31 (i.e. further down the periodic table than Zn).If vasp_gam=True (not recommended) or self.vasp_std = None (i.e. Γ-only_k_-point sampling converged for the kpoints settings used), then outputs:- vasp_gam -> Γ-point only defect relaxation. Usually not needed if ShakeNBreak structure searching has been performed (recommended).By default, does not generate a `vasp_gam` folder unless`DefectRelaxSet.vasp_std` is None (i.e. only Γ-point sampling requiredfor this system), as `vasp_gam` calculations should be performed using`ShakeNBreak` for defect structure-searching and initial relaxations.If `vasp_gam` files are desired, set `vasp_gam=True`.By default, `POSCAR` files are not generated for the `vasp_(nkred_)std`(and `vasp_ncl` if `self.soc` is True) folders, as these shouldbe taken from `ShakeNBreak` calculations (via `snb-groundstate`)or, if not following the recommended structure-searching workflow,from the `CONTCAR`s of `vasp_gam` calculations. If including SOCeffects (`self.soc = True`), then the `vasp_std` `CONTCAR`sshould be used as the `vasp_ncl` `POSCAR`s. If unperturbed`POSCAR` files are desired for the `vasp_(nkred_)std` (and `vasp_ncl`)folders, set `unperturbed_poscar=True`.Input files for the singlepoint (static) bulk supercell referencecalculation are also written to "{formula}_bulk/{subfolder}" if `bulk`is True (default), where `subfolder` corresponds to the final (highestaccuracy) VASP calculation in the workflow (i.e. `vasp_ncl` if`self.soc=True`, otherwise `vasp_std` or `vasp_gam` if only Γ-pointreciprocal space sampling is required). If `bulk = "all"`, then theinput files for all VASP calculations in the workflow are written tothe bulk supercell folder, or if `bulk = False`, then no bulk folderis created.The `DefectEntry` objects are also written to `json` files in the defectfolders, as well as `self.defect_entries` (`self.json_obj`) in the topfolder, to aid calculation provenance.See the `RelaxSet.yaml` and `DefectSet.yaml` files in the`doped/VASP_sets` folder for the default `INCAR` and `KPOINT` settings,and `PotcarSet.yaml` for the default `POTCAR` settings. **These arereasonable defaults that _roughly_ match the typical values needed foraccurate defect calculations, but usually will need to be modified foryour specific system, such as converged ENCUT and KPOINTS, and NCORE /KPAR matching your HPC setup.**Note that any changes to the default `INCAR`/`POTCAR` settings shouldbe consistent with those used for all defect and competing phase (chemical potential) calculations.Args: output_path (str): Folder in which to create the VASP defect calculation folders. Default is the current directory ("."). Output folder structure is `<output_path>/<defect_species>/<subfolder>` where `defect_species` is the key of the DefectRelaxSet in `self.defect_sets` (same as `self.defect_entries` keys, see `DefectsSet` docstring) and `subfolder` is the name of the corresponding VASP program to run (e.g. `vasp_std`). unperturbed_poscar (bool): If True, write the unperturbed defect POSCARs to the generated folders as well. Not recommended, as the recommended workflow is to initially perform `vasp_gam` ground-state structure searching using ShakeNBreak (https://shakenbreak.readthedocs.io), then continue the `vasp_std` relaxations from the 'Groundstate' `CONTCAR`s (first with NKRED if using hybrid DFT, then without), then use the `vasp_std` `CONTCAR`s as the input structures for the final `vasp_ncl` singlepoint calculations. (default: False) vasp_gam (bool): If True, write the `vasp_gam` input files, with unperturbed defect POSCARs. Not recommended, as the recommended workflow is to initially perform `vasp_gam` ground-state structure searching using ShakeNBreak (https://shakenbreak.readthedocs.io), then continue the `vasp_std` relaxations from the 'Groundstate' `CONTCAR`s (first with NKRED if using hybrid DFT, then without), then if including SOC effects, use the `vasp_std` `CONTCAR`s as the input structures for the final `vasp_ncl` singlepoint calculations. (default: False) bulk (bool, str): If True, the input files for a singlepoint calculation of the bulk supercell are also written to "{formula}_bulk/{subfolder}", where `subfolder` corresponds to the final (highest accuracy) VASP calculation in the workflow (i.e. `vasp_ncl` if `self.soc=True`, otherwise `vasp_std` or `vasp_gam` if only Γ-point reciprocal space sampling is required). If `bulk = "all"` then the input files for all VASP calculations in the workflow (`vasp_gam`, `vasp_nkred_std`, `vasp_std`, `vasp_ncl` (if applicable)) are written to the bulk supercell folder. (Default: False) processes (int): Number of processes to use for multiprocessing for file writing. If not set, defaults to one less than the number of CPUs available. **kwargs: Keyword arguments to pass to `DefectDictSet.write_input()`.File: /mnt/c/Users/Irea/OneDrive - Imperial College London/07_Python_Packages/doped/doped/vasp.pyType: method

defect_set.write_files(output_path="./MgO/Defects") # again add "?" to see the docstring and options

Generating and writing input files: 100%|██████████| 5/5 [00:00<00:00, 6.75it/s]

!ls ./MgO/Defects/*Mg_O*/*vasp* # list the generated VASP input files

./MgO/Defects/Mg_O_+1/vasp_std:INCAR KPOINTSMg_O_+1.json POTCAR./MgO/Defects/Mg_O_+2/vasp_std:INCAR KPOINTSMg_O_+2.json POTCAR./MgO/Defects/Mg_O_+3/vasp_std:INCAR KPOINTSMg_O_+3.json POTCAR./MgO/Defects/Mg_O_+4/vasp_std:INCAR KPOINTSMg_O_+4.json POTCAR./MgO/Defects/Mg_O_0/vasp_std:INCAR KPOINTSMg_O_0.json POTCAR

import shutilimport osfor defect in os.listdir("./MgO/SnB/"): # if last character of defect is a number (i.e. charge state) if defect[-1].isnumeric(): shutil.copy( os.path.join("./MgO/SnB/", defect, "groundstate_POSCAR"), os.path.join("./MgO/Defects/", defect, "vasp_std", "POSCAR") )

!ls MgO/Defects/MgO_bulk/vasp_std # only the final workflow VASP calculation is required for the bulk, see docstrings

INCAR KPOINTSPOSCARPOTCAR

from doped.chemical_potentials import CompetingPhases

e_above_hull = 0.01 # default e_above_hull = 0.1 eV/atom but for this tutorial here we use a slightly less strict valuecp = CompetingPhases("MgO", e_above_hull=e_above_hull)# if you don't have your MP API key set up in ~/.pmgrc.yaml, you can supply it with the parameter "api_key" to this function

print(len(cp.entries))print([entry.name for entry in cp.entries])

5['Mg', 'O2', 'MgO', 'Mg', 'Mg']

import dopedimport matplotlib.pyplot as pltplt.style.use(f"{doped.__path__[0]}/utils/doped.mplstyle") # use doped stylefrom pymatgen.ext.matproj import MPResterfrom pymatgen.analysis.phase_diagram import PhaseDiagram, PDPlottersystem = ["Mg", "O"] # system we want to get phase diagram formpr = MPRester() # object for connecting to MP Rest interface, may need to specify API key hereentries = mpr.get_entries_in_chemsys(system) # get all entries in the chemical systempd = PhaseDiagram(entries) # create phase diagram objectplotter = PDPlotter(pd, show_unstable=e_above_hull, backend="matplotlib") # plot phase diagramplotter.get_plot()

<Axes: xlabel='Fraction', ylabel='Formation energy (eV/atom)'>