Ribasim

https://ribasim.org/
Admin
Ribasim is a water resources model to simulate the physical behavior of a managed open water system...
Tokens:90,016
Snippets:1,062
Trust Score:5.7
Update:3 months ago
Show doc for...
Tokens:
Raw
### Start Julia REPL

Source: https://ribasim.org/dev/core.html

Starts the Julia REPL with the root environment activated. This is a prerequisite for running tests.

```bash
julia --project
```

--------------------------------

### Install QGIS Plugins

Source: https://ribasim.org/dev/qgis.html

Installs QGIS plugins and creates a symlink to the ribasim_qgis folder for QGIS to find. Also installs plugins for reloading and debugging within QGIS.

```bash
pixi run install-qgis-plugins
```

--------------------------------

### Render a single documentation file

Source: https://ribasim.org/dev/core.html

Previews a specific documentation file, such as a guide, from the 'docs/' folder.

```bash
pixi run docs guide/delwaq.qmd
```

--------------------------------

### Install Ribasim Development Environment

Source: https://ribasim.org/dev

Run this command to install all required Python and Julia packages for development using Pixi. This task also provides Juliaup, QGIS, and the Rust compiler.

```bash
pixi run install
```

--------------------------------

### Warm Start Allocation Model

Source: https://ribasim.org/dev/allocation.html

Improves solver performance by initializing the optimization with flow rates from the physical layer. Use this to guide the solver to a good initial solution, potentially reducing iterations.

```julia
function warm_start!(allocation_model::AllocationModel, integrator::DEIntegrator)::Nothing
    (; problem, scaling, Δt_allocation) = allocation_model
    flow = problem[:flow]
    du = get_du(integrator)  # du/dt from physical layer

    # Extrapolate current flow rates
    for link in only(flow.axes)
        # Get current flow from physical layer
        current_flow = get_flow(du, p, link)

        # Set as starting value for optimization
        JuMP.set_start_value(
            flow[link],
            current_flow / scaling.flow
        )
    end

    # Similar for basin storage changes...
end
```

--------------------------------

### Release Candidate Versioning Example

Source: https://ribasim.org/dev/release.html

Illustrates version numbering for release candidates and stable releases using the YYYY.MINOR.MICRO format.

```text
2023.1.0-rc1 as the first release candidate pre-release of 2023.1.0
2023.1.0-rc2 as the second release candidate pre-release of 2023.1.0
2023.1.0 as the release
```

--------------------------------

### Install Ribasim Dependencies with Pixi

Source: https://ribasim.org/dev/copilot.html

Use Pixi to manage the environment and install all project dependencies.

```bash
# Use Pixi for environment management
pixi run install            # Install and configure all dependencies
```

--------------------------------

### Run Python with uv

Source: https://ribasim.org/getting-started/install.html

Start a Python interpreter within the uv-managed environment. This allows you to interact with installed packages like Ribasim.

```bash
uv run python
```

--------------------------------

### Generate Test Models for Ribasim

Source: https://ribasim.org/dev/python.html

Create example model input files required for Julia tests and binary builds. Re-run this script if example models change.

```bash
pixi run generate-testmodels
```

--------------------------------

### JuMP Sparse Array Examples

Source: https://ribasim.org/dev/allocation.html

Illustrates the use of JuMP's SparseAxisArray for multi-dimensional variables, showing doubly and triply-indexed examples.

```julia
# Example: doubly-indexed variable
user_demand_allocated[node_id, demand_priority]

# Example: triply-indexed variable
user_demand_error[node_id, demand_priority, objective_type]
```

--------------------------------

### Verify Ribasim Installation (Windows CMD)

Source: https://ribasim.org/getting-started/install.html

After manual installation, use this command in cmd.exe to verify the Ribasim executable is accessible and functioning.

```bash
ribasim --help
```

--------------------------------

### Ribasim CLI Help Output

Source: https://ribasim.org/getting-started/install.html

This is the expected output when running `ribasim --help` or `./ribasim --help` after a successful installation, showing usage and available arguments/options.

```text
Usage: ribasim.exe <TOML_PATH>

Arguments:
  <TOML_PATH>  Path to the TOML file

Options:
  -h, --help     Print help
  -V, --version  Print version
```

