landlab.core.model¶

Base class and runner for a grid-based Landlab model.

Model authors subclass Model and implement update to advance their components by a supplied time step. The base class constructs the grid and clock, while ModelRunner advances time and runs scheduled output events.

The following landscape-evolution model combines uniform uplift, stream-power erosion, and linear hillslope diffusion:

(Greg Tucker, University of Colorado Boulder)

Examples

>>> import numpy as np
>>> from landlab.components import FlowAccumulator
>>> from landlab.components import LinearDiffuser
>>> from landlab.components import StreamPowerEroder
>>> from landlab.core.model import Model

>>> class LandscapeEvolutionModel(Model):
...     DEFAULT_PARAMS = {
...         "grid": {
...             "source": "create",
...             "create_grid": {
...                 "RasterModelGrid": {
...                     "shape": (5, 5),
...                     "xy_spacing": 1.0,
...                 },
...             },
...         },
...     }
...
...     def __init__(self, grid, *, clock, params):
...         super().__init__(grid, clock=clock, params=params)
...         rng = np.random.default_rng()
...         elevation = grid.add_zeros("topographic__elevation", at="node")
...         elevation[grid.core_nodes] = rng.uniform(size=len(grid.core_nodes))
...
...         self._uplift_rate = params["model"]["parameters"]["uplift_rate"]
...         self._flow_accumulator = FlowAccumulator(
...             grid, **params["model"]["components"]["flow_accumulator"]
...         )
...         self._flow_accumulator.run_one_step()
...         self._eroder = StreamPowerEroder(
...             grid, **params["model"]["components"]["eroder"]
...         )
...         self._diffuser = LinearDiffuser(
...             grid, **params["model"]["components"]["diffuser"]
...         )
...
...     def update(self, dt):
...         elevation = self.grid.at_node["topographic__elevation"]
...         elevation[self.grid.core_nodes] += self._uplift_rate * dt
...         self._diffuser.run_one_step(dt)
...         self._flow_accumulator.run_one_step()
...         self._eroder.run_one_step(dt)
...
...     def report(self, current_time):
...         print(f"model time: {current_time:g}")
...

>>> model = LandscapeEvolutionModel.from_params(
...     {
...         "clock": {"start": 0.0, "stop": 2.0, "step": 1.0},
...         "model": {
...             "parameters": {"uplift_rate": 0.001},
...             "components": {
...                 "flow_accumulator": {"flow_director": "D8"},
...                 "eroder": {"K_sp": 0.01},
...                 "diffuser": {"linear_diffusivity": 0.1},
...             },
...         },
...         "events": {
...             "report": {"times": [0.0, 1.0, 2.0]},
...         },
...     }
... )

>>> model.run()
model time: 0
model time: 1
model time: 2
>>> model.current_time
2.0
>>> np.all(np.isfinite(model.grid.at_node["topographic__elevation"]))
True

class Model[source]¶

Bases: object

Base class for a time-dependent, grid-based Landlab model.

Model provides configuration constructors, scheduled reporting and output, and model time management. Subclasses define the model physics by constructing their components and implementing update. They may override plot, report, and save to customize the corresponding scheduled events.

Parameters:

grid (ModelGrid) – Grid shared by the model’s components.
clock (Clock) – Start time, stop time, and default time-step duration.
params (mapping) – Model parameters. The events section configures the scheduled events.