landlab.graph.hex.hex¶

Examples

    * - *
   / \ / \
  * - * - *
 / \ / \ / \
* - * - * - *
 \ / \ / \ /
  * - * - *
   \ / \ /
    * - *

>>> from landlab.graph import TriGraph
>>> graph = TriGraph((5, 2), node_layout="hex", sort=True)
>>> graph.number_of_nodes
14
>>> graph.x_of_node
array([1. , 2. ,
       0.5, 1.5, 2.5,
       0. , 1. , 2. , 3. ,
       0.5, 1.5, 2.5,
       1. , 2. ])
>>> graph.number_of_links
29
>>> graph.number_of_patches
16

* - * - * - *
 \ / \ / \ / \
  * - * - * - *
 / \ / \ / \ /
* - * - * - *

>>> from landlab.graph import TriGraph
>>> graph = TriGraph((3, 4), orientation="horizontal", node_layout="rect", sort=True)
>>> graph.number_of_nodes
12
>>> graph.x_of_node.reshape((3, 4))
array([[0. , 1. , 2. , 3. ],
       [0.5, 1.5, 2.5, 3.5],
       [0. , 1. , 2. , 3. ]])
>>> graph.number_of_links
23
>>> graph.number_of_patches
12

class HexGraphExtras[source]¶

Bases: object

__init__()¶

__new__(**kwargs)¶

property length_of_link¶

property nodes_at_bottom_edge¶

Get nodes along the bottom edge.

Examples

>>> import numpy as np
>>> from landlab.graph import TriGraph
>>> graph = TriGraph((3, 4), node_layout="rect")
>>> graph.nodes_at_bottom_edge
array([0, 1, 2, 3])

property nodes_at_left_edge¶

Get nodes along the left edge.

Examples

>>> import numpy as np
>>> from landlab.graph import TriGraph
>>> graph = TriGraph((3, 4), node_layout="rect")
>>> graph.nodes_at_left_edge
array([0, 4, 8])

property nodes_at_right_edge¶

Get nodes along the right edge.

Examples

>>> import numpy as np
>>> from landlab.graph import TriGraph
>>> graph = TriGraph((3, 4), node_layout="rect")
>>> graph.nodes_at_right_edge
array([ 3,  7, 11])

property nodes_at_top_edge¶

Get nodes along the top edge.

Examples

>>> import numpy as np
>>> from landlab.graph import TriGraph
>>> graph = TriGraph((3, 4), node_layout="rect")
>>> graph.nodes_at_top_edge
array([ 8,  9, 10, 11])

property orientation_of_link¶

Return array of link orientation codes (one value per link).

Orientation codes are defined by LinkOrientation; 1 = E, 2 = ENE, 4 = NNE, 8 = N, 16 = NNW, 32 = ESE (using powers of 2 allows for future applications that might want additive combinations).

Examples

>>> from landlab import HexModelGrid
>>> import numpy as np
>>> grid = HexModelGrid((3, 2))
>>> grid.orientation_of_link
array([ 1, 16,  4, 16,  4,  1,  1,  4, 16,  4, 16,  1], dtype=uint8)
>>> grid = HexModelGrid((2, 3), orientation="vertical")
>>> grid.orientation_of_link
array([32,  2,  8,  2, 32,  8,  8, 32,  2,  8,  2, 32], dtype=uint8)

property parallel_links_at_link¶

Return similarly oriented links connected to each link.

Return IDs of links of the same orientation that are connected to each given link’s tail or head node.

The data structure is a numpy array of shape (n_links, 2) containing the IDs of the “tail-wise” (connected to tail node) and “head-wise” (connected to head node) links, or -1 if the link is inactive (e.g., on the perimeter) or it has no attached parallel neighbor in the given direction.

For instance, consider a 3x3 hex, in which link IDs are as shown:

    o---17--o---18--o
   / .     / .     / .
  11 12   13  14  15  16
 /     . /     . /     .
o---8---o---9---o---10--o
 .     / .     / .     /
  2   3   4   5   6   7
   . /     . /     . /
    o---0---o---1---o

Here’s a mapping of the tail-wise and head-wise links, where there are valid parallel links:

    o-------o-------o
   / .     / .     / .
  /   .   /   .   /   .
 /     4 3     6 5     .
o-----9-o-8--10-o-9-----o
 .    13 12   15 14    /
  .   /   .   /   .   /
   . /     . /     . /
    o-------o-------o

The corresponding data structure would be mostly filled with -1, but for the 11 active links, it would look like:

[[-1, 13],
 [-1, 12],
 [-1, 15],
 [-1, 14],
 [-1,  9],
 [ 8, 10],
[ 9, -1],
[ 4, -1],
[ 3, -1],
[ 6, -1],
[ 5, -1]]

Examples