--------------------------------

### Compare Allocation Instances

Source: https://ribasim.org/reference/python/Allocation.html

Example demonstrating the usage of the diff method to compare two Allocation instances and inspect the differences.

```python
>>> nbasic == basic
False
>>> x = nbasic.diff(basic)
{'basin': {'node': {'diff': <datacompy.pandas.PandasCompare object at 0x16e5a45c0>},
        'static': {'diff': <datacompy.pandas.PandasCompare object at 0x16eb90080>}},
'solver': {'saveat': {'other': 86400.0, 'self': 0.0}}}
>>> x["basin"]["static"]["diff"].report()
DataComPy Comparison
--------------------
...

```

--------------------------------

### Run QGIS with Plugins

Source: https://ribasim.org/dev/qgis.html

Launches QGIS with the installed Ribasim plugin available in the toolbar. Ensure you are running this from the Pixi environment on Windows to enable Python and plugins.

```bash
pixi run qgis
```

--------------------------------

### Activate Ribasim project and instantiate dependencies

Source: https://ribasim.org/dev/core.html

Activates the Ribasim project and installs its dependencies using the Pkg REPL. This is a prerequisite for running Ribasim simulations.

```julia
activate .
```

```julia
instantiate
```

--------------------------------

### Setup level boundary nodes

Source: https://ribasim.org/getting-started/examples.html

Configures level boundary nodes with a fixed water level. Level is specified in meters.

```python
level_boundary11 = model.level_boundary.add(
    Node(11, Point(2.0, 2.0)), [level_boundary.Static(level=[0.5])]
)
level_boundary17 = model.level_boundary.add(
    Node(17, Point(6.0, 1.0)), [level_boundary.Static(level=[1.5])]
)
```

--------------------------------

### Verify Ribasim Installation (Windows PowerShell)

Source: https://ribasim.org/getting-started/install.html

After manual installation, use this command in PowerShell to verify the Ribasim executable is accessible and functioning.

```powershell
./ribasim --help
```

--------------------------------

### Setup Basins with Profiles and Forcing Data

Source: https://ribasim.org/getting-started/examples.html

Configures four basins (two polders and two boezems) with identical profiles and time-varying forcing data for precipitation and evaporation. Initial state levels are also set.

```python
basin_data = [
    basin.Profile(area=[0.01, 1000000.0], level=[-10, 2.0]),
    basin.Time(
        time=time,
        drainage=0.0,
        potential_evaporation=evaporation,
        infiltration=0.0,
        precipitation=precipitation,
    ),
    basin.State(level=[0.9]),
]

basin3 = model.basin.add(Node(3, Point(2.0, 0.0), name="Boezem"), basin_data)
basin4 = model.basin.add(Node(4, Point(2.0, 2.0), name="Polder"), basin_data)
basin6 = model.basin.add(Node(6, Point(4.0, 2.0), name="Polder"), basin_data)
basin9 = model.basin.add(Node(9, Point(4.0, 0.0), name="Boezem"), basin_data)
```

--------------------------------

### Setup pump node

Source: https://ribasim.org/getting-started/examples.html

Adds a pump node to the model with a static flow rate. Flow rate is specified in m³/s.

```python
pump7 = model.pump.add(Node(7, Point(4.0, 1.0)), [pump.Static(flow_rate=[0.5 / 3600])])
```

--------------------------------

### Setup basins with static forcing

Source: https://ribasim.org/getting-started/examples.html

Configures basin nodes with profile and time-dependent data, including drainage, evaporation, infiltration, and precipitation. Forcing data is converted to m/s.

