My Community

Code: Select all

KSPACING = 0.02  in \AA ^-1

Code: Select all

mpirun -np 1 /path/to/vasp_std --dry-run

Code: Select all

Automatic generation of k-mesh.
 Grid dimensions derived from KSPACING:
 generate k-points for:   10   10   10

Code: Select all

import math

def calculate_grid_dimensions(bnorm, spacing, multipl=None):
    """
    Calculate the Monkhorst-Pack grid dimensions based on lattice norms and spacing.

    :param bnorm: Lattice norms (list or tuple of three floats).
    :param spacing: KPOINTS spacing (float).
    :param multipl: Optional multiplier (list or tuple of three integers).
    :return: Tuple of grid dimensions (NKPX, NKPY, NKPZ).
    """
    # Calculate initial grid dimensions based on spacing
    nkpx = max(1, math.ceil(bnorm[0] * math.pi * 2 / spacing))
    nkpy = max(1, math.ceil(bnorm[1] * math.pi * 2 / spacing))
    nkpz = max(1, math.ceil(bnorm[2] * math.pi * 2 / spacing))

    # Apply multiplier if provided
    if multipl:
        nkpx *= multipl[0]
        nkpy *= multipl[1]
        nkpz *= multipl[2]

    return nkpx, nkpy, nkpz

# Example usage
bnorm = [1.0, 2.0, 3.0]  # Example lattice norms
spacing = 0.5  # Example KPOINTS spacing
multipl = [2, 2, 2]  # Example multiplier

nkpx, nkpy, nkpz = calculate_grid_dimensions(bnorm, spacing, multipl)
print("Grid dimensions:", nkpx, nkpy, nkpz)

Code: Select all

werner@x13dai-t:~/Desktop/Jinyu-Qiao/Bulk_Systems_-_Tutorial/Fcc_Si$ ug -i kspa
vasprun.xml:    <i name="KSPACING">      0.50000000</i>
werner@x13dai-t:~/Desktop/Jinyu-Qiao/Bulk_Systems_-_Tutorial/Fcc_Si$ ug -A2 -B3 -i 'grid dim'
OUTCAR- KPOINTS: pymatgen with grid density = 787 / numbe
OUTCAR-
OUTCAR-Automatic generation of k-mesh.
OUTCAR: Grid dimensions read from file:
OUTCAR- generate k-points for:    7    7    7
OUTCAR-

Code: Select all

Grid dimensions read from file:

Code: Select all

Grid dimensions derived from KSPACING:

Code: Select all

(datasci) werner@x13dai-t:~/Desktop/Jinyu-Qiao/Fcc_Si$ ug -i pymatgen
KPOINTS:pymatgen with grid density = 787 / number of atoms
Binary file vaspout.h5 matches
OUTCAR: KPOINTS: pymatgen with grid density = 787 / numbe
OUTCAR: k-points in units of 2pi/SCALE and weight: pymatgen with grid density = 787 / numbe
OUTCAR: k-points in reciprocal lattice and weights: pymatgen with grid density = 787 / number

(datasci) werner@x13dai-t:~/Desktop/Jinyu-Qiao/Fcc_Si$ cat KPOINTS 
pymatgen with grid density = 787 / number of atoms
0
Gamma
7 7 7

Code: Select all

from mp_api.client import MPRester
from pymatgen.io.vasp.inputs import Kpoints
from pymatgen.io.vasp.sets import MPRelaxSet

# Use Materials Project API to get Si structure with Fd-3m space group
with MPRester() as mpr:
    results = mpr.materials.summary.search(
        formula="Si",
        spacegroup_symbol="Fd-3m"
    )

    if results:
        result = results[0]
        mp_id = result.material_id
        structure = mpr.get_structure_by_material_id(mp_id)
    else:
        print("No matching materials found.")
        exit()

# Set k-point density
kppa = 787

# Generate k-points using pymatgen's method
kpoints = Kpoints.automatic_density(structure, kppa)

# Get the actual k-point grid
grid = kpoints.kpts[0]

# User-defined INCAR settings
user_incar_settings = {
    'ALGO': 'N',
    'GGA': 're',
    'KSPACING': 0.3,
#    'KGAMMA': '.TRUE.',
}

# Create VASP input set
vasp_input = MPRelaxSet(structure, user_potcar_functional="PBE_64", user_incar_settings=user_incar_settings)
vasp_input.write_input("./Fcc_Si")

# Print results
print(f"Material ID: {mp_id}")
print(f"kppa (grid density) = {kppa}")
print(f"Generated k-point grid: {grid[0]} x {grid[1]} x {grid[2]}")

Code: Select all

Material ID: mp-149
kppa (grid density) = 787
Generated k-point grid: 7 x 7 x 7

Code: Select all

$ ug -A2 -B2 -i 'grid dim' -g OUTCAR 
OUTCAR-
OUTCAR-Automatic generation of k-mesh.
OUTCAR: Grid dimensions derived from KSPACING:
OUTCAR- generate k-points for:    7    7    7
OUTCAR-

Code: Select all

    def automatic_density(cls, structure: Structure, kppa: float, force_gamma: bool = False) -> Self:
        """Get an automatic Kpoint object based on a structure and a kpoint
        density. Uses Gamma centered meshes for hexagonal cells and face-centered cells,
        Monkhorst-Pack grids otherwise.

        Algorithm:
            Uses a simple approach scaling the number of divisions along each
            reciprocal lattice vector proportional to its length.

        Args:
            structure (Structure): Input structure
            kppa (float): Grid density
            force_gamma (bool): Force a gamma centered mesh (default is to
                use gamma only for hexagonal cells or odd meshes)

        Returns:
            Kpoints
        """
        comment = f"pymatgen with grid density = {kppa:.0f} / number of atoms"
        if math.fabs((math.floor(kppa ** (1 / 3) + 0.5)) ** 3 - kppa) < 1:
            kppa += kppa * 0.01
        lattice = structure.lattice
        lengths: Vector3D = lattice.abc
        ngrid = kppa / len(structure)
        mult: float = (ngrid * lengths[0] * lengths[1] * lengths[2]) ** (1 / 3)

        num_div: Tuple3Ints = cast(Tuple3Ints, [math.floor(max(mult / length, 1)) for length in lengths])

        is_hexagonal: bool = lattice.is_hexagonal()
        is_face_centered: bool = structure.get_space_group_info()[0][0] == "F"
        has_odd: bool = any(idx % 2 == 1 for idx in num_div)
        if has_odd or is_hexagonal or is_face_centered or force_gamma:
            style = cls.supported_modes.Gamma
        else:
            style = cls.supported_modes.Monkhorst

        return cls(
            comment,
            0,
            style,
            [num_div],
            (0, 0, 0),
        )