>>> from landlab import HexModelGrid
>>> grid = HexModelGrid((3, 3))
>>> pll = grid.parallel_links_at_link
>>> pll[3:16]
array([[-1, 13],
       [-1, 12],
       [-1, 15],
       [-1, 14],
       [-1, -1],
       [-1,  9],
       [ 8, 10],
       [ 9, -1],
       [-1, -1],
       [ 4, -1],
       [ 3, -1],
       [ 6, -1],
       [ 5, -1]])

class HorizontalHexTriGraph[source]¶

Bases: object

__init__()¶

__new__(**kwargs)¶

static corner_nodes(shape)[source]¶

Examples

>>> from landlab.graph.hex.hex import HorizontalHexTriGraph
>>> HorizontalHexTriGraph.corner_nodes((3, 2))
(4, 6, 5, 2, 0, 1)
>>> HorizontalHexTriGraph.corner_nodes((7, 1))
(9, 15, 15, 6, 0, 0)
>>> HorizontalHexTriGraph.corner_nodes((6, 1))
(9, 14, 13, 6, 0, 0)
>>> HorizontalHexTriGraph.corner_nodes((4, 2))
(8, 11, 9, 5, 0, 1)

static nodes_at_edge(shape)[source]¶

Examples

>>> from landlab.graph.hex.hex import HorizontalHexTriGraph
>>> HorizontalHexTriGraph.nodes_at_edge((5, 3))
(array([11, 15]), array([18, 17]), array([16, 12]), array([7, 3]),
 array([0, 1]), array([2, 6]))
>>> HorizontalHexTriGraph.nodes_at_edge((4, 3))
(array([11]), array([15, 14, 13]), array([12]), array([7, 3]), array([0, 1]),
 array([2, 6]))

static number_of_nodes(shape)[source]¶

static number_of_perimeter_nodes(shape)[source]¶

static perimeter_nodes(shape)[source]¶

Examples

>>> from landlab.graph.hex.hex import HorizontalHexTriGraph
>>> HorizontalHexTriGraph.perimeter_nodes((3, 2))
array([4, 6, 5, 2, 0, 1])
>>> HorizontalHexTriGraph.perimeter_nodes((1, 3))
array([2, 1, 0])

static xy_of_node(shape, spacing=1.0, xy_of_lower_left=(0.0, 0.0))[source]¶

class HorizontalHexTriGraphCython[source]¶

Bases: object

__init__()¶

__new__(**kwargs)¶

static xy_of_node(shape, spacing=1.0, xy_of_lower_left=(0.0, 0.0))[source]¶

class HorizontalRectTriGraph[source]¶

Bases: object

__init__()¶

__new__(**kwargs)¶

static corner_nodes(shape)[source]¶

Examples

>>> from landlab.graph.hex.hex import HorizontalRectTriGraph
>>> HorizontalRectTriGraph.corner_nodes((3, 4))
(11, 8, 0, 3)
>>> HorizontalRectTriGraph.corner_nodes((3, 2))
(5, 4, 0, 1)
>>> HorizontalRectTriGraph.corner_nodes((7, 1))
(6, 6, 0, 0)
>>> HorizontalRectTriGraph.corner_nodes((1, 3))
(2, 0, 0, 2)

static nodes_at_edge(shape)[source]¶

static number_of_nodes(shape)[source]¶

static number_of_perimeter_nodes(shape)[source]¶

static perimeter_nodes(shape)[source]¶

Examples

>>> from landlab.graph.hex.hex import HorizontalRectTriGraph
>>> HorizontalRectTriGraph.perimeter_nodes((3, 2))
array([1, 3, 5, 4, 2, 0])

static xy_of_node(shape, spacing=1.0, xy_of_lower_left=(0.0, 0.0))[source]¶

class HorizontalRectTriGraphCython[source]¶

Bases: object

__init__()¶

__new__(**kwargs)¶

static xy_of_node(shape, spacing=1.0, xy_of_lower_left=(0.0, 0.0))[source]¶

class TriGraph[source]¶

Bases: HexGraphExtras, DelaunayGraph

Graph of a structured grid of triangles.

Examples

>>> import numpy as np
>>> from landlab.graph import TriGraph

>>> graph = TriGraph((3, 2))
>>> graph.number_of_nodes == 6
True
>>> np.round(graph.y_of_node * 2.0 / np.sqrt(3))
array([0., 0., 1., 1., 2., 2.])
>>> graph.x_of_node
array([0. , 1. , 0.5, 1.5, 0. , 1. ])

Create a structured grid of triangles.

Parameters:

shape (tuple of int) – Number of rows and columns of the hex grid. The first value is the number of nodes in the first column and the second the number of nodes in the first column.
spacing (float, optional) – Length of links.
xy_of_lower_left (tuple of float, optional) – Coordinates of lower-left corner of the grid.
orientation ({'horizontal', 'vertical'}) – Specify if triangles should be laid out in rows or columns.
node_layout ({'rect', 'hex'}) – Specify the overall layout of the nodes. Use rect for the layout to approximate a rectangle and hex for a hexagon.

__init__(shape, spacing=1.0, xy_of_lower_left=(0.0, 0.0), orientation='horizontal', node_layout='rect', sort=False)[source]¶