```python
time = pd.date_range(model.starttime, model.endtime)
day_of_year = time.day_of_year.to_numpy()
seconds_per_day = 24 * 60 * 60
evaporation = (
    (-1.0 * np.cos(day_of_year / 365.0 * 2 * np.pi) + 1.0) * 0.0025 / seconds_per_day
)
rng = np.random.default_rng(seed=0)
precipitation = (
    rng.lognormal(mean=-1.0, sigma=1.7, size=time.size) * 0.001 / seconds_per_day
)

# Convert steady forcing to m/s
# 2 mm/d precipitation, 1 mm/d evaporation

basin_data = [
    basin.Profile(area=[0.01, 1000.0], level=[0.0, 1.0]),
    basin.Time(
        time=pd.date_range(model.starttime, model.endtime),
        drainage=0.0,
        potential_evaporation=evaporation,
        infiltration=0.0,
        precipitation=precipitation,
    ),
    basin.State(level=[1.4]),
]

basin1 = model.basin.add(Node(1, Point(0.0, 0.0)), basin_data)
basin3 = model.basin.add(Node(3, Point(2.0, 0.0)), basin_data)
basin6 = model.basin.add(Node(6, Point(3.0, 2.0)), basin_data)
basin9 = model.basin.add(Node(9, Point(5.0, 0.0)), basin_data)
```

--------------------------------

### Initialize Ribasim Model with Allocation Enabled

Source: https://ribasim.org/getting-started/examples.html

Sets up the Ribasim model with specified start and end times, coordinate reference system, and enables the experimental allocation feature.

```python
from ribasim.nodes import (
    flow_demand
)

model = Model(
    starttime="2020-01-01",
    endtime="2021-01-01",
    crs="EPSG:4326",
    experimental=Experimental(allocation=True),
)
```

--------------------------------

### Setup Discrete Control Logic

Source: https://ribasim.org/getting-started/examples.html

Defines a discrete control node, linking it to a basin's level variable and setting conditions for control states.

```python
model.discrete_control.add(
    Node(7, Point(1.0, 0.0)),
    [
        discrete_control.Variable(
            compound_variable_id=1,
            listen_node_id=1,
            variable=["level"],
        ),
        discrete_control.Condition(
            compound_variable_id=1,
            condition_id=[1, 2],
            # min, max
            threshold_high=[5.0, 15.0],
        ),
        discrete_control.Logic(
            truth_state=["FF", "TF", "TT"],
            control_state=["in", "none", "out"],
        ),
    ],
)
```

--------------------------------

### Setup flow boundary nodes

Source: https://ribasim.org/getting-started/examples.html

Adds flow boundary nodes to the model with a specified flow rate. Flow rate is specified in m³/s.

```python
flow_boundary15 = model.flow_boundary.add(
    Node(15, Point(3.0, 3.0)), [flow_boundary.Static(flow_rate=[1e-4])]
)
flow_boundary16 = model.flow_boundary.add(
    Node(16, Point(0.0, 1.0)), [flow_boundary.Static(flow_rate=[1e-4])]
)
```

--------------------------------

### Setup Allocation-Controlled Outlets

Source: https://ribasim.org/getting-started/examples.html

Configure outlets that are controlled by the allocation algorithm. This is used for inlets from a boezem to a polder and for bidirectional flow between polders. Ensure `allocation_controlled=True` is set.

```python
# Inlet from boezem to polder 4
outlet5 = model.outlet.add(
    Node(5, Point(2, 1), name="inlaat"),
    [
        outlet.Static(
            allocation_controlled=True,
            flow_rate=[0.0],
            max_flow_rate=5.0,
        )
    ],
)

# Bidirectional flow between polders
outlet13 = model.outlet.add(
    Node(13, Point(3, 2), name="inlaat/uitlaat"),
    [
        outlet.Static(
            allocation_controlled=True,
            flow_rate=[0.0],
            max_flow_rate=5.0
        )
    ],
)

# Allocation-controlled outlets for water balance management
outlet10 = model.outlet.add(
    Node(10, Point(5.0, 0.0)),
    [outlet.Static(
        allocation_controlled=True,
        flow_rate=[0.0],
        max_flow_rate=10
    )],
)

outlet12 = model.outlet.add(
    Node(12, Point(1.0, 0)),
    [outlet.Static(
        allocation_controlled=True,
        flow_rate=[0.0],
        max_flow_rate=10.0)],
)
```

--------------------------------

### Setup linear resistance nodes

Source: https://ribasim.org/getting-started/examples.html

Adds linear resistance nodes to the model with static resistance values. Resistance is defined in units of s/m².

