Discrete Space#

Cell spaces for active, property-rich spatial modeling in Mesa.

Cell spaces extend Mesa’s spatial modeling capabilities by making the space itself active - each position (cell) can have properties and behaviors rather than just containing agents. This enables more sophisticated environmental modeling and agent-environment interactions.

Key components: - Cells: Active positions that can have properties and contain agents - CellAgents: Agents that understand how to interact with cells - Spaces: Different cell organization patterns (grids, networks, etc.) - PropertyLayers: Efficient property storage and manipulation

This is particularly useful for models where the environment plays an active role, like resource growth, pollution diffusion, or infrastructure networks. The cell space system is experimental and under active development.

class Cell(coordinate: tuple[int, ...], capacity: int | None = None, random: Random | None = None)[source]#

The cell represents a position in a discrete space.

coordinate#

the position of the cell in the discrete space

Type:: Tuple[int, int]

agents#

the agents occupying the cell

Type:: List[Agent]

capacity#

the maximum number of agents that can simultaneously occupy the cell

Type:: int

random#

the random number generator

Type:: Random

Initialise the cell.

Parameters:

coordinate – coordinates of the cell
capacity (int) – the capacity of the cell. If None, the capacity is infinite
random (Random) – the random number generator to use

add_agent(agent: CellAgent) → None[source]#

Adds an agent to the cell.

Parameters:: agent (CellAgent) – agent to add to this Cell

property agents: list[CellAgent]#: Returns a list of the agents occupying the cell.

connect(other: Cell, key: tuple[int, ...] | None = None) → None[source]#

Connects this cell to another cell.

Parameters:

other (Cell) – other cell to connect to
key (Tuple[int, ...]) – key for the connection. Should resemble a relative coordinate

disconnect(other: Cell) → None[source]#

Disconnects this cell from another cell.

Parameters:: other (Cell) – other cell to remove from connections

get_neighborhood(radius: int = 1, include_center: bool = False) → CellCollection[Cell][source]#

Returns a list of all neighboring cells for the given radius.

For getting the direct neighborhood (i.e., radius=1) you can also use the neighborhood property.

Parameters:

radius (int) – the radius of the neighborhood
include_center (bool) – include the center of the neighborhood

Returns:

a list of all neighboring cells

property is_empty: bool#: Returns a bool of the contents of a cell.

property is_full: bool#: Returns a bool of the contents of a cell.

property neighborhood: CellCollection[Cell][source]#

Returns the direct neighborhood of the cell.

This is equivalent to cell.get_neighborhood(radius=1)

remove_agent(agent: CellAgent) → None[source]#

Removes an agent from the cell.

Parameters:: agent (CellAgent) – agent to remove from this cell

class CellAgent(model: Model, *args, **kwargs)[source]#

Cell Agent is an extension of the Agent class and adds behavior for moving in discrete spaces.

cell#

The cell the agent is currently in.

Type:: Cell

Create a new agent.

Parameters:

model (Model) – The model instance in which the agent exists.
args – Passed on to super.
kwargs – Passed on to super.

Notes

to make proper use of python’s super, in each class remove the arguments and keyword arguments you need and pass on the rest to super

remove()[source]#: Remove the agent from the model.

class CellCollection(cells: Mapping[T, list[CellAgent]] | Iterable[T], random: Random | None = None)[source]#

An immutable collection of cells.

cells[source]#

The list of cells this collection represents

Type:: List[Cell]

agents#

List of agents occupying the cells in this collection

Type:: List[CellAgent]

random#

The random number generator

Type:: Random

Notes

A UserWarning is issued if random=None. You can resolve this warning by explicitly passing a random number generator. In most cases, this will be the seeded random number generator in the model. So, you would do random=self.random in a Model or Agent instance.

Initialize a CellCollection.

Parameters:

cells – cells to add to the collection
random – a seeded random number generator.

select(filter_func: Callable[[T], bool] | None = None, at_most: int | float = inf)[source]#

Select cells based on filter function.

Parameters:

filter_func – filter function
at_most – The maximum amount of cells to select. Defaults to infinity. - If an integer, at most the first number of matching cells is selected. - If a float between 0 and 1, at most that fraction of original number of cells

