landlab.utils.structured_grid module#

Utility functions for structured grid of elements with four neighbors.

active_cell_count(shape)[source]#

Number of active cells.

Number of active cells. By default, all cells are active so this is the same as cell_count. (active = core+open boundary)

Array of active links pointing to the the east.

Examples

>>> from landlab.utils.structured_grid import active_east_links
>>> active_east_links((3, 4))
array([[-1, -1, -1, -1],
       [ 4,  5,  6, -1],
       [-1, -1, -1, -1]])
active_east_links2(shape, node_status=None)[source]#

Array of active links pointing to the the east.

Examples

>>> from landlab.utils.structured_grid import active_east_links2
>>> active_east_links2((3, 4))
array([[-1, -1, -1, -1],
       [ 7,  8,  9, -1],
       [-1, -1, -1, -1]])
active_face_count(shape)[source]#

Number of active faces.

Total number of active faces in a structured grid with dimensions, shape. Each cell has four faces, and shared faces only count once. An active face is one that has a corresponing active link.

>>> from landlab.utils.structured_grid import active_face_count
>>> active_face_count((3, 4))
7
active_face_index(shape)[source]#

Array of face indices.

Number of active links entering each node.

Array of active links entering nodes.

active_inlinks2(shape, node_status=None)[source]#

Array of active links entering nodes.

Finds and returns the link IDs of active links coming in to each node (that is, active links for which the node is the link head).

Parameters
  • shape (2-element tuple of ints) – Number of rows and columns in the grid

  • (optional) (node_status) – False where node is a closed boundary; True elsewhere

Returns

Link ID of incoming links to each node

Return type

2d numpy array of int (2 x number of grid nodes)

Examples

>>> from landlab.utils.structured_grid import active_inlinks2
>>> active_inlinks2((3,4))
array([[-1, -1, -1, -1, -1,  4,  5, -1, -1, 11, 12, -1],
       [-1, -1, -1, -1, -1,  7,  8,  9, -1, -1, -1, -1]])

Notes

There are at most two inlinks for each node. The first row in the returned array gives the ID of the vertical incoming link from below (south), or -1 if there is none. The second row gives the link ID of the horizontal link coming in from the left (or -1).

Number of active links.

Number of active links in a structured grid with dimensions, shape. A link is active if it connects to at least one active node.

>>> from landlab.utils.structured_grid import link_count, active_link_count
>>> link_count((3, 2))
7
>>> active_link_count((3, 2))
0
>>> active_link_count((3, 4))
7

Link IDs for active links of a structured quad grid.

Return the link IDs for links that are active in a structured grid of quadrilaterals. Use the node_status_array keyword to specify the status for each of the grid’s nodes. If not given, each of the perimeter nodes is assumed to be NodeStatus.FIXED_VALUE.

Use the link_nodes keyword to provide, as a tuple of arrays, that give the from-node and the to-node for each for each link in the grid.

Parameters
  • shape (tuple) – Shape of grid as number of node rows and columns.

  • node_status_array (array_like, optional) – Status of each grid node.

  • link_nodes (array_like, optional) –

Examples

Because, by default, the perimeter nodes are NodeStatus.FIXED_VALUE nodes, only links attached to the interior nodes are active.

>>> from landlab.utils.structured_grid import active_links
>>> from landlab.grid.nodestatus import NodeStatus
>>> active_links((3, 4))
array([ 1,  2,  5,  6, 11, 12, 13])

If all the perimeter nodes NodeStatus.CLOSED nodes, the only active link is between the two core nodes.

>>> node_status = np.ones(3 * 4) * NodeStatus.CLOSED
>>> node_status[5:7] = NodeStatus.CORE
>>> active_links((3, 4), node_status_array=node_status)
array([12])

You can also provide a list of all the from_nodes and to_nodes for the grid. The following describes a grid with only a single link (between nodes 5 and 6).

>>> active_links((3, 4), link_nodes=(np.array([5]), np.array([6])))
array([0])

Array of active links pointing to the the north.

active_north_links2(shape, node_status=None)[source]#

Array of active links pointing to the the north.

>>> from landlab.utils.structured_grid import active_north_links2
>>> active_north_links2((3, 4))
array([[-1,  4,  5, -1],
       [-1, 11, 12, -1],
       [-1, -1, -1, -1]])

Number of active links leaving each node.

Array of active links leaving nodes.