```python
linear_resistance10 = model.linear_resistance.add(
    Node(10, Point(6.0, 0.0)),
    [linear_resistance.Static(resistance=[5e3])],
)
linear_resistance12 = model.linear_resistance.add(
    Node(12, Point(2.0, 1.0)),
    [linear_resistance.Static(resistance=[3600.0 * 24.0 / 100.0])],
)
```

--------------------------------

### Setup Allocation-Controlled Pump

Source: https://ribasim.org/getting-started/examples.html

Configure a pump that is controlled by allocation for removing excess water. Set `allocation_controlled=True` on the pump configuration.

```python
pump7 = model.pump.add(
    Node(7, Point(4, 1), name="drainage pumping station"),
    [
        pump.Static(
            allocation_controlled=True,
            flow_rate=[0.0],
            max_flow_rate=20.0,
        )
    ],
)
```

--------------------------------

### Setup Manning resistance nodes

Source: https://ribasim.org/getting-started/examples.html

Configures Manning resistance nodes with parameters for length, Manning's n, profile width, and profile slope.

```python
manning_resistance2 = model.manning_resistance.add(
    Node(2, Point(1.0, 0.0)),
    [
        manning_resistance.Static(
            length=[900], manning_n=[0.04], profile_width=[6.0], profile_slope=[3.0]
        )
    ],
)
```

--------------------------------

### Run Python with Pixi

Source: https://ribasim.org/getting-started/install.html

Start a Python interpreter within the Pixi-managed environment. Use this to run Python scripts or interact with Ribasim.

```bash
pixi run python
```

--------------------------------

### Run QGIS Plugin Test

Source: https://ribasim.org/dev/release.html

Execute the automated task to test QGIS plugin installation. This command might require multiple runs due to potential timing issues.

```bash
# This test might give a fatal error on the first run, this is most likely a timing issue.
# Try to run it again when that happens.
pixi run test-ribasim-qgis
```

--------------------------------

### Setup Level Boundary Nodes for External Water Systems

Source: https://ribasim.org/getting-started/examples.html

Configures two level boundary nodes to represent external water systems with fixed water levels. These boundaries interact with the polder/boezem system.

```python
level_boundary11 = model.level_boundary.add(
    Node(11, Point(0, 0)), [level_boundary.Static(level=[10])]
)
level_boundary17 = model.level_boundary.add(
    Node(17, Point(6, 0)), [level_boundary.Static(level=[0.9])]
)
```

--------------------------------

### Forward Fill Interpolation Example

Source: https://ribasim.org/reference/node/basin.html

Demonstrates forward-fill interpolation for time-series data, showing how missing data points are handled by maintaining the last available value. This is useful for variables like precipitation that can be updated independently.

```python
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from IPython.display import display, Markdown

np.random.seed(1)
fig, ax = plt.subplots()
fontsize = 15

N = 5
y = np.random.rand(N)
x = np.cumsum(np.random.rand(N))

def forward_fill(x_):
    i = min(max(0, np.searchsorted(x, x_)-1), len(x)-1)
    return y[i]

def plot_forward_fill(i):
    ax.plot([x[i], x[i+1]], [y[i], y[i]], color = "C0", label = "interpolation" if i == 0 else None)

ax.scatter(x[:-1],y[:-1], label = "forcing at data points")
for i in range(N-1):
    plot_forward_fill(i)

x_missing_data = np.sort(x[0] + (x[-1] - x[0]) * np.random.rand(5))
y_missing_data = [forward_fill(x_) for x_ in x_missing_data]
ax.scatter(x_missing_data, y_missing_data, color = "C0", marker = "x", label = "missing data")
ax.set_xticks([])
ax.set_yticks([])
ax.set_xlabel("time", fontsize = fontsize)
ax.set_ylabel("forcing", fontsize = fontsize)
xlim = ax.get_xlim()
ax.set_xlim(xlim[0], (x[-2] + x[-1])/2)
ax.legend()

markdown_table = pd.DataFrame(
        data = {
            "time" : x,
            "forcing" : y
        }
    ).to_markdown(index = False)

display(Markdown(markdown_table))
```

--------------------------------

### Run Ribasim with Custom Ribasim Home Directory

Source: https://ribasim.org/getting-started/tutorial/natural-flow.html

Execute a Ribasim simulation, specifying a custom path to the Ribasim installation directory. This is useful when Ribasim is not in the system's PATH.

