Skip to content

Brillouin zones and polyhedra

BrillouinZone 

BrillouinZone(lattice: Lattice, use_primitive: bool = True, search_length: int = 1, time_reversal_symmetry: bool = False, wedge_search: bool = True, divide_primitive: bool = True, *, warn_near_symmetry: bool = True)

BrillouinZone(lattice: Lattice, approx_config: ApproxConfig, use_primitive: bool = True, search_length: int = 1, time_reversal_symmetry: bool = False, wedge_search: bool = True, divide_primitive: bool = True, *, warn_near_symmetry: bool = True)

BrillouinZone(lattice: Lattice, use_primitive: bool = True, search_length: int = 1, time_reversal_symmetry: bool = False, wedge_search: bool = True, divide_primitive: bool = True, *, warn_near_symmetry: bool = True)

Construct and hold a first Brillouin zone and, optionally and by default, an irreducible Brillouin zone.

The region closer to a given lattice point than to any other is the Wigner-Seitz cell of that lattice. The same construction is one possible first Brillouin zone of a reciprocal lattice and is used within brille. For example, a two-dimensional hexagonal lattice has a first Brillouin zone which is a hexagon:

.. tikz:: :libs: calc

\begin{tikzpicture}[scale=5,dot/.style = {fill,radius=0.02},
latpt/.style = {color=gray!50!white, fill},]
\coordinate (astar) at (1,0);
\coordinate (bstar) at (0.5,0.8660254037844386);
\clip ($-0.1*(bstar)$) rectangle ($3*(astar)+2.1*(bstar)$);
%
\coordinate (C1) at ($0.3333*(astar)+0.3333*(bstar)$);
\coordinate (C2) at ($-0.3333*(astar)+0.6667*(bstar)$);
\coordinate (C3) at ($-0.6667*(astar)+0.3333*(bstar)$);
\coordinate (C4) at ($-0.3333*(astar)-0.3333*(bstar)$);
\coordinate (C5) at ($0.3333*(astar)-0.6667*(bstar)$);
\coordinate (C6) at ($0.6667*(astar)-0.3333*(bstar)$);
%
\foreach \h in {-1,...,6}{
\foreach \k in {-1,...,3}{
  \draw[latpt] ($\h*(astar) + \k*(bstar)$) circle[dot];
  \draw[color=yellow!75!black,dotted] ($\h*(astar)+\k*(bstar)$) +(C1)
    -- +(C2) -- +(C3) -- +(C4) -- +(C5) -- +(C6) -- cycle;
}}
%
\coordinate (G) at ($(astar)+(bstar)$);
\draw[color=yellow!75!black, line width=1mm] (G) +(C1) -- +(C2) -- +(C3) -- +(C4) -- +(C5) -- +(C6) -- cycle;
\end{tikzpicture}

Since all physical properties of a crystal must have the same periodicity as its lattice, the powerful feature of the first Brillouin zone is that it encompasses a region of reciprocal space which must fully represent all of reciprocal space.

Most crystals contain rotational or rotoinversion symmetries in addition to the translational ones which give rise to the first Brillouin zone. These symmetries are the pointgroup of the lattice and enforce that the properties of the crystal also have the same symmetry. The first Brillouin zone, therefore, typically contains redundant information.

An irreducible Brillouin zone is a subsection of the first Brillouin zone which contains the minimal part required to have only unique crystal properties. This class can find an irreducible Brillouin zone for any crystal lattice. In the example of the hexagonal lattice there are six equivalent irreducible Brillouin zones one of which is:

.. tikz:: :libs: calc

