landlab.grid.unstructured package

Submodules

landlab.grid.unstructured.base module

class BaseGrid([coord0, coord1, ..., ]axis_name=None, axis_units=None)

Bases: object

Parameters:

coord0, coord1, ... : sequence of array-like

Coordinates of grid nodes

axis_name : sequence of strings, optional

Names of coordinate axes

axis_units : sequence of strings, optional

Units of coordinate axes

Returns:

BaseGrid :

A newly-created BaseGrid

Examples

>>> from landlab.grid.unstructured.base import BaseGrid
>>> ngrid = BaseGrid(([0, 0, 1, 1], [0, 1, 0, 1]))
>>> ngrid.number_of_nodes
4
>>> ngrid.x_at_node
array([ 0.,  1.,  0.,  1.])
>>> ngrid.x_at_node[2]
0.0
>>> ngrid.point_at_node[2]
array([ 1.,  0.])
>>> ngrid.coord_at_node[:, [2, 3]]
array([[ 1.,  1.],
       [ 0.,  1.]])

>>> cells = ([0, 1, 2, 1, 3, 2], [3, 3], [0, 1])
>>> ngrid = BaseGrid(([0, 0, 1, 1], [0, 1, 0, 1]), cells=cells)
>>> ngrid.number_of_cells
2
>>> ngrid.node_at_cell
array([0, 1])

>>> links = [(0, 2), (1, 3), (0, 1), (1, 2), (0, 3)]
>>> ngrid = BaseGrid(([0, 0, 1, 1], [0, 1, 0, 1]), links=zip(*links))
>>> ngrid.number_of_links
5
>>> ngrid.links_leaving_at_node(0)
array([0, 2, 4])
>>> len(ngrid.links_entering_at_node(0)) == 0
True

>>> tails, heads = zip(*links)
>>> grid = BaseGrid(([0, 0, 1, 1], [0, 1, 0, 1]),
...     node_status=[0, 0, 0, 4], links=[tails, heads])
>>> grid.status_at_node
array([0, 0, 0, 4])
>>> len(grid.active_links_entering_at_node(0)) == 0
True
>>> grid.active_links_leaving_at_node(0)
array([0, 2])

active_links()

active_links_entering_at_node(node)

active_links_leaving_at_node(node)

active_nodes()

axis_name

Name of each axis.

Returns:

tuple of strings :

Names of each axis.

Examples

>>> from landlab.grid.unstructured.base import BaseGrid
>>> ngrid = BaseGrid(([0, 1, 0], [1, 1, 0]))
>>> ngrid.axis_name
('y', 'x')

>>> ngrid = BaseGrid(([0, 1, 0], [1, 1, 0]), axis_name=['lat', 'lon'])
>>> ngrid.axis_name
('lat', 'lon')

axis_units

Coordinate units of each axis.

Returns:

tuple of strings :

Coordinate units of each axis.

Examples

>>> from landlab.grid.unstructured.base import BaseGrid
>>> ngrid = BaseGrid(([0, 1, 0], [1, 1, 0]))
>>> ngrid.axis_units
('-', '-')

>>> ngrid = BaseGrid(([0, 1, 0], [1, 1, 0]),
...     axis_units=['degrees_north', 'degrees_east'])
>>> ngrid.axis_units
('degrees_north', 'degrees_east')

boundary_nodes()

cell_at_node

closed_boundary_nodes()

coord_at_node

core_cells()

core_nodes()

static create_active_link_grid(node_status, links, number_of_nodes)

fixed_gradient_boundary_nodes()

fixed_value_boundary_nodes()

length_of_link(link=None)

Length of grid links.

Parameters:

link : array-like, optional

Link IDs

Examples

>>> from landlab.grid.unstructured.base import BaseGrid
>>> links = [(0, 2), (1, 3), (0, 1), (2, 3), (0, 3)]
>>> grid = BaseGrid(([0, 0, 4, 4], [0, 3, 0, 3]), links=links)
>>> grid.length_of_link()
array([ 4.,  4.,  3.,  3.,  5.])
>>> grid.length_of_link(0)
array([ 4.])

>>> grid.length_of_link().min()
3.0
>>> grid.length_of_link().max()
5.0

link_length(*args, **kwargs)

Note

This method is deprecated as of Landlab version 1.0.

Use length_of_link() instead.

links_entering_at_node(node)

links_leaving_at_node(node)

ndim

node_at_cell

node_at_link_end

node_at_link_start

node_to_node_distance(node0, node1, out=None)