```python
run_ribasim(toml_path, ribasim_home="path/to/ribasim")
```

--------------------------------

### Scaled Volume Conservation Example

Source: https://ribasim.org/dev/allocation.html

Illustrates the scaled formulation of volume conservation, showing how scaling factors are applied to storage and flow variables within the code. This helps in understanding the practical implementation of scaling.

```julia
storage_change[node_id] ==
    Δt_allocation / scaling.storage * (
        sum(flow[link] for link in inflow_links) * scaling.flow - ...
    )
```

--------------------------------

### Initialize Solver

Source: https://ribasim.org/reference/python/Solver.html

Instantiates the Solver with provided data. Refer to DiffEqDocs for common solver options.

```python
Solver(**data)
```

--------------------------------

### Initialize uv Project

Source: https://ribasim.org/getting-started/install.html

Initialize a new uv project with a specified Python version. This command sets up the project environment for package management.

```bash
uv init --python '>=3.12'
```

--------------------------------

### Initialize Sparse Jacobian Backend and Prepare for Differentiation

Source: https://ribasim.org/dev/numerics.html

Sets up the automatic sparse differentiation backend using forward-mode AD, sparsity detection, and graph coloring. It then prepares the necessary structures for computing the Jacobian of the `water_balance!` function.

```julia
backend_jac = AutoSparse(
    AutoForwardDiff(; tag = :Ribasim),
    sparsity_detector = TracerSparsityDetector(),
    coloring_algorithm = GreedyColoringAlgorithm(),
)
jac_prep = prepare_jacobian(
    water_balance!, du, backend_jac,
    u_reduced,
    Constant(p_independent),
    Cache(state_and_time_dependent_cache),
    Constant(time_dependent_cache),
    Constant(p_mutable),
    Constant(t);
    strict = Val(true),
)
```

--------------------------------

### Install Ribasim Python Package with pip

Source: https://ribasim.org/guide/installing-other-versions.html

Use this command to install or upgrade to a specific version of the Ribasim Python package using pip.

```bash
pip install --upgrade ribasim==2026.1.0-rc2
```

--------------------------------

### Install Ribasim Python with conda

Source: https://ribasim.org/getting-started/install.html

Install the Ribasim Python package from the conda-forge channel using conda. This command ensures Ribasim is available in your conda environment.

```bash
conda install -c conda-forge ribasim=2026.1.2
```

--------------------------------

### Get Node Table

Source: https://ribasim.org/reference/python/Model.html

Retrieve the node table of the model.

```python
Model.node_table()
```

--------------------------------

### Initialize Ribasim Model

Source: https://ribasim.org/getting-started/examples.html

Sets up the core Ribasim model with time range, coordinate reference system, and solver settings.

```python
model = Model(
    starttime="2020-01-01",
    endtime="2021-01-01",
    crs="EPSG:4326",
    solver=Solver(abstol=1e-6, reltol=1e-5),
)
```

--------------------------------

### Initialize Logging

Source: https://ribasim.org/reference/python/Logging.html

Instantiate the Logging class with optional data.

```python
Logging(**data)
```

--------------------------------

### Get Tablename

Source: https://ribasim.org/reference/python/LinkTable.html

Retrieves the tablename based on the attached Schema.

```python
LinkTable.tablename()
```

--------------------------------

### Get Input Directory

Source: https://ribasim.org/reference/python/LinkTable.html

Retrieves the input directory path for this LinkTable.

```python
LinkTable.get_inputdir()
```

--------------------------------

### Initialize Pixi Environment

Source: https://ribasim.org/getting-started/install.html

Initialize a new Pixi project environment. This command sets up the necessary configuration for Pixi to manage dependencies.

```bash
pixi init
```

--------------------------------

### Get Default Filepath

Source: https://ribasim.org/reference/python/LinkTable.html

Retrieves the default filepath associated with this LinkTable.

```python
LinkTable.default_filepath()
```

--------------------------------

### Get Default Filepath for Model

Source: https://ribasim.org/reference/python/Model.html

Retrieve the default file path associated with this FileModel.

```python
Model.default_filepath()
```

--------------------------------

### Model Post Initialization