Returns:

CellCollection

select_random_agent() → CellAgent[source]#

Select a random agent.

Returns:: CellAgent instance

select_random_cell() → T[source]#: Select a random cell.

class DiscreteSpace(capacity: int | None = None, cell_klass: type[~mesa.discrete_space.discrete_space.T] = <class 'mesa.discrete_space.cell.Cell'>, random: ~random.Random | None = None)[source]#

Base class for all discrete spaces.

capacity#

The capacity of the cells in the discrete space

Type:: int

all_cells[source]#

The cells composing the discrete space

Type:: CellCollection

random#

The random number generator

Type:: Random

cell_klass#

the type of cell class

Type:: Type

empties#

collection of all cells that are empty

Type:: CellCollection

property_layers#

the property layers of the discrete space

Type:: dict[str, PropertyLayer]

Notes

Instantiate a DiscreteSpace.

Parameters:

capacity – capacity of cells
cell_klass – base class for all cells
random – random number generator

add_cell(cell: T)[source]#

Add a cell to the space.

Parameters:: cell – cell to add

Note

Discrete spaces rely on caching neighborhood relations for speedups. Adding or removing cells and connections at runtime is possible. However, only the caches of cells directly affected will be cleared. So if you rely on getting neighborhoods of cells with a radius higher than 1, these might not be cleared correctly if you are adding or removing cells and connections at runtime.

add_connection(cell1: T, cell2: T)[source]#: Add a connection between the two cells.

Note

Discrete spaces rely on caching neighborhood relations for speedups. Adding or removing cells and connections at runtime is possible. However, only the caches of cells directly affected will be cleared. So if you rely on getting neighborhoods of cells with a radius higher than 1, these might not be cleared correctly if you are adding or removing cells and connections at runtime.

property agents: AgentSet#: Return an AgentSet with the agents in the space.

property all_cells[source]#: Return all cells in space.

property empties: CellCollection[T]#: Return all empty in spaces.

remove_cell(cell: T)[source]#: Remove a cell from the space.

Note

Discrete spaces rely on caching neighborhood relations for speedups. Adding or removing cells and connections at runtime is possible. However, only the caches of cells directly affected will be cleared. So if you rely on getting neighborhoods of cells with a radius higher than 1, these might not be cleared correctly if you are adding or removing cells and connections at runtime.

remove_connection(cell1: T, cell2: T)[source]#: Remove a connection between the two cells.

Note

Discrete spaces rely on caching neighborhood relations for speedups. Adding or removing cells and connections at runtime is possible. However, only the caches of cells directly affected will be cleared. So if you rely on getting neighborhoods of cells with a radius higher than 1, these might not be cleared correctly if you are adding or removing cells and connections at runtime.

select_random_empty_cell() → T[source]#: Select random empty cell.

class FixedAgent(model: Model, *args, **kwargs)[source]#

A patch in a 2D grid.

Create a new agent.

Parameters:

model (Model) – The model instance in which the agent exists.
args – Passed on to super.
kwargs – Passed on to super.

Notes

to make proper use of python’s super, in each class remove the arguments and keyword arguments you need and pass on the rest to super

remove()[source]#: Remove the agent from the model.

class Grid(dimensions: ~collections.abc.Sequence[int], torus: bool = False, capacity: float | None = None, random: ~random.Random | None = None, cell_klass: type[~mesa.discrete_space.grid.T] = <class 'mesa.discrete_space.cell.Cell'>)[source]#

Base class for all grid classes.

dimensions#

the dimensions of the grid

Type:: Sequence[int]

torus#

whether the grid is a torus

Type:: bool

capacity#

the capacity of a grid cell

Type:: int

random#

the random number generator

Type:: Random

_try_random#

whether to get empty cell be repeatedly trying random cell

Type:: bool

Notes

width and height are accessible via properties, higher dimensions can be retrieved via dimensions

Initialise the grid class.

Parameters:

dimensions – the dimensions of the space
torus – whether the space wraps
capacity – capacity of the grid cell
random – a random number generator
cell_klass – the base class to use for the cells

