Skip to content

kpts

Utilities for k-point handling.

bandgap_to_kspacing 

bandgap_to_kspacing(bandgap: float) -> float

Takes the bandgap energy and computes the required KSPACING value. Refer to https://drive.google.com/file/d/1fUUx0wrrtMRcSss5yv3NiQuC7J5IiEKL/view

Parameters:

  • bandgap (float) –

    The bandgap of the material in eV.

Returns:

  • kspacing –

    Value of the KSPACING INCAR tag in inverse angstroms.

Source code in quacc/utils/kpts.py 
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
def bandgap_to_kspacing(bandgap: float) -> float:
    """
    Takes the bandgap energy and computes the required KSPACING value.
    Refer to https://drive.google.com/file/d/1fUUx0wrrtMRcSss5yv3NiQuC7J5IiEKL/view

    Parameters
    ----------
    bandgap
        The bandgap of the material in eV.

    Returns
    ----------
    kspacing
        Value of the KSPACING INCAR tag in inverse angstroms.
    """

    deltak_min = 0.2
    deltak_max = 0.45
    a = 0.9
    b = 2.35
    c = 8.0

    delta = a * (bandgap - b)
    return 0.5 * (
        deltak_min
        + deltak_max
        + (deltak_max - deltak_min) * delta / ((1 + delta**c) ** (1 / c))
    )

convert_pmg_kpts 

convert_pmg_kpts(
    pmg_kpts: PmgKpts,
    input_atoms: Atoms,
    force_gamma: bool = False,
) -> tuple[list[int], bool]

Shortcuts for pymatgen k-point generation schemes.

Parameters:

  • pmg_kpts (PmgKpts) –

    The pmg_kpts kwargs. Has the following options:

    • {"line_density": float}. This will call pymatgen.symmetry.bandstructure.HighSymmKpath with path_type="latimer_munro". The line_density value will be set in the .get_kpoints attribute.

    • {"kppvol": float}. This will call pymatgen.io.vasp.inputs.Kpoints.automatic_density_by_vol with the given value for kppvol.

    • {"kppa": float}. This will call pymatgen.io.vasp.inputs.Kpoints.automatic_density with the given value for kppa.

    • {"length_densities": [float, float, float]}. This will call pymatgen.io.vasp.inputs.Kpoints.automatic_density_by_lengths with the given value for length_densities.

    If multiple options are specified, the most dense k-point scheme will be chosen.

  • input_atoms (Atoms) –

    The input atoms.

  • force_gamma (bool, default: False ) –

    Force gamma-centered k-points.

Returns:

  • kpts –

    The generated k-points.

  • gamma –

    Whether the k-points are gamma-centered.

Source code in quacc/utils/kpts.py 
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
def convert_pmg_kpts(
    pmg_kpts: PmgKpts, input_atoms: Atoms, force_gamma: bool = False
) -> tuple[list[int], bool]:
    """
    Shortcuts for pymatgen k-point generation schemes.

    Parameters
    ----------
    pmg_kpts
        The pmg_kpts kwargs. Has the following options:

        - {"line_density": float}. This will call
        `pymatgen.symmetry.bandstructure.HighSymmKpath`
            with `path_type="latimer_munro"`. The `line_density` value will be
            set in the `.get_kpoints` attribute.

        - {"kppvol": float}. This will call
        `pymatgen.io.vasp.inputs.Kpoints.automatic_density_by_vol`
            with the given value for `kppvol`.

        - {"kppa": float}. This will call
        `pymatgen.io.vasp.inputs.Kpoints.automatic_density`
            with the given value for `kppa`.

        - {"length_densities": [float, float, float]}. This will call
        `pymatgen.io.vasp.inputs.Kpoints.automatic_density_by_lengths`
            with the given value for `length_densities`.

        If multiple options are specified, the most dense k-point scheme will be
        chosen.
    input_atoms
        The input atoms.
    force_gamma
        Force gamma-centered k-points.

    Returns
    -------
    kpts
        The generated k-points.
    gamma
        Whether the k-points are gamma-centered.
    """
    struct = AseAtomsAdaptor.get_structure(input_atoms)

    if pmg_kpts.get("line_density"):
        kpath = HighSymmKpath(
            struct,
            path_type="latimer_munro",
            has_magmoms=np.any(struct.site_properties.get("magmom", None)),
        )
        kpts, _ = kpath.get_kpoints(
            line_density=pmg_kpts["line_density"], coords_are_cartesian=False
        )
        kpts = np.stack(kpts)
        gamma = False

    else:
        max_pmg_kpts: PmgKpts = None
        for k, v in pmg_kpts.items():
            if k == "kppvol":
                pmg_kpts = Kpoints.automatic_density_by_vol(
                    struct, v, force_gamma=force_gamma
                )
            elif k == "kppa":
                pmg_kpts = Kpoints.automatic_density(struct, v, force_gamma=force_gamma)
            elif k == "length_densities":
                pmg_kpts = Kpoints.automatic_density_by_lengths(
                    struct, v, force_gamma=force_gamma
                )
            else:
                msg = f"Unsupported k-point generation scheme: {pmg_kpts}."
                raise ValueError(msg)

            max_pmg_kpts = (
                pmg_kpts
                if (
                    not max_pmg_kpts
                    or np.prod(pmg_kpts.kpts[0]) >= np.prod(max_pmg_kpts.kpts[0])
                )
                else max_pmg_kpts
            )

        kpts = [int(k) for k in max_pmg_kpts.kpts[0]]
        gamma = max_pmg_kpts.style.name.lower() == "gamma"

    return kpts, gamma

kspacing_to_kpts 

kspacing_to_kpts(
    kspacing: float, atoms: Atoms
) -> list[int]

Converts KSPACING to k-points.

Parameters:

  • kspacing (float) –

    The KSPACING value in inverse angstroms.

  • atoms (Atoms) –

    The input atoms.

Returns:

  • list[int] –

    The k-points as a list of integers.

Source code in quacc/utils/kpts.py 
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
def kspacing_to_kpts(kspacing: float, atoms: Atoms) -> list[int]:
    """
    Converts KSPACING to k-points.

    Parameters
    ----------
    kspacing
        The KSPACING value in inverse angstroms.
    atoms
        The input atoms.

    Returns
    -------
    list[int]
        The k-points as a list of integers.
    """
    return [
        int(
            max(
                1,
                np.ceil(
                    Structure.from_ase_atoms(atoms).lattice.reciprocal_lattice.abc[ik]
                    / kspacing
                ),
            )
        )
        for ik in range(3)
    ]