# General class methods and attributes of the landlab.grid.voronoi module¶

Landlab’s unstructured, irregular grids are implemented by the class VoronoiDelaunayGrid, which inherits from ModelGrid. This text lists grid methods available for the class:

# Getting Information about a Grid¶

The following attributes, properties, and methods provide data about the grid, its geometry, and the connectivity among the various elements. Each grid element has an ID number, which is also its position in an array that contains information about that type of element. For example, the x coordinate of node 5 would be found at grid.node_x[5].

The naming of grid-element arrays is attribute*_at_*element, where attribute is the name of the data in question, and element is the element to which the attribute applies. For example, the property node_at_cell contains the ID of the node associated with each cell. For example, node_at_cell[3] contains the node ID of the node associated with cell 3. The attribute is singular if there is only one value per element; for example, there is only one node associated with each cell. It is plural when there are multiple values per element; for example, the faces_at_cell array contains multiple faces for each cell. Exceptions to these general rules are functions that return indices of a subset of all elements of a particular type. For example, you can obtain an array with IDs of only the core nodes using core_nodes, while active_links provides an array of IDs of active links (only). Finally, attributes that represent a measurement of something, such as the length of a link or the surface area of a cell, are described using _of_, as in the example area_of_cell.

## Information about the grid as a whole¶

 axis_name Get the name of each coordinate axis. axis_units Get units for each axis. move_origin(origin) Changes the x, y values of all nodes. ndim Number of spatial dimensions of the grid. node_axis_coordinates(*args, **kwds) Get the coordinates of nodes along a particular axis. number_of_elements(name) Number of instances of an element. save(path[, clobber]) Save a grid and fields. size(group) Size of the arrays stored in a group.

 area_of_cell Get areas of grid cells. cell_area_at_node Cell areas in a nnodes-long array. cell_at_node Node ID associated with grid cells. core_cells Get array of core cells. faces_at_cell Return array containing face IDs at each cell. node_at_cell Node ID associated with grid cells. node_at_core_cell Get array of nodes associated with core cells. number_of_cells Total number of cells. number_of_core_cells Number of core cells. number_of_faces_at_cell() Number of faces attached to each cell. x_of_cell Get array of the x-coordinates of nodes at cells. y_of_cell Get array of the y-coordinates of nodes at cells.

 active_faces Get array of active faces. face_at_link Get array of faces associated with links. faces_at_cell Return array containing face IDs at each cell. link_at_face Get links associated with faces. number_of_active_faces Total number of active faces. number_of_faces Total number of faces. number_of_faces_at_cell() Number of faces attached to each cell. width_of_face Width of grid faces. x_of_face Get array of the x-coordinates of face midpoints. y_of_face Get array of the y-coordinates of face midpoints.

 links_at_patch Returns the links forming each patch. nodes_at_patch Get the four nodes at the corners of each patch in a regular grid. number_of_patches Number of patches. number_of_patches_present_at_link Return the number of patches at a link without a closed node. number_of_patches_present_at_node Return the number of patches at a node without a closed node. patches_at_link Returns the patches adjoined to each link. patches_at_node Return a (nnodes, max_voronoi_polygon_sides) array of patches at nodes. patches_present_at_link A boolean array, False where a patch has a closed node or is missing. patches_present_at_node A boolean array, False where a patch has a closed node or is missing.

 number_of_corners Total number of corners.

# Data Fields in ModelGrid¶

ModelGrid inherits from the ModelDataFields class. This provides ~.ModelGrid, and its subclasses, with the ability to, optionally, store data values that are associated with the different types grid elements (nodes, cells, etc.). In particular, as part of ModelGrid.__init__(), data field groups are added to the ModelGrid that provide containers to put data fields into. There is one group for each of the eight grid elements (node, cell, link, face, core_node, core_cell, active_link, and active_face).

To access these groups, use the same methods as accessing groups with ~.ModelDataFields. ModelGrid.__init__() adds the following attributes to itself that provide access to the values groups:

 at_node at_cell at_link at_face at_patch at_corner

Each of these attributes returns a dict-like object whose keys are value names as strings and values are numpy arrays that gives quantities at grid elements.

## Create Field Arrays¶

ModelGrid inherits several useful methods for creating new data fields and adding new data fields to a ModelGrid instance. Methods to add or create a new data array follow the numpy syntax for creating arrays. The folowing methods create and, optionally, initialize new arrays. These arrays are of the correct size but a new field will not be added to the field:

 empty Uninitialized array whose size is that of the field. ones Array, initialized to 1, whose size is that of the field. zeros Array, initialized to 0, whose size is that of the field.

## Add Fields to a ModelGrid¶

Unlike with the equivalent numpy functions, these do not take a size argument as the size of the returned arrays is determined from the size of the ModelGrid. However, the keyword arguments are the same as those of the numpy equivalents.

The following methods will create a new array and add a reference to that array to the ModelGrid:

 add_empty Create and add an uninitialized array of values to the field. add_field Add an array of values to the field. add_ones Create and add an array of values, initialized to 1, to the field. add_zeros Create and add an array of values, initialized to 0, to the field. delete_field Erases an existing field. set_units Set the units for a field of values.

These methods operate in the same way as the previous set except that, in addition to creating a new array, the newly-created array is added to the ModelGrid. The calling signature is the same but with the addition of an argument that gives the name of the new field as a string. The additional method, add_field(), adds a previously allocation array to the ModelGrid. If the array is of the incorrect size it will raise ValueError.

## Query Fields¶

Use the following methods/attributes get information about the stored data fields:

 size Size of the arrays stored in a group. keys List of field names in a group. has_group Check if a group exists. has_field Check if a field is in a group. field_units Get units for a field. field_values Get values of a field. groups List of group names.

i.e., call, e.g. mg.has_field(‘node’, ‘my_field_name’)

# Gradients, fluxes, and divergences on the grid¶

Landlab is designed to easily calculate gradients in quantities across the grid, and to construct fluxes and flux divergences from them. Because these calculations tend to be a little more involved than property lookups, the methods tend to start with calc_.

# Mappers¶

These methods allow mapping of values defined on one grid element type onto a second, e.g., mapping upwind node values onto links, or mean link values onto nodes.

# Boundary condition control¶

These are the primary properties for getting and setting the grid boundary conditions. Changes made to status_at_node() and status_at_node() will automatically update the conditions defined at other grid elements automatically.

# Identifying node subsets¶

These methods are useful in identifying subsets of nodes, e.g., closest node to a point; nodes at edges.

(None are available for this grid type)

# Surface analysis¶

These methods permit the kinds of surface analysis that you might expect to find in GIS software.

 calc_aspect_at_node(grid[, …]) Get array of aspect of a surface. calc_hillshade_at_node([alt, az, slp, asp, …]) Get array of hillshade. calc_slope_at_node(grid[, elevs, method, …]) Array of slopes at nodes, averaged over neighboring patches.

# Notes¶

It is important that when creating a new grid class that inherits from ModelGrid, to call ModelGrid.__init__() in the new grid’s __init__(). For example, the new class’s __init__ should contain the following code,

class NewGrid(ModelGrid):
def __init__(self, *args, **kwds):
ModelGrid.__init__(self, **kwds)
# Code that initializes the NewGrid

Without this, the new grid class will not have the at_* attributes.