\begin{tikzpicture}[scale=5,dot/.style = {fill,radius=0.02},
latpt/.style = {color=gray!50!white, fill},]
\coordinate (astar) at (1,0);
\coordinate (bstar) at (0.5,0.8660254037844386);
\clip ($-0.1*(bstar)$) rectangle ($3*(astar)+2.1*(bstar)$);
%
\coordinate (C1) at ($0.3333*(astar)+0.3333*(bstar)$);
\coordinate (C2) at ($-0.3333*(astar)+0.6667*(bstar)$);
\coordinate (C3) at ($-0.6667*(astar)+0.3333*(bstar)$);
\coordinate (C4) at ($-0.3333*(astar)-0.3333*(bstar)$);
\coordinate (C5) at ($0.3333*(astar)-0.6667*(bstar)$);
\coordinate (C6) at ($0.6667*(astar)-0.3333*(bstar)$);
%
\foreach \h in {-1,...,6}{
\foreach \k in {-1,...,3}{
  \draw[latpt] ($\h*(astar) + \k*(bstar)$) circle[dot];
  \draw[color=yellow!75!black,dotted] ($\h*(astar)+\k*(bstar)$) +(C1)
    -- +(C2) -- +(C3) -- +(C4) -- +(C5) -- +(C6) -- cycle;
}}
%
\coordinate (G) at ($(astar)+(bstar)$);
\draw[color=yellow!75!black,line width=1mm] (G) -- +(C4) -- +(C5) -- cycle;
\end{tikzpicture}

Parameters:

  • lattice (Lattice) –

    The reciprocal space lattice for which a Brillouin zone will be found

  • use_primitive (bool, default: True ) –

    If the provided brille._brille.Reciprocal lattice is a conventional Bravais lattice, this parameter controls whether the equivalent primitive Bravais lattice should be used to find the first Brillouin zone. This is True by default and should only be modified for testing purposes.

  • search_length (int, default: 1 ) –

    The Wigner-Seitz construction of the first Brillouin zone finds the volume of space closer to a chosen reciprocal lattice point than any other reciprocal lattice point. This is accomplished by successively dividing the space by planes halfway between the chosen point and a subset of all other planes. The subset used is controlled by search_length and is every unique \((\pm s_i\,0\,0)\), \((0\,\pm s_j\,0)\), \((0\,0\,\pm s_k)\), \((\pm s_i\,\pm s_j\,0)\), \((\pm s_i\,0\,\pm s_k)\), \((0\,\pm s_j\,\pm s_k)\), \((\pm s_i\,\pm s_j\,\pm s_k)\) for \(1 \le s_\alpha \le\) search_length. If the reciprocal lattice is primitive then the default search_length of 1 should always give the correct first Brillouin zone. For extra assurance that the correct first Brillouin zone is found, the procedure is internally repeated with search_length incremented by one and an error is raised if the two constructed polyhedra have different volumes.

  • time_reversal_symmetry (bool, default: False ) –

    Controls whether time reversal symmetry should be added to pointgroups lacking space inversion. This affects the found irreducible Brillouin zone for such systems. To avoid inadvertently adding time reversal symmetry when it is not appropriate, this is False by default. Time reversal holds for non-magnetic systems. It is anti-unitary: phonon eigenvectors (RotatesLike.Gamma) at a time-reversed point \(-R\mathbf{q}\) are the complex conjugates of those at \(R\mathbf{q}\), so no inversion symmetry of the crystal is needed.

  • wedge_search (bool, default: True ) –

    Controls whether an irreducible Brillouin zone should be found. With this set to False the returned brille._brille.BrillouinZone will only contain the first Brillouin zone. If True the pointgroup symmetry operations will be used to identify an irreducible Brillouin zone as well. If the provided lattice's parameters do not match the symmetry of the pointgroup (e.g., a lattice which should be tetragonal like \(I4/mmm\) but constructed with \(\gamma=120^\circ\)) the algorithm will fail to find an appropriate irreducible Brillouin zone and an error will be raised. (Set to True by default).

  • warn_near_symmetry (bool, default: True ) –

    Keyword only. Whether to warn, with a brille.NearSymmetryWarning, when the lattice is within 1e-4 of a lattice with more symmetry operations (e.g., rhombohedral but nearly cubic). Such a zone has faces or edges much smaller than itself, which make meshes slow and poorly shaped. The zone is not changed. (Set to True by default).