Create a structured grid of triangles.

Parameters:

shape (tuple of int) – Number of rows and columns of the hex grid. The first value is the number of nodes in the first column and the second the number of nodes in the first column.
spacing (float, optional) – Length of links.
xy_of_lower_left (tuple of float, optional) – Coordinates of lower-left corner of the grid.
orientation ({'horizontal', 'vertical'}) – Specify if triangles should be laid out in rows or columns.
node_layout ({'rect', 'hex'}) – Specify the overall layout of the nodes. Use rect for the layout to approximate a rectangle and hex for a hexagon.

__new__(**kwargs)¶

property adjacent_links_at_link¶

property adjacent_nodes_at_node¶

Get adjacent nodes.

Examples

>>> from landlab.graph import Graph

First, a simple example with no diagonals.

>>> node_x, node_y = [0, 0, 0, 1, 1, 1, 2, 2, 2], [0, 1, 2, 0, 1, 2, 0, 1, 2]
>>> links = (
...     (0, 1),
...     (1, 2),
...     (0, 3),
...     (1, 4),
...     (2, 5),
...     (3, 4),
...     (4, 5),
...     (3, 6),
...     (4, 7),
...     (5, 8),
...     (6, 7),
...     (7, 8),
... )
>>> graph = Graph((node_y, node_x), links=links, sort=True)
>>> graph.adjacent_nodes_at_node
array([[ 1,  3, -1, -1],
       [ 2,  4,  0, -1],
       [ 5,  1, -1, -1],
       [ 4,  6,  0, -1],
       [ 5,  7,  3,  1],
       [ 8,  4,  2, -1],
       [ 7,  3, -1, -1],
       [ 8,  6,  4, -1],
       [ 7,  5, -1, -1]])

Next, we add the diagonal from node 0 to node 4.

>>> node_x, node_y = [0, 0, 0, 1, 1, 1, 2, 2, 2], [0, 1, 2, 0, 1, 2, 0, 1, 2]
>>> links = (
...     (0, 1),
...     (1, 2),
...     (0, 3),
...     (1, 4),
...     (2, 5),
...     (3, 4),
...     (4, 5),
...     (3, 6),
...     (4, 7),
...     (5, 8),
...     (6, 7),
...     (7, 8),
...     (0, 4),
... )
>>> graph = Graph((node_y, node_x), links=links, sort=True)
>>> graph.adjacent_nodes_at_node
array([[ 1,  4,  3, -1, -1],
       [ 2,  4,  0, -1, -1],
       [ 5,  1, -1, -1, -1],
       [ 4,  6,  0, -1, -1],
       [ 5,  7,  3,  0,  1],
       [ 8,  4,  2, -1, -1],
       [ 7,  3, -1, -1, -1],
       [ 8,  6,  4, -1, -1],
       [ 7,  5, -1, -1, -1]])

property angle_of_link¶

Get the angle of each link.

Examples

>>> import numpy as np
>>> from landlab.graph import Graph

>>> node_x, node_y = ([0, 1, 2, 0, 1, 2], [0, 0, 0, 1, 1, 1])
>>> links = ((0, 1), (1, 2), (0, 3), (1, 4), (2, 5), (3, 4), (4, 5))
>>> graph = Graph((node_y, node_x), links=links)
>>> graph.angle_of_link * 180.0 / np.pi
array([ 0.,  0., 90., 90., 90.,  0.,  0.])

property area_of_patch¶

Get the area of each patch.

Examples

>>> from landlab.graph import Graph
>>> node_x, node_y = [0, 1, 2, 0, 1, 2, 0, 1, 2], [0, 0, 0, 1, 1, 1, 2, 2, 2]
>>> links = (
...     (0, 1),
...     (1, 2),
...     (0, 3),
...     (1, 4),
...     (2, 5),
...     (3, 4),
...     (4, 5),
...     (3, 6),
...     (4, 7),
...     (5, 8),
...     (6, 7),
...     (7, 8),
... )
>>> patches = ((0, 3, 5, 2), (1, 4, 6, 3))
>>> graph = Graph((node_y, node_x), links=links, patches=patches)
>>> graph.area_of_patch
array([1.,  1.])

property ds¶

freeze()¶: Freeze the graph by making arrays read-only.

classmethod from_dict(meta)¶

classmethod from_netcdf(fname)¶

property frozen¶

property length_of_link¶

Get the length of links.

Examples

>>> import numpy as np
>>> from landlab.graph import UniformRectilinearGraph

>>> graph = UniformRectilinearGraph((2, 3), spacing=(1, 2))
>>> graph.length_of_link
array([2., 2., 1., 1., 1., 2., 2.])

property link_dirs_at_node¶

Return link directions into each node.

A value of 1 indicates a link points toward a given node, while a value of -1 indicates a link points away from a node.

Returns:: Link directions relative to the nodes of a grid. The shape of the matrix will be number of nodes by the maximum number of links per node. A zero indicates no link at this position.
Return type:: (n_nodes, max_links_per_node) ndarray of int