active_outlinks2(shape, node_status=None)[source]#

Array of active links leaving nodes.

Finds and returns the link IDs of active links going out of each node (that is, active links for which the node is the link tail).

Parameters
  • shape (2-element tuple of ints) – Number of rows and columns in the grid

  • (optional) (node_status) – False where node is a closed boundary; True elsewhere

Returns

Link ID of outgoing links from each node

Return type

2d numpy array of int (2 x number of grid nodes)

Examples

>>> from landlab.utils.structured_grid import active_outlinks2
>>> active_outlinks2((3,4))
array([[-1,  4,  5, -1, -1, 11, 12, -1, -1, -1, -1, -1],
       [-1, -1, -1, -1,  7,  8,  9, -1, -1, -1, -1, -1]])

Notes

There are at most two outlinks for each node. The first row in the returned array gives the ID of the vertical outgoing link to above (north), or -1 if there is none. The second row gives the link ID of the horizontal link going out to the right (east) (or -1).

Array of active links pointing to the the south.

active_south_links2(shape, node_status=None)[source]#

Array of active links pointing to the the south.

Finds and returns link IDs of active links that enter each node from the south (bottom), or -1 where no such active link exists.

Parameters
  • shape (2-element tuple of int) – number of rows and columns in grid

  • (optional) (node_status) – False where node is a closed boundary, True otherwise

Returns

Link ID of active link connecting to a node from the south, or -1

Return type

2d numpy array of int

Examples

>>> from landlab.utils.structured_grid import active_south_links2
>>> active_south_links2((3, 4))
array([[-1, -1, -1, -1],
       [-1,  4,  5, -1],
       [-1, 11, 12, -1]])

Notes

Like active_south_links, but returns link IDs.

Array of active links pointing to the the west.

Examples

>>> from landlab.utils.structured_grid import active_west_links
>>> active_west_links((3, 4))
array([[-1, -1, -1, -1],
       [-1,  4,  5,  6],
       [-1, -1, -1, -1]])
active_west_links2(shape, node_status=None)[source]#

Array of active links pointing to the the west.

Examples

>>> from landlab.utils.structured_grid import active_west_links2
>>> active_west_links2((3, 4))
array([[-1, -1, -1, -1],
       [-1,  7,  8,  9],
       [-1, -1, -1, -1]])
bottom_edge_node_ids(shape)[source]#

Array of nodes on the bottom edge.

bottom_index_iter(shape)[source]#

Iterator for the bottom boundary indices of a structured grid.

bottom_top_iter(shape)[source]#

Iterator for bottom then top indices of a structured grid.

Examples

>>> import numpy as np
>>> from landlab.utils.structured_grid import bottom_top_iter
>>> np.fromiter(bottom_top_iter((4, 3)), dtype=int)
array([ 0,  1,  2,  9, 10, 11])
cell_count(shape)[source]#

Total number of cells.

The total number of cells in a structured grid with dimensions, shape. Where shape is a tuple that gives the dimensions of the grid as number of rows of nodes followed by number of columns of nodes.

>>> from landlab.utils.structured_grid import cell_count
>>> cell_count((3, 4))
2
>>> cell_count((1, 4))
0
cell_index_with_halo(shape, halo_indices=-1, inactive_indices=None)[source]#

Array of cells with a halo of no-data values.

Examples

>>> from landlab.utils.structured_grid import cell_index_with_halo
>>> cell_index_with_halo((2, 3), halo_indices=-1)
array([[-1, -1, -1, -1, -1],
       [-1,  0,  1,  2, -1],
       [-1,  3,  4,  5, -1],
       [-1, -1, -1, -1, -1]])
>>> cell_index_with_halo((2, 3), halo_indices=-1, inactive_indices=-1)
array([[-1, -1, -1, -1, -1],
       [-1, -1, -1, -1, -1],
       [-1, -1, -1, -1, -1],
       [-1, -1, -1, -1, -1]])
core_cell_count(shape)[source]#

Number of core cells.

Number of core cells. By default, all cells are core so this is the same as cell_count.

corners(shape)[source]#

Array of the indices of the grid corner nodes.

diagonal_cell_array(shape, out_of_bounds=-1, contiguous=True)[source]#

Array of diagonal cells.

Construct a matrix of cell indices to each diagonally adjacent cell of a structured grid. If a cell does not have a diagonal neighbor, set the index for that neighbor to out_of_bounds.