Methods:

  • from_file –

    Load an object from an HDF5 file

  • ir_moveinto –

    Find points equivalent to those provided within the irreducible Brillouin zone.

  • ir_moveinto_wedge –

    Find points equivalent to those provided within the irreducible wedge.

  • isinside –

    Determine whether each of the provided reciprocal lattice points is located

  • lattice_symmetry_counts –

    The number of symmetry operations of the lattice itself, exactly and nearly

  • moveinto –

    Find points equivalent to those provided within the first Brillouin zone.

  • to_file –

    Save the object to an HDF5 file

Attributes:

faces_per_vertex property 

faces_per_vertex: list[list[int]]

Return the first Brillouin zone face indices for each unique face corner

half_edge_points property 

half_edge_points: ndarray[float64]

Return the first Brillouin zone face edge centres in rlu

half_edge_points_invA property 

half_edge_points_invA: ndarray[float64]

Return the first Brillouin zone face edge centres in inverse ångstrom

ir_faces_per_vertex property 

ir_faces_per_vertex: list[list[int]]

Return the irreducible Brillouin zone face index per unique face corner

ir_normals property 

ir_normals: ndarray[float64]

Return the irreducible Brillouin zone face normals in rlu

ir_normals_invA property 

ir_normals_invA: ndarray[float64]

Return the irreducible Brillouin zone face normals in inverse ångstrom

ir_normals_primitive property 

ir_normals_primitive: ndarray[float64]

Return the irreducible Brillouin zone face normals in primitive-lattice rlu

ir_points property 

ir_points: ndarray[float64]

Return the irreducible Brillouin zone face centres in rlu

ir_points_invA property 

ir_points_invA: ndarray[float64]

Return the irreducible Brillouin zone face centres in inverse ångstrom

ir_points_primitive property 

ir_points_primitive: ndarray[float64]

Return the irreducible Brillouin zone face centres in primitive-lattice rlu

ir_polyhedron property 

ir_polyhedron: LPolyhedron

Returns the irreducible Brillouin zone brille._brille.Polyhedron

Returns:

  • [`brille._brille.Polyhedron`][brille._brille.Polyhedron] –

    If no irreducible Brillouin zone was requested at construction, the returned polyhedron is that of the first Brillouin zone instead.

ir_polyhedron_generated property 

ir_polyhedron_generated: LPolyhedron

Returns the found irreducible Brillouin zone brille._brille.Polyhedron

If the lattice pointgroup does not contain the space inversion operator the internally held 'irreducible' polyhedron is only half of the real irreducible polyhedron. This method gives access to the polyhedron found by the algorithm before being doubled for output.

ir_vertices property 

ir_vertices: ndarray[float64]

Return the irreducible Brillouin zone unique face corners in rlu

ir_vertices_invA property 

ir_vertices_invA: ndarray[float64]

Return the irreducible Brillouin zone unique face corners in inverse ångstrom

ir_vertices_per_face property 

ir_vertices_per_face: list[list[int]]

Return the irreducible Brillouin zone unique face corners per face

ir_vertices_primitive property 

ir_vertices_primitive: ndarray[float64]

Return the irreducible Brillouin zone unique face corners in primitive-lattice rlu

lattice property 

lattice: Lattice

Returns the defining brille._brille.Lattice lattice

normals property 

normals: ndarray[float64]

Return the first Brillouin zone face normals in rlu

normals_invA property 

normals_invA: ndarray[float64]

Return the first Brillouin zone face normals in inverse ångstrom

normals_primitive property 

normals_primitive: ndarray[float64]

Return the first Brillouin zone face normals in primitive-lattice rlu

points property 

points: ndarray[float64]

Return the first Brillouin zone face centres in rlu

points_invA property 

points_invA: ndarray[float64]

Return the first Brillouin zone face centres in inverse ångstrom

points_primitive property 

points_primitive: ndarray[float64]

Return the first Brillouin zone face centres in primitive-lattice rlu

polyhedron property 

polyhedron: LPolyhedron

Returns the first Brillouin zone brille._brille.Polyhedron

vertices property 