Source: https://ribasim.org/reference/python/Model.html

Perform actions after the model has been initialized, using a provided context.

```python
Model.model_post_init(__context)
```

--------------------------------

### Check Ribasim Version

Source: https://ribasim.org/getting-started/tutorial/natural-flow.html

Retrieve the installed Ribasim version. This can be done by calling the `run_ribasim` function with the `version=True` argument.

```python
run_ribasim(version=True)
```

--------------------------------

### Generate Ribasim Documentation

Source: https://ribasim.org/dev/copilot.html

Preview the Ribasim documentation locally using the Pixi command.

```bash
# Documentation
pixi run docs                    # Preview docs locally
```

--------------------------------

### Setup terminal node

Source: https://ribasim.org/getting-started/examples.html

Adds a terminal node to the model, typically used to represent the end of a flow path.

```python
terminal14 = model.terminal.add(Node(14, Point(3.0, -2.0)))
```

--------------------------------

### Ribasim TOML Configuration Example

Source: https://ribasim.org/reference/usage.html

This TOML file defines the core settings for a Ribasim simulation, including time, CRS, directories, version, and specific configurations for basins, interpolation, allocation, solver, logging, and results. It also shows how to specify NetCDF files for input tables and experimental features.

```toml
# start- and endtime of the simulation
# can also be set to a date-time like 1979-05-27T07:32:00
starttime = 2019-01-01 # required
endtime = 2021-01-01   # required

# Coordinate Reference System
# The accepted strings are documented here:
# https://proj.org/en/9.4/development/reference/functions.html#c.proj_create
crs = "EPSG:4326"      # required

# input and results directories relative to the TOML file
input_dir = "input"     # required
results_dir = "results" # required

ribasim_version = "2026.1.2" # required

# Specific tables can also go into NetCDF files rather than the database.
# For large tables this can benefit from better compressed file sizes.
# This is optional, tables are retrieved from the database if not specified in the TOML.
[basin]
time = "basin/time.nc"

[interpolation]
flow_boundary = "block"   # optional, default "block", can otherwise be "linear"
block_transition_period = 0  # optional, default 0

[allocation]
dt = 86400                  # optional, remove for adaptive time stepping
dtmin = 3600.0              # optional, 3600.0
reltol_linearization = 0.01 # optional, default 0.01

[allocation.route_priority]
level_boundary = 1000       # optional, default 1000
basin = 0                   # optional, default 0
manning_resistance = 10     # optional, default 10
linear_resistance = 20      # optional, default 20
tabulated_rating_curve = -10   # optional, default -10
outlet = 40                 # optional, default 40
pump = 50                   # optional, default 50

[solver]
algorithm = "QNDF"  # optional, default "QNDF"
saveat = 86400      # optional, default 86400, 0 saves every timestep, inf saves only at start- and endtime
dt = 60.0           # optional, remove for adaptive time stepping
dtmin = 0.0         # optional, default 0.0
dtmax = 0.0         # optional, default length of simulation
force_dtmin = false # optional, default false
abstol = 1e-5       # optional, default 1e-5
reltol = 1e-5       # optional, default 1e-5
water_balance_abstol = 1e-3 # optional, default 1e-3
water_balance_reltol = 1e-2 # optional, default 1e-2
maxiters = 1e9      # optional, default 1e9
sparse = true       # optional, default true
autodiff = true     # optional, default true
evaporate_mass = true  # optional, default true to simulate a correct mass balance
depth_threshold = 0.1  # optional, default 0.1
level_difference_threshold = 0.02 # optional, default 0.02
specialize = false  # optional, default false

[logging]
# defines the logging level of Ribasim
verbosity = "info" # optional, default "info", can also be "debug", "warn" or "error"

[results]
compression = true    # optional, default true, using deflate compression
compression_level = 1 # optional, default 1 (0-9)
subgrid = false       # optional, default false

[experimental]
# Experimental features, disabled by default
concentration = false # tracer calculations
allocation = false # allocation layer, replaced by 'first come first serve' when inactive

```

--------------------------------

### Model.to_xugrid

Source: https://ribasim.org/reference/python/Model.html

Converts the network model to a `xugrid.UgridDataset`, optionally including flow or allocation results. Requires the 'xugrid' library to be installed.

