quimb.tensor.geometry ===================== .. py:module:: quimb.tensor.geometry .. autoapi-nested-parse:: Some functions for generating the edges of a lattice. Functions --------- .. autoapisummary:: quimb.tensor.geometry.sort_unique quimb.tensor.geometry.check_2d quimb.tensor.geometry.edges_2d_square quimb.tensor.geometry.edges_2d_hexagonal quimb.tensor.geometry.edges_2d_triangular quimb.tensor.geometry.edges_2d_triangular_rectangular quimb.tensor.geometry.edges_2d_kagome quimb.tensor.geometry.check_3d quimb.tensor.geometry.edges_3d_cubic quimb.tensor.geometry.edges_3d_pyrochlore quimb.tensor.geometry.edges_3d_diamond quimb.tensor.geometry.edges_3d_diamond_cubic quimb.tensor.geometry.edges_tree_rand Module Contents --------------- .. py:function:: sort_unique(edges) Make sure there are no duplicate edges and that for each ``coo_a < coo_b``. .. py:function:: check_2d(coo, Lx, Ly, cyclic) Check ``coo`` in inbounds for a maybe cyclic 2D lattice. .. py:function:: edges_2d_square(Lx, Ly, cyclic=False, cells=None) Return the graph edges of a finite 2D square lattice. The nodes (sites) are labelled like ``(i, j)``. :param Lx: The number of cells along the x-direction. :type Lx: int :param Ly: The number of cells along the y-direction. :type Ly: int :param cyclic: Whether to use periodic boundary conditions. :type cyclic: bool, optional :param cells: A list of cells to use. If not given the cells used are ``itertools.product(range(Lx), range(Ly))``. :type cells: list, optional :returns: **edges** :rtype: list[((int, int), (int, int))] .. py:function:: edges_2d_hexagonal(Lx, Ly, cyclic=False, cells=None) Return the graph edges of a finite 2D hexagonal lattice. There are two sites per cell, and note the cells do not form a square tiling. The nodes (sites) are labelled like ``(i, j, s)`` for ``s`` in ``'AB'``. :param Lx: The number of cells along the x-direction. :type Lx: int :param Ly: The number of cells along the y-direction. :type Ly: int :param cyclic: Whether to use periodic boundary conditions. :type cyclic: bool, optional :param cells: A list of cells to use. If not given the cells used are ``itertools.product(range(Lx), range(Ly))``. :type cells: list, optional :returns: **edges** :rtype: list[((int, int, str), (int, int, str))] .. py:function:: edges_2d_triangular(Lx, Ly, cyclic=False, cells=None) Return the graph edges of a finite 2D triangular lattice. There is a single site per cell, and note the cells do not form a square tiling. The nodes (sites) are labelled like ``(i, j)``. :param Lx: The number of cells along the x-direction. :type Lx: int :param Ly: The number of cells along the y-direction. :type Ly: int :param cyclic: Whether to use periodic boundary conditions. :type cyclic: bool, optional :param cells: A list of cells to use. If not given the cells used are ``itertools.product(range(Lx), range(Ly))``. :type cells: list, optional :returns: **edges** :rtype: list[((int, int), (int, int))] .. py:function:: edges_2d_triangular_rectangular(Lx, Ly, cyclic=False, cells=None) Return the graph edges of a finite 2D triangular lattice tiled in a rectangular geometry. There are two sites per rectangular cell. The nodes (sites) are labelled like ``(i, j, s)`` for ``s`` in ``'AB'``. :param Lx: The number of cells along the x-direction. :type Lx: int :param Ly: The number of cells along the y-direction. :type Ly: int :param cyclic: Whether to use periodic boundary conditions. :type cyclic: bool, optional :param cells: A list of cells to use. If not given the cells used are ``itertools.product(range(Lx), range(Ly))``. :type cells: list, optional :returns: **edges** :rtype: list[((int, int, s), (int, int, s))] .. py:function:: edges_2d_kagome(Lx, Ly, cyclic=False, cells=None) Return the graph edges of a finite 2D kagome lattice. There are three sites per cell, and note the cells do not form a square tiling. The nodes (sites) are labelled like ``(i, j, s)`` for ``s`` in ``'ABC'``. :param Lx: The number of cells along the x-direction. :type Lx: int :param Ly: The number of cells along the y-direction. :type Ly: int :param cyclic: Whether to use periodic boundary conditions. :type cyclic: bool, optional :param cells: A list of cells to use. If not given the cells used are ``itertools.product(range(Lx), range(Ly))``. :type cells: list, optional :returns: **edges** :rtype: list[((int, int, str), (int, int, str))] .. py:function:: check_3d(coo, Lx, Ly, Lz, cyclic) Check ``coo`` in inbounds for a maybe cyclic 3D lattice. .. py:function:: edges_3d_cubic(Lx, Ly, Lz, cyclic=False, cells=None) Return the graph edges of a finite 3D cubic lattice. The nodes (sites) are labelled like ``(i, j, k)``. :param Lx: The number of cells along the x-direction. :type Lx: int :param Ly: The number of cells along the y-direction. :type Ly: int :param Lz: The number of cells along the z-direction. :type Lz: int :param cyclic: Whether to use periodic boundary conditions. :type cyclic: bool, optional :param cells: A list of cells to use. If not given the cells used are ``itertools.product(range(Lx), range(Ly), range(Lz))``. :type cells: list, optional :returns: **edges** :rtype: list[((int, int, int), (int, int, int))] .. py:function:: edges_3d_pyrochlore(Lx, Ly, Lz, cyclic=False, cells=None) Return the graph edges of a finite 3D pyorchlore lattice. There are four sites per cell, and note the cells do not form a cubic tiling. The nodes (sites) are labelled like ``(i, j, k, s)`` for ``s`` in ``'ABCD'``. :param Lx: The number of cells along the x-direction. :type Lx: int :param Ly: The number of cells along the y-direction. :type Ly: int :param Lz: The number of cells along the z-direction. :type Lz: int :param cyclic: Whether to use periodic boundary conditions. :type cyclic: bool, optional :param cells: A list of cells to use. If not given the cells used are ``itertools.product(range(Lx), range(Ly), range(Lz))``. :type cells: list, optional :returns: **edges** :rtype: list[((int, int, int, str), (int, int, int, str))] .. py:function:: edges_3d_diamond(Lx, Ly, Lz, cyclic=False, cells=None) Return the graph edges of a finite 3D diamond lattice. There are two sites per cell, and note the cells do not form a cubic tiling. The nodes (sites) are labelled like ``(i, j, k, s)`` for ``s`` in ``'AB'``. :param Lx: The number of cells along the x-direction. :type Lx: int :param Ly: The number of cells along the y-direction. :type Ly: int :param Lz: The number of cells along the z-direction. :type Lz: int :param cyclic: Whether to use periodic boundary conditions. :type cyclic: bool, optional :param cells: A list of cells to use. If not given the cells used are ``itertools.product(range(Lx), range(Ly), range(Lz))``. :type cells: list, optional :returns: **edges** :rtype: list[((int, int, int, str), (int, int, int, str))] .. py:function:: edges_3d_diamond_cubic(Lx, Ly, Lz, cyclic=False, cells=None) Return the graph edges of a finite 3D diamond lattice tiled in a cubic geometry. There are eight sites per cubic cell. The nodes (sites) are labelled like ``(i, j, k, s)`` for ``s`` in ``'ABCDEFGH'``. :param Lx: The number of cells along the x-direction. :type Lx: int :param Ly: The number of cells along the y-direction. :type Ly: int :param Lz: The number of cells along the z-direction. :type Lz: int :param cyclic: Whether to use periodic boundary conditions. :type cyclic: bool, optional :param cells: A list of cells to use. If not given the cells used are ``itertools.product(range(Lx), range(Ly), range(Lz))``. :type cells: list, optional :returns: **edges** :rtype: list[((int, int, int, str), (int, int, int, str))] .. py:function:: edges_tree_rand(n, max_degree=None, seed=None) Return a random tree with ``n`` nodes. This a convenience function for testing purposes and the trees generated are not guaranteed to be uniformly random (for that see ``networkx.random_tree``). :param n: The number of nodes. :type n: int :param max_degree: The maximum degree of the nodes. For example ``max_degree=3`` means generate a binary tree. :type max_degree: int, optional :param seed: The random seed. :type seed: int, optional :returns: **edges** :rtype: list[(int, int)]