triqs.mesh.meshes.MeshBrZone

class triqs.mesh.meshes.MeshBrZone

Bases: object

Brillouin zone mesh type.

A Brillouin zone (BZ) mesh is defined by an underlying Brillouin zone and the number of mesh points in the primitive reciprocal unit cell along each of the three dimensions, \(N_1\), \(N_2\) and \(N_3\). The periodic boundary conditions (PBC) in real space (see cyclic-lattice mesh) translate in reciprocal space to \(f(\mathbf{k}) = f(\mathbf{k} + \mathbf{G}^{\mathbf{m}})\), where \(\mathbf{G}^{\mathbf{m}} = \sum_{i=1}^3 \mathbf{b}_i m_i = \mathbf{B} \mathbf{m}\) is a reciprocal lattice vector, \(\mathbf{b}_i\) is a reciprocal lattice basis vector in direction \(i\) and \(\mathbf{m} = (m_1, m_2, m_3)\) with \(m_i \in \mathbb{Z}\).

It has the following properties:

Each mesh point is identified by
- a unique index in the first BZ \(\mathbf{n} = (n_1, n_2, n_3)\), where \(0 \leq n_i < N_i\), and
- an infinite set of indices due to the periodic boundary conditions, i.e. \(\{ \tilde{\mathbf{n}} = \mathbf{n} + \mathbf{N} \mathbf{m} : \mathbf{N} \mathbf{m} = (N_1 m_1, N_2 m_2, N_3 m_3) \in \mathbb{Z}^3 \}\).
The size of the mesh is \(N = N_1 \, N_2 \, N_3\), i.e. the total number of mesh points in the BZ.
An index \(\mathbf{n}\) is mapped to the corresponding data index \(d\) by the function \(d(\mathbf{n}) = n_3 + N_3 (n_2 + N_2 n_1) = n_3 + n_2 N_3 + n_1 N_2 N_3\). The inverse map is \(\mathbf{n}(d) = (\lfloor d / s_1 \rfloor, \lfloor (d \mod s_1) / s_2 \rfloor, (d \mod s_1) \mod s_2 )\), where \(s_1 = N_2 N_3\) and \(s_2 = N_3\).
An index \(\mathbf{n}\) is mapped to the corresponding value (\(\mathbf{k}\)-vector) \(\mathbf{k}(\mathbf{n}) \equiv \mathbf{k}^{\mathbf{n}} = \sum_{i=1}^3 \mathbf{b}_i n_i / N_i = \tilde{\mathbf{B}} \mathbf{n}\), where \(\mathbf{b}_i\) is the reciprocal lattice basis vector in direction \(i\). The inverse map is then \(\mathbf{n}(\mathbf{k}^{\mathbf{n}}) = \tilde{\mathbf{B}}^{-1} \mathbf{k}^{\mathbf{n}} = \mathbf{n}\).

Green’s function containers that are based on a BZ mesh store the function values at the discrete \(\mathbf{k}\) -points \(\mathbf{k}^{\mathbf{n}}\), i.e. \(f_{\mathbf{n}} = f(\mathbf{k}^{\mathbf{n}})\). Because of the PBC, the container only has to store values for indices with \(0 \leq n_i < N_i\). To evaluate the function

at an arbitrary \(\mathbf{k}\)-vector, \(\mathbf{k}\) is first mapped to the BZ using PBC and then trilinear interpolation is performed.
at one of the \(\mathbf{k}^{\mathbf{n}}\), it is first mapped to the BZ using PBC and then the corresponding function value is returned.

Dispatched C++ constructor(s).

[1] ()

[2] (bz: BrillouinZone, dims: [int, len = 3])

[3] (bz: BrillouinZone, n_k: int)

[1] Default constructor constructs an empty mesh.

[2] Construct a Brillouin zone mesh with the given number of mesh points.

[3] Construct a Brillouin zone mesh with the same number of mesh points in each direction.

Parameters:

bzBrillouinZone: Brillouin zone object representing the underlying BZ.
dims[int, len = 3]: Number of mesh points along each of the three dimensions, i.e. \((N_1, N_2, N_3)\).
n_kint: Number of mesh points along each of the three dimensions.

Attributes

`bz`	Get the underlying Brillouin zone.
`dims`	Get the number of mesh points in each of the three dimensions.
`mesh_hash`	Get the hash value of the mesh.
`units`	Get the matrix \(\tilde{\mathbf{B}}^T\) containing the scaled reciprocal basis vectors in its rows.
`units_inv`	Get the matrix \(\left( \tilde{\mathbf{B}}^T \right)^{-1}\).

Methods

`__call__`(args, *kwargs)	Call self as a function.
`closest_index`	Map a given \(\mathbf{k}\)-vector or expression to the closest \(\mathbf{k}^{\mathbf{n}}\) in the
`copy`	Get a copy of a mesh (for Python bindings).
`copy_from`	Copy one mesh into another (for Python bindings).
`index_modulo`	Map an arbitrary index \(\tilde{\mathbf{n}}\) to the unique index \(\mathbf{n}\) in the first BZ.
`is_index_valid`	Check if an index \(\mathbf{n}\) is valid, i.e. corresponds to a \(\mathbf{k}^\mathbf{n}\) in the.
`to_data_index`	Map an index \(\mathbf{n}\) to its corresponding data index \(d(\mathbf{n})\).
`to_index`	Map a data index \(d \in \{0, 1, \ldots, N-1\}\) to the corresponding index \(\mathbf{n}(d)\).
`to_value`	Map an index \(\mathbf{n}\) to its corresponding \(\mathbf{k}\)-point \(\mathbf{k}^{\mathbf{n}}\)
`values`	Get the values of all mesh points in a mesh.