Examples

A grid without any cells returns an empty array.

>>> from landlab.utils.structured_grid import diagonal_cell_array
>>> diags = diagonal_cell_array((2, 3), out_of_bounds=-1)
>>> len(diags) == 0
True

A grid that has only one cell does not have any neighbors so all of its diagonals are set to out_of_bounds. >>> diags = diagonal_cell_array((3, 3), out_of_bounds=-1) >>> diags array([[-1, -1, -1, -1]])

>>> diags = diagonal_cell_array((4, 4), out_of_bounds=-1)
>>> diags 
array([[ 3, -1, -1, -1], [-1,  2, -1, -1],
       [-1, -1, -1,  1], [-1, -1,  0, -1]])
>>> diags = diagonal_cell_array((4, 5), out_of_bounds=-1)
>>> diags 
array([[ 4, -1, -1, -1], [ 5,  3, -1, -1], [-1,  4, -1, -1],
       [-1, -1, -1,  1], [-1, -1,  0,  2], [-1, -1,  1, -1]])
diagonal_node_array(shape, out_of_bounds=-1, contiguous=True, boundary_node_mask=None)[source]#

Array of diagonal nodes.

Creates a list of IDs of the diagonal cells to each cell, as a 2D array. Only interior cells are assigned neighbors; boundary cells get -1 for each neighbor. The order of the diagonal cells is [topright, topleft, bottomleft, bottomright].

Examples

>>> from landlab.utils.structured_grid import diagonal_node_array
>>> diags = diagonal_node_array((2, 3), out_of_bounds=-1)
>>> diags
array([[ 4, -1, -1, -1],
       [ 5,  3, -1, -1],
       [-1,  4, -1, -1],
       [-1, -1, -1,  1],
       [-1, -1,  0,  2],
       [-1, -1,  1, -1]])
>>> diags.flags['C_CONTIGUOUS']
True
>>> diags = diagonal_node_array((2, 3), out_of_bounds=-1, contiguous=False)
>>> diags.flags['C_CONTIGUOUS']
False

Array of links pointing to the the east.

Examples

>>> from landlab.utils.structured_grid import east_links
>>> east_links((3, 4))
array([[ 0,  1,  2, -1],
       [ 7,  8,  9, -1],
       [14, 15, 16, -1]])

Array of faces associated with links.

Returns an array that maps link ids to face ids. For inactive links, which do not have associated faces, set their ids to inactive_link_index. Use the actives keyword to specify an array that contains the ids of all active links in the grid. The default assumes that only the perimeter nodes are inactive.

Examples

>>> from landlab.utils.structured_grid import face_at_link
>>> faces = face_at_link((3, 4), inactive_link_index=-1)
>>> faces 
array([-1,  0,  1, -1, -1,  2,  3,
       -1, -1, -1, -1,  4,  5,  6, -1, -1, -1])
face_count(shape)[source]#

Total number of faces.

Total number of faces in a structured grid with dimensions, shape. Each cell has four faces, and shared faces only count once.

Examples

>>> from landlab.utils.structured_grid import face_count
>>> face_count((3, 4))
7

Number of active links oriented horizontally.

Array of active links oriented horizontally.

Array of active links oriented horizontally.

Returns the link IDs of horizontal active links as an (R-2) x (C-1) array.

Parameters
  • shape (2-element tuple of int) – number of rows and columns in grid

  • (optional) (node_status) – False where node is a closed boundary, True otherwise

Returns

Link IDs of horizontal active links, not including horizontal links on top and bottom grid edges. If a horizontal link is inactive, its ID is given as -1.

Return type

2d numpy array of int

Examples

>>> from landlab.utils.structured_grid import horizontal_active_link_ids2
>>> horizontal_active_link_ids2((3,4))
array([[7, 8, 9]])
>>> ns = np.ones(12, dtype=bool)
>>> ns[4] = False
>>> ns[7] = False
>>> horizontal_active_link_ids2((3,4), ns)
array([[-1,  8, -1]])

Notes

Same as horizontal_active_link_ids() but returns “link IDs” for active links rather than “active link IDs” for active links. Designed to ultimately replace the original horizontal_active_link_ids().

Array mask of horizontal links that are inactive.

Number of horizontal links.

Array of links oriented horizontally.

Number of links entering each node.

Array of links entering nodes.