Distance between nodes.

Parameters:

node0 : array-like

Node ID of start

node1 : array-like

Node ID of end

Returns:

array :

Distances between nodes.

Examples

>>> from landlab.grid.unstructured.base import BaseGrid
>>> grid = BaseGrid(([0, 0, 4, 4], [0, 3, 0, 3]))
>>> grid.node_to_node_distance(0, 3)
array([ 5.])
>>> grid.node_to_node_distance(0, [0, 1, 2, 3])
array([ 0.,  3.,  4.,  5.])

number_of_cells

Number of cells.

number_of_links

Number of links.

number_of_nodes

Number of nodes.

point_at_node

point_to_node_angle(point, node=None, out=None)

Angle from a point to a node.

Parameters:

point : tuple

Coordinates of point

node : array-like

Node IDs

Returns:

array :

Angles from point to node as radians.

Examples

>>> from landlab.grid.unstructured.base import BaseGrid
>>> grid = BaseGrid(([0, 0, 1, 1], [0, 1, 0, 1]))
>>> grid.point_to_node_angle((0., 0.), [1, 2, 3]) / np.pi
array([ 0.  ,  0.5 ,  0.25])
>>> grid.point_to_node_angle((0., 0.)) / np.pi
array([ 0.  ,  0.  ,  0.5 ,  0.25])
>>> out = np.empty(4)
>>> out is grid.point_to_node_angle((0., 0.), out=out)
True
>>> out / np.pi
array([ 0.  ,  0.  ,  0.5 ,  0.25])

point_to_node_azimuth(point, node=None, out=None)

Azimuth from a point to a node.

Parameters:

point : tuple

Coordinates of point

node : array-like

Node IDs

Returns:

array :

Azimuths from point to node.

Examples

>>> from landlab.grid.unstructured.base import BaseGrid
>>> grid = BaseGrid(([0, 0, 1, 1], [0, 1, 0, 1]))
>>> grid.point_to_node_azimuth((0., 0.), [1, 2, 3])
array([ 90.,   0.,  45.])
>>> grid.point_to_node_azimuth((0., 0.))
array([ 90.,  90.,   0.,  45.])
>>> grid.point_to_node_azimuth((0., 0.), 1)
array([ 90.])
>>> out = np.empty(4)
>>> out is grid.point_to_node_azimuth((0., 0.), out=out)
True
>>> out
array([ 90.,  90.,   0.,  45.])

point_to_node_distance(point, node=None, out=None)

Distance from a point to a node.

Parameters:

point : tuple

Coordinates of point

node : array-like

Node IDs

Returns:

array :

Distances from point to node.

Examples

>>> from landlab.grid.unstructured.base import BaseGrid
>>> grid = BaseGrid(([0, 0, 4, 4], [0, 3, 0, 3]))
>>> grid.point_to_node_distance((0., 0.), [1, 2, 3])
array([ 3.,  4.,  5.])
>>> grid.point_to_node_distance((0., 0.))
array([ 0.,  3.,  4.,  5.])
>>> out = np.empty(4)
>>> out is grid.point_to_node_distance((0., 0.), out=out)
True
>>> out
array([ 0.,  3.,  4.,  5.])

point_to_node_vector(point, node=None, out=None)

Azimuth from a point to a node.

Parameters:

point : tuple

Coordinates of point

node : array-like

Node IDs

Returns:

array :

Vector from point to node.

Examples

>>> from landlab.grid.unstructured.base import BaseGrid
>>> grid = BaseGrid(([0, 0, 1, 1], [0, 1, 0, 1]))
>>> grid.point_to_node_vector((0., 0.), [1, 2, 3])
array([[ 0.,  1.,  1.],
       [ 1.,  0.,  1.]])
>>> grid.point_to_node_vector((0., 0.))
array([[ 0.,  0.,  1.,  1.],
       [ 0.,  1.,  0.,  1.]])
>>> grid.point_to_node_vector((0., 0.), 1)
array([[ 0.],
       [ 1.]])
>>> out = np.empty((2, 1))
>>> out is grid.point_to_node_vector((0., 0.), 1, out=out)
True
>>> out
array([[ 0.],
       [ 1.]])

status_at_node

x_at_node

y_at_node

point_to_point_angle(point0, point1, out=None)

Angle of vector that joins two points.

Parameters:

(y0, x0) : tuple of array_like

(y1, x1) : tuple of array_like

out : array_like, optional

An array to store the output. Must be the same shape as the output would have.

Returns:

a : array_like

