# K-Points

Periodic Quickstep calculations approximate Brillouin-zone integrals with a finite, weighted set of
k-points. The sampling set used for the self-consistent-field (SCF) calculation is defined in
[&DFT%KPOINTS](#CP2K_INPUT.FORCE_EVAL.DFT.KPOINTS).

This page introduces k-point sampling in CP2K, explains the available sampling schemes, and
summarizes the experimental atomic-symmetry reduction path. A band-structure path is a different
object from the SCF integration mesh; it is defined through
[&DFT%PRINT%BAND_STRUCTURE](#CP2K_INPUT.FORCE_EVAL.DFT.PRINT.BAND_STRUCTURE), not through an
arbitrary `SCHEME GENERAL` list.

## Why k-points are needed

### Brillouin-zone integration

For a periodic system, Bloch's theorem labels the one-electron states by a crystal momentum
$\mathbf{k}$ in the Brillouin zone. Quantities such as the electronic density, total energy, and
occupations contain integrals over this zone. In a numerical calculation, CP2K replaces such an
integral by a weighted sum over a finite set of k-points,

$$
  \frac{1}{\Omega_\mathrm{BZ}}\int_\mathrm{BZ} f(\mathbf{k})\,d\mathbf{k}
  \approx \sum_{\mathbf{k}} w_{\mathbf{k}} f(\mathbf{k}),
$$

where $w_{\mathbf{k}}$ are normalized k-point weights.

A Gamma-only calculation samples only $\mathbf{k}=0$. It is often appropriate for isolated systems,
large supercells, or other cases where the Brillouin zone is sufficiently small. Smaller primitive
cells, metals, and systems with strongly dispersive bands usually need a converged k-point mesh.

### K-points in CP2K

For every sampled k-point, CP2K solves a k-dependent Kohn--Sham problem and combines the resulting
quantities with the k-point weights. The `&KPOINTS` section therefore describes the sampling used
during the SCF calculation, rather than a post-processing path through selected high-symmetry
points.

Omitting `&KPOINTS` gives the usual Gamma-only calculation (`SCHEME NONE`). `SCHEME GAMMA` instead
creates an explicit one-point k-point set at Gamma. The physical sampling is the same in most cases,
but the two inputs use different implementation paths.

Complex wavefunctions are the default for k-point calculations; see
[WAVEFUNCTIONS](#CP2K_INPUT.FORCE_EVAL.DFT.KPOINTS.WAVEFUNCTIONS). Real wavefunctions are only valid
for Gamma and special k-points whose Bloch phases can be represented as real. Use complex
wavefunctions for a general mesh or for atomic k-point symmetry reduction.

#### Feature compatibility

Compatibility with k-point sampling depends on the selected CP2K feature and implementation path.
The following table summarizes selected common cases for `DFT%KPOINTS`; it is not exhaustive. Refer
to the documentation of the relevant feature for detailed requirements and limitations or see issue
[#4854](https://github.com/cp2k/cp2k/issues/4854) which tracks the current status of k-points
support.

| Feature                       | Compatibility and limitations                                           |
| ----------------------------- | ----------------------------------------------------------------------- |
| Standard diagonalization      | **Supported.**                                                          |
| Orbital transformation (OT)   | **Unsupported.** No k-point path available.                             |
| Atomic symmetry reduction     | **Experimental.** Validate against an equivalent unreduced calculation. |
| WFN extrapolation             | **Supported.**                                                          |
| Other diagonalization methods | **Unsupported.** No k-point path available.                             |
| Hybrid functionals            | **Supported via [RI-HFXk](hartree-fock/ri_kpoints).**                   |
| DFT+U                         | **Limited.** Mulliken populations only.                                 |
| SCCS                          | **Not validated.** Use with caution.                                    |
| Constrained DFT (CDFT)        | **Unsupported.** No k-point path available.                             |
| TDDFPT                        | **Limited.** Independent-particle response only (`KERNEL NONE`).        |
| XAS and RIXS                  | **Unsupported.** No k-point path available.                             |
| Linear response / DFPT        | **Unsupported.** No k-point path available.                             |
| GW                            | **Support with separate workflow.** Does not rely on `DFT%KPOINTS`.     |
| Periodic electric field       | **Unsupported.** Requires OT first.                                     |
| Active-space calculations     | **Unsupported.** Only `SCHEME NONE` and `SCHEME GAMMA` available.       |

The reason why a specialized feature does not have support for k-point sampling is twofold: it is
possible that code implementation in CP2K is not present, complete, or verified yet, but it is also
possible that the underlying theories and algorithms do not have an updated k-point version
(compared with an isolated, non-periodic formalism) to begin with. In the latter case it is not a
far stretch to think that a novel k-point generalization to existing methods is worthy of academic
publications and takes serious collaboration and devoted efforts to investigate. It is therefore
strongly suggested that reference implementation of k-point formalism in other softwares be provided
whenever making a feature request of this kind.

Note that a successful calculation does not by itself establish that a feature--k-point combination
is reliable for a particular system or property. For a new workflow, converge the k-point mesh and,
where appropriate, compare with an equivalent real-space supercell calculation.

## Choosing and converging a mesh

Although rules of thumb can provide a useful starting point, reliable results require converging the
k-point mesh for the specific system and property of interest. Total energies, forces, stresses,
metallic occupations, density of states, and band edges can converge at different rates. Increase
the mesh density until the relevant quantity no longer changes at the accuracy required for the
calculation.

For slabs, wires, and other low-dimensional systems, sample the periodic directions and normally use
one k-point in a non-periodic or vacuum direction. Enlarging a real-space supercell reduces the
Brillouin zone and can reduce the required k-point density, but does not by itself remove
finite-size effects.

```{important}
Electronic smearing and DOS broadening do not replace k-point convergence. In particular, a smooth
DOS obtained from a sparse mesh may still be physically unconverged. See
[](../electronic_structure/dos.md#broadening-k-points-and-gaps).
```

For a conventional band structure, first converge the SCF calculation on an appropriate integration
mesh. Then use [&BAND_STRUCTURE](#CP2K_INPUT.FORCE_EVAL.DFT.PRINT.BAND_STRUCTURE) and
[&KPOINT_SET](#CP2K_INPUT.FORCE_EVAL.DFT.PRINT.BAND_STRUCTURE.KPOINT_SET) to define the path.

## Sampling schemes

[SCHEME](#CP2K_INPUT.FORCE_EVAL.DFT.KPOINTS.SCHEME) selects one of the schemes described below.
Regular meshes are evaluated as full meshes by default: atomic symmetry reduction is only requested
when [SYMMETRY](#CP2K_INPUT.FORCE_EVAL.DFT.KPOINTS.SYMMETRY) is explicitly enabled.

### Gamma-only sampling

For the conventional Gamma-only calculation, omit `&KPOINTS` entirely:

```text
&DFT
  ...
&END DFT
```

An explicit Gamma-point set can be requested when a k-point calculation path is required by the
workflow:

```text
&DFT
  &KPOINTS
    SCHEME GAMMA
  &END KPOINTS
&END DFT
```

### Monkhorst--Pack meshes

A Monkhorst--Pack mesh is the usual regular sampling scheme for periodic calculations:

```text
&DFT
  &KPOINTS
    SCHEME MONKHORST-PACK 6 6 6
  &END KPOINTS
&END DFT
```

The three integers specify the mesh dimensions along the reciprocal lattice vectors. Use
[GAMMA_CENTERED](#CP2K_INPUT.FORCE_EVAL.DFT.KPOINTS.GAMMA_CENTERED) to generate a Gamma-centered
variant:

```text
&KPOINTS
  SCHEME MONKHORST-PACK 6 6 6
  GAMMA_CENTERED T
&END KPOINTS
```

Gamma centering is supported for Monkhorst--Pack meshes. It is most useful when an even number of
subdivisions is used and the mesh is required to include Gamma point.

### MacDonald meshes

A MacDonald mesh specifies both the mesh dimensions and an explicit shift:

```text
&KPOINTS
  SCHEME MACDONALD 4 4 4 0.25 0.25 0.25
&END KPOINTS
```

The first three values define the mesh dimensions; the final three define the shift.

### Explicit k-point sets

`SCHEME GENERAL` accepts an explicitly supplied weighted set of k-points:

```text
&KPOINTS
  SCHEME GENERAL
  KPOINT 0.0 0.0 0.0 1.0
  KPOINT 0.5 0.0 0.0 1.0
&END KPOINTS
```

Each [KPOINT](#CP2K_INPUT.FORCE_EVAL.DFT.KPOINTS.KPOINT) line contains three coordinates and one
weight. CP2K normalizes the supplied weights internally.

By default, [UNITS](#CP2K_INPUT.FORCE_EVAL.DFT.KPOINTS.UNITS) is `B_VECTOR`, so the coordinates are
expressed in reciprocal-lattice-vector coordinates. Cartesian coordinates can instead be selected
with `CART_BOHR` or `CART_ANGSTROM`; their units are $2\pi/\mathrm{Bohr}$ and $2\pi/\mathrm{\AA}$,
respectively.

```{note}
`SCHEME GENERAL` defines an integration set for the SCF calculation. It is not the usual interface
for a high-symmetry band path. Use `&DFT%PRINT%BAND_STRUCTURE` for that purpose.
```

### Parallelization over k-points

[PARALLEL_GROUP_SIZE](#CP2K_INPUT.FORCE_EVAL.DFT.KPOINTS.PARALLEL_GROUP_SIZE) controls how MPI
processes are grouped for a k-point calculation. Its value is the number of MPI processes assigned
to one k-point group. The group size must divide the total number of MPI processes, and the
resulting number of groups must divide the number of k-points.

The default `-1` selects the smallest valid number of processes per group. `0` uses all processes
for each k-point, while a positive value requests that exact group size. This setting is a
parallelization choice and does not change the physical k-point mesh.

## Related workflows and output

The k-point mesh used for SCF can also be used by several electronic-structure workflows. Their
additional requirements are documented separately:

- [](../electronic_structure/dos) explains DOS and PDOS output. DOS/PDOS commonly need a denser mesh
  than a geometry optimization.
- [](../electronic_structure/molecular_orbitals.md#k-point-mo-output-mokp) documents the `.mokp`
  k-point MO output. Molden output is not available for k-point calculations.
- [](hartree-fock/ri_kpoints) documents RI-HFX with k-point sampling and includes a band-structure
  example.
- [](../electronic_structure/wannier90) documents the experimental Wannier90 interface, including
  export from the SCF k-point mesh and the treatment of symmetry-reduced SCF meshes.
- [](../optimization/geometry_and_cell_opt) describes geometry and cell optimization. Their
  interaction with experimental atomic k-point symmetry is discussed below.

## K-point symmetry reduction

For regular Monkhorst--Pack and MacDonald meshes, CP2K distinguishes two levels of k-point
reduction:

1. **k-space inversion (time-reversal) reduction**, which pairs $\mathbf{k}$ and $-\mathbf{k}$ and
   is used by default for regular meshes; and
1. **atomic (space-group) symmetry reduction**, which uses additional operations that map the
   current periodic structure onto itself.

The [SYMMETRY](#CP2K_INPUT.FORCE_EVAL.DFT.KPOINTS.SYMMETRY) keyword controls the second level. It is
off by default; this does **not** disable the default time-reversal reduction for regular meshes.

### Time-reversal reduction

For a regular Monkhorst--Pack or MacDonald mesh, CP2K normally combines inversion-related
$\mathbf{k}$ and $-\mathbf{k}$ points. This is the standard reduction path when both `SYMMETRY F`
(the default) and `FULL_GRID F` (the default) are used:

```text
&KPOINTS
  SCHEME MONKHORST-PACK 8 8 8
&END KPOINTS
```

The reduction can also be requested explicitly with
[INVERSION_SYMMETRY_ONLY](#CP2K_INPUT.FORCE_EVAL.DFT.KPOINTS.INVERSION_SYMMETRY_ONLY). This is
useful when `SYMMETRY T` is present in a shared input template, but only time-reversal reduction is
desired:

```text
&KPOINTS
  SCHEME MONKHORST-PACK 8 8 8
  SYMMETRY T
  INVERSION_SYMMETRY_ONLY T
&END KPOINTS
```

`SCHEME GENERAL` preserves the supplied list by default. When inversion-only reduction is requested
for an explicit list, each $\mathbf{k}$/$-\mathbf{k}$ pair must be present with equal weights.

To calculate every point of a regular mesh explicitly, disable atomic symmetry and request the full
mesh:

```text
&KPOINTS
  SCHEME MONKHORST-PACK 8 8 8
  SYMMETRY F
  FULL_GRID T
&END KPOINTS
```

```{note}
For Monkhorst--Pack and MacDonald meshes, `FULL_GRID T` together with `SYMMETRY T` disables atomic
symmetry reduction but retains k-space inversion (time-reversal) reduction. Use both `SYMMETRY F`
and `FULL_GRID T` to obtain a strict full-mesh reference calculation.
```

### Atomic (space-group) symmetry reduction

```{warning}
Atomic k-point symmetry reduction is experimental. Validate the energy, forces, stress, and any
other target property against an equivalent full-mesh calculation before using it for production.
```

Atomic symmetry reduction further groups regular-grid k-points that are related by operations of the
current atomic structure. Enable it with `SYMMETRY T`:

```text
&KPOINTS
  SCHEME MONKHORST-PACK 8 8 8
  SYMMETRY T
  WAVEFUNCTIONS COMPLEX
&END KPOINTS
```

This combines the default time-reversal reduction with the additional atomic symmetry operations.
Complex wavefunctions are required for general atomic symmetry operations with nontrivial Bloch
phases.

#### Compatible sampling sets

Atomic symmetry reduction applies to regular Monkhorst--Pack and MacDonald meshes. It can also be
used with `SCHEME GENERAL`, provided that all explicit weights are equal and that the complete set
is closed under every requested symmetry operation. A nonuniform `GENERAL` list, including a band
path, should keep `SYMMETRY F`.

#### Cell requirements

For regular Monkhorst--Pack and MacDonald meshes, full atomic reduction currently requires a cell
matrix in the standard CP2K lower-triangular convention. If a full atomic reduction is requested for
a non-orthogonal cell or for a cell matrix outside that convention, CP2K warns and falls back to
[INVERSION_SYMMETRY_ONLY](#CP2K_INPUT.FORCE_EVAL.DFT.KPOINTS.INVERSION_SYMMETRY_ONLY).

Defining the cell through [ABC](#CP2K_INPUT.FORCE_EVAL.SUBSYS.CELL.ABC) and
[ALPHA_BETA_GAMMA](#CP2K_INPUT.FORCE_EVAL.SUBSYS.CELL.ALPHA_BETA_GAMMA), or reading a suitable CIF
structure, lets CP2K construct the standard cell orientation from orientation-independent lattice
parameters.

#### Symmetry backends

[K290](#CP2K_INPUT.FORCE_EVAL.DFT.KPOINTS.SYMMETRY_BACKEND) is the established default backend. The
optional `SPGLIB` backend uses symmetry operations returned by spglib, including fractional
translations:

```text
&KPOINTS
  SCHEME MONKHORST-PACK 8 8 8
  SYMMETRY T
  SYMMETRY_BACKEND SPGLIB
  WAVEFUNCTIONS COMPLEX
&END KPOINTS
```

This option requires CP2K to be built with
[spglib](../../technologies/libraries.md#spglib-crystal-symmetries-tools). If `SYMMETRY_BACKEND` is
specified and
[SYMMETRY_REDUCTION_METHOD](#CP2K_INPUT.FORCE_EVAL.DFT.KPOINTS.SYMMETRY_REDUCTION_METHOD) is
omitted, the reduction method follows the selected backend.

`SYMMETRY_REDUCTION_METHOD SPGLIB` together with `SYMMETRY_BACKEND K290` is a comparison mode:
SPGLIB proposes the k-point orbits, while K290 operations are used for the actual transformations.
It is primarily useful for validation and development rather than as a default production setup.

#### Moving geometries

For `GEO_OPT`, `CELL_OPT`, molecular dynamics, and related calculations, CP2K determines atomic
k-point symmetry from the current cell and coordinates rather than assuming that the initial
operations remain valid. The irreducible k-point set can consequently change as the geometry
evolves. A `SCHEME GENERAL` list must remain symmetry-closed at every step or it is rejected.

When a geometry or cell optimization is intended to preserve the full space group, use the relevant
[KEEP_SPACE_GROUP](#CP2K_INPUT.MOTION.GEO_OPT.KEEP_SPACE_GROUP) setting. For `CELL_OPT`, see also
the discussion of [KEEP_SYMMETRY](#CP2K_INPUT.MOTION.CELL_OPT.KEEP_SYMMETRY) in
[](../optimization/geometry_and_cell_opt.md#constraints-cell-degrees-of-freedom-and-symmetry).

#### Validation and troubleshooting

For every new system or workflow, compare an atomic-symmetry-reduced calculation with the strict
full-mesh reference:

```text
&KPOINTS
  SCHEME MONKHORST-PACK 8 8 8
  SYMMETRY F
  FULL_GRID T
  WAVEFUNCTIONS COMPLEX
&END KPOINTS
```

[&DFT%PRINT%KPOINTS](#CP2K_INPUT.FORCE_EVAL.DFT.PRINT.KPOINTS) prints k-point information and is
useful for checking the generated set. For further diagnostics, use
[VERBOSE](#CP2K_INPUT.FORCE_EVAL.DFT.KPOINTS.VERBOSE) and, where necessary, adjust
[EPS_SYMMETRY](#CP2K_INPUT.FORCE_EVAL.DFT.KPOINTS.EPS_SYMMETRY). The
[DEBUG_FULL_KPOINT_SYMMETRY](#CP2K_INPUT.FORCE_EVAL.DFT.KPOINTS.DEBUG_FULL_KPOINT_SYMMETRY) option
is intended for expert finite-difference debugging.