Examples

>>> from landlab.graph import Graph
>>> node_x, node_y = [0, 1, 2, 0, 1, 2, 0, 1, 2], [0, 0, 0, 1, 1, 1, 2, 2, 2]
>>> links = (
...     (0, 1),
...     (1, 2),
...     (0, 3),
...     (1, 4),
...     (2, 5),
...     (3, 4),
...     (4, 5),
...     (3, 6),
...     (4, 7),
...     (5, 8),
...     (6, 7),
...     (7, 8),
... )
>>> graph = Graph((node_y, node_x), links=links)
>>> graph.link_dirs_at_node
array([[-1, -1,  0,  0], [-1, -1,  1,  0], [-1,  1,  0,  0],
       [-1, -1,  1,  0], [-1, -1,  1,  1], [-1,  1,  1,  0],
       [-1,  1,  0,  0], [-1,  1,  1,  0], [ 1,  1,  0,  0]],
      dtype=int8)

property links_at_node¶

Get links touching a node.

Examples

>>> from landlab.graph import Graph
>>> node_x = [0, 1, 2, 0, 1, 2, 0, 1, 2]
>>> node_y = [0, 0, 0, 1, 1, 1, 2, 2, 2]
>>> links = (
...     (0, 1),
...     (1, 2),
...     (0, 3),
...     (1, 4),
...     (2, 5),
...     (3, 4),
...     (4, 5),
...     (3, 6),
...     (4, 7),
...     (5, 8),
...     (6, 7),
...     (7, 8),
... )
>>> graph = Graph((node_y, node_x), links=links)
>>> graph.links_at_node
array([[ 0,  2, -1, -1], [ 1,  3,  0, -1], [ 4,  1, -1, -1],
       [ 5,  7,  2, -1], [ 6,  8,  5,  3], [ 9,  6,  4, -1],
       [10,  7, -1, -1], [11, 10,  8, -1], [11,  9, -1, -1]])

property links_at_patch¶

Get the links that define a patch.

Examples

>>> from landlab.graph import Graph
>>> node_x, node_y = [0, 1, 2, 0, 1, 2, 0, 1, 2], [0, 0, 0, 1, 1, 1, 2, 2, 2]
>>> links = (
...     (0, 1),
...     (1, 2),
...     (0, 3),
...     (1, 4),
...     (2, 5),
...     (3, 4),
...     (4, 5),
...     (3, 6),
...     (4, 7),
...     (5, 8),
...     (6, 7),
...     (7, 8),
... )
>>> patches = ((0, 3, 5, 2), (1, 4, 6, 3))
>>> graph = Graph((node_y, node_x), links=links, patches=patches, sort=True)
>>> graph.links_at_patch
array([[3, 5, 2, 0],
       [4, 6, 3, 1]])

classmethod load(source)¶

merge(dual, node_at_cell=None, nodes_at_face=None)¶

property midpoint_of_link¶

Get the middle of links.

Examples

>>> import numpy as np
>>> from landlab.graph import UniformRectilinearGraph

>>> graph = UniformRectilinearGraph((2, 3), spacing=(1, 2))
>>> graph.midpoint_of_link
array([[1. , 0. ], [3. , 0. ],
       [0. , 0.5], [2. , 0.5], [4. , 0.5],
       [1. , 1. ], [3. , 1. ]])

property ndim¶

property node_at_link_head¶

Get nodes at link head.

Examples

>>> from landlab.graph import Graph
>>> node_x, node_y = [0, 1, 2, 0, 1, 2, 0, 1, 2], [0, 0, 0, 1, 1, 1, 2, 2, 2]
>>> links = (
...     (0, 1),
...     (1, 2),
...     (0, 3),
...     (1, 4),
...     (2, 5),
...     (3, 4),
...     (4, 5),
...     (3, 6),
...     (4, 7),
...     (5, 8),
...     (6, 7),
...     (7, 8),
... )
>>> graph = Graph((node_y, node_x), links=links)
>>> graph.node_at_link_head
array([1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 7, 8])

property node_at_link_tail¶

Get nodes at link tail.

Examples

>>> from landlab.graph import Graph
>>> node_x, node_y = [0, 1, 2, 0, 1, 2, 0, 1, 2], [0, 0, 0, 1, 1, 1, 2, 2, 2]
>>> links = (
...     (0, 1),
...     (1, 2),
...     (0, 3),
...     (1, 4),
...     (2, 5),
...     (3, 4),
...     (4, 5),
...     (3, 6),
...     (4, 7),
...     (5, 8),
...     (6, 7),
...     (7, 8),
... )
>>> graph = Graph((node_y, node_x), links=links)
>>> graph.node_at_link_tail
array([0, 1, 0, 1, 2, 3, 4, 3, 4, 5, 6, 7])

property node_layout¶

property node_x¶

property node_y¶

property nodes¶

Get identifier for each node.

Examples