vertices: ndarray[float64]

Return the first Brillouin zone unique face corners in rlu

vertices_invA property 

vertices_invA: ndarray[float64]

Return the first Brillouin zone unique face corners in inverse ångstrom

vertices_per_face property 

vertices_per_face: list[list[int]]

Return the first Brillouin zone face corner indices for each face

vertices_primitive property 

vertices_primitive: ndarray[float64]

Return the first Brillouin zone unique face corners in primitive-lattice rlu

wedge_normals property 

wedge_normals: ndarray[float64]

Return the normals of the irreducible wedge rlu

wedge_normals_invA property 

wedge_normals_invA: ndarray[float64]

Return the normals of the irreducible wedge inverse ångstrom

wedge_normals_primitive property 

wedge_normals_primitive: ndarray[float64]

Return the normals of the irreducible wedge primitive-lattice rlu

from_file staticmethod 

from_file(filename: str, entry: str = 'BrillouinZone') -> BrillouinZone

Load an object from an HDF5 file

Parameters:

  • filename (str) –

    The full path specification for the file to read from

  • entry (str, default: 'BrillouinZone' ) –

    The group path, e.g., "my/cool/bz", where to read from inside the file, with a default equal to the object Class name

Returns:

  • clsObj –

ir_moveinto 

ir_moveinto(Q: ndarray[float64], threads: int = 0) -> tuple

Find points equivalent to those provided within the irreducible Brillouin zone.

The BrillouinZone object defines a volume of reciprocal space which contains an irreducible part of the full reciprocal-space. This method will find points equivalent under the operations of the lattice which fall within this irreducible volume.

Parameters:

  • Q ([`numpy.ndarray`][numpy.ndarray]) –

    A 2 dimensional array of three-vectors (Q.shape[1]==3) expressed in units of the reciprocal lattice.

  • threads (integer, default: 0 ) –

    The number of parallel threads that should be used. If this value is less than one, the BRILLE_NUM_THREADS environment variable sets the number, or one thread per logical core is used if it is not set.

Returns:

  • Qir ( [`numpy.ndarray`][numpy.ndarray] ) –

    The array of equivalent irreducible \(\mathbf{q}_\text{ir}\) points for all \(\mathbf{Q}\);

  • tau ( [`numpy.ndarray`][numpy.ndarray] ) –

    the closest reciprocal lattice vector, \(\boldsymbol{\tau}\), to each \(\mathbf{Q}\);

  • R ( [`numpy.ndarray`][numpy.ndarray] ) –

    the pointgroup symmetry operation \(R\)

  • Rinv ( [`numpy.ndarray`][numpy.ndarray] ) –

    the inverse point group symmetry operation which obey \(\mathbf{Q} = R^{-1} \mathbf{q}_\text{ir} + \boldsymbol{\tau}\).

ir_moveinto_wedge 

ir_moveinto_wedge(Q: ndarray[float64], threads: int = 0) -> tuple

Find points equivalent to those provided within the irreducible wedge.

The BrillouinZone object defines a wedge of reciprocal space which contains an irreducible part of the full-space 4π steradian solid angle. This method will find points equivalent under the pointgroup operations of the lattice which fall within this irreducible solid angle and maintain their absolute magnitude.

Parameters:

  • Q ([`numpy.ndarray`][numpy.ndarray]) –

    A 2 dimensional array of three-vectors (Q.shape[1]==3) expressed in units of the reciprocal lattice.

  • threads (integer, optional (default 0), default: 0 ) –

    The number of parallel threads that should be used. If this value is less than one, the BRILLE_NUM_THREADS environment variable sets the number, or one thread per logical core is used if it is not set.

Returns:

  • [`numpy.ndarray`][numpy.ndarray], [`numpy.ndarray`][numpy.ndarray] –

    The array of equivalent in-wedge \(\mathbf{Q}_\text{ir}\) points for all \(\mathbf{Q}\), and the pointgroup operation fulfilling \(\mathbf{Q}_\text{ir} = R \mathbf{Q}\).

isinside 