property height: int#: Convenience access to the height of the grid.

select_random_empty_cell() → T[source]#: Select random empty cell.

property width: int#: Convenience access to the width of the grid.

class Grid2DMovingAgent(model: Model, *args, **kwargs)[source]#

Mixin for moving agents in 2D grids.

Create a new agent.

Parameters:

model (Model) – The model instance in which the agent exists.
args – Passed on to super.
kwargs – Passed on to super.

Notes

to make proper use of python’s super, in each class remove the arguments and keyword arguments you need and pass on the rest to super

move(direction: str, distance: int = 1)[source]#

Move the agent in a cardinal direction.

Parameters:

direction – The cardinal direction to move in.
distance – The distance to move.

class HexGrid(dimensions: ~collections.abc.Sequence[int], torus: bool = False, capacity: float | None = None, random: ~random.Random | None = None, cell_klass: type[~mesa.discrete_space.grid.T] = <class 'mesa.discrete_space.cell.Cell'>)[source]#

A Grid with hexagonal tilling of the space.

Initialise the grid class.

Parameters:

dimensions – the dimensions of the space
torus – whether the space wraps
capacity – capacity of the grid cell
random – a random number generator
cell_klass – the base class to use for the cells

class Network(G: ~typing.Any, capacity: int | None = None, random: ~random.Random | None = None, cell_klass: type[~mesa.discrete_space.cell.Cell] = <class 'mesa.discrete_space.cell.Cell'>)[source]#

A networked discrete space.

A Networked grid.

Parameters:

G – a NetworkX Graph instance.
capacity (int) – the capacity of the cell
random (Random) – a random number generator
cell_klass (type[Cell]) – The base Cell class to use in the Network

add_cell(cell: Cell)[source]#: Add a cell to the space.

add_connection(cell1: Cell, cell2: Cell)[source]#: Add a connection between the two cells.

remove_cell(cell: Cell)[source]#: Remove a cell from the space.

remove_connection(cell1: Cell, cell2: Cell)[source]#: Remove a connection between the two cells.

class OrthogonalMooreGrid(dimensions: ~collections.abc.Sequence[int], torus: bool = False, capacity: float | None = None, random: ~random.Random | None = None, cell_klass: type[~mesa.discrete_space.grid.T] = <class 'mesa.discrete_space.cell.Cell'>)[source]#

Grid where cells are connected to their 8 neighbors.

Example for two dimensions: directions = [

(-1, -1), (-1, 0), (-1, 1), ( 0, -1), ( 0, 1), ( 1, -1), ( 1, 0), ( 1, 1),

]

Initialise the grid class.

Parameters:

dimensions – the dimensions of the space
torus – whether the space wraps
capacity – capacity of the grid cell
random – a random number generator
cell_klass – the base class to use for the cells

class OrthogonalVonNeumannGrid(dimensions: ~collections.abc.Sequence[int], torus: bool = False, capacity: float | None = None, random: ~random.Random | None = None, cell_klass: type[~mesa.discrete_space.grid.T] = <class 'mesa.discrete_space.cell.Cell'>)[source]#

Grid where cells are connected to their 4 neighbors.

Example for two dimensions: directions = [

(0, -1),

(-1, 0), ( 1, 0),
(0, 1),

]

Initialise the grid class.

Parameters:

dimensions – the dimensions of the space
torus – whether the space wraps
capacity – capacity of the grid cell
random – a random number generator
cell_klass – the base class to use for the cells

class PropertyLayer(name: str, dimensions: ~collections.abc.Sequence[int], default_value=0.0, dtype=<class 'float'>)[source]#

A class representing a layer of properties in a two-dimensional grid.

Each cell in the grid can store a value of a specified data type.

name#: The name of the property layer.

dimensions#: The width of the grid (number of columns).

data#: A NumPy array representing the grid data.

Initializes a new PropertyLayer instance.

Parameters:

name – The name of the property layer.
dimensions – the dimensions of the property layer.
default_value – The default value to initialize each cell in the grid. Should ideally be of the same type as specified by the dtype parameter.
dtype (data-type, optional) – The desired data-type for the grid’s elements. Default is float.