>>> from landlab.graph import Graph
>>> node_x, node_y = [0, 1, 2, 0, 1, 2], [0, 0, 0, 1, 1, 1]
>>> graph = Graph((node_y, node_x))
>>> graph.nodes
array([0, 1, 2, 3, 4, 5])

property nodes_at_bottom_edge¶

Get nodes along the bottom edge.

Examples

>>> import numpy as np
>>> from landlab.graph import TriGraph
>>> graph = TriGraph((3, 4), node_layout="rect")
>>> graph.nodes_at_bottom_edge
array([0, 1, 2, 3])

property nodes_at_left_edge¶

Get nodes along the left edge.

Examples

>>> import numpy as np
>>> from landlab.graph import TriGraph
>>> graph = TriGraph((3, 4), node_layout="rect")
>>> graph.nodes_at_left_edge
array([0, 4, 8])

property nodes_at_link¶

Get nodes at either end of links.

Examples

>>> from landlab.graph import Graph
>>> node_x, node_y = [0, 1, 2, 0, 1, 2, 0, 1, 2], [0, 0, 0, 1, 1, 1, 2, 2, 2]
>>> links = (
...     (0, 1),
...     (1, 2),
...     (0, 3),
...     (1, 4),
...     (2, 5),
...     (3, 4),
...     (4, 5),
...     (3, 6),
...     (4, 7),
...     (5, 8),
...     (6, 7),
...     (7, 8),
... )
>>> graph = Graph((node_y, node_x), links=links)
>>> graph.nodes_at_link
array([[0, 1], [1, 2],
       [0, 3], [1, 4], [2, 5],
       [3, 4], [4, 5],
       [3, 6], [4, 7], [5, 8],
       [6, 7], [7, 8]])

property nodes_at_patch¶

Get the nodes that define a patch.

Examples

>>> from landlab.graph import Graph
>>> node_x, node_y = ([0, 1, 2, 0, 1, 2, 0, 1, 2], [0, 0, 0, 1, 1, 1, 2, 2, 2])
>>> links = (
...     (0, 1),
...     (1, 2),
...     (0, 3),
...     (1, 4),
...     (2, 5),
...     (3, 4),
...     (4, 5),
...     (3, 6),
...     (4, 7),
...     (5, 8),
...     (6, 7),
...     (7, 8),
... )
>>> patches = ((0, 3, 5, 2), (1, 4, 6, 3))
>>> graph = Graph((node_y, node_x), links=links, patches=patches, sort=True)
>>> graph.nodes_at_patch
array([[4, 3, 0, 1],
       [5, 4, 1, 2]])

property nodes_at_right_edge¶

Get nodes along the right edge.

Examples

>>> import numpy as np
>>> from landlab.graph import TriGraph
>>> graph = TriGraph((3, 4), node_layout="rect")
>>> graph.nodes_at_right_edge
array([ 3,  7, 11])

property nodes_at_top_edge¶

Get nodes along the top edge.

Examples

>>> import numpy as np
>>> from landlab.graph import TriGraph
>>> graph = TriGraph((3, 4), node_layout="rect")
>>> graph.nodes_at_top_edge
array([ 8,  9, 10, 11])

property number_of_links¶

Get nodes at link head.

Examples

>>> from landlab.graph import Graph
>>> node_x, node_y = [0, 1, 2, 0, 1, 2, 0, 1, 2], [0, 0, 0, 1, 1, 1, 2, 2, 2]
>>> links = (
...     (0, 1),
...     (1, 2),
...     (0, 3),
...     (1, 4),
...     (2, 5),
...     (3, 4),
...     (4, 5),
...     (3, 6),
...     (4, 7),
...     (5, 8),
...     (6, 7),
...     (7, 8),
... )
>>> graph = Graph((node_y, node_x), links=links)
>>> graph.number_of_links == 12
True

property number_of_nodes¶

Get total number of nodes.

Examples

>>> from landlab.graph import Graph
>>> node_x, node_y = [0, 1, 2, 0, 1, 2], [0, 0, 0, 1, 1, 1]
>>> graph = Graph((node_y, node_x))
>>> graph.number_of_nodes == 6
True

property number_of_patches¶

Get the number of patches.

Examples

>>> from landlab.graph import Graph
>>> node_x, node_y = [0, 1, 2, 0, 1, 2, 0, 1, 2], [0, 0, 0, 1, 1, 1, 2, 2, 2]
>>> links = (
...     (0, 1),
...     (1, 2),
...     (0, 3),
...     (1, 4),
...     (2, 5),
...     (3, 4),
...     (4, 5),
...     (3, 6),
...     (4, 7),
...     (5, 8),
...     (6, 7),
...     (7, 8),
... )
>>> patches = ((0, 3, 5, 2), (1, 4, 6, 3))
>>> graph = Graph((node_y, node_x), links=links, patches=patches)
>>> graph.number_of_patches == 2
True

property orientation¶

property orientation_of_link¶

Return array of link orientation codes (one value per link).