Array of links entering nodes.

interior_cell_count(shape)[source]#

Number of interior cells.

Number of interior cells. Since cells are only defined on interior nodes, this is the same as cell_count.

interior_iter(shape)[source]#

Iterator for the interior nodes of a structured grid.

Examples

>>> import numpy as np
>>> from landlab.utils.structured_grid import interior_iter
>>> np.fromiter(interior_iter((4, 3)), dtype=int)
array([4, 7])
interior_node_count(shape)[source]#

Number of interior nodes.

Return the count of the number of interior nodes of a structured grid of dimensions, shape.

>>> from landlab.utils.structured_grid import (node_count,
...                                            interior_node_count)
>>> node_count((2, 4))
8
>>> interior_node_count((2, 4))
0
>>> interior_node_count((1, 4))
0
>>> interior_node_count((3, 4))
2
interior_nodes(shape)[source]#

Array of interior nodes.

left_edge_node_ids(shape)[source]#

Array of nodes on the left edge.

left_index_iter(shape)[source]#

Iterator for the left boundary indices of a structured grid.

left_right_iter(shape, *args)[source]#

Iterator for the left and right boundary indices of a structured grid.

This iterates over the indices in order rather than iterating all of the left boundary and then all of the right boundary.

Examples

>>> import numpy as np
>>> from landlab.utils.structured_grid import left_right_iter
>>> np.fromiter(left_right_iter((4, 3)), dtype=int)
array([ 0,  2,  3,  5,  6,  8,  9, 11])
>>> np.fromiter(left_right_iter((4, 3), 2), dtype=int)
array([0, 2, 3, 5])
>>> np.fromiter(left_right_iter((4, 3), 2, 4), dtype=int)
array([ 6,  8,  9, 11])
>>> np.fromiter(left_right_iter((4, 3), 1, 4, 2), dtype=int)
array([ 3,  5,  9, 11])

Total number of links.

Total (active and inactive) number of links in a structured grid with dimensions, shape. This is the number of to-links and from-links, not the total of the two.

>>> from landlab.utils.structured_grid import link_count
>>> link_count((3,2))
7
linked_neighbor_node_ids(shape, closed_boundary_nodes, open_boundary_nodes=None, inactive=-1)[source]#

Matrix of four neighbor nodes for each node.

neighbor_cell_array(shape, out_of_bounds=-1, contiguous=True)[source]#

Array of neighbor cells.

Examples

>>> from landlab.utils.structured_grid import neighbor_cell_array
>>> neighbors = neighbor_cell_array((2, 3), out_of_bounds=-1)
>>> len(neighbors) == 0
True
>>> neighbors = neighbor_cell_array((3, 3), out_of_bounds=-1)
>>> neighbors
array([[-1, -1, -1, -1]])
>>> neighbors = neighbor_cell_array((5, 4), out_of_bounds=-1)
>>> neighbors 
array([[ 1,  2, -1, -1], [-1,  3,  0, -1],
       [ 3,  4, -1,  0], [-1,  5,  2,  1],
       [ 5, -1, -1,  2], [-1, -1,  4,  3]])
neighbor_node_array(shape, **kwds)[source]#

Array of neighbor nodes.

Examples

>>> from landlab.utils.structured_grid import neighbor_node_array
>>> neighbors = neighbor_node_array((2, 3), inactive=-1)
>>> neighbors.T
array([[ 1,  3, -1, -1],
       [ 2,  4,  0, -1],
       [-1,  5,  1, -1],
       [ 4, -1, -1,  0],
       [ 5, -1,  3,  1],
       [-1, -1,  4,  2]])
neighbor_node_ids(shape, inactive=-1)[source]#

Matrix of four neighbor nodes for each node.

node_at_cell(shape)[source]#

Array of nodes at cells.

Indices of the nodes belonging to each cell.

Examples

>>> from landlab.utils.structured_grid import node_at_cell
>>> node_at_cell((4, 3))
array([4, 7])

Array of nodes at the end of links.

Array of nodes at the start of links.

node_coords(shape, *args)[source]#

Get node x and y coordinates.

Get x, y coordinates for nodes in a structured grid with dimensions, shape. Use the optional argument spacing to give the spacing in each dimension, and origin the start of the coordinates in each dimension.

Parameters
  • shape (tuple of int) – Number of node rows and columns.

  • spacing (tuple, optional) – Row and column spacing.

  • origin (tuple, optional) – Coordinate of lower-left node.