Notes

A UserWarning is raised if the default_value is not of a type compatible with dtype. The dtype parameter can accept both Python data types (like bool, int or float) and NumPy data types (like np.int64 or np.float64).

aggregate(operation: Callable)[source]#

Perform an aggregate operation (e.g., sum, mean) on a property across all cells.

Parameters:: operation – A function to apply. Can be a lambda function or a NumPy ufunc.

classmethod from_data(name: str, data: ndarray)[source]#

Create a property layer from a NumPy array.

Parameters:

name – The name of the property layer.
data – A NumPy array representing the grid data.

modify_cells(operation: Callable, value=None, condition: Callable | None = None)[source]#

Modify cells using an operation, which can be a lambda function or a NumPy ufunc.

If a NumPy ufunc is used, an additional value should be provided.

Parameters:

operation – A function to apply. Can be a lambda function or a NumPy ufunc.
value – The value to be used if the operation is a NumPy ufunc. Ignored for lambda functions.
condition – (Optional) A callable that returns a boolean array when applied to the data.

select_cells(condition: Callable, return_list=True)[source]#

Find cells that meet a specified condition using NumPy’s boolean indexing, in-place.

Parameters:

condition – A callable that returns a boolean array when applied to the data.
return_list – (Optional) If True, return a list of (x, y) tuples. Otherwise, return a boolean array.

Returns:

A list of (x, y) tuples or a boolean array.

set_cells(value, condition: Callable | None = None)[source]#

Perform a batch update either on the entire grid or conditionally, in-place.

Parameters:

value – The value to be used for the update.
condition – (Optional) A callable that returns a boolean array when applied to the data.

class VoronoiGrid(centroids_coordinates: ~collections.abc.Sequence[~collections.abc.Sequence[float]], capacity: float | None = None, random: ~random.Random | None = None, cell_klass: type[~mesa.discrete_space.cell.Cell] = <class 'mesa.discrete_space.cell.Cell'>, capacity_function: callable = <function round_float>)[source]#

Voronoi meshed GridSpace.

A Voronoi Tessellation Grid.

Given a set of points, this class creates a grid where a cell is centered in each point, its neighbors are given by Voronoi Tessellation cells neighbors and the capacity by the polygon area.

Parameters:

centroids_coordinates – coordinates of centroids to build the tessellation space
capacity (int) – capacity of the cells in the discrete space
random (Random) – random number generator
cell_klass (type[Cell]) – type of cell class
capacity_function (Callable) – function to compute (int) capacity according to (float) area

Cells are positions in space that can have properties and contain agents.

A cell represents a location that can: - Have properties (like temperature or resources) - Track and limit the agents it contains - Connect to neighboring cells - Provide neighborhood information

Cells form the foundation of the cell space system, enabling rich spatial environments where both location properties and agent behaviors matter. They’re useful for modeling things like varying terrain, infrastructure capacity, or environmental conditions.

class Cell(coordinate: tuple[int, ...], capacity: int | None = None, random: Random | None = None)[source]#

The cell represents a position in a discrete space.

coordinate#

the position of the cell in the discrete space

Type:: Tuple[int, int]

agents#

the agents occupying the cell

Type:: List[Agent]

capacity#

the maximum number of agents that can simultaneously occupy the cell

Type:: int

random#

the random number generator

Type:: Random

Initialise the cell.

Parameters:

coordinate – coordinates of the cell
capacity (int) – the capacity of the cell. If None, the capacity is infinite
random (Random) – the random number generator to use

connect(other: Cell, key: tuple[int, ...] | None = None) → None[source]#

Connects this cell to another cell.

Parameters:

other (Cell) – other cell to connect to
key (Tuple[int, ...]) – key for the connection. Should resemble a relative coordinate

disconnect(other: Cell) → None[source]#

Disconnects this cell from another cell.

Parameters:: other (Cell) – other cell to remove from connections

add_agent(agent: CellAgent) → None[source]#

Adds an agent to the cell.

Parameters:: agent (CellAgent) – agent to add to this Cell