Angle of vector joining points; if out is provided, v will be equal to out.

point_to_point_azimuth(point0, point1, out=None)

Azimuth of vector that joins two points.

Parameters:

(y0, x0) : tuple of array_like

(y1, x1) : tuple of array_like

out : array_like, optional

An array to store the output. Must be the same shape as the output would have.

Returns:

azimuth : array_like

Azimuth of vector joining points; if out is provided, v will be equal to out.

Examples

>>> from landlab.grid.unstructured.base import point_to_point_azimuth
>>> point_to_point_azimuth((0, 0), (1, 0))
array([ 0.])
>>> point_to_point_azimuth([(0, 1), (0, 1)], (1, 0))
array([  0., -90.])
>>> point_to_point_azimuth([(0, 1, 0), (0, 1, 2)], [(1, 1, 2), (0, 0, 4)])
array([  0., -90.,  45.])

point_to_point_distance(point0, point1, out=None)

Length of vector that joins two points.

Parameters:

(y0, x0) : tuple of array_like

(y1, x1) : tuple of array_like

out : array_like, optional

An array to store the output. Must be the same shape as the output would have.

Returns:

l : array_like

Length of vector joining points; if out is provided, v will be equal to out.

Examples

>>> from landlab.grid.unstructured.base import point_to_point_distance
>>> point_to_point_distance((0, 0), (3, 4))
array([ 5.])
>>> point_to_point_distance((0, 0), ([3, 6], [4, 8]))
array([  5.,  10.])

point_to_point_vector(point0, point1, out=None)

Vector that joins two points.

Parameters:

(y0, x0) : tuple of array_like

(y1, x1) : tuple of array_like

out : array_like, optional

An array to store the output. Must be the same shape as the output would have.

Returns:

(dy, dx) : tuple of array_like

Vectors between points; if out is provided, v will be equal to out.

Examples

>>> from landlab.grid.unstructured.base import point_to_point_vector
>>> point_to_point_vector((0, 0), (1, 2))
array([[1],
       [2]])
>>> point_to_point_vector([(0, 1), (0, 1)], (1, 2))
array([[1, 0],
       [2, 1]])
>>> point_to_point_vector([(0, 0, 0), (0, 1, 2)], [(1, 2, 2), (2, 4, 4)])
array([[1, 2, 2],
       [2, 3, 2]])

landlab.grid.unstructured.cells module

class CellGrid(vertices, vertices_per_cell, node_at_cell=None)

Bases: object

Parameters:

vertices : array-like

Vertex IDs at each grid cell

vertices_per_cell : array-like

Number of vertices per grid cell

Returns:

CellGrid :

A newly-created CellGrid

Examples

Create a grid of two cells where the first cell has four vertices and the second has three.

>>> from landlab.grid.unstructured.cells import CellGrid
>>> cgrid = CellGrid([0, 1, 3, 2, 1, 4, 3], [4, 3])
>>> cgrid.number_of_cells
2
>>> cgrid.number_of_vertices_at_cell(0)
4
>>> cgrid.number_of_vertices_at_cell(1)
3
>>> cgrid.vertices_at_cell(0)
array([0, 1, 3, 2])
>>> cgrid.vertices_at_cell(1)
array([1, 4, 3])

Associate nodes with each cell.

>>> cgrid = CellGrid([0, 1, 2, 3, 1, 3, 4], [4, 3], node_at_cell=[10, 11])
>>> cgrid.node_at_cell
array([10, 11])
>>> cgrid.cell_at_node[10]
0
>>> cgrid.cell_at_node[11]
1

cell_at_node

cell_id

iter()

Iterate over the cells of the grid.

Returns:

ndarray :

Nodes entering and leaving each node

node_at_cell

number_of_cells

number_of_vertices_at_cell(cell)

vertices_at_cell(cell)

vertices_at_cell_id(cell_id)

landlab.grid.unstructured.links module

class LinkGrid(link_ends, number_of_nodes, link_ids=None, node_status=None)

Bases: object

Create a grid of links that enter and leave nodes. __init__((node0, node1), number_of_nodes=None)

Parameters:

node0, node1 : sequence of array-like

Node ID at link start and end.

number_of_nodes : int, optional

Number of nodes in the grid

Returns:

LinkGrid :

A newly-created grid

Examples