Examples

>>> from landlab.utils.structured_grid import node_coords
>>> (cols, rows) = node_coords((3, 2))
>>> rows
array([ 0.,  0.,  1.,  1.,  2.,  2.])
>>> cols
array([ 0.,  1.,  0.,  1.,  0.,  1.])
node_count(shape)[source]#

Total number of nodes.

The total number of nodes in a structured grid with dimensions given by the tuple, shape. Where shape is the number of node rows and node columns.

>>> from landlab.utils.structured_grid import node_count
>>> node_count((3, 4))
12
node_has_boundary_neighbor(neighbors, diagonals, out_of_bounds=-1)[source]#

Array of booleans that indicate if a node has a boundary neighbor.

Note

DEJH thinks this method is broken since terminology update: it returns closed neighbors, not boundary neighbors.

Array of nodes at each end of links.

node_index_with_halo(shape, halo_indices=-1)[source]#

Array of links with a halo of no-data values.

Examples

>>> from landlab.utils.structured_grid import node_index_with_halo
>>> node_index_with_halo((2, 3), halo_indices=-1)
array([[-1, -1, -1, -1, -1],
       [-1,  0,  1,  2, -1],
       [-1,  3,  4,  5, -1],
       [-1, -1, -1, -1, -1]])
nodes_around_point(shape, coords, spacing=(1.0, 1.0))[source]#

Array of nodes around a single point on a grid of non-unit spacing.

nodes_around_points(shape, coords, spacing=(1.0, 1.0), origin=(0.0, 0.0))[source]#

Array of nodes around x, y points on a grid of non-unit spacing.

Returns the nodes around a point on a structured grid with row and column spacing, and origin.

Examples

>>> from landlab.utils.structured_grid import nodes_around_points
>>> x = np.array([.9, 1.])
>>> y = np.array([.1, 1.])
>>> nodes_around_points((3, 3), (y, x))
array([[0, 3, 4, 1],
       [4, 7, 8, 5]])
>>> nodes_around_points((3, 3), (2., 1.))
Traceback (most recent call last):
    ...
ValueError: invalid entry in coordinates array
nodes_around_points_on_unit_grid(shape, coords, mode='raise')[source]#

Array of nodes around x, y points on a grid of unit spacing.

Returns the nodes around a point on a structured grid with unit spacing and zero origin.

Examples

>>> from landlab.utils.structured_grid import (
...     nodes_around_points_on_unit_grid)
>>> nodes_around_points_on_unit_grid((3, 3), (.1, .1))
array([0, 3, 4, 1])
>>> nodes_around_points_on_unit_grid((3, 3), (1., 1.))
array([4, 7, 8, 5])

Array of links pointing to the north.

Examples

>>> from landlab.utils.structured_grid import north_links
>>> north_links((3, 4))
array([[ 3,  4,  5,  6],
       [10, 11, 12, 13],
       [-1, -1, -1, -1]])

Number of links leaving each node.

Array of links leaving nodes.

Array of links leaving nodes.

perimeter_iter(shape)[source]#

Iterator for perimeter nodes.

Iterates over all of the perimeter node indices of a structured grid in order.

Examples

>>> import numpy as np
>>> from landlab.utils.structured_grid import perimeter_iter
>>> np.fromiter(perimeter_iter((4, 3)), dtype=int)
array([ 0,  1,  2,  3,  5,  6,  8,  9, 10, 11])
perimeter_node_count(shape)[source]#

Number of perimeter nodes.

Number of nodes that are on the perimeter of a structured grid with dimensions, shape, and thus boundary nodes.

Examples

>>> from landlab.utils.structured_grid import perimeter_node_count
>>> perimeter_node_count((3, 4))
10
perimeter_nodes(shape)[source]#

Array of perimeter nodes.

An array of the indices of the perimeter nodes of a structured grid.

Examples

>>> from landlab.utils.structured_grid import perimeter_nodes
>>> perimeter_nodes((3, 4))
array([ 0,  1,  2,  3,  4,  7,  8,  9, 10, 11])
reshape_array(shape, array, flip_vertically=False, copy=False)[source]#

Reshape a flat array.

Examples