remove_agent(agent: CellAgent) → None[source]#

Removes an agent from the cell.

Parameters:: agent (CellAgent) – agent to remove from this cell

property is_empty: bool#: Returns a bool of the contents of a cell.

property is_full: bool#: Returns a bool of the contents of a cell.

property agents: list[CellAgent]#: Returns a list of the agents occupying the cell.

property neighborhood: CellCollection[Cell][source]#

Returns the direct neighborhood of the cell.

This is equivalent to cell.get_neighborhood(radius=1)

get_neighborhood(radius: int = 1, include_center: bool = False) → CellCollection[Cell][source]#

Returns a list of all neighboring cells for the given radius.

For getting the direct neighborhood (i.e., radius=1) you can also use the neighborhood property.

Parameters:

radius (int) – the radius of the neighborhood
include_center (bool) – include the center of the neighborhood

Returns:

a list of all neighboring cells

Agents that understand how to exist in and move through cell spaces.

Provides specialized agent classes that handle cell occupation, movement, and proper registration: - CellAgent: Mobile agents that can move between cells - FixedAgent: Immobile agents permanently fixed to cells - Grid2DMovingAgent: Agents with grid-specific movement capabilities

These classes ensure consistent agent-cell relationships and proper state management as agents move through the space. They can be used directly or as examples for creating custom cell-aware agents.

class HasCellProtocol(*args, **kwargs)[source]#: Protocol for discrete space cell holders.

class HasCell[source]#: Descriptor for cell movement behavior.

class BasicMovement[source]#

Mixin for moving agents in discrete space.

move_to(cell: Cell) → None[source]#: Move to a new cell.

move_relative(direction: tuple[int, ...])[source]#

Move to a cell relative to the current cell.

Parameters:: direction – The direction to move in.

class FixedCell[source]#: Mixin for agents that are fixed to a cell.

class CellAgent(model: Model, *args, **kwargs)[source]#

Cell Agent is an extension of the Agent class and adds behavior for moving in discrete spaces.

cell#

The cell the agent is currently in.

Type:: Cell

Create a new agent.

Parameters:

model (Model) – The model instance in which the agent exists.
args – Passed on to super.
kwargs – Passed on to super.

Notes

to make proper use of python’s super, in each class remove the arguments and keyword arguments you need and pass on the rest to super

remove()[source]#: Remove the agent from the model.

class FixedAgent(model: Model, *args, **kwargs)[source]#

A patch in a 2D grid.

Create a new agent.

Parameters:

model (Model) – The model instance in which the agent exists.
args – Passed on to super.
kwargs – Passed on to super.

Notes

to make proper use of python’s super, in each class remove the arguments and keyword arguments you need and pass on the rest to super

remove()[source]#: Remove the agent from the model.

class Grid2DMovingAgent(model: Model, *args, **kwargs)[source]#

Mixin for moving agents in 2D grids.

Create a new agent.

Parameters:

model (Model) – The model instance in which the agent exists.
args – Passed on to super.
kwargs – Passed on to super.

Notes

to make proper use of python’s super, in each class remove the arguments and keyword arguments you need and pass on the rest to super

move(direction: str, distance: int = 1)[source]#

Move the agent in a cardinal direction.

Parameters:

direction – The cardinal direction to move in.
distance – The distance to move.

Collection class for managing and querying groups of cells.

The CellCollection class provides a consistent interface for operating on multiple cells, supporting: - Filtering and selecting cells based on conditions - Random cell and agent selection - Access to contained agents - Group operations

This is useful for implementing area effects, zones, or any operation that needs to work with multiple cells as a unit. The collection handles efficient iteration and agent access across cells. The class is used throughout the cell space implementation to represent neighborhoods, selections, and other cell groupings.

class CellCollection(cells: Mapping[T, list[CellAgent]] | Iterable[T], random: Random | None = None)[source]#

An immutable collection of cells.

cells[source]#

The list of cells this collection represents

Type:: List[Cell]

agents#

List of agents occupying the cells in this collection

Type:: List[CellAgent]

random#

The random number generator

Type:: Random

Notes

Initialize a CellCollection.