>>> from landlab.grid.unstructured.links import LinkGrid
>>> lgrid = LinkGrid([(0, 1, 0, 2, 0), (2, 3, 1, 3, 3)], 4)
>>> lgrid.number_of_links
5
>>> lgrid.number_of_nodes
4
>>> lgrid.number_of_in_links_at_node(0)
0
>>> lgrid.number_of_out_links_at_node(0)
3
>>> lgrid.out_link_at_node(0)
array([0, 2, 4])
>>> lgrid.nodes_at_link_id(1)
array([1, 3])

>>> lgrid = LinkGrid([(0, 1, 0, 2, 0), (2, 3, 1, 3, 3)], 4,
...                  link_ids=range(1, 6))
>>> lgrid.nodes_at_link
array([[0, 2],
       [1, 3],
       [0, 1],
       [2, 3],
       [0, 3]])
>>> lgrid.out_link_at_node(0)
array([1, 3, 5])
>>> lgrid.nodes_at_link_id(1)
array([0, 2])

in_link_at_node(node)

Links entering a node.

Parameters:

node : int

Node ID

Returns:

ndarray :

Links entering the node

Examples

>>> from landlab.grid.unstructured.links import LinkGrid
>>> lgrid = LinkGrid([(0, 1, 0, 2), (2, 3, 1, 3)], 4)
>>> len(lgrid.in_link_at_node(0)) == 0
True
>>> lgrid.in_link_at_node(3)
array([1, 3])

iter_nodes()

Iterate of the nodes of the grid.

Returns:

ndarray :

Links entering and leaving each node

Examples

>>> from landlab.grid.unstructured.links import LinkGrid
>>> lgrid = LinkGrid([(0, 1, 0, 2), (2, 3, 1, 3)], 4)
>>> for link in lgrid.iter_nodes(): link
array([0, 2])
array([2, 1])
array([0, 3])
array([1, 3])

link_id

node_at_link_end

node_at_link_start

node_status_at_link_end

node_status_at_link_start

nodes_at_link

nodes_at_link_id(link_id)

number_of_in_links_at_node(node)

Number of links entering a node.

Parameters:

node : int

Node ID

Returns:

int :

Number of links entering the node.

Examples

>>> from landlab.grid.unstructured.links import LinkGrid
>>> lgrid = LinkGrid([(0, 1, 0, 2), (2, 3, 1, 3)], 4)
>>> [lgrid.number_of_in_links_at_node(node) for node in range(4)]
[0, 1, 1, 2]

number_of_links

Number of links in the grid.

number_of_links_at_node(node)

Number of links entering and leaving a node.

Parameters:

node : int

Node ID

Returns:

int :

Number of links entering and leaving the node.

Examples

>>> from landlab.grid.unstructured.links import LinkGrid
>>> lgrid = LinkGrid([(0, 1, 0, 2), (2, 3, 1, 3)], 4)
>>> [lgrid.number_of_links_at_node(node) for node in range(4)]
[2, 2, 2, 2]

number_of_nodes

Number of nodes in the grid.

number_of_out_links_at_node(node)

Number of links leaving a node.

Parameters:

node : int

Node ID

Returns:

int :

Number of links leaving the node.

Examples

>>> from landlab.grid.unstructured.links import LinkGrid
>>> lgrid = LinkGrid([(0, 1, 0, 2), (2, 3, 1, 3)], 4)
>>> [lgrid.number_of_out_links_at_node(node) for node in range(4)]
[2, 1, 1, 0]

out_link_at_node(node)

Links leaving a node.

Parameters:

node : int

Node ID

Returns:

ndarray :

Links leaving the node

Examples

>>> from landlab.grid.unstructured.links import LinkGrid
>>> lgrid = LinkGrid([(0, 1, 0, 2), (2, 3, 1, 3)], 4)
>>> lgrid.out_link_at_node(0)
array([0, 2])
>>> len(lgrid.out_link_at_node(3)) == 0
True

find_active_links(node_status, (node0, node1))

IDs of active links.

Parameters:

node_status : ndarray

Status of nodes.

node0, node1 : sequence of array-like

Node ID at link start and end.

Returns:

ndarray :

Links IDs of active links.

Examples

>>> from landlab.grid.unstructured.links import find_active_links
>>> links = [(0, 2), (1, 3), (0, 1), (1, 2), (0, 3)]
>>> status = np.array([0, 0, 0, 0])
>>> find_active_links(status, links)
array([0, 1, 2, 3, 4])

in_link_count_per_node((node0, node1), number_of_nodes=None)

Number of links entering nodes.

Parameters:

node0, node1 : sequence of array-like

Node ID at link start and end.

number_of_nodes : int, optional

Number of nodes in the grid

Returns:

ndarray :

Number of links entering nodes.

Examples

>>> from landlab.grid.unstructured.links import in_link_count_per_node
>>> link_ends = [(0, 3), (1, 4), (2, 5), (3, 6), (4, 7), (5, 8)]
>>> in_link_count_per_node(zip(*link_ends))
array([0, 0, 0, 1, 1, 1, 1, 1, 1])

in_link_ids_at_node((node0, node1), number_of_nodes=None)

Links entering nodes.

Parameters:

node0, node1 : sequence of array-like

Node ID at link start and end.

number_of_nodes : int, optional

Number of nodes in the grid

Returns:

tuple :

Tuple of link id array and offset into link id array.

Examples

>>> from landlab.grid.unstructured.links import in_link_ids_at_node
>>> (links, count) = in_link_ids_at_node(([0, 1, 2, 3, 4, 5],
...                                       [3, 4, 5, 6, 7, 8]))
>>> links
array([0, 1, 2, 3, 4, 5])
>>> count
array([0, 0, 0, 1, 1, 1, 1, 1, 1])

>>> (links, count) = in_link_ids_at_node(([0, 1, 2, 3, 4, 5],
...                                       [3, 4, 5, 6, 7, 8]),
...                                      link_ids=range(1, 7))
>>> links
array([1, 2, 3, 4, 5, 6])
>>> count
array([0, 0, 0, 1, 1, 1, 1, 1, 1])

link_count_per_node((node0, node1), number_of_nodes=None)

Number of links per node.

Parameters:

node0, node1 : sequence of array-like

Node ID at link start and end.

number_of_nodes : int, optional

Number of nodes in the grid

Returns:

ndarray :

Number of links per nodes.

Examples

>>> from landlab.grid.unstructured.links import link_count_per_node
>>> link_count_per_node(([0, 1, 2, 3, 4, 5], [3, 4, 5, 6, 7, 8]))
array([1, 1, 1, 2, 2, 2, 1, 1, 1])

link_ids_at_node((node0, node1), number_of_nodes=None)

Links entering and leaving nodes.

Parameters:

node0, node1 : sequence of array-like

Node ID at link start and end.

number_of_nodes : int, optional

Number of nodes in the grid

Returns:

tuple :

Tuple of link id array and offset into link id array.

Examples

>>> from landlab.grid.unstructured.links import link_ids_at_node
>>> (links, count) = link_ids_at_node(
...     ([0, 1, 2, 3, 4, 5], [3, 4, 5, 6, 7, 8]), number_of_nodes=9)
>>> links
array([0, 1, 2, 0, 3, 1, 4, 2, 5, 3, 4, 5])
>>> count
array([1, 1, 1, 2, 2, 2, 1, 1, 1])

link_is_active((status0, status1))

Check if a link is active.

Links are inactive if they connect two boundary nodes or touch a closed boundary. Otherwise, the link is active.

Parameters:

status0, status1 : sequence of array-like

Status at link start and end

Returns:

ndarray, boolean :

Boolean array that indicates if a link is active.

out_link_count_per_node((node0, node1), number_of_nodes=None)

Number of links leaving nodes.

Parameters:

node0, node1 : sequence of array-like

Node ID at link start and end.

number_of_nodes : int, optional

Number of nodes in the grid

Returns:

ndarray :

Number of links leaving nodes.

Examples

>>> from landlab.grid.unstructured.links import out_link_count_per_node
>>> out_link_count_per_node(([0, 1, 2, 3, 4, 5], [3, 4, 5, 6, 7, 8]))
array([1, 1, 1, 1, 1, 1])
>>> out_link_count_per_node(([0, 1, 2, 3, 4, 5], [3, 4, 5, 6, 7, 8]),
...     number_of_nodes=9)
array([1, 1, 1, 1, 1, 1, 0, 0, 0])

out_link_ids_at_node((node0, node1), number_of_nodes=None)

Links leaving nodes.

Parameters:

node0, node1 : sequence of array-like

Node ID at link start and end.

number_of_nodes : int, optional

Number of nodes in the grid

Returns:

tuple :

Tuple of link id array and offset into link id array.

Examples

>>> from landlab.grid.unstructured.links import out_link_ids_at_node
>>> (links, count) = out_link_ids_at_node(
...     ([0, 1, 2, 3, 4, 5], [3, 4, 5, 6, 7, 8]), link_ids=range(-1, 5),
...     number_of_nodes=9)
>>> links
array([-1,  0,  1,  2,  3,  4])
>>> count
array([1, 1, 1, 1, 1, 1, 0, 0, 0])