>>> from landlab.utils.structured_grid import reshape_array
>>> x = np.arange(12.)
>>> y = reshape_array((3, 4), x)
>>> y.shape == (3, 4)
True
>>> y
array([[  0.,   1.,   2.,   3.],
       [  4.,   5.,   6.,   7.],
       [  8.,   9.,  10.,  11.]])
>>> y.flags['C_CONTIGUOUS']
True
>>> x[0] = -1
>>> y[0, 0]
-1.0
>>> x = np.arange(12.)
>>> y = reshape_array((3, 4), x, flip_vertically=True)
>>> y
array([[  8.,   9.,  10.,  11.],
       [  4.,   5.,   6.,   7.],
       [  0.,   1.,   2.,   3.]])
>>> y.flags['C_CONTIGUOUS']
False
>>> x[0] = -1
>>> y[-1, 0]
-1.0
right_edge_node_ids(shape)[source]#

Array of nodes on the right edge.

right_index_iter(shape)[source]#

Iterator for the right boundary indices of a structured grid.

Create a matrix of active links entering each node.

Return the IDs of the active links that enter each node of a grid. The shape of the returned array is (2, N) where N is the number of nodes in the grid. The first row contains the link ID entering the node from the bottom, and the second row the link entering the node from the left.

Use the return_count keyword to, in addition to the link IDs, return the number of active links attached to each grid node.

Use the node_status_array keyword to specify the status for each of the grid’s nodes. If not given, each of the perimeter nodes is assumed to be NodeStatus.FIXED_VALUE.

Parameters
  • shape (tuple) – Shape of the structured grid

  • node_status (array_like, optional) – Status of each node in the grid.

  • return_count (boolean, optional) – If True, also return an array of active link counts per node.

Returns

  • links ((2, N) ndarray) – Active link IDs for each node.

  • count (ndarray) – Number of active links per node.

Examples

Get the active link IDs for a grid of 3 nodes by 4 nodes. The first row list links entering nodes from the bottom, and the second links entering from the left.

>>> from landlab.utils.structured_grid import setup_active_inlink_matrix
>>> setup_active_inlink_matrix((3, 4), return_count=False)
array([[-1, -1, -1, -1, -1,  0,  1, -1, -1,  2,  3, -1],
       [-1, -1, -1, -1, -1,  4,  5,  6, -1, -1, -1, -1]])
>>> _, count = setup_active_inlink_matrix((3, 4))
>>> count
array([0, 0, 0, 0, 0, 2, 2, 1, 0, 1, 1, 0])

Create a matrix of active links entering each node.

Return the link IDs of the active links that enter each node of a grid. The shape of the returned array is (2, N) where N is the number of nodes in the grid. The first row contains the link ID entering the node from the bottom, and the second row the link entering the node from the left.

Use the return_count keyword to, in addition to the link IDs, return the number of active links attached to each grid node.

Use the node_status_array keyword to specify the status for each of the grid’s nodes. If not given, each of the perimeter nodes is assumed to be NodeStatus.FIXED_VALUE.

Parameters
  • shape (tuple) – Shape of the structured grid

  • node_status (array_like, optional) – Status of each node in the grid.

  • return_count (boolean, optional) – If True, also return an array of active link counts per node.

Returns

  • links ((2, N) ndarray) – Active link IDs for each node.

  • count (ndarray) – Number of active links per node.

Examples

Get the active link IDs for a grid of 3 nodes by 4 nodes. The first row lists links entering nodes from the bottom, and the second links entering from the left.

>>> from landlab.utils.structured_grid import setup_active_inlink_matrix2
>>> setup_active_inlink_matrix2((3, 4), return_count=False)
array([[-1, -1, -1, -1, -1,  4,  5, -1, -1, 11, 12, -1],
       [-1, -1, -1, -1, -1,  7,  8,  9, -1, -1, -1, -1]])
>>> _, count = setup_active_inlink_matrix2((3, 4))
>>> count
array([0, 0, 0, 0, 0, 2, 2, 1, 0, 1, 1, 0])

Create a matrix of active links leaving each node.

Create a matrix of active links leaving each node.

Return the link IDs of the active links that leave each node of a grid. The shape of the returned array is (2, N) where N is the number of nodes in the grid. The first row contains the link ID exiting the node to the top, and the second row the link exiting the node to the right.

Use the return_count keyword to, in addition to the link IDs, return the number of active links attached to each grid node.

Use the node_status_array keyword to specify the status for each of the grid’s nodes. If not given, each of the perimeter nodes is assumed to be NodeStatus.FIXED_VALUE.