Parameters:

cells – cells to add to the collection
random – a seeded random number generator.

select_random_cell() → T[source]#: Select a random cell.

select_random_agent() → CellAgent[source]#

Select a random agent.

Returns:: CellAgent instance

select(filter_func: Callable[[T], bool] | None = None, at_most: int | float = inf)[source]#

Select cells based on filter function.

Parameters:

filter_func – filter function
at_most – The maximum amount of cells to select. Defaults to infinity. - If an integer, at most the first number of matching cells is selected. - If a float between 0 and 1, at most that fraction of original number of cells

Returns:

CellCollection

Base class for building cell-based spatial environments.

DiscreteSpace provides the core functionality needed by all cell-based spaces: - Cell creation and tracking - Agent-cell relationship management - Property layer support - Random selection capabilities - Capacity management

This serves as the foundation for specific space implementations like grids and networks, ensuring consistent behavior and shared functionality across different space types. All concrete cell space implementations (grids, networks, etc.) inherit from this class.

Base class for all discrete spaces.

capacity#

The capacity of the cells in the discrete space

Type:: int

all_cells[source]#

The cells composing the discrete space

Type:: CellCollection

random#

The random number generator

Type:: Random

cell_klass#

the type of cell class

Type:: Type

empties#

collection of all cells that are empty

Type:: CellCollection

property_layers#

the property layers of the discrete space

Type:: dict[str, PropertyLayer]

Notes

Instantiate a DiscreteSpace.

Parameters:

capacity – capacity of cells
cell_klass – base class for all cells
random – random number generator

property agents: AgentSet#: Return an AgentSet with the agents in the space.

add_cell(cell: T)[source]#

Add a cell to the space.

Parameters:: cell – cell to add

Note

remove_cell(cell: T)[source]#: Remove a cell from the space.

Note

Discrete spaces rely on caching neighborhood relations for speedups. Adding or removing cells and connections at runtime is possible. However, only the caches of cells directly affected will be cleared. So if you rely on getting neighborhoods of cells with a radius higher than 1, these might not be cleared correctly if you are adding or removing cells and connections at runtime.

add_connection(cell1: T, cell2: T)[source]#: Add a connection between the two cells.

Note

Discrete spaces rely on caching neighborhood relations for speedups. Adding or removing cells and connections at runtime is possible. However, only the caches of cells directly affected will be cleared. So if you rely on getting neighborhoods of cells with a radius higher than 1, these might not be cleared correctly if you are adding or removing cells and connections at runtime.

remove_connection(cell1: T, cell2: T)[source]#: Remove a connection between the two cells.

Note

Discrete spaces rely on caching neighborhood relations for speedups. Adding or removing cells and connections at runtime is possible. However, only the caches of cells directly affected will be cleared. So if you rely on getting neighborhoods of cells with a radius higher than 1, these might not be cleared correctly if you are adding or removing cells and connections at runtime.

property all_cells[source]#: Return all cells in space.

property empties: CellCollection[T]#: Return all empty in spaces.

select_random_empty_cell() → T[source]#: Select random empty cell.

Grid-based cell space implementations with different connection patterns.

Provides several grid types for organizing cells: - OrthogonalMooreGrid: 8 neighbors in 2D, (3^n)-1 in nD - OrthogonalVonNeumannGrid: 4 neighbors in 2D, 2n in nD - HexGrid: 6 neighbors in hexagonal pattern (2D only)

Each grid type supports optional wrapping (torus) and cell capacity limits. Choose based on how movement and connectivity should work in your model - Moore for unrestricted movement, Von Neumann for orthogonal-only movement, or Hex for more uniform distances.

pickle_gridcell(obj)[source]#: Helper function for pickling GridCell instances.

unpickle_gridcell(parent, fields)[source]#: Helper function for unpickling GridCell instances.

Base class for all grid classes.

dimensions#

the dimensions of the grid

Type:: Sequence[int]

torus#

whether the grid is a torus

Type:: bool

capacity#

the capacity of a grid cell

Type:: int

random#

the random number generator

Type:: Random

_try_random#

whether to get empty cell be repeatedly trying random cell