Orientation codes are defined by LinkOrientation; 1 = E, 2 = ENE, 4 = NNE, 8 = N, 16 = NNW, 32 = ESE (using powers of 2 allows for future applications that might want additive combinations).

Examples

>>> from landlab import HexModelGrid
>>> import numpy as np
>>> grid = HexModelGrid((3, 2))
>>> grid.orientation_of_link
array([ 1, 16,  4, 16,  4,  1,  1,  4, 16,  4, 16,  1], dtype=uint8)
>>> grid = HexModelGrid((2, 3), orientation="vertical")
>>> grid.orientation_of_link
array([32,  2,  8,  2, 32,  8,  8, 32,  2,  8,  2, 32], dtype=uint8)

property parallel_links_at_link¶

Return similarly oriented links connected to each link.

Return IDs of links of the same orientation that are connected to each given link’s tail or head node.

For instance, consider a 3x3 hex, in which link IDs are as shown:

    o---17--o---18--o
   / .     / .     / .
  11 12   13  14  15  16
 /     . /     . /     .
o---8---o---9---o---10--o
 .     / .     / .     /
  2   3   4   5   6   7
   . /     . /     . /
    o---0---o---1---o

Here’s a mapping of the tail-wise and head-wise links, where there are valid parallel links:

    o-------o-------o
   / .     / .     / .
  /   .   /   .   /   .
 /     4 3     6 5     .
o-----9-o-8--10-o-9-----o
 .    13 12   15 14    /
  .   /   .   /   .   /
   . /     . /     . /
    o-------o-------o

The corresponding data structure would be mostly filled with -1, but for the 11 active links, it would look like:

[[-1, 13],
 [-1, 12],
 [-1, 15],
 [-1, 14],
 [-1,  9],
 [ 8, 10],
[ 9, -1],
[ 4, -1],
[ 3, -1],
[ 6, -1],
[ 5, -1]]

Examples

>>> from landlab import HexModelGrid
>>> grid = HexModelGrid((3, 3))
>>> pll = grid.parallel_links_at_link
>>> pll[3:16]
array([[-1, 13],
       [-1, 12],
       [-1, 15],
       [-1, 14],
       [-1, -1],
       [-1,  9],
       [ 8, 10],
       [ 9, -1],
       [-1, -1],
       [ 4, -1],
       [ 3, -1],
       [ 6, -1],
       [ 5, -1]])

property patches_at_link¶

Get the patches on either side of each link.

Examples

>>> from landlab.graph import Graph
>>> node_x, node_y = ([0, 1, 2, 0, 1, 2], [0, 0, 0, 1, 1, 1])
>>> links = ((0, 1), (1, 2), (0, 3), (1, 4), (2, 5), (3, 4), (4, 5))
>>> patches = ((0, 3, 5, 2), (1, 4, 6, 3))
>>> graph = Graph((node_y, node_x), links=links, patches=patches)
>>> graph.patches_at_link
array([[ 0, -1], [ 1, -1],
       [ 0, -1], [ 0,  1], [ 1, -1],
       [ 0, -1], [ 1, -1]])

property patches_at_node¶

Get the patches that touch each node.

Examples

>>> from landlab.graph import Graph
>>> node_x, node_y = ([0, 1, 2, 0, 1, 2], [0, 0, 0, 1, 1, 1])
>>> links = ((0, 1), (1, 2), (0, 3), (1, 4), (2, 5), (3, 4), (4, 5))
>>> patches = ((0, 3, 5, 2), (1, 4, 6, 3))
>>> graph = Graph((node_y, node_x), links=links, patches=patches, sort=True)
>>> graph.patches_at_node
array([[ 0, -1], [ 1,  0], [ 1, -1],
       [ 0, -1], [ 0,  1], [ 1, -1]])

property perimeter_nodes¶

Get nodes on the convex hull of a Graph.

Examples

>>> import numpy as np
>>> from landlab.graph import Graph
>>> node_x, node_y = [0, 1, 2, 0, 1, 2], [0, 0, 0, 1, 1, 1]
>>> graph = Graph((node_y, node_x))
>>> np.sort(graph.perimeter_nodes)
array([0, 2, 3, 5])

property shape¶

sort()¶: Sort graph elements.

property spacing¶

thaw()¶: Thaw the graph by making arrays writable.

thawed()¶

to_dict()¶

to_json()¶

to_netcdf(*args, **kwds)¶

Write graph contents to a netCDF file.

See xarray.Dataset.to_netcdf for a complete list of parameters. Below are only the most common.

Parameters:

path (str, optional) – Path to which to save this graph.
mode ({'w', 'a'}, optional) – Write (‘w’) or append (‘a’) mode. If mode=’w’, any existing file at this location will be overwritten.
format ({'NETCDF4', 'NETCDF4_CLASSIC', 'NETCDF3_64BIT', 'NETCDF3_CLASSIC'}, optional) –
File format for the resulting netCDF file:
- NETCDF4: Data is stored in an HDF5 file, using netCDF4 API features.
- NETCDF4_CLASSIC: Data is stored in an HDF5 file, using only netCDF 3 compatible API features.
- NETCDF3_64BIT: 64-bit offset version of the netCDF 3 file format, which fully supports 2+ GB files, but is only compatible with clients linked against netCDF version 3.6.0 or later.
- NETCDF3_CLASSIC: The classic netCDF 3 file format. It does not handle 2+ GB files very well.
All formats are supported by the netCDF4-python library. scipy.io.netcdf only supports the last two formats.

The default format is NETCDF4 if you are saving a file to disk and have the netCDF4-python library available. Otherwise, xarray falls back to using scipy to write netCDF files and defaults to the NETCDF3_64BIT format (scipy does not support netCDF4).

property unit_vector_at_link¶

Make arrays to store the unit vectors associated with each link.

For each link, the x and y components of the link’s unit vector (that is, the link’s x and y dimensions if it were shrunk to unit length but retained its orientation).

Examples