isinside(points: ndarray[float64]) -> list[bool]

Determine whether each of the provided reciprocal lattice points is located within the first Brillouin zone

Parameters:

  • points ([`numpy.ndarray`][numpy.ndarray]) –

    A 2 dimensional array of three-vectors (points.shape[1]==3) expressed in units of the reciprocal lattice.

Returns:

  • [`numpy.ndarray`][numpy.ndarray] –

    One dimensional logical array with True indicating 'inside'

lattice_symmetry_counts 

lattice_symmetry_counts(exact: float = 1e-10, near: float = 0.0001) -> tuple[int, int]

The number of symmetry operations of the lattice itself, exactly and nearly

Counts the lattice's own symmetries (its holohedry, not the crystal's symmetry) within exact and within near, relative to the lattice metric.

Returns:

  • tuple[int, int] –

    The counts within exact and within near; more near than exact symmetries mean the lattice is close to a more symmetric one.

moveinto 

moveinto(Q: ndarray[float64], threads: int = 0) -> tuple

Find points equivalent to those provided within the first Brillouin zone.

Parameters:

  • Q ([`numpy.ndarray`][numpy.ndarray]) –

    A 2 dimensional array of three-vectors (Q.shape[1]==3) expressed in units of the reciprocal lattice.

  • threads (integer, default: 0 ) –

    The number of parallel threads that should be used. If this value is less than one, the BRILLE_NUM_THREADS environment variable sets the number, or one thread per logical core is used if it is not set.

Returns:

  • [`numpy.ndarray`][numpy.ndarray], [`numpy.ndarray`][numpy.ndarray] –

    The floating point array of equivalent reduced \(\mathbf{q}\) points for all \(\mathbf{Q}\), and an integer array filled with \(\boldsymbol{\tau} = \mathbf{Q}-\mathbf{q}\).

to_file 

to_file(filename: str, entry: str = 'BrillouinZone', flags: str = 'ac') -> bool

Save the object to an HDF5 file

Parameters:

  • filename (str) –

    The full path specification for the file to write into

  • entry (str, default: 'BrillouinZone' ) –

    The group path, e.g., "my/cool/bz", where to write inside the file, with a default equal to BrillouinZone name

  • flags (str, default: 'ac' ) –

    The HDF5 permissions to use when opening the file. Default 'a' writes to an existing file -- if entry exists in the file it is overwritten.

Note

Possible flags are:

flags meaning HDF equivalent
'r' read H5F_ACC_RDONLY
'x' write, error if exists H5F_ACC_EXCL
'a' write, append to file H5F_ACC_RDWR
'c' write, error if exists H5F_ACC_CREAT
't' write, replace existing H5F_ACC_TRUNC

Returns:

  • bool –

    Indication of writing success.

NearSymmetryWarning

Bases: UserWarning

The lattice is close to one with more symmetry, so its Brillouin zone has features much smaller than itself.

Polyhedron 

Polyhedron(vertices: ndarray[float64])

Polyhedron(vertices: ndarray[float64], faces: list[list[int]])

Polyhedron(vertices: ndarray[float64])

Methods:

Attributes:

centre property 

centre: Polyhedron

faces property 

faces: list[list[int]]

mirror property 

mirror: Polyhedron

normals property 

normals: ndarray[float64]

points property 

points: ndarray[float64]

vertices property 

vertices: ndarray[float64]

volume property 

volume: float

intersection 

intersection(arg0: Polyhedron) -> Polyhedron

LPolyhedron

Methods:

Attributes:

centre property 

centre: LPolyhedron

faces property 

faces: list[list[int]]

mirror property 

mirror: LPolyhedron

normals property 

normals: ndarray[float64]

points property 

points: ndarray[float64]

vertices property 

vertices: ndarray[float64]

volume property 

volume: float

intersection 

intersection(arg0: LPolyhedron) -> LPolyhedron

rotate 

rotate(arg0: PointSymmetry, arg1: int) -> LPolyhedron

to_Cartesian 

to_Cartesian() -> Polyhedron