```APIDOC
## Model.to_xugrid

### Description
Convert the network to a `xugrid.UgridDataset`.
Either the flow or the allocation data can be added, but not both simultaneously. This method will throw `ImportError` if the optional dependency `xugrid` isn’t installed.

### Method
Model.to_xugrid

### Parameters
#### Path Parameters
- **add_flow** (bool) - Optional - add flow results. Defaults to `False`.
- **add_allocation** (bool) - Optional - add allocation results. Defaults to `False`.
```

--------------------------------

### Initializing a RIBSim Model

Source: https://ribasim.org/getting-started/examples.html

Initializes a RIBSim model with a specified start time, end time, and coordinate reference system.

```python
model = Model(starttime="2020-01-01", endtime="2021-01-01", crs="EPSG:28992")
```

--------------------------------

### Render Ribasim documentation

Source: https://ribasim.org/dev/core.html

Builds and previews the Ribasim documentation from the 'docs/' folder. A browser tab will open with the rendered documentation, updating as changes are made.

```bash
pixi run docs
```

--------------------------------

### Instantiate Allocation

Source: https://ribasim.org/reference/python/Allocation.html

Defines the allocation optimization algorithm options. Requires data as input.

```python
Allocation(**data)
```

--------------------------------

### Set Initial Basin State from File

Source: https://ribasim.org/reference/node/basin.html

Configure Ribasim to use a previous simulation's basin state as the initial condition for a new simulation by specifying the state file path.

```toml
[basin]
state = "basin_state.nc"

```

--------------------------------

### Import Ribasim in Julia REPL

Source: https://ribasim.org/dev/core.html

Imports the Ribasim package to check for installation issues. This is an optional but recommended step before running tests.

```julia
using Ribasim
```

--------------------------------

### Run Ribasim with TOML path and Ribasim home

Source: https://ribasim.org/reference/python/run_ribasim.html

Execute the Ribasim CLI with a specified TOML configuration file and Ribasim home directory.

```python
run_ribasim("model.toml", ribasim_home="/path/to/ribasim")
```

--------------------------------

### Precompiling Packages for RIBASIM

Source: https://ribasim.org/reference/node/tabulated-rating-curve.html

Shows the output of package precompilation for various RIBASIM extensions. This is typically seen during environment setup or updates.

```text
Precompiling packages...
    925.7 ms  ✓ QuartoNotebookWorkerTablesExt (serial)
  1 dependency successfully precompiled in 1 seconds
Precompiling packages...
    948.6 ms  ✓ QuartoNotebookWorkerLaTeXStringsExt (serial)
  1 dependency successfully precompiled in 1 seconds
Precompiling packages...
   1143.9 ms  ✓ QuartoNotebookWorkerJSONExt (serial)
  1 dependency successfully precompiled in 1 seconds
Precompiling packages...
   2447.7 ms  ✓ QuartoNotebookWorkerPlotsExt (serial)
  1 dependency successfully precompiled in 2 seconds

```

--------------------------------

### Initialize Ribasim Model

Source: https://ribasim.org/getting-started/tutorial/reservoir.html

Sets up the Ribasim model with a specified time range and coordinate reference system.

```python
base_dir = Path("crystal-basin")

starttime = "2022-01-01"
endtime = "2023-01-01"
model = Model(
    starttime=starttime,
    endtime=endtime,
    crs="EPSG:4326",
)
```

--------------------------------

### Convert Model to UgridDataset

Source: https://ribasim.org/reference/python/Model.html

Converts the model network to a xugrid.UgridDataset. Optionally add flow or allocation data. Requires the 'xugrid' library to be installed.

```python
Model.to_xugrid(add_flow=False, add_allocation=False)
```

--------------------------------

### Clone Ribasim Repository

Source: https://ribasim.org/dev

Use this Git command to clone the Ribasim repository to your local machine. Ensure Git is installed from git-scm.com before running.

```bash
git clone https://github.com/Deltares/Ribasim.git
```

--------------------------------

### Run Linting Suite Locally

Source: https://ribasim.org/dev/python.html

Execute the linting suite to check code style and quality locally.

```bash
pixi run lint
```
Tokens:
Raw