Upload NetCDF forcing data for spatially-varying temperature, oxygen, or other environmental variables.
Disclaimer: These are indicative stock-status metrics relative to user-supplied or ICES-auto-filled reference points. They are not a formal stock assessment. No uncertainty or retrospective pattern analysis is performed.
Tip: For community-level size-spectrum and mean trophic level indicators, see the Results page (select Size Spectrum or Mean Trophic Level from the output type dropdown).
After running the Python engine, timing breakdowns, Numba JIT status, and memory usage will appear here.
Run both Java and Python engines on the same config to see a side-by-side timing comparison.
Select parameters to optimize:
Total parameters in registry: 271
OSMOSE (Object-oriented Simulator of Marine Ecosystems) is an individual-based model for exploring marine ecosystem dynamics. This Python interface provides configuration, execution, calibration, and visualization of OSMOSE simulations.
| Component | Technology |
|---|---|
| Web Framework | Shiny for Python |
| Plotting | Plotly |
| Calibration | pymoo (NSGA-II) |
| Sensitivity | SALib (Sobol) |
| GP Surrogate | scikit-learn |
| Data | xarray, pandas |
| Simulation | Java (OSMOSE engine) |
Released under the MIT License. View on GitHub
Python orchestration layer, simulation engine, and Shiny web interface for the OSMOSE marine ecosystem simulator. Ships with a pure-Python engine (within an order of magnitude of Java on 14/14 Eastern English Channel and 7/8 Bay of Biscay species) and a subprocess driver for the original Java engine.
Python 3.12 · NumPy + Numba · Shiny for Python · 3250+ tests · ruff clean · MIT
🚀 New here? Run and perturb a calibrated Baltic ecosystem in 30 minutes: Tutorial. Then keep the Usage Guide handy for scripting runs, reading outputs, comparing, and calibrating.
| Surface | State |
|---|---|
| Python engine | Within 1 order of magnitude of Java on Eastern English Channel (14/14) and Bay of Biscay (7/8). The exception is Bay of Biscay Hake, whose biomass runs ~123× Java's, a pre-existing gap. Anchovy, ~3× low, is inside 1 OoM but not equivalent at 3×. Faster than Java on every benchmarked config. |
| Java engine | Async subprocess runner. OSMOSE 4.4.1 JAR by default (4.3.3 still selectable). Bundled configs are native 4.4.0; background-species configs (e.g. Baltic) stage + run on the 4.4.1 jar from the UI. |
| Shiny UI | End-to-end UI: Setup · Grid · Forcing · Fishing · Movement · Run · Results (with Scenario Diff & Config Diff) · Spatial Results · Diagnostics · Calibration · Sensitivity · Scenarios · Advanced · Map Viewer. Live-during-run movement map; in-app About (README/Changelog) + a per-version startup "what's new" modal. |
| Calibration | pymoo NSGA-II, GP surrogate, SALib Morris/Sobol sensitivity; preflight stage + Pareto find_optimum. |
| Examples | Eastern English Channel (14 sp), the reference example: a published calibrated model in which 12 of 14 species hold steady over its 70-year run. Baltic Sea (8 sp + 6 LTL) with ICES SAG cross-validation. Bay of Biscay (8 sp) for short runs only: it isn't self-sustaining. |
| Tests | 3250+ passed. Pyright clean on osmose/ and ui/. |
| Config validation | Opt-in typo catcher at EngineConfig.from_dict load time. Silent by default; validation.strict.enabled=warn logs difflib suggestions, =error raises with the full unknown-key list. |
git clone https://github.com/razinkele/osmopy.git
cd osmopy
python -m venv .venv
source .venv/bin/activate
pip install -e ".[dev]"
.venv/bin/shiny run app.py --host 0.0.0.0 --port 8000
Open http://localhost:8000. The UI runs without Java — it defaults to the Python engine.
Requirements: Python 3.12+. Java 17+ only if you want to use the Java engine backend; the Python engine has no Java dependency.
Both engines implement the same Engine protocol and produce identical output shapes (biomass, abundance, mortality-by-cause, diet, trophic level, size/age distributions). The UI flips between them with one click.
| Python engine | Java engine | |
|---|---|---|
| Implementation | Pure Python (NumPy + Numba JIT) | Java subprocess (OSMOSE 4.4.1 JAR default; 4.3.3 selectable) |
| Dependencies | Python packages only | Java 17+ and an OSMOSE JAR |
| Parity | EEC 14/14, Bay of Biscay 7/8 within 1 OoM | Reference implementation |
| Speed | 1.2×–5.7× faster than Java (below) | Production-ready |
| Use case | Production runs, calibration, development | Legacy compatibility, reference |
Numba JIT + parallel cell processing + vectorized diet aggregation put the Python engine ahead of Java on every benchmarked config:
| Configuration | Python | Java | Speedup |
|---|---|---|---|
| Bay of Biscay, 1 yr (8 species) | 0.24 s | 0.80 s | 3.3× |
| Bay of Biscay, 5 yr (8 species) | 1.99 s | 2.3 s | 1.2× |
| Eastern English Channel, 1 yr (14 species) | 0.44 s | 2.5 s | 5.7× |
| Eastern English Channel, 5 yr (14 species) | 5.2 s | 7.2 s | 1.4× |
Benchmarked on Linux x86_64 with Numba 0.60, NumPy 1.26, Python 3.12. First run includes ~20 s Numba compilation overhead (cached for subsequent runs).
Key optimisations:
prange parallel cell processing with per-cell deterministic seedingnp.add.at per prey-species rollup)Run the suite yourself:
.venv/bin/python scripts/benchmark_engine.py --years 5 --seed 42 --repeats 3
EEC 1-year biomass parity (Python vs Java, tonnes):
| Species | Python | Java | Ratio |
|---|---|---|---|
| lesserSpottedDogfish | 93 | 78 | 1.18 |
| redMullet | 95 | 121 | 0.79 |
| pouting | 336 738 | 314 956 | 1.07 |
| whiting | 101 094 | 86 767 | 1.17 |
| poorCod | 114 268 | 109 860 | 1.04 |
| cod | 1 441 | 1 466 | 0.98 |
| dragonet | 104 756 | 107 661 | 0.97 |
| sole | 43 117 | 53 184 | 0.81 |
| plaice | 15 040 | 18 483 | 0.81 |
| horseMackerel | 157 119 | 163 585 | 0.96 |
| mackerel | 13 982 | 17 326 | 0.81 |
| herring | 32 752 826 | 30 541 764 | 1.07 |
| sardine | 14 968 | 14 126 | 1.06 |
| squids | 131 280 | 119 896 | 1.09 |
All 14 species within 1 order of magnitude of Java.
Bay of Biscay is now a fully-native OSMOSE 4.4.1 config. The rigorous N=16 cross-engine parity gate finds 6 of 8 species equivalent — Anchovy and Hake show a pre-existing Python-port-vs-Java divergence, present against both the 4.3.3 and 4.4.1 jars. Read those figures with care: the demo is not self-sustaining, and in its accessibility matrix (authored with predators as rows, the transpose of what both engines read) hake can eat nothing at all. Re-run it:
.venv/bin/python scripts/cross_engine_parity_440.py --config data/examples/osm_all-parameters.csv --engines python,4.4.1
See docs/parity-roadmap.md for the 7-phase closure history of the final parity gaps.
Three ready-to-run configurations ship in-tree.
| Location | Species | Ocean cells (grid) | Notes |
|---|---|---|---|
data/eec_full/ |
14 | 460 (45 × 22) | Eastern English Channel. Reference example and cross-engine parity benchmark. Over 70 years, 12 of 14 species hold steady; cod and whiting decline toward zero. |
data/baltic/ |
8 + 6 LTL | 616 (50 × 40) | Baltic Sea. Calibration sandbox + ICES cross-validation |
data/examples/ |
8 | 250 (20 × 20) | Bay of Biscay. Short runs and engine smoke tests only. Not self-sustaining: no fish ever matures, so all species die out once the initial seeding ends (by year 40). |
The Baltic example is the newest and most documented. It covers cod, herring, sprat, flounder, perch, pikeperch, smelt, stickleback plus six CMEMS-forced LTL groups, 50 × 40 cells over 10–30° E × 54–66° N, 24 dt/yr.
Live movement during a run. The Run page streams every timestep of a Python-engine simulation onto the map — toggle between an aggregated density heatmap and individual dots coloured by species. Below is the Baltic ecosystem (8 fish species over the 50 × 40-cell domain) at the end of a 1-year run:
![]() Heatmap — school density |
![]() Dots — individual schools by species |
docs/baltic_example.md.docs/baltic_ices_validation_2026-11-06.md. Unit-aware (the ICES API mislabels some stocks' SSB units; the validator detects this via Blim magnitude).data/baltic/reference/ices_snapshots/README.md.scripts/calibrate_baltic.py (phases: larval mortality, adult mortality + F) runs the Python engine directly, no Java needed.scripts/rebuild_baltic_mask.py and mcp_servers/copernicus/server.py regenerate the mask + LTL NetCDF from CMEMS data..venv/bin/python scripts/validate_baltic_vs_ices_sag.py --report
.venv/bin/python -m pytest tests/test_baltic_ices_validation.py -v
osmose/ Core library (usable without Shiny)
engine/ Python simulation engine (44 files, ~11.5k LOC)
simulate.py Main simulation loop; SimulationContext, frozen StepOutput
processes/ Growth, predation, mortality, reproduction, movement, fishing
config.py Typed parameter extraction
grid.py Spatial grid with NetCDF loading
resources.py LTL plankton/resource forcing
output.py CSV + NetCDF output writer
path_resolution.py Consolidated resolver with traversal protection
schema/ Parameter definitions + registry (153 params)
config/ Config reader/writer (auto-detected separators; recursive includes)
calibration/ pymoo NSGA-II + GP surrogate + SALib sensitivity + preflight
runner.py Async Java subprocess manager
results.py CSV/NetCDF output reader (xarray)
scenarios.py Save/load/compare/fork
ui/ Shiny web interface
pages/ One module per tab
components/ Reusable widgets (param form)
theme.py shinyswatch superhero theme
mcp_servers/ MCP servers
copernicus/ CMEMS forcing downloader (env-based credentials)
data/
eec_full/ Eastern English Channel reference config (14 species)
examples/ Bay of Biscay config (8 species; short runs only, not self-sustaining)
baltic/ Baltic Sea calibration sandbox (8 sp + 6 LTL); see docs/baltic_example.md
reference/ Biomass targets + frozen ICES SAG snapshots
scripts/ One-shot tools: benchmarks, validators, calibration, mask rebuild
tests/ 2510 tests (schema, config, engine processes, parity, calibration,
UI state, MCP hygiene, Baltic ICES cross-validation)
docs/
baltic_example.md Baltic example full provenance
baltic_ices_validation_2026-11-06.md ICES cross-validation report (2026 advice)
parity-roadmap.md Engine parity roadmap (7 phases)
osmose-master-java-fixes.patch Portable patch for upstream osmose-master
plans/ Historical and active implementation plans
superpowers/plans/ Superpowers-skill-generated plans
.venv/bin/python -m pytest # run all tests (~50 s)
.venv/bin/python -m pytest --cov=osmose # with coverage
.venv/bin/python -m pytest -v -k test_name # specific test
.venv/bin/ruff check osmose/ ui/ tests/ # lint
.venv/bin/ruff format osmose/ ui/ tests/ # format
2510 tests across schema, config I/O, config-key validation, every engine process, parity regressions, numerical edge cases, type invariants, thread safety, UI state, calibration, scenario management, MCP credential hygiene, and integration scenarios. Pyright passes with zero errors on the osmose/ and ui/ trees.
from pathlib import Path
from osmose.engine import PythonEngine
# Python engine — no Java needed
engine = PythonEngine()
result = engine.run(config=config_dict, output_dir=Path("output"), seed=42) # writes CSV/NetCDF
results = engine.run_in_memory(config=config_dict, seed=42) # OsmoseResults, no disk
# Java engine — requires an OSMOSE JAR; run() is a coroutine
import asyncio
from osmose.runner import OsmoseRunner
runner = OsmoseRunner(jar_path=Path("osmose-java/osmose.jar"))
result = asyncio.run(runner.run(config_path=Path("config.csv"), output_dir=Path("output")))
from osmose.config.reader import OsmoseConfigReader
from osmose.config.writer import OsmoseConfigWriter
reader = OsmoseConfigReader()
config = reader.read(Path("path/to/osm_all-parameters.csv")) # -> dict[str, str]
writer = OsmoseConfigWriter()
writer.write(config, Path("path/to/output_dir/")) # writes the config tree into a directory
EngineConfig.from_dict() checks every key against an allowlist built from the ParameterRegistry plus an AST walk of osmose/engine/config.py. The allowlist knows all ~390 keys the engine or reader touches, including {idx}-patterned families (species.linf.sp{idx}, movement.file.map{idx}, …). Default is silent; opt in with validation.strict.enabled:
| Mode | Behavior on unknowns |
|---|---|
off (default) |
Single INFO-level nudge ("Config has N unknown keys; set validation.strict.enabled=warn for details.") — zero output on clean configs. |
warn |
One WARNING per unknown, with a difflib suggestion when the ratio passes 0.85. E.g. species.liinf.sp0 → "did you mean 'species.linf.sp{idx}'?" |
error |
Collect all unknowns, then raise a single ValueError listing them (not fail-fast). |
cfg = reader.read("path/to/osm_all-parameters.csv")
cfg["validation.strict.enabled"] = "warn" # or "error"
EngineConfig.from_dict(cfg) # emits per-key warnings
from osmose.results import OsmoseResults
# strict=True (default): FileNotFoundError if outputs are missing
results = OsmoseResults(Path("path/to/output/"), prefix="osm")
biomass = results.biomass() # wide DataFrame: Time + per-species columns
mortality = results.mortality() # per-species mortality by cause
diet = results.diet_matrix() # diet composition matrix
# strict=False for partial/speculative loads (calibration, UI)
with OsmoseResults(Path("path/to/output/"), strict=False) as results:
biomass = results.biomass()
Selecting one species is column selection (biomass()[["Time", "Anchovy"]]); the
species= argument filters the row-label column and returns empty on the standard wide
files. See docs/usage-guide.md.
The Python engine is re-entrant. Per-simulation state is encapsulated in a SimulationContext dataclass passed through the call chain — no module-level globals. Safe for ProcessPoolExecutor-based calibration runs.
from concurrent.futures import ProcessPoolExecutor
engine = PythonEngine()
with ProcessPoolExecutor(max_workers=8) as pool:
futures = [pool.submit(engine.run_in_memory, config=cfg, seed=i) for i, cfg in enumerate(configs)]
# Drive a calibration (DE / CMA-ES / surrogate-DE) — long-running, writes to data/calibration_history:
# python scripts/calibrate_baltic.py --optimizer de --phase 12 --maxiter 100
from pathlib import Path
from osmose.calibration import list_runs, load_run, OsmoseCalibrationProblem
runs = list_runs() # list[dict] of finished runs
data = load_run(Path(runs[-1]["path"])) if runs else None
# OsmoseCalibrationProblem(...) is the programmatic entry for a custom problem
# (use_java_engine=True for bit-exact Java). See docs/usage-guide.md §4.
MCP integrations ship under mcp_servers/. The Copernicus Marine server reads credentials from environment variables only — no hardcoded fallbacks. Populate .env (gitignored) at the repo root:
cp .env.example .env
$EDITOR .env # fill in CMEMS_USERNAME / CMEMS_PASSWORD
server.py auto-loads .env via python-dotenv. Two enforcement tests guard against regressions:
tests/test_copernicus_mcp_env.py — server source must not contain a hardcoded credential default; _require_creds() must raise RuntimeError on missing env.tests/test_mcp_config_hygiene.py — .mcp.json must not ship a CMEMS password literal under any server's env block.The ICES data-access MCP server lives out-of-tree at /home/razinka/ices-mcp-server/ (stdio-based, uv runner). Wire it via .mcp.json — see the Baltic ICES snapshots README for the refresh workflow.
docker build -t osmose-python .
docker run -p 8000:8000 osmose-python
Place osmose.jar in osmose-java/ before building if you need Java-engine support. The Python engine works without it.
Start here depending on what you want:
| Goal | Doc |
|---|---|
| Rendered docs site (API reference + guides) | razinkele.github.io/osmopy |
| Learn OSMOSE by running and perturbing a real Baltic ecosystem in 30 min | docs/tutorials/30-minute-ecosystem.md |
| Script runs, read outputs, compare, and calibrate (Python + CLI) | docs/usage-guide.md |
| Run an existing example | Quick start above |
| Understand the Baltic example, its parameters, and their sources | docs/baltic_example.md |
| See where model F and biomass sit vs ICES 2026 advice | docs/baltic_ices_validation_2026-11-06.md |
| Refresh ICES snapshots when a new advice year lands | data/baltic/reference/ices_snapshots/README.md |
| Port progress vs Java (what was fixed, what's next) | docs/parity-roadmap.md |
| Per-release change history | CHANGELOG.md |
| Build a Java-side fix patch | docs/osmose-master-java-fixes.patch |
| Implementation plans (historical and active) | docs/plans/ and docs/superpowers/plans/ |
| Project conventions for contributors (tooling rules, gotchas) | CLAUDE.md |
All notable changes to this project will be documented in this file.
Format based on Keep a Changelog, generated from Conventional Commits.
overwrite, not overwrite_output_data (closes #162) (a132c3e)advanced baseline (694 -> 710px) (d39d80e)OSMOSE (Object-oriented Simulator of Marine Ecosystems) is an individual-based model (IBM) for simulating multispecies marine ecosystems. It was developed at IRD (Institut de Recherche pour le Developpement) and is designed to explore the combined effects of fishing, climate change, and species interactions on fish communities.
Unlike traditional stock-assessment models that treat each species independently, OSMOSE explicitly models predator-prey interactions among all species simultaneously, creating emergent food-web dynamics.
OSMOSE is built on a single unifying hypothesis: predation is an opportunistic, size-structured process. A fish can eat any other organism that:
There are no fixed predator-prey links. The food web emerges from the spatial overlap and relative body sizes of all organisms in the system. This makes OSMOSE fundamentally different from models with pre-defined diet matrices.
OSMOSE distinguishes three types of organisms:
The main modelled fish and invertebrate species. Each focal species is represented as a population of schools — groups of individuals sharing the same age, size, and location. Schools undergo the full life cycle: growth, reproduction, predation, natural mortality, starvation, fishing, and movement. Typically 5-15 focal species per application.
Plankton and lower trophic level organisms that serve as prey for focal species but are not explicitly modelled as individuals. Their biomass is provided as external forcing (typically from a biogeochemical model such as ROMS-PISCES or NEMO-PISCES) in the form of spatiotemporal NetCDF fields. Resource groups have a fixed size range and trophic level, and their accessibility to fish predators is controlled by a coefficient (0-1).
Species that interact with focal species through predation but are not the primary focus of the study. They have simplified dynamics compared to focal species — typically constant biomass distributions read from CSV maps. Background species fill ecological niches that would otherwise be empty in a model with only a few focal species.
OSMOSE simulates the following processes at each time step, applied sequentially to every school in the system:
Each species has a set of distribution maps (CSV grids) defining where individuals can be found. Maps vary by:
At each time step, schools are distributed across grid cells according to the active map for their species, age, and season. This creates the spatial overlap patterns that drive predation.
The central process. For each predator school in each grid cell:
The predator/prey size ratio parameters (predation.predPrey.sizeRatio.min
and .max) define the feeding window. Typical values are 1.0-5.0,
meaning a predator eats prey 1x to 5x smaller than itself.
If a school's predation efficiency (actual food intake / maximum
possible intake) falls below a critical threshold
(predation.efficiency.critical), the school suffers starvation
mortality. This creates a feedback loop: when prey is scarce,
predators starve, reducing predation pressure, which allows prey to
recover.
Fish grow according to the von Bertalanffy growth equation:
L(t) = L∞ × (1 - exp(-K × (t - t₀)))
Where L∞ is the asymptotic length, K is the growth coefficient, and
t₀ is the theoretical age at zero length. Weight is derived from
length via the allometric relationship W = a × L^b.
Growth parameters are species-specific and set from literature (e.g., FishBase).
In addition to predation and starvation, schools experience additional mortality (also called "diverse" mortality) at a constant rate. This represents all other causes of death not explicitly modelled (disease, senescence, etc.). Separate rates can be set for larvae and post-larval stages.
Mature females (determined by size or age at maturity) produce eggs proportional to their body weight and a fecundity parameter (eggs per gram of mature female). Egg production follows a seasonal pattern defined by a CSV file specifying reproductive activity at each time step. New schools of age-0 fish are seeded into the population each time step based on total egg production.
Fishing removes biomass at a specified rate per species per time step. Parameters include:
Multiple fisheries can target different species with different gears, selectivities, and spatial patterns.
The simulation domain is a 2D regular or curvilinear grid covering the study area. Two grid types are supported:
A land/sea mask determines which cells are ocean (habitable) and which are land. The grid resolution typically ranges from 1/12° to 1/3° depending on the application area.
OSMOSE operates on a fixed time step, typically bi-weekly or monthly (12 or 24 steps per year). At each step, all processes are applied in sequence:
The order of processes within a time step is important — predation occurs before growth, so feeding success in a time step affects the energy available for growth.
OSMOSE is designed to be coupled with hydrodynamic and biogeochemical models (e.g., ROMS, NEMO) to form "end-to-end" ecosystem models:
Physical ocean model (ROMS/NEMO)
↓
Biogeochemical model (PISCES) → plankton biomass fields
↓
OSMOSE (fish + invertebrates) → emergent food web
↓
Fisheries & economic modules → catch, revenue, fleet dynamics
The biogeochemical model provides spatiotemporal plankton biomass (the LTL forcing), which feeds into OSMOSE as the base of the food web. OSMOSE then simulates all fish-to-fish and fish-to-plankton interactions. Optional economic modules simulate fleet behavior and market dynamics.
Since version 4.3.3, OSMOSE includes several optional modules:
Replaces the simple von Bertalanffy growth with a Dynamic Energy Budget (DEB) approach. Fish growth, reproduction, and maintenance are driven by food intake and temperature, allowing physiological responses to environmental change. Includes oxygen limitation effects on metabolism (Morell et al., 2023).
Adds heritable trait variation to populations, enabling evolutionary dynamics. Traits such as growth rate, maturation size, and thermal tolerance can evolve over generations through natural selection, allowing exploration of fisheries-induced evolution and climate adaptation (Morell et al., 2023).
Extended fishing representation with:
Defines predation accessibility between species pairs beyond pure size-based rules. Values between 0 (no predation possible) and 1 (full accessibility) can encode habitat separation, diel vertical migration, or taxonomic avoidance patterns.
OSMOSE configurations require careful calibration due to the emergent nature of the food web. Common approaches:
Key calibration targets typically include: species biomass time series, catch data, diet composition, mean trophic level of the community, and size spectrum slopes.
OSMOSE has been applied to marine ecosystems worldwide:
| Region | Key Reference |
|---|---|
| Southern Benguela (South Africa) | Shin et al. (2004); Travers et al. (2006, 2009) |
| Humboldt Current (Peru) | Marzloff et al. (2009); Oliveros-Ramos et al. (2017) |
| Gulf of Lions (NW Mediterranean) | Banaru et al. (2019); Diaz et al. (2019) |
| Pan-Mediterranean | Moullec et al. (2019, 2022) |
| Eastern English Channel | Travers-Trolet et al. (2014, 2019); Bourdaud et al. (2025) |
| West Florida Shelf (USA) | Gruss et al. (2015, 2016, 2019) |
| Jiaozhou Bay (China) | Xing et al. (2017, 2020, 2021) |
| Southern Ocean | Xing et al. (2023, 2025) |
| Bay of Biscay | Fu et al. (2012, 2020) |
| Gulf of Gabes (Tunisia) | Halouani et al. (2016, 2019) |
| Yellow Sea (China) | Sun et al. (2023, 2024) |
For full documentation and the complete publication list visit osmose-model.org
OSMOSE is an individual-based model for simulating marine ecosystems. This interface lets you configure, run, and analyze simulations without touching configuration files directly.
General simulation parameters: simulation name, number of time steps, number of species, output directory, and JAR path. These are the foundational settings every simulation needs.
Define the spatial grid (longitude/latitude bounds, cell size) and preview the simulation domain on an interactive map. Upload custom land/sea masks if needed.
Environmental forcing data: temperature, salinity, plankton fields. Set file paths, variable names, and time step mappings for each forcing variable.
Configure fishing mortality by species. Set fishing rates, seasonal patterns, and selectivity curves. Supports both constant and time-varying mortality.
Species movement parameters: diffusion coefficients, habitat preferences, and migration patterns. Configure independently for each species in the simulation.
Output files are written to the directory specified in Setup.
After a run completes, view results as interactive Plotly charts:
Use the species selector and time range controls to focus on specific aspects of the output.
Multi-objective calibration using the NSGA-II genetic algorithm:
Gaussian Process surrogate model for faster calibration:
Sobol sensitivity analysis (SALib):
Save and manage simulation configurations:
Full history under About → Changelog.
Stored on this server with the app version and the tab you were on. Your email is kept separately and never published.