>>> (links, count) = out_link_ids_at_node(
...     ([0, 1, 2, 3, 4, 5], [3, 4, 5, 6, 7, 8]), number_of_nodes=9)
>>> links
array([0, 1, 2, 3, 4, 5])
>>> count
array([1, 1, 1, 1, 1, 1, 0, 0, 0])

landlab.grid.unstructured.nodes module

class NodeGrid((coord0, coord1))

Bases: object

Create a grid of nodes.

Parameters:

coord0, coord1 : sequence of array-like

Coordinates of grid nodes

Returns:

NodeGrid :

A newly-created NodeGrid

Examples

>>> from landlab.grid.unstructured.nodes import NodeGrid
>>> ngrid = NodeGrid(([0, 0, 1, 1], [0, 1, 0, 1]))
>>> ngrid.ndim == 2
True
>>> ngrid.number_of_nodes == 4
True
>>> ngrid.x
array([ 0.,  1.,  0.,  1.])
>>> ngrid.y
array([ 0.,  0.,  1.,  1.])

Create a 1D grid.

>>> ngrid = NodeGrid(((0, 1, 3), ))
>>> ngrid.ndim == 1
True
>>> ngrid.number_of_nodes
3
>>> ngrid.x
array([ 0.,  1.,  3.])
>>> ngrid.y
Traceback (most recent call last):
AttributeError: Grid has no y-coordinate

coord

Examples

>>> from landlab.grid.unstructured.nodes import NodeGrid
>>> ngrid = NodeGrid(([0, 0, 1], [0, 1, 0]))
>>> ngrid.coord[0]
array([ 0.,  0.,  1.])
>>> ngrid.coord[1]
array([ 0.,  1.,  0.])

ndim

number_of_nodes

Examples

>>> from landlab.grid.unstructured.nodes import NodeGrid
>>> ngrid = NodeGrid(([0, 0, 1], [0, 1, 0]))
>>> ngrid.number_of_nodes
3

point

Examples

>>> from landlab.grid.unstructured.nodes import NodeGrid
>>> ngrid = NodeGrid(([0, 0, 1], [0, 1, 0]))
>>> ngrid.point
array([[ 0.,  0.],
       [ 0.,  1.],
       [ 1.,  0.]])
>>> ngrid.point[1]
array([ 0.,  1.])

x

Node coordinates of the “fast” dimension.

Examples

>>> from landlab.grid.unstructured.nodes import NodeGrid
>>> ngrid = NodeGrid(([0, 0, 1], [0, 1, 0]))
>>> ngrid.x
array([ 0.,  1.,  0.])

y

Node y-coordinates.

Examples

>>> from landlab.grid.unstructured.nodes import NodeGrid
>>> ngrid = NodeGrid(([0, 0, 1], [0, 1, 0]))
>>> ngrid.y
array([ 0.,  0.,  1.])

z

Node z-coordinates.

Examples

>>> from landlab.grid.unstructured.nodes import NodeGrid
>>> ngrid = NodeGrid(([0, 0, 1], [0, 1, 0]))
>>> ngrid.y
array([ 0.,  0.,  1.])

landlab.grid.unstructured.status module

CLOSED_BOUNDARY = 4

Indicates a boundary node is closed

CORE_NODE = 0

Indicates a node is core.

FIXED_GRADIENT_BOUNDARY = 2

Indicates a boundary node is has a fixed gradient.

FIXED_VALUE_BOUNDARY = 1

Indicates a boundary node is has a fixed values.

LOOPED_BOUNDARY = 3

Indicates a boundary node is wrap-around.

class StatusGrid(node_status)

Bases: object

active_nodes()

Node IDs of all active (core & open boundary) nodes. core_nodes will return just core nodes.

boundary_nodes()

Node IDs of all boundary nodes.

closed_boundary_nodes()

Node id of all closed boundary nodes.

core_nodes()

Node IDs of all core nodes.

fixed_gradient_boundary_nodes()

Node id of all fixed gradient boundary nodes

fixed_value_boundary_nodes()

Node id of all fixed value boundary nodes

node_status

Status of nodes

Return an array of the status of a grid’s nodes. The node status can be one of the following: - CORE_NODE - FIXED_VALUE_BOUNDARY - FIXED_GRADIENT_BOUNDARY ` - `LOOPED_BOUNDARY - `CLOSED_BOUNDARY `

open_boundary_nodes()

Node id of all open boundary nodes.

Module contents