Parameters
  • shape (tuple) – Shape of the structured grid

  • node_status (array_like, optional) – Status of each node in the grid.

  • return_count (boolean, optional) – If True, also return an array of active link counts per node.

Returns

  • links ((2, N) ndarray) – Active link IDs for each node.

  • count (ndarray) – Number of active links per node.

Examples

Get the active link IDs for a grid of 3 nodes by 4 nodes. The first row lists links entering nodes from the bottom, and the second links entering from the left.

>>> from landlab.utils.structured_grid import setup_active_outlink_matrix2
>>> setup_active_outlink_matrix2((3, 4), return_count=False)
array([[-1,  4,  5, -1, -1, 11, 12, -1, -1, -1, -1, -1],
       [-1, -1, -1, -1,  7,  8,  9, -1, -1, -1, -1, -1]])
>>> _, count = setup_active_outlink_matrix2((3, 4))
>>> count
array([0, 1, 1, 0, 1, 2, 2, 0, 0, 0, 0, 0])

Create a matrix of links entering each node.

Create a matrix of links leaving each node.

Array of links pointing to the the south.

Examples

>>> from landlab.utils.structured_grid import south_links
>>> south_links((3, 4))
array([[-1, -1, -1, -1],
       [ 3,  4,  5,  6],
       [10, 11, 12, 13]])
status_at_node(shape, boundary_status=NodeStatus.FIXED_VALUE)[source]#

Array of the statuses of nodes.

The statuses of the nodes in a structured grid with dimensions, shape. Use the boundary_status keyword to specify the status of the top, bottom, left and right boundary nodes.

top_edge_node_ids(shape)[source]#

Array of nodes on the top edge.

top_index_iter(shape)[source]#

Iterator for the top boundary indices of a structured grid.

Number of active links oriented vertically.

Array of active links oriented vertically.

Array of active links oriented vertically.

Returns the link IDs of vertical active links as an (R-1) x (C-2) array.

Parameters
  • shape (2-element tuple of int) – number of rows and columns in grid

  • (optional) (node_status) – False where node is a closed boundary, True otherwise

Returns

Link IDs of vertical active links, not including vertical links on the left and right grid edges. If a vertical link is inactive, its ID is given as -1.

Return type

2d numpy array of int

Examples

>>> from landlab.utils.structured_grid import vertical_active_link_ids2
>>> vertical_active_link_ids2((3,4))
array([[ 4,  5],
       [11, 12]])
>>> ns = np.ones(12, dtype=bool)
>>> ns[1] = False
>>> ns[10] = False
>>> vertical_active_link_ids2((3,4), ns)
array([[-1,  5],
       [11, -1]])

Notes

Same as vertical_active_link_ids() but returns “link IDs” for active links rather than “active link IDs” for active links. Designed to ultimately replace the original vertical_active_link_ids().

Array mask of vertical links that are inactive.

Creates and returns a boolean 2D array dimensioned as the number of vertical links in the grid, not including the left and right boundaries.

Parameters
  • shape (2-element tuple of ints) – Number of rows and columns in the grid

  • node_status (numpy array of bool (x # of nodes)) – False where node is a closed boundary; True elsewhere

Returns

Flags indicating whether the corresponding vertical link is inactive

Return type

(NR-1,NC-2) array of bool (NR=# of rows, NC=# of columns)

Examples

>>> import numpy as np
>>> from landlab.utils.structured_grid import vertical_inactive_link_mask
>>> ns = np.ones(12, dtype=bool)  # case of no closed boundary nodes
>>> vertical_inactive_link_mask((3,4), ns)
array([[False, False],
       [False, False]], dtype=bool)
>>> ns[2] = False    # node 2 is a closed boundary
>>> vertical_inactive_link_mask((3,4), ns)
array([[False,  True],
       [False, False]], dtype=bool)
>>> ns[9] = False    # node 9 is also a closed boundary
>>> vertical_inactive_link_mask((3,4), ns)
array([[False,  True],
       [ True, False]], dtype=bool)

Number of vertical links.

Array of links oriented vertically.

Array of links pointing to the west.

Examples

>>> from landlab.utils.structured_grid import west_links
>>> west_links((3, 4))
array([[-1,  0,  1,  2],
       [-1,  7,  8,  9],
       [-1, 14, 15, 16]])