Type:: bool

Notes

width and height are accessible via properties, higher dimensions can be retrieved via dimensions

Initialise the grid class.

Parameters:

dimensions – the dimensions of the space
torus – whether the space wraps
capacity – capacity of the grid cell
random – a random number generator
cell_klass – the base class to use for the cells

property width: int#: Convenience access to the width of the grid.

property height: int#: Convenience access to the height of the grid.

select_random_empty_cell() → T[source]#: Select random empty cell.

Grid where cells are connected to their 8 neighbors.

Example for two dimensions: directions = [

(-1, -1), (-1, 0), (-1, 1), ( 0, -1), ( 0, 1), ( 1, -1), ( 1, 0), ( 1, 1),

]

Initialise the grid class.

Parameters:

dimensions – the dimensions of the space
torus – whether the space wraps
capacity – capacity of the grid cell
random – a random number generator
cell_klass – the base class to use for the cells

Grid where cells are connected to their 4 neighbors.

Example for two dimensions: directions = [

(0, -1),

(-1, 0), ( 1, 0),
(0, 1),

]

Initialise the grid class.

Parameters:

dimensions – the dimensions of the space
torus – whether the space wraps
capacity – capacity of the grid cell
random – a random number generator
cell_klass – the base class to use for the cells

A Grid with hexagonal tilling of the space.

Initialise the grid class.

Parameters:

dimensions – the dimensions of the space
torus – whether the space wraps
capacity – capacity of the grid cell
random – a random number generator
cell_klass – the base class to use for the cells

Network-based cell space using arbitrary connection patterns.

Creates spaces where cells connect based on network relationships rather than spatial proximity. Built on NetworkX graphs, this enables: - Arbitrary connectivity patterns between cells - Graph-based neighborhood definitions - Logical rather than physical distances - Dynamic connectivity changes - Integration with NetworkX’s graph algorithms

Useful for modeling systems like social networks, transportation systems, or any environment where connectivity matters more than physical location.

A networked discrete space.

A Networked grid.

Parameters:

G – a NetworkX Graph instance.
capacity (int) – the capacity of the cell
random (Random) – a random number generator
cell_klass (type[Cell]) – The base Cell class to use in the Network

add_cell(cell: Cell)[source]#: Add a cell to the space.

remove_cell(cell: Cell)[source]#: Remove a cell from the space.

add_connection(cell1: Cell, cell2: Cell)[source]#: Add a connection between the two cells.

remove_connection(cell1: Cell, cell2: Cell)[source]#: Remove a connection between the two cells.

Cell spaces based on Voronoi tessellation around seed points.

Creates irregular spatial divisions by building cells around seed points, where each cell contains the area closer to its seed than any other. Features: - Organic-looking spaces from point sets - Automatic neighbor determination - Area-based cell capacities - Natural regional divisions

Useful for models requiring irregular but mathematically meaningful spatial divisions, like territories, service areas, or natural regions.

class Delaunay(center: tuple = (0, 0), radius: int = 9999)[source]#

Class to compute a Delaunay triangulation in 2D.

ref: jmespadero/pyDelaunay2D

Init and create a new frame to contain the triangulation.

Parameters:

center – Optional position for the center of the frame. Default (0,0)
radius – Optional distance from corners to the center.

add_point(point: Sequence) → None[source]#: Add a point to the current DT, and refine it using Bowyer-Watson.

export_triangles() → list[source]#: Export the current list of Delaunay triangles.

export_voronoi_regions()[source]#: Export coordinates and regions of Voronoi diagram as indexed data.

Voronoi meshed GridSpace.

A Voronoi Tessellation Grid.

Given a set of points, this class creates a grid where a cell is centered in each point, its neighbors are given by Voronoi Tessellation cells neighbors and the capacity by the polygon area.

Parameters:

centroids_coordinates – coordinates of centroids to build the tessellation space
capacity (int) – capacity of the cells in the discrete space
random (Random) – random number generator
cell_klass (type[Cell]) – type of cell class
capacity_function (Callable) – function to compute (int) capacity according to (float) area

Discrete Space#

This Page