The example below is a seven-node hexagonal grid, with six nodes around the perimeter and one node (#3) in the interior. There are four horizontal links with unit vector (1,0), and 8 diagonal links with unit vector (+/-0.5, +/-sqrt(3)/2) (note: sqrt(3)/2 ~ 0.866).

>>> from landlab.graph import TriGraph
>>> graph = TriGraph((3, 2), spacing=2.0, node_layout="hex", sort=True)

>>> np.round(graph.unit_vector_at_link[:, 0], decimals=5)
array([ 1. , -0.5,  0.5, -0.5,  0.5,  1. ,  1. ,  0.5, -0.5,  0.5, -0.5,
        1. ])
>>> np.round(graph.unit_vector_at_link[:, 1], decimals=5)
array([0.     , 0.86603, 0.86603, 0.86603, 0.86603, 0.     ,
       0.     , 0.86603, 0.86603, 0.86603, 0.86603, 0.     ])

property unit_vector_at_node¶

Get a unit vector for each node.

Examples

>>> from landlab.graph import UniformRectilinearGraph
>>> graph = UniformRectilinearGraph((3, 3))
>>> graph.unit_vector_at_node
array([[1., 1.],
       [2., 1.],
       [1., 1.],
       [1., 2.],
       [2., 2.],
       [1., 2.],
       [1., 1.],
       [2., 1.],
       [1., 1.]])

>>> from landlab.graph import TriGraph
>>> graph = TriGraph((3, 2), spacing=2.0, node_layout="hex", sort=True)

>>> unit_vector_at_node = np.round(graph.unit_vector_at_node, decimals=5)
>>> unit_vector_at_node[:, 0]
array([2., 2., 2., 4., 2., 2., 2.])
>>> unit_vector_at_node[:, 1]
array([1.73205, 1.73205, 1.73205, 3.4641 , 1.73205, 1.73205, 1.73205])

property x_of_node¶

Get x-coordinate of node.

Examples

>>> from landlab.graph import Graph
>>> node_x, node_y = [0, 1, 2, 0, 1, 2], [0, 0, 0, 1, 1, 1]
>>> graph = Graph((node_y, node_x))
>>> graph.x_of_node
array([0., 1., 2., 0., 1., 2.])

property xy_of_link¶

property xy_of_node¶

Get x and y-coordinates of node.

Examples

>>> from landlab.graph import Graph
>>> node_x, node_y = [0, 1, 2, 0, 1, 2], [0, 0, 0, 1, 1, 1]
>>> graph = Graph((node_y, node_x))
>>> graph.xy_of_node[:, 0]
array([0., 1., 2., 0., 1., 2.])
>>> graph.xy_of_node[:, 1]
array([0., 0., 0., 1., 1., 1.])

property xy_of_patch¶

Get the centroid of each patch.

Examples

>>> from landlab.graph import Graph
>>> node_x, node_y = [0, 1, 2, 0, 1, 2, 0, 1, 2], [0, 0, 0, 1, 1, 1, 2, 2, 2]
>>> links = (
...     (0, 1),
...     (1, 2),
...     (0, 3),
...     (1, 4),
...     (2, 5),
...     (3, 4),
...     (4, 5),
...     (3, 6),
...     (4, 7),
...     (5, 8),
...     (6, 7),
...     (7, 8),
... )
>>> patches = ((0, 3, 5, 2), (1, 4, 6, 3))
>>> graph = Graph((node_y, node_x), links=links, patches=patches)
>>> graph.xy_of_patch
array([[0.5, 0.5],
       [1.5, 0.5]])

property y_of_node¶

Get y-coordinate of node.

Examples

>>> from landlab.graph import Graph
>>> node_x, node_y = [0, 1, 2, 0, 1, 2], [0, 0, 0, 1, 1, 1]
>>> graph = Graph((node_y, node_x))
>>> graph.y_of_node
array([0., 0., 0., 1., 1., 1.])

class VerticalHexTriGraph[source]¶

Bases: object

__init__()¶

__new__(**kwargs)¶

static corner_nodes(shape)[source]¶

Examples

>>> from landlab.graph.hex.hex import VerticalHexTriGraph
>>> VerticalHexTriGraph.corner_nodes((2, 5))
(10, 13, 8, 3, 0, 5)
>>> VerticalHexTriGraph.corner_nodes((2, 3))
(5, 6, 4, 1, 0, 2)
>>> VerticalHexTriGraph.corner_nodes((2, 4))
(10, 11, 7, 3, 0, 2)
>>> VerticalHexTriGraph.corner_nodes((2, 2))
(4, 4, 3, 1, 0, 0)
>>> VerticalHexTriGraph.corner_nodes((3, 1))
(2, 2, 2, 0, 0, 0)
>>> VerticalHexTriGraph.corner_nodes((1, 3))
(2, 3, 1, 1, 0, 2)

static nodes_at_edge(shape)[source]¶

Examples

>>> from landlab.graph.hex.hex import VerticalHexTriGraph
>>> VerticalHexTriGraph.nodes_at_edge((3, 7))
(array([ 9, 16]), array([23, 26, 28]), array([29, 27, 24]), array([20, 13]),
 array([6, 3, 1]), array([0, 2, 5]))
>>> VerticalHexTriGraph.nodes_at_edge((2, 3))
(array([2]), array([5]), array([6]), array([4]), array([1]), array([0]))
>>> VerticalHexTriGraph.nodes_at_edge((2, 4))
(array([2, 6]), array([10]), array([11, 9]), array([7]), array([3, 1]), array([0]))

static number_of_nodes(shape)[source]¶

static number_of_perimeter_nodes(shape)[source]¶

Examples

>>> from landlab.graph.hex.hex import VerticalHexTriGraph
>>> VerticalHexTriGraph.number_of_perimeter_nodes((2, 3))
6
>>> VerticalHexTriGraph.number_of_perimeter_nodes((2, 2))
5

static perimeter_nodes(shape)[source]¶

Examples

>>> from landlab.graph.hex.hex import VerticalHexTriGraph
>>> VerticalHexTriGraph.perimeter_nodes((3, 7))
array([ 9, 16, 23, 26, 28, 29, 27, 24, 20, 13,  6,  3,  1,  0,  2,  5])
>>> VerticalHexTriGraph.perimeter_nodes((2, 3))
array([2, 5, 6, 4, 1, 0])
>>> VerticalHexTriGraph.perimeter_nodes((2, 4))
array([ 2, 6, 10, 11, 9, 7, 3, 1, 0])
>>> VerticalHexTriGraph.perimeter_nodes((2, 2))
array([0, 2, 4, 3, 1])
>>> VerticalHexTriGraph.perimeter_nodes((3, 1))
array([0, 1, 2])

static xy_of_node(shape, spacing=1.0, xy_of_lower_left=(0.0, 0.0))[source]¶

class VerticalHexTriGraphCython[source]¶

Bases: object

__init__()¶

__new__(**kwargs)¶

static xy_of_node(shape, spacing=1.0, xy_of_lower_left=(0.0, 0.0))[source]¶

class VerticalRectTriGraph[source]¶

Bases: object

__init__()¶

__new__(**kwargs)¶

static corner_nodes(shape)[source]¶

Examples

>>> from landlab.graph.hex.hex import VerticalRectTriGraph
>>> VerticalRectTriGraph.corner_nodes((4, 3))
(10, 9, 0, 1)
>>> VerticalRectTriGraph.corner_nodes((4, 4))
(15, 12, 0, 3)
>>> VerticalRectTriGraph.corner_nodes((3, 2))
(5, 4, 0, 1)
>>> VerticalRectTriGraph.corner_nodes((7, 1))
(6, 6, 0, 0)
>>> VerticalRectTriGraph.corner_nodes((1, 3))
(1, 0, 0, 1)
>>> VerticalRectTriGraph.corner_nodes((2, 3))
(4, 3, 0, 1)

static nodes_at_edge(shape)[source]¶

static number_of_nodes(shape)[source]¶

static number_of_perimeter_nodes(shape)[source]¶

static perimeter_nodes(shape)[source]¶

Examples

>>> from landlab.graph.hex.hex import VerticalRectTriGraph
>>> VerticalRectTriGraph.perimeter_nodes((3, 2))
array([1, 3, 5, 4, 2, 0])
>>> VerticalRectTriGraph.perimeter_nodes((2, 3))
array([1, 4, 5, 3, 0, 2])
>>> VerticalRectTriGraph.perimeter_nodes((2, 4))
array([3, 7, 5, 6, 4, 0, 2, 1])

static xy_of_node(shape, spacing=1.0, xy_of_lower_left=(0.0, 0.0))[source]¶

class VerticalRectTriGraphCython[source]¶

Bases: object

__init__()¶

__new__(**kwargs)¶

static xy_of_node(shape, spacing=1.0, xy_of_lower_left=(0.0, 0.0))[source]¶