Refactor declining_increment_growth to accumulate increments, fix negative height/DBH; enable robust multi-model support

README.md

@@ -1,124 +1,92 @@
-# ER Model - Nigeria Mangroves
-
-A Python implementation of the Emissions Reduction (ER) model for Nigeria mangrove projects. This repository provides tools to estimate carbon sequestration over a 30-year period based on mangrove growth and survival rates.
-
-## Recent Updates and Improvements
-
-### Growth Model Enhancements (August 2024)
-- **Updated Growth Parameters**: Back-solved from August 2024 field data (t=1.58 years):
-  - DBH growth rate (b): Changed from 0.1237 to 0.4736 yr⁻¹
-  - Height growth rate (b): Changed from 0.1237 to 0.1335 yr⁻¹
-  - Height shape parameter (c): Changed from 2.1 to 1.5
-  - Rhizophora height asymptote: Changed from 12.0m to 11.58m
-
-- **Allometric Equations**: Using Zanvo et al. (2023) species-specific equations:
-  - Rhizophora: Total = 1.938 × (DBH² H)^0.67628
-  - Avicennia: Total = 1.486 × (DBH² H)^0.55864
-
-### Dashboard Improvements
-- **Enhanced Parameter Controls**:
-  - Direct input of Chapman-Richards parameters
-  - Separate growth parameters for DBH and height
-  - Real-time model updates
-  - Improved validation and error handling
-
-- **Improved Visualizations**:
-  - Carbon sequestration over time
-  - Annual emission reductions
-  - Per-tree biomass growth curves
-  - Enhanced data tables and summaries
-
-- **Detailed Metrics**:
-  - Project overview with total area and buffer pool
-  - Comprehensive carbon sequestration metrics
-  - Milestone year comparisons (10, 20, 30 years)
-  - Per hectare metrics with annual rates
-  - Species-specific results
-
-## Model Parameters
-
-### Species Parameters
-- **Rhizophora spp.**
-  - DBH: a = 11.07 cm, b = 0.4736 yr⁻¹, c = 2.1
-  - Height: a = 11.58 m, b = 0.1335 yr⁻¹, c = 1.5
-  - Initial values: DBH = 1.0 cm, Height = 0.5 m
-  - Configurable planting density and mortality rates
-
-- **Avicennia germinans**
-  - DBH: a = 11.07 cm, b = 0.4736 yr⁻¹, c = 2.1
-  - Height: a = 11.58 m, b = 0.1335 yr⁻¹, c = 1.5
-  - Initial values: DBH = 1.0 cm, Height = 0.5 m
-  - Configurable planting density and mortality rates
-
-### Project Configuration
-- Total area: 5000 ha (2500 ha each in years 1-2)
-- Project duration: 30 years
-- Buffer pool: 20%
-- Species mix: Rhizophora spp. and Avicennia germinans
-
-## Installation
-
-1. Install [Miniconda](https://docs.conda.io/en/latest/miniconda.html) or [Miniforge](https://github.com/conda-forge/miniforge)
-
-2. Create and activate the environment:
+# Mangrove Emissions Reduction (ER) Modeling Suite
+
+A Python toolkit and interactive dashboard for modeling carbon sequestration and tree survival in mangrove restoration projects. Supports multiple growth and mortality models, including Chapman-Richards and Jimenez & Lugo parameterizations.
+
+---
+
+## 🚀 Quickstart
+
+1. **Install dependencies**
    ```bash
    conda env create -f environment.yml
    conda activate er-model
-   ```
-
-3. Install pre-commit hooks:
-   ```bash
    pre-commit install
    ```
 
-## Usage
-
-1. Configure parameters in `configs/params.yaml`
-
-2. Launch the dashboard:
+2. **Launch the dashboard**
    ```bash
    python -m dashboard.app
    ```
-   This will start a Gradio server and open the dashboard in your default web browser.
-   The dashboard will be accessible via a public URL for sharing.
-
-3. Using the Dashboard:
-   - Adjust species parameters (density, mortality, growth)
-   - Set planting schedule (up to 5 years)
-   - Configure buffer pool percentage
-   - View real-time updates to:
-     * Carbon sequestration curves
-     * Annual emission reductions
-     * Biomass per tree growth
-     * Detailed metrics and summaries
-
-## Project Structure
-
-- `src/` - Core model implementation
-  - `er_model.py` - Main ER calculation logic
-  - `allometry.py` - Species-specific allometric equations
-  - `metrics.py` - Carbon conversion and statistics
-- `dashboard/` - Gradio web application
-- `configs/` - Parameter configuration files
-- `tests/` - Test suite
-
-## Dependencies
-
-Key dependencies (specified in `environment.yml`):
-- numpy
-- pandas
-- gradio
-- matplotlib
-- pyyaml
-- pytest (for development)
-
-## Development
-
-- Code style is enforced using `black` and `isort`
-- Type hints are required for all public functions
-- Tests are written using `pytest`
+   - The dashboard opens in your browser.
+   - Each tab represents a different model/configuration.
+
+---
+
+## 🖥️ Dashboard Usage
+- **Multi-model:** Switch between models (e.g., "Original Model", "Jimenez & Lugo") using tabs.
+- **Interactive plots:** All plots are interactive (hover, zoom, export).
+- **Parameter editing:** Adjust planting schedule and see real-time results (where enabled).
+- **Tables:** View carbon, species, and survival tables for each model.
+
+---
+
+## 📚 Model Documentation
+
+- [Original Model](models/original/README.md): Chapman-Richards growth, DBH-dependent mortality, field-calibrated.
+- [Jimenez & Lugo Model](models/jimenez_lugo/README.md): Literature-based, fixed annual mortality rates.
+
+---
+
+## 🗂️ Directory Structure
+```
+er-chapman-richards/
+├─�� README.md                # This file
+├── environment.yml          # Conda environment
+├── dashboard/               # Gradio dashboard app
+├── src/                     # Core model code
+├── configs/                 # Model parameter YAMLs
+├── models/                  # Model-specific docs
+│   ├── original/README.md
+│   └── jimenez_lugo/README.md
+├── tests/                   # Pytest suite
+└── ...
+```
+
+---
+
+## ➕ Adding a New Model
+1. Create a new config YAML in `configs/` (e.g., `configs/my_model.yaml`).
+2. Add a new entry to `MODEL_CONFIGS` in `dashboard/app.py`:
+   ```python
+   MODEL_CONFIGS = {
+       "Original Model": "configs/params.yaml",
+       "Jimenez & Lugo": "configs/jimenez_lugo.yaml",
+       "My Model": "configs/my_model.yaml"
+   }
+   ```
+3. (Optional) Add a new subdirectory and README in `models/` for documentation.
+4. Restart the dashboard. Your model appears as a new tab.
+
+---
+
+## 🧑‍💻 Development & Testing
+- Code style: [black](https://black.readthedocs.io/), [isort](https://pycqa.github.io/isort/)
+- Type hints required for all public functions
+- Run tests with:
+  ```bash
+  pytest
+  ```
 - Pre-commit hooks ensure code quality
 
-## License
+---
+
+## 📖 References
+- Chapman-Richards growth model literature
+- Jimenez, J.A. & Lugo, A.E. (1985, 1987)
+- Zanvo et al. (2023) for allometric equations
+- Field data from Nigeria mangrove sites (2024)
+
+---
 
+## 📝 License
 [License details to be added] 

configs/declining_increment.yaml

@@ -0,0 +1,78 @@
+growth_model: declining_increment
+
+species:
+  - name: "species_A"  # Rhizophora spp.
+    planting_density: 4000  # trees/ha
+    mortality_rates:
+      year_1: 15  # %
+      year_2: 12  # %
+      year_3: 6   # %
+      year_4: 5   # %
+      year_5: 5   # %
+      year_6: 5   # %
+      year_7: 5   # %
+      year_8: 5   # %
+      year_9: 5   # %
+      year_10: 5  # %
+      subsequent: 1.5  # % (years 11-30)
+    declining_increment:
+      dbh:
+        r0: 1.83  # cm/yr
+        T_m: 30  # years
+      height:
+        r0: 0.61  # m/yr
+        T_m: 12  # years
+    allometry:
+      equation: "Zanvo et al. 2023: Total = 1.938 × (DBH² H)^0.67628"
+    initial_values:
+      dbh: 1.0    # cm
+      height: 0.5  # m
+
+  - name: "species_B"  # Avicennia germinans
+    planting_density: 444  # trees/ha
+    mortality_rates:
+      year_1: 15  # %
+      year_2: 12  # %
+      year_3: 6   # %
+      year_4: 5   # %
+      year_5: 5   # %
+      year_6: 5   # %
+      year_7: 5   # %
+      year_8: 5   # %
+      year_9: 5   # %
+      year_10: 5  # %
+      subsequent: 1.5  # % (years 11-30)
+    declining_increment:
+      dbh:
+        r0: 1.2  # cm/yr (example, adjust as needed)
+        T_m: 30
+      height:
+        r0: 0.4  # m/yr (example, adjust as needed)
+        T_m: 12
+    allometry:
+      equation: "Zanvo et al. 2023: Total = 1.486 × (DBH² H)^0.55864"
+    initial_values:
+      dbh: 1.0    # cm
+      height: 0.5  # m
+
+project:
+  duration_years: 30  # matches project_years
+  planting_schedule:
+    year_1: 2500  # ha
+    year_2: 2500  # ha
+    year_3: 0  # ha
+    year_4: 0  # ha
+    year_5: 0  # ha
+
+carbon:
+  biomass_to_carbon: 0.47  # IPCC default
+  carbon_to_co2: 3.67     # molecular weight ratio
+  buffer_percentage: 20    # risk buffer
+  leakage_percentage: 0    # no leakage assumed
+  baseline_emissions: 0    # tCO2/ha/year
+
+scenarios:
+  area: 1000.0  # ha
+  dbh_range: [1.0, 25.0]  # cm
+  height_range: [0.5, 15.0]  # m
+  growth_rate_factor: 1.0 

configs/linear.yaml

@@ -0,0 +1,74 @@
+growth_model: linear
+
+species:
+  - name: "species_A"  # Rhizophora spp.
+    planting_density: 4000  # trees/ha
+    mortality_rates:
+      year_1: 15  # %
+      year_2: 12  # %
+      year_3: 6   # %
+      year_4: 5   # %
+      year_5: 5   # %
+      year_6: 5   # %
+      year_7: 5   # %
+      year_8: 5   # %
+      year_9: 5   # %
+      year_10: 5  # %
+      subsequent: 1.5  # % (years 11-30)
+    linear:
+      dbh:
+        r: 1.83  # cm/yr
+      height:
+        r: 0.61  # m/yr
+    allometry:
+      equation: "Zanvo et al. 2023: Total = 1.938 × (DBH² H)^0.67628"
+    initial_values:
+      dbh: 1.0    # cm
+      height: 0.5  # m
+
+  - name: "species_B"  # Avicennia germinans
+    planting_density: 444  # trees/ha
+    mortality_rates:
+      year_1: 15  # %
+      year_2: 12  # %
+      year_3: 6   # %
+      year_4: 5   # %
+      year_5: 5   # %
+      year_6: 5   # %
+      year_7: 5   # %
+      year_8: 5   # %
+      year_9: 5   # %
+      year_10: 5  # %
+      subsequent: 1.5  # % (years 11-30)
+    linear:
+      dbh:
+        r: 1.2  # cm/yr (example, adjust as needed)
+      height:
+        r: 0.4  # m/yr (example, adjust as needed)
+    allometry:
+      equation: "Zanvo et al. 2023: Total = 1.486 × (DBH² H)^0.55864"
+    initial_values:
+      dbh: 1.0    # cm
+      height: 0.5  # m
+
+project:
+  duration_years: 30  # matches project_years
+  planting_schedule:
+    year_1: 2500  # ha
+    year_2: 2500  # ha
+    year_3: 0  # ha
+    year_4: 0  # ha
+    year_5: 0  # ha
+
+carbon:
+  biomass_to_carbon: 0.47  # IPCC default
+  carbon_to_co2: 3.67     # molecular weight ratio
+  buffer_percentage: 20    # risk buffer
+  leakage_percentage: 0    # no leakage assumed
+  baseline_emissions: 0    # tCO2/ha/year
+
+scenarios:
+  area: 1000.0  # ha
+  dbh_range: [1.0, 25.0]  # cm
+  height_range: [0.5, 15.0]  # m
+  growth_rate_factor: 1.0 

configs/linear_plateau.yaml

@@ -0,0 +1,82 @@
+growth_model: linear_plateau
+
+species:
+  - name: "species_A"  # Rhizophora spp.
+    planting_density: 4000  # trees/ha
+    mortality_rates:
+      year_1: 15  # %
+      year_2: 12  # %
+      year_3: 6   # %
+      year_4: 5   # %
+      year_5: 5   # %
+      year_6: 5   # %
+      year_7: 5   # %
+      year_8: 5   # %
+      year_9: 5   # %
+      year_10: 5  # %
+      subsequent: 1.5  # % (years 11-30)
+    linear_plateau:
+      dbh:
+        r: 1.83  # cm/yr
+        T_p: 30  # plateau at 30 years
+        a: 11.07  # asymptote from params.yaml
+      height:
+        r: 0.61  # m/yr
+        T_p: 12  # plateau at 12 years
+        a: 11.58  # asymptote from params.yaml
+    allometry:
+      equation: "Zanvo et al. 2023: Total = 1.938 × (DBH² H)^0.67628"
+    initial_values:
+      dbh: 1.0    # cm
+      height: 0.5  # m
+
+  - name: "species_B"  # Avicennia germinans
+    planting_density: 444  # trees/ha
+    mortality_rates:
+      year_1: 15  # %
+      year_2: 12  # %
+      year_3: 6   # %
+      year_4: 5   # %
+      year_5: 5   # %
+      year_6: 5   # %
+      year_7: 5   # %
+      year_8: 5   # %
+      year_9: 5   # %
+      year_10: 5  # %
+      subsequent: 1.5  # % (years 11-30)
+    linear_plateau:
+      dbh:
+        r: 1.2  # cm/yr (example, adjust as needed)
+        T_p: 30
+        a: 17.0
+      height:
+        r: 0.4  # m/yr (example, adjust as needed)
+        T_p: 12
+        a: 8.8
+    allometry:
+      equation: "Zanvo et al. 2023: Total = 1.486 × (DBH² H)^0.55864"
+    initial_values:
+      dbh: 1.0    # cm
+      height: 0.5  # m
+
+project:
+  duration_years: 30  # matches project_years
+  planting_schedule:
+    year_1: 2500  # ha
+    year_2: 2500  # ha
+    year_3: 0  # ha
+    year_4: 0  # ha
+    year_5: 0  # ha
+
+carbon:
+  biomass_to_carbon: 0.47  # IPCC default
+  carbon_to_co2: 3.67     # molecular weight ratio
+  buffer_percentage: 20    # risk buffer
+  leakage_percentage: 0    # no leakage assumed
+  baseline_emissions: 0    # tCO2/ha/year
+
+scenarios:
+  area: 1000.0  # ha
+  dbh_range: [1.0, 25.0]  # cm
+  height_range: [0.5, 15.0]  # m
+  growth_rate_factor: 1.0 

configs/params.yaml

@@ -16,12 +16,12 @@ species:
     chapman_richards:
       dbh:
         a: 11.07  # asymptotic maximum DBH (cm)
-        b: 0.1237   # growth rate parameter (yr^-1)
+        b: 0.4736   # growth rate parameter (yr^-1), back-solved from Aug 2024 data
         c: 2.1    # shape parameter
       height:
-        a: 12.0   # asymptotic maximum height (m)
-        b: 0.1237   # growth rate parameter (yr^-1)
-        c: 2.1    # shape parameter
+        a: 11.58   # asymptotic maximum height (m)
+        b: 0.1335   # growth rate parameter (yr^-1), back-solved from Aug 2024 data
+        c: 1.5    # shape parameter
     allometry:
       equation: "Zanvo et al. 2023: Total = 1.938 × (DBH² H)^0.67628"
     initial_values:
@@ -45,12 +45,12 @@ species:
     chapman_richards:
       dbh:
         a: 17.0   # asymptotic maximum DBH (cm)
-        b: 0.1237  # growth rate parameter (yr^-1)
+        b: 0.4736  # growth rate parameter (yr^-1), back-solved from Aug 2024 data
         c: 2.1    # shape parameter
       height:
         a: 8.8    # asymptotic maximum height (m)
-        b: 0.1237  # growth rate parameter (yr^-1)
-        c: 2.1    # shape parameter
+        b: 0.1335  # growth rate parameter (yr^-1), back-solved from Aug 2024 data
+        c: 1.5    # shape parameter
     allometry:
       equation: "Zanvo et al. 2023: Total = 1.486 × (DBH² H)^0.55864"
     initial_values:

dashboard/app.py

@@ -1,459 +1,408 @@
 """
-Gradio dashboard for exploring ER model results and parameters.
-"""
-from pathlib import Path
-from typing import Dict, List, Tuple
+Mangrove ER Model Dashboard
 
+- Each tab corresponds to a different model/config.
+- To add a new model, add its config to configs/ and add an entry to MODEL_CONFIGS below.
+- Each tab shows the results for the base config (no parameter editing).
+"""
 import gradio as gr
+from pathlib import Path
+from src.er_model import ERModel
+import yaml
+import tempfile
 import matplotlib.pyplot as plt
-import numpy as np
 import pandas as pd
-import yaml
-import uuid
-
-from src.er_model import ERModel
+import numpy as np
+import plotly.graph_objs as go
+from plotly.subplots import make_subplots
+import warnings
+import traceback
 
+MODEL_CONFIGS = {
+    "Original Model": "configs/params.yaml",
+    "Simple Linear": "configs/linear.yaml",
+    "Linear Plateau": "configs/linear_plateau.yaml",
+    "Declining Increment": "configs/declining_increment.yaml"
+}
 
-def load_config(config_path: Path = Path("configs/params.yaml")) -> dict:
-    """Load and parse YAML configuration."""
+# Helper to update planting schedule in a config file
+def update_planting_schedule(config_path, year_areas):
     with open(config_path) as f:
-        return yaml.safe_load(f)
+        config = yaml.safe_load(f)
+    for i, area in enumerate(year_areas, 1):
+        config["project"]["planting_schedule"][f"year_{i}"] = area
+    return config
 
+def create_survival_table(model):
+    """
+    Returns a DataFrame with years as rows and columns for each species and total surviving trees.
+    """
+    years = range(1, model.project.duration_years + 1)
+    data = {"Year": []}
+    species_names = [s.name for s in model.species]
+    for name in species_names:
+        data[name] = []
+    data["Total Surviving Trees"] = []
+    for year in years:
+        data["Year"].append(year)
+        totals = model.calculate_total_surviving_trees(year)
+        total = 0
+        for name in species_names:
+            val = totals.get(name, 0)
+            data[name].append(val)
+            total += val
+        data["Total Surviving Trees"].append(total)
+    df = pd.DataFrame(data)
+    # Format numbers: no decimals, thousands separator
+    for name in species_names + ["Total Surviving Trees"]:
+        df[name] = df[name].apply(lambda x: f"{x:,.0f}")
+    return df
 
-def run_model(config: dict) -> Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
-    """Run model with current parameters."""
-    # Create a temporary config file with a unique name
-    temp_config = Path(f"configs/temp_config_{uuid.uuid4()}.yaml")
-    
-    try:
-        # Save temporary config
-        with open(temp_config, "w") as f:
-            yaml.dump(config, f)
-        
-        # Run model
-        model = ERModel(temp_config)
-        results, species_results, scenario_results = model.run()
-        
-        return results, species_results, scenario_results
-    finally:
-        # Clean up temp file
-        if temp_config.exists():
-            temp_config.unlink()
+def run_model_from_config(config):
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as tmp:
+        yaml.dump(config, tmp)
+        tmp_path = tmp.name
+    model = ERModel(Path(tmp_path))
+    results, species_results = model.run()
+    plots = create_all_plots(results, species_results, config)
+    summary = create_summary(results, species_results, config, model)
+    survival_table = create_survival_table(model)
+    # Format tables
+    results_fmt = results.copy()
+    species_results_fmt = species_results.copy()
+    for col in results_fmt.columns:
+        if results_fmt[col].dtype in [float, int]:
+            results_fmt[col] = results_fmt[col].apply(lambda x: f"{x:,.2f}" if isinstance(x, float) else f"{x:,}")
+    for col in species_results_fmt.columns:
+        if species_results_fmt[col].dtype in [float, int]:
+            species_results_fmt[col] = species_results_fmt[col].apply(lambda x: f"{x:,.2f}" if isinstance(x, float) else f"{x:,}")
+    return (*plots, summary, results_fmt.head(30), species_results_fmt.head(30), survival_table.head(30))
 
+def run_model(config_path):
+    with open(config_path) as f:
+        config = yaml.safe_load(f)
+    model = ERModel(Path(config_path))
+    results, species_results = model.run()
+    plots = create_all_plots(results, species_results, config)
+    summary = create_summary(results, species_results, config, model)
+    survival_table = create_survival_table(model)
+    # Format tables
+    results_fmt = results.copy()
+    species_results_fmt = species_results.copy()
+    for col in results_fmt.columns:
+        if results_fmt[col].dtype in [float, int]:
+            results_fmt[col] = results_fmt[col].apply(lambda x: f"{x:,.2f}" if isinstance(x, float) else f"{x:,}")
+    for col in species_results_fmt.columns:
+        if species_results_fmt[col].dtype in [float, int]:
+            species_results_fmt[col] = species_results_fmt[col].apply(lambda x: f"{x:,.2f}" if isinstance(x, float) else f"{x:,}")
+    return (*plots, summary, results_fmt.head(30), species_results_fmt.head(30), survival_table.head(30))
 
-def format_number(x):
-    """Format number with comma separators, handling NaN and floating points."""
-    if pd.isna(x):
-        return "0"
-    if isinstance(x, (int, float)):
-        if isinstance(x, int) or float(x).is_integer():
-            return format(int(x), ',')
-        return format(round(float(x), 2), ',')
-    return str(x)
+def check_complex(arr, label):
+    if np.iscomplexobj(arr):
+        complex_indices = np.where(np.iscomplex(arr))[0]
+        warnings.warn(f"[ERROR] Complex values in {label}: indices={complex_indices}, values={arr[complex_indices]}")
+        traceback.print_stack()
 
+def create_growth_increment_plots(config, model_type=None):
+    """
+    Create a 2x2 grid of growth and increment plots for DBH and Height using Plotly.
+    model_type: 'chapman_richards', 'linear', 'linear_plateau', or 'declining_increment'
+    """
+    if model_type is None:
+        model_type = config.get('growth_model', 'chapman_richards')
+    years = np.arange(1, config["project"]["duration_years"] + 1)
+    fig = make_subplots(rows=2, cols=2, subplot_titles=("DBH Growth", "HEIGHT Growth", "DBH Annual Increment", "HEIGHT Annual Increment"))
+    from src.er_model import ERModel
+    for sp in config["species"]:
+        name = sp["name"]
+        initial_dbh = sp["initial_values"]["dbh"]
+        initial_height = sp["initial_values"]["height"]
+        if model_type == "linear":
+            dbh_params = sp["linear"]["dbh"]
+            height_params = sp["linear"]["height"]
+            dbh = [ERModel.linear_growth(t, dbh_params, initial_dbh) for t in years]
+            height = [ERModel.linear_growth(t, height_params, initial_height) for t in years]
+        elif model_type == "linear_plateau":
+            dbh_params = sp["linear_plateau"]["dbh"]
+            height_params = sp["linear_plateau"]["height"]
+            dbh = [ERModel.linear_plateau_growth(t, dbh_params, initial_dbh) for t in years]
+            height = [ERModel.linear_plateau_growth(t, height_params, initial_height) for t in years]
+        elif model_type == "declining_increment":
+            dbh_params = sp["declining_increment"]["dbh"]
+            height_params = sp["declining_increment"]["height"]
+            dbh = [ERModel.declining_increment_growth(t, dbh_params, initial_dbh) for t in years]
+            height = [ERModel.declining_increment_growth(t, height_params, initial_height) for t in years]
+        else:  # Default to Chapman-Richards
+            dbh_params = sp["chapman_richards"]["dbh"]
+            height_params = sp["chapman_richards"]["height"]
+            def chapman_richards(t, params, initial):
+                a, b, c = params["a"], params["b"], params["c"]
+                return initial + (a - initial) * (1 - np.exp(-b * t)) ** c
+            dbh = [chapman_richards(t, dbh_params, initial_dbh) for t in years]
+            height = [chapman_richards(t, height_params, initial_height) for t in years]
+        dbh = np.array(dbh)
+        height = np.array(height)
+        check_complex(dbh, f"{name} DBH (growth)")
+        check_complex(height, f"{name} Height (growth)")
+        dbh_inc = np.diff(np.insert(dbh, 0, dbh[0]))
+        height_inc = np.diff(np.insert(height, 0, height[0]))
+        check_complex(dbh_inc, f"{name} DBH Δ (increment)")
+        check_complex(height_inc, f"{name} Height Δ (increment)")
+        fig.add_trace(go.Scatter(x=years, y=dbh, mode='lines', name=f"{name} DBH", legendgroup=name, line=dict(width=2)), row=1, col=1)
+        fig.add_trace(go.Scatter(x=years, y=height, mode='lines', name=f"{name} Height", legendgroup=name, line=dict(width=2)), row=1, col=2)
+        fig.add_trace(go.Scatter(x=years, y=dbh_inc, mode='lines', name=f"{name} DBH Δ", legendgroup=name, showlegend=False, line=dict(width=2)), row=2, col=1)
+        fig.add_trace(go.Scatter(x=years, y=height_inc, mode='lines', name=f"{name} Height Δ", legendgroup=name, showlegend=False, line=dict(width=2)), row=2, col=2)
+    fig.update_layout(height=700, width=900, title_text="Growth and Increment Curves", hovermode="x unified")
+    fig.update_xaxes(title_text="Age (years)", row=1, col=1)
+    fig.update_xaxes(title_text="Age (years)", row=1, col=2)
+    fig.update_xaxes(title_text="Age (years)", row=2, col=1)
+    fig.update_xaxes(title_text="Age (years)", row=2, col=2)
+    fig.update_yaxes(title_text="Size (cm)", row=1, col=1)
+    fig.update_yaxes(title_text="Size (m)", row=1, col=2)
+    fig.update_yaxes(title_text="Annual increment (cm/year)", row=2, col=1)
+    fig.update_yaxes(title_text="Annual increment (m/year)", row=2, col=2)
+    return fig
 
-def create_plots_and_tables(
-    results: pd.DataFrame,
-    species_results: pd.DataFrame,
-    scenario_results: pd.DataFrame,
-    config: dict,
-    year_1_area: float,
-    year_2_area: float,
-    year_3_area: float,
-    year_4_area: float,
-    year_5_area: float
-) -> Tuple[plt.Figure, plt.Figure, plt.Figure, str, pd.DataFrame, pd.DataFrame]:
-    """Create carbon sequestration plots, summary, and tables."""
-    # Clear any existing plots
-    plt.close('all')
-    
-    # Time series plot
-    fig1 = plt.figure(figsize=(10, 6))
-    ax1 = fig1.add_subplot(111)
-    results.plot(
-        x="year",
-        y=["gross_carbon", "net_carbon"],
-        ax=ax1,
-        title="Carbon Sequestration Over Time"
-    )
-    ax1.set_xlabel("Year")
-    ax1.set_ylabel("Carbon (tCO2)")
-    ax1.legend(["Gross Carbon", "Net Carbon"])
-    # Format y-axis with comma separator
-    ax1.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: format_number(x)))
-    
-    # Annual ERs plot (replacing milestone years plot)
-    fig2 = plt.figure(figsize=(10, 6))
-    ax2 = fig2.add_subplot(111)
-    
-    # Calculate annual ERs (year-over-year change in net carbon)
-    annual_ers = results["net_carbon"].diff()
-    annual_ers.iloc[0] = results["net_carbon"].iloc[0]  # First year is total, not difference
-    
-    # Plot annual ERs as bars
-    ax2.bar(results["year"], annual_ers, color='#2ecc71', alpha=0.7)
-    ax2.set_xlabel("Year")
-    ax2.set_ylabel("Annual ERs (tCO2)")
-    ax2.set_title("Annual Emission Reductions")
-    
-    # Format y-axis with comma separator
-    ax2.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: format_number(x)))
-    
-    # Add grid for better readability
-    ax2.grid(True, axis='y', linestyle='--', alpha=0.7)
-    
-    # Ensure integer ticks for years
-    ax2.xaxis.set_major_locator(plt.MaxNLocator(integer=True))
+def create_all_plots(results, species_results, config):
+    # Diagnostic: Check for complex numbers in results DataFrame columns used for plotting
+    for col in ["gross_carbon", "net_carbon"]:
+        arr = np.array(results[col])
+        check_complex(arr, f"results['{col}']")
+    # 1. Carbon curve (gross and net)
+    fig1 = go.Figure()
+    fig1.add_trace(go.Scatter(x=results["year"], y=results["gross_carbon"], mode="lines+markers", name="Gross Carbon", line=dict(width=2)))
+    fig1.add_trace(go.Scatter(x=results["year"], y=results["net_carbon"], mode="lines+markers", name="Net Carbon", line=dict(width=2)))
+    fig1.update_layout(title="Carbon Sequestration Over Time", xaxis_title="Year", yaxis_title="Carbon (tCO2)", hovermode="x unified", template="plotly_white")
+
+    # 2. Annual carbon (ERs)
+    annual_ers = results["net_carbon"].diff().fillna(results["net_carbon"].iloc[0])
+    arr = np.array(annual_ers)
+    check_complex(arr, "annual_ers")
+    fig2 = go.Figure()
+    fig2.add_trace(go.Bar(x=results["year"], y=annual_ers, name="Annual ERs", marker_color="#2ecc71", opacity=0.7))
+    fig2.update_layout(title="Annual Emission Reductions", xaxis_title="Year", yaxis_title="Annual ERs (tCO2)", hovermode="x unified", template="plotly_white")
 
-    # New biomass per tree plot
-    fig3 = plt.figure(figsize=(10, 6))
-    ax3 = fig3.add_subplot(111)
-    
-    # Get initial values
-    rhiz_init = config["species"][0]["initial_values"]
-    avic_init = config["species"][1]["initial_values"]
-    
-    # Create time series
-    years = np.arange(len(species_results))
-    
-    # Calculate DBH and height for each species over time
-    def chapman_richards(t, params, initial):
-        a, b, c = params["a"], params["b"], params["c"]
-        return initial + (a - initial) * (1 - np.exp(-b * t)) ** c
-    
-    # Calculate growth for Rhizophora
-    rhiz_dbh = chapman_richards(years, config["species"][0]["chapman_richards"]["dbh"], rhiz_init["dbh"])
-    rhiz_height = chapman_richards(years, config["species"][0]["chapman_richards"]["height"], rhiz_init["height"])
-    
-    # Calculate growth for Avicennia
-    avic_dbh = chapman_richards(years, config["species"][1]["chapman_richards"]["dbh"], avic_init["dbh"])
-    avic_height = chapman_richards(years, config["species"][1]["chapman_richards"]["height"], avic_init["height"])
-    
-    # Calculate biomass using Zanvo equations (convert kg to tonnes)
-    rhiz_biomass = 1.938 * (rhiz_dbh**2 * rhiz_height)**0.67628 / 1000  # Convert kg to tonnes
-    avic_biomass = 1.486 * (avic_dbh**2 * avic_height)**0.55864 / 1000  # Convert kg to tonnes
-    
-    # Plot with proper formatting
-    ax3.plot(years, rhiz_biomass, 'o-', color='#1f77b4', label='Rhizophora spp. - Total Biomass')
-    ax3.plot(years, avic_biomass, 'o-', color='#ff7f0e', label='Avicennia germinans - Total Biomass')
-    
-    ax3.set_xlabel("Year since planting")
-    ax3.set_ylabel("Biomass (tonnes per tree)")
-    ax3.set_title("Total Biomass per Tree")
-    ax3.grid(True)
-    ax3.legend()
-    
-    # Set proper axis limits
-    ax3.set_xlim(0, len(years)-1)
-    ax3.set_ylim(bottom=0)  # Start y-axis at 0
-    
-    # Format y-axis with comma separator
-    ax3.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: format_number(x)))
-    
-    # Ensure the plot is drawn
-    fig3.tight_layout()
-    plt.draw()
+    # 3. Biomass per tree for all species
+    years = results["year"]
+    fig3 = go.Figure()
+    from src.er_model import ERModel
+    growth_model = config.get('growth_model', 'chapman_richards')
+    for sp in config["species"]:
+        name = sp["name"]
+        initial_dbh = sp["initial_values"]["dbh"]
+        initial_height = sp["initial_values"]["height"]
+        if growth_model == "linear":
+            dbh_params = sp["linear"]["dbh"]
+            height_params = sp["linear"]["height"]
+            dbh = [ERModel.linear_growth(t, dbh_params, initial_dbh) for t in years]
+            height = [ERModel.linear_growth(t, height_params, initial_height) for t in years]
+        elif growth_model == "linear_plateau":
+            dbh_params = sp["linear_plateau"]["dbh"]
+            height_params = sp["linear_plateau"]["height"]
+            dbh = [ERModel.linear_plateau_growth(t, dbh_params, initial_dbh) for t in years]
+            height = [ERModel.linear_plateau_growth(t, height_params, initial_height) for t in years]
+        elif growth_model == "declining_increment":
+            dbh_params = sp["declining_increment"]["dbh"]
+            height_params = sp["declining_increment"]["height"]
+            dbh = [ERModel.declining_increment_growth(t, dbh_params, initial_dbh) for t in years]
+            height = [ERModel.declining_increment_growth(t, height_params, initial_height) for t in years]
+        else:  # Default to Chapman-Richards
+            dbh_params = sp["chapman_richards"]["dbh"]
+            height_params = sp["chapman_richards"]["height"]
+            def chapman_richards(t, params, initial):
+                a, b, c = params["a"], params["b"], params["c"]
+                return initial + (a - initial) * (1 - np.exp(-b * t)) ** c
+            dbh = [chapman_richards(t, dbh_params, initial_dbh) for t in years]
+            height = [chapman_richards(t, height_params, initial_height) for t in years]
+        if "Zanvo" in sp["allometry"]["equation"]:
+            if "1.938" in sp["allometry"]["equation"]:
+                biomass = 1.938 * (np.array(dbh) ** 2 * np.array(height)) ** 0.67628 / 1000
+            else:
+                biomass = 1.486 * (np.array(dbh) ** 2 * np.array(height)) ** 0.55864 / 1000
+        else:
+            biomass = dbh
+        check_complex(biomass, f"{name} biomass (allometry)")
+        fig3.add_trace(go.Scatter(x=years, y=biomass, mode="lines+markers", name=name, line=dict(width=2)))
+    fig3.update_layout(title="Total Biomass per Tree", xaxis_title="Year since planting", yaxis_title="Biomass (tonnes per tree)", hovermode="x unified", template="plotly_white")
+    return (fig1, fig2, fig3)
 
-    # Calculate total area from planting schedule
-    total_area = sum([
-        year_1_area, year_2_area, year_3_area, year_4_area, year_5_area
-    ])
-    
-    # Get final year carbon values
+def create_summary(results, species_results, config, model):
+    total_area = sum(config["project"]["planting_schedule"].values())
     final_gross = results["gross_carbon"].iloc[-1]
     final_net = results["net_carbon"].iloc[-1]
-    
-    # Calculate per hectare metrics
-    if total_area > 0:
-        gross_carbon_per_ha = final_gross / total_area
-        net_carbon_per_ha = final_net / total_area
-        annual_net_per_ha = net_carbon_per_ha / len(results)  # Divide by actual years
-    else:
-        gross_carbon_per_ha = 0
-        net_carbon_per_ha = 0
-        annual_net_per_ha = 0
-    
-    # Get year 10 and year 20 values for intermediate metrics
-    year_10_gross = results["gross_carbon"].iloc[9] if len(results) > 9 else 0
-    year_10_net = results["net_carbon"].iloc[9] if len(results) > 9 else 0
-    year_20_gross = results["gross_carbon"].iloc[19] if len(results) > 19 else 0
-    year_20_net = results["net_carbon"].iloc[19] if len(results) > 19 else 0
-    
-    # Calculate annual averages
-    years_with_carbon = len(results[results["gross_carbon"] > 0])
-    if years_with_carbon > 0:
-        avg_annual_gross = final_gross / years_with_carbon
-        avg_annual_net = final_net / years_with_carbon
-    else:
-        avg_annual_gross = 0
-        avg_annual_net = 0
-    
-    # Create summary text with formatted numbers
-    summary = f"""
-Project Overview:
-----------------
-Duration: {len(results)} years
-Total Area Planted: {format_number(total_area)} ha
-Buffer Pool: {config["carbon"]["buffer_percentage"]}%
-
-Carbon Sequestration:
--------------------
-Total Gross Carbon (Year 30): {format_number(final_gross)} tCO2
-Total Net Carbon (Year 30): {format_number(final_net)} tCO2
-Average Annual Gross: {format_number(avg_annual_gross)} tCO2/yr
-Average Annual Net: {format_number(avg_annual_net)} tCO2/yr
-
-Milestone Years:
---------------
-Year 10 Gross: {format_number(year_10_gross)} tCO2
-Year 10 Net: {format_number(year_10_net)} tCO2
-Year 20 Gross: {format_number(year_20_gross)} tCO2
-Year 20 Net: {format_number(year_20_net)} tCO2
-
-Per Hectare Metrics (Year 30):
------------------------------
-Gross Carbon per ha: {format_number(gross_carbon_per_ha)} tCO2/ha
-Net Carbon per ha: {format_number(net_carbon_per_ha)} tCO2/ha
-Average Annual Net per ha: {format_number(annual_net_per_ha)} tCO2/ha/yr
-"""
-    
-    # Format species results table with comma separators
-    species_table = species_results.copy()
-    species_table.index.name = "Year"
-    for col in species_table.select_dtypes(include=[np.number]).columns:
-        species_table[col] = species_table[col].apply(format_number)
-    
-    # Create annual ERs table
-    annual_results = pd.DataFrame({
-        'Year': results['year'],
-        'Annual ERs (tCO2)': annual_ers,
-        'Cumulative ERs (tCO2)': results['net_carbon'],
-        'Area Planted (ha)': results[[col for col in results.columns if col.startswith('area_year_')]].sum(axis=1),
-        'Cumulative Area (ha)': results[[col for col in results.columns if col.startswith('area_year_')]].cumsum().sum(axis=1)
-    })
-    
-    # Format annual results table with comma separators
-    for col in annual_results.select_dtypes(include=[np.number]).columns:
-        annual_results[col] = annual_results[col].apply(format_number)
-    
-    # Format scenario comparison table with comma separators
-    scenario_table = scenario_results.copy()
-    scenario_table.index.name = "Scenario"
-    for col in scenario_table.select_dtypes(include=[np.number]).columns:
-        scenario_table[col] = scenario_table[col].apply(format_number)
-    
-    return fig1, fig2, fig3, summary, annual_results, scenario_table
-
-
-def update_model(
-    rhiz_density: float,
-    rhiz_mort_1: float,
-    rhiz_mort_2: float,
-    rhiz_mort_3: float,
-    rhiz_mort_4: float,
-    rhiz_mort_5: float,
-    avic_density: float,
-    avic_mort_1: float,
-    avic_mort_2: float,
-    avic_mort_3: float,
-    avic_mort_4: float,
-    avic_mort_5: float,
-    year_1_area: float,
-    year_2_area: float,
-    year_3_area: float,
-    year_4_area: float,
-    year_5_area: float,
-    buffer_percentage: float,
-    # Chapman-Richards parameters for Rhizophora
-    rhiz_dbh_a: float,
-    rhiz_dbh_b: float,
-    rhiz_dbh_c: float,
-    rhiz_height_a: float,
-    rhiz_height_b: float,
-    rhiz_height_c: float,
-    rhiz_initial_dbh: float,
-    rhiz_initial_height: float,
-    # Chapman-Richards parameters for Avicennia
-    avic_dbh_a: float,
-    avic_dbh_b: float,
-    avic_dbh_c: float,
-    avic_height_a: float,
-    avic_height_b: float,
-    avic_height_c: float,
-    avic_initial_dbh: float,
-    avic_initial_height: float,
-) -> Tuple[plt.Figure, plt.Figure, plt.Figure, str, pd.DataFrame, pd.DataFrame]:
-    """Update model with new parameters and return plots and tables."""
-    # Load base config
-    config = load_config()
-    
-    # Update Rhizophora parameters
-    config["species"][0]["planting_density"] = rhiz_density
-    config["species"][0]["mortality_rates"].update({
-        "year_1": rhiz_mort_1,
-        "year_2": rhiz_mort_2,
-        "year_3": rhiz_mort_3,
-        "year_4": rhiz_mort_4,
-        "year_5": rhiz_mort_5
-    })
-    
-    # Update Rhizophora Chapman-Richards parameters
-    config["species"][0]["chapman_richards"]["dbh"].update({
-        "a": rhiz_dbh_a,
-        "b": rhiz_dbh_b,
-        "c": rhiz_dbh_c
-    })
-    config["species"][0]["chapman_richards"]["height"].update({
-        "a": rhiz_height_a,
-        "b": rhiz_height_b,
-        "c": rhiz_height_c
-    })
-    config["species"][0]["initial_values"].update({
-        "dbh": rhiz_initial_dbh,
-        "height": rhiz_initial_height
-    })
-    
-    # Update Avicennia parameters
-    config["species"][1]["planting_density"] = avic_density
-    config["species"][1]["mortality_rates"].update({
-        "year_1": avic_mort_1,
-        "year_2": avic_mort_2,
-        "year_3": avic_mort_3,
-        "year_4": avic_mort_4,
-        "year_5": avic_mort_5
-    })
-    
-    # Update Avicennia Chapman-Richards parameters
-    config["species"][1]["chapman_richards"]["dbh"].update({
-        "a": avic_dbh_a,
-        "b": avic_dbh_b,
-        "c": avic_dbh_c
-    })
-    config["species"][1]["chapman_richards"]["height"].update({
-        "a": avic_height_a,
-        "b": avic_height_b,
-        "c": avic_height_c
-    })
-    config["species"][1]["initial_values"].update({
-        "dbh": avic_initial_dbh,
-        "height": avic_initial_height
-    })
-    
-    # Update planting schedule
-    config["project"]["planting_schedule"].update({
-        "year_1": year_1_area,
-        "year_2": year_2_area,
-        "year_3": year_3_area,
-        "year_4": year_4_area,
-        "year_5": year_5_area
-    })
-    
-    # Update carbon parameters
-    config["carbon"]["buffer_percentage"] = buffer_percentage
-    
-    # Run model and create plots/tables
-    results, species_results, scenario_results = run_model(config)
-    return create_plots_and_tables(results, species_results, scenario_results, config, year_1_area, year_2_area, year_3_area, year_4_area, year_5_area)
-
+    years = len(results)
+    gross_carbon_per_ha = final_gross / total_area if total_area > 0 else 0
+    net_carbon_per_ha = final_net / total_area if total_area > 0 else 0
+    annual_net_per_ha = net_carbon_per_ha / years if years > 0 else 0
+    # Milestone years
+    def get_val(col, idx):
+        return results[col].iloc[idx] if len(results) > idx else 0
+    year_5_gross = get_val("gross_carbon", 4)
+    year_5_net = get_val("net_carbon", 4)
+    year_10_gross = get_val("gross_carbon", 9)
+    year_10_net = get_val("net_carbon", 9)
+    year_20_gross = get_val("gross_carbon", 19)
+    year_20_net = get_val("net_carbon", 19)
+    avg_annual_gross = final_gross / years if years > 0 else 0
+    avg_annual_net = final_net / years if years > 0 else 0
+    # Surviving trees at milestones
+    milestones = [5, 10, 20, 30]
+    survival_lines = []
+    for m in milestones:
+        if m <= years:
+            surv = model.calculate_total_surviving_trees(m)
+            surv_str = ", ".join([f"{k}: {v:,.0f}" for k, v in surv.items()])
+            survival_lines.append(f"Year {m} surviving trees: {surv_str}")
+    # Per hectare (final year)
+    surv_30 = model.calculate_total_surviving_trees(years)
+    per_ha_lines = []
+    for k, v in surv_30.items():
+        per_ha = v / total_area if total_area > 0 else 0
+        per_ha_lines.append(f"{k}: {per_ha:,.0f} trees/ha")
+    summary = (
+        f"Project Overview:\n----------------\nDuration: {years} years\nTotal Area Planted: {total_area:,.0f} ha\nBuffer Pool: {config['carbon']['buffer_percentage']}%\n\n"
+        f"Carbon Sequestration:\n-------------------\nTotal Gross Carbon (Year {years}): {final_gross:,.0f} tCO2\nTotal Net Carbon (Year {years}): {final_net:,.0f} tCO2\nAverage Annual Gross: {avg_annual_gross:,.0f} tCO2/yr\nAverage Annual Net: {avg_annual_net:,.0f} tCO2/yr\n\n"
+        f"Milestone Years:\n--------------\nYear 5 Gross: {year_5_gross:,.0f} tCO2\nYear 5 Net: {year_5_net:,.0f} tCO2\nYear 10 Gross: {year_10_gross:,.0f} tCO2\nYear 10 Net: {year_10_net:,.0f} tCO2\nYear 20 Gross: {year_20_gross:,.0f} tCO2\nYear 20 Net: {year_20_net:,.0f} tCO2\n\n"
+        "Surviving Trees (Milestones):\n----------------------------\n"
+        + "\n".join(survival_lines)
+        + "\n\nPer Hectare Surviving Trees (Final Year):\n----------------------------------------\n"
+        + "\n".join(per_ha_lines)
+        + f"\n\nPer Hectare Metrics (Year {years}):\n-----------------------------\nGross Carbon per ha: {gross_carbon_per_ha:,.0f} tCO2/ha\nNet Carbon per ha: {net_carbon_per_ha:,.0f} tCO2/ha\nAverage Annual Net per ha: {annual_net_per_ha:,.2f} tCO2/ha/yr\n"
+    )
+    return summary
 
-def main():
-    """Run the Gradio interface."""
-    with gr.Blocks(theme=gr.themes.Soft()) as app:
-        gr.Markdown("# ER Model Dashboard")
-        gr.Markdown("Explore carbon sequestration results with different growth parameters")
-        
-        with gr.Tab("Model Parameters"):
+with gr.Blocks() as demo:
+    gr.Markdown("# Mangrove ER Model Dashboard\nSelect a model tab to view results for that model's base configuration.")
+    with gr.Tabs():
+        # Original Model tab with planting schedule editing
+        with gr.Tab("Original Model"):
+            gr.Markdown("## Planting Schedule (ha per year)")
+            year_1 = gr.Number(value=2500, label="Year 1 Area (ha)")
+            year_2 = gr.Number(value=2500, label="Year 2 Area (ha)")
+            year_3 = gr.Number(value=0, label="Year 3 Area (ha)")
+            year_4 = gr.Number(value=0, label="Year 4 Area (ha)")
+            year_5 = gr.Number(value=0, label="Year 5 Area (ha)")
+            update_btn = gr.Button("Update Results", variant="primary")
             with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### Rhizophora Parameters")
-                    rhiz_density = gr.Number(value=2500, label="Planting Density (trees/ha)")
-                    rhiz_mort_1 = gr.Number(value=20, label="Year 1 Mortality (%)")
-                    rhiz_mort_2 = gr.Number(value=10, label="Year 2 Mortality (%)")
-                    rhiz_mort_3 = gr.Number(value=5, label="Year 3 Mortality (%)")
-                    rhiz_mort_4 = gr.Number(value=2, label="Year 4 Mortality (%)")
-                    rhiz_mort_5 = gr.Number(value=1, label="Year 5 Mortality (%)")
-                    
-                    gr.Markdown("### Rhizophora Growth Parameters")
-                    rhiz_dbh_a = gr.Number(value=11.07, label="DBH Asymptote (cm)")
-                    rhiz_dbh_b = gr.Number(value=0.4736, label="DBH Growth Rate (yr⁻¹)")
-                    rhiz_dbh_c = gr.Number(value=2.1, label="DBH Shape Parameter")
-                    rhiz_height_a = gr.Number(value=11.58, label="Height Asymptote (m)")
-                    rhiz_height_b = gr.Number(value=0.1335, label="Height Growth Rate (yr⁻¹)")
-                    rhiz_height_c = gr.Number(value=1.5, label="Height Shape Parameter")
-                    rhiz_initial_dbh = gr.Number(value=1.0, label="Initial DBH (cm)")
-                    rhiz_initial_height = gr.Number(value=0.5, label="Initial Height (m)")
-                    
-                with gr.Column():
-                    gr.Markdown("### Avicennia Parameters")
-                    avic_density = gr.Number(value=2500, label="Planting Density (trees/ha)")
-                    avic_mort_1 = gr.Number(value=20, label="Year 1 Mortality (%)")
-                    avic_mort_2 = gr.Number(value=10, label="Year 2 Mortality (%)")
-                    avic_mort_3 = gr.Number(value=5, label="Year 3 Mortality (%)")
-                    avic_mort_4 = gr.Number(value=2, label="Year 4 Mortality (%)")
-                    avic_mort_5 = gr.Number(value=1, label="Year 5 Mortality (%)")
-                    
-                    gr.Markdown("### Avicennia Growth Parameters")
-                    avic_dbh_a = gr.Number(value=11.07, label="DBH Asymptote (cm)")
-                    avic_dbh_b = gr.Number(value=0.4736, label="DBH Growth Rate (yr⁻¹)")
-                    avic_dbh_c = gr.Number(value=2.1, label="DBH Shape Parameter")
-                    avic_height_a = gr.Number(value=11.58, label="Height Asymptote (m)")
-                    avic_height_b = gr.Number(value=0.1335, label="Height Growth Rate (yr⁻¹)")
-                    avic_height_c = gr.Number(value=1.5, label="Height Shape Parameter")
-                    avic_initial_dbh = gr.Number(value=1.0, label="Initial DBH (cm)")
-                    avic_initial_height = gr.Number(value=0.5, label="Initial Height (m)")
-                    
+                carbon_plot = gr.Plot()
+                annual_plot = gr.Plot()
+                biomass_plot = gr.Plot()
+                # Now re-enable carbon_plot as well
+            # growth_plot = gr.Plot(label="Growth & Increment Curves")
+            summary_box = gr.Textbox(label="Summary", lines=12)
+            results_box = gr.Dataframe()
+            species_box = gr.Dataframe()
+            survival_box = gr.Dataframe(label="Surviving Trees Table")
+            def update_original_model(y1, y2, y3, y4, y5):
+                config = update_planting_schedule(MODEL_CONFIGS["Original Model"], [y1, y2, y3, y4, y5])
+                import tempfile
+                import yaml
+                with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as tmp:
+                    yaml.dump(config, tmp)
+                    tmp_path = tmp.name
+                model = ERModel(Path(tmp_path))
+                results, species_results = model.run()
+                plots = create_all_plots(results, species_results, config)
+                summary = create_summary(results, species_results, config, model)
+                survival_table = create_survival_table(model)
+                results_fmt = results.copy()
+                species_results_fmt = species_results.copy()
+                for col in results_fmt.columns:
+                    if results_fmt[col].dtype in [float, int]:
+                        results_fmt[col] = results_fmt[col].apply(lambda x: f"{x:,.2f}" if isinstance(x, float) else f"{x:,}")
+                for col in species_results_fmt.columns:
+                    if species_results_fmt[col].dtype in [float, int]:
+                        species_results_fmt[col] = species_results_fmt[col].apply(lambda x: f"{x:,.2f}" if isinstance(x, float) else f"{x:,}")
+                # Return the carbon plot (plots[0]), biomass plot (plots[2]), and annual plot (plots[1])
+                return plots[0], plots[2], plots[1], summary, results_fmt.head(30), species_results_fmt.head(30), survival_table.head(30)
+            update_btn.click(
+                update_original_model,
+                inputs=[year_1, year_2, year_3, year_4, year_5],
+                outputs=[carbon_plot, biomass_plot, annual_plot, summary_box, results_box, species_box, survival_box]
+            )
+            # Show initial results
+            c, a, b, summary, r, s, surv = run_model(MODEL_CONFIGS["Original Model"])
+            # Assign the carbon plot (c), biomass plot (b), and annual plot (a)
+            carbon_plot.value = c
+            biomass_plot.value = b
+            annual_plot.value = a
+            summary_box.value = summary
+            results_box.value = r
+            species_box.value = s
+            survival_box.value = surv
+        # Simple Linear tab
+        with gr.Tab("Simple Linear"):
+            gr.Markdown("## Simple Linear Model Results (base config)")
+            carbon_plot, annual_plot, biomass_plot, summary, results, species, survival = run_model(MODEL_CONFIGS["Simple Linear"])
+            growth_fig = create_growth_increment_plots(yaml.safe_load(open(MODEL_CONFIGS["Simple Linear"])), model_type="linear")
             with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### Project Parameters")
-                    year_1_area = gr.Number(value=2500, label="Year 1 Planting Area (ha)")
-                    year_2_area = gr.Number(value=2500, label="Year 2 Planting Area (ha)")
-                    year_3_area = gr.Number(value=0, label="Year 3 Planting Area (ha)")
-                    year_4_area = gr.Number(value=0, label="Year 4 Planting Area (ha)")
-                    year_5_area = gr.Number(value=0, label="Year 5 Planting Area (ha)")
-                    buffer_percentage = gr.Number(value=20, label="Buffer Pool (%)")
-        
-        with gr.Row():
-            update_btn = gr.Button("Update Model")
-        
-        with gr.Tab("Results"):
+                carbon_plot_comp = gr.Plot(value=carbon_plot)
+                biomass_plot_comp = gr.Plot(value=biomass_plot)
+                annual_plot_comp = gr.Plot(value=annual_plot)
+            # gr.Plot(value=growth_fig, label="Growth & Increment Curves")
+            gr.Textbox(value=summary, label="Summary", lines=12)
+            gr.Markdown("### Results Table")
+            gr.Dataframe(value=results)
+            gr.Markdown("### Species Table")
+            gr.Dataframe(value=species)
+            gr.Markdown("### Surviving Trees Table")
+            gr.Dataframe(value=survival)
+        # Linear Plateau tab
+        with gr.Tab("Linear Plateau"):
+            gr.Markdown("## Linear Plateau Model Results (base config)")
+            carbon_plot, annual_plot, biomass_plot, summary, results, species, survival = run_model(MODEL_CONFIGS["Linear Plateau"])
+            growth_fig = create_growth_increment_plots(yaml.safe_load(open(MODEL_CONFIGS["Linear Plateau"])), model_type="linear_plateau")
             with gr.Row():
-                carbon_plot = gr.Plot(label="Carbon Sequestration")
-                annual_plot = gr.Plot(label="Annual ERs")
-                biomass_plot = gr.Plot(label="Biomass per Tree")
-            
-            summary_text = gr.Textbox(label="Summary", lines=10)
-            
+                carbon_plot_comp = gr.Plot(value=carbon_plot)
+                biomass_plot_comp = gr.Plot(value=biomass_plot)
+                annual_plot_comp = gr.Plot(value=annual_plot)
+            # gr.Plot(value=growth_fig, label="Growth & Increment Curves")
+            gr.Textbox(value=summary, label="Summary", lines=12)
+            gr.Markdown("### Results Table")
+            gr.Dataframe(value=results)
+            gr.Markdown("### Species Table")
+            gr.Dataframe(value=species)
+            gr.Markdown("### Surviving Trees Table")
+            gr.Dataframe(value=survival)
+        # Declining Increment tab
+        with gr.Tab("Declining Increment"):
+            gr.Markdown("## Declining Increment Model Results (base config)")
+            carbon_plot, annual_plot, biomass_plot, summary, results, species, survival = run_model(MODEL_CONFIGS["Declining Increment"])
+            growth_fig = create_growth_increment_plots(yaml.safe_load(open(MODEL_CONFIGS["Declining Increment"])), model_type="declining_increment")
+            # Diagnostics for DBH, height, and biomass arrays before plotting (biomass plot)
+            config = yaml.safe_load(open(MODEL_CONFIGS["Declining Increment"]))
+            years = results["year"]
+            from src.er_model import ERModel
+            for sp in config["species"]:
+                name = sp["name"]
+                initial_dbh = sp["initial_values"]["dbh"]
+                initial_height = sp["initial_values"]["height"]
+                dbh_params = sp["declining_increment"]["dbh"]
+                height_params = sp["declining_increment"]["height"]
+                dbh = np.array([ERModel.declining_increment_growth(float(t), dbh_params, initial_dbh) for t in years])
+                height = np.array([ERModel.declining_increment_growth(float(t), height_params, initial_height) for t in years])
+                if "Zanvo" in sp["allometry"]["equation"]:
+                    if "1.938" in sp["allometry"]["equation"]:
+                        biomass = 1.938 * (dbh ** 2 * height) ** 0.67628 / 1000
+                    else:
+                        biomass = 1.486 * (dbh ** 2 * height) ** 0.55864 / 1000
+                else:
+                    biomass = dbh
+                print(f"[DEBUG] {name} DBH: min={dbh.min()}, max={dbh.max()}, any_negative={np.any(dbh < 0)}, any_complex={np.iscomplexobj(dbh)}")
+                print(f"[DEBUG] {name} Height: min={height.min()}, max={height.max()}, any_negative={np.any(height < 0)}, any_complex={np.iscomplexobj(height)}")
+                print(f"[DEBUG] {name} Biomass: min={biomass.min()}, max={biomass.max()}, any_negative={np.any(biomass < 0)}, any_complex={np.iscomplexobj(biomass)}")
             with gr.Row():
-                annual_table = gr.DataFrame(label="Annual Results")
-                species_table = gr.DataFrame(label="Species Results")
-        
-        # Connect the update button to the model update function
-        inputs = [
-            rhiz_density, rhiz_mort_1, rhiz_mort_2, rhiz_mort_3, rhiz_mort_4, rhiz_mort_5,
-            avic_density, avic_mort_1, avic_mort_2, avic_mort_3, avic_mort_4, avic_mort_5,
-            year_1_area, year_2_area, year_3_area, year_4_area, year_5_area,
-            buffer_percentage,
-            # Chapman-Richards parameters for Rhizophora
-            rhiz_dbh_a, rhiz_dbh_b, rhiz_dbh_c,
-            rhiz_height_a, rhiz_height_b, rhiz_height_c,
-            rhiz_initial_dbh, rhiz_initial_height,
-            # Chapman-Richards parameters for Avicennia
-            avic_dbh_a, avic_dbh_b, avic_dbh_c,
-            avic_height_a, avic_height_b, avic_height_c,
-            avic_initial_dbh, avic_initial_height
-        ]
-        
-        outputs = [carbon_plot, annual_plot, biomass_plot, summary_text, annual_table, species_table]
-        
-        # Connect button click event
-        update_btn.click(fn=update_model, inputs=inputs, outputs=outputs)
-        
-        # Initialize the UI with default values
-        app.load(fn=update_model, inputs=inputs, outputs=outputs)
-    
-    return app
-
+                carbon_plot_comp = gr.Plot(value=carbon_plot)
+                biomass_plot_comp = gr.Plot(value=biomass_plot)
+                annual_plot_comp = gr.Plot(value=annual_plot)
+            # gr.Plot(value=growth_fig, label="Growth & Increment Curves")
+            gr.Textbox(value=summary, label="Summary", lines=12)
+            gr.Markdown("### Results Table")
+            gr.Dataframe(value=results)
+            gr.Markdown("### Species Table")
+            gr.Dataframe(value=species)
+            gr.Markdown("### Surviving Trees Table")
+            gr.Dataframe(value=survival)
 
 if __name__ == "__main__":
-    app = main()
-    app.launch(share=True) 
+    demo.launch() 

models/original/README.md

@@ -0,0 +1,30 @@
+# Original Model
+
+## Model Overview
+This is the default Chapman-Richards-based mangrove growth and carbon model for the project. It uses species-specific growth curves and DBH-dependent mortality to estimate carbon sequestration and tree survival over time.
+
+## Growth & Mortality Logic
+- **Growth:**
+  - Uses Chapman-Richards equations for both DBH and height for each species.
+  - Parameters are derived from field data and literature.
+- **Mortality:**
+  - Applies a DBH-dependent mortality rate, where annual mortality is a function of tree size (DBH) and its increment.
+  - This dynamic approach reflects higher mortality when trees are small, leveling off as they mature.
+
+## Parameters
+- See `configs/params.yaml` for all parameter values, including:
+  - Chapman-Richards parameters for DBH and height
+  - Initial values for DBH and height
+  - Planting density
+  - Mortality parameters (m_ref, DBH_ref, p)
+  - Allometric equations for biomass
+
+## References
+- Chapman-Richards growth model literature
+- Zanvo et al. (2023) for allometric equations
+- Field data from Nigeria mangrove sites (2024)
+
+## Usage
+- This model is available as the "Original Model" tab in the dashboard.
+- To modify parameters, edit `configs/params.yaml`.
+- For more details on running the dashboard, see the top-level README. 

src/allometry.py

@@ -17,6 +17,9 @@ def calculate_biomass(dbh: float, height: float, species_name: str, params: Dict
     Returns:
         Total tree biomass (above + below ground) in kg
     """
+    base = dbh**2 * height
+    if base <= 0:
+        print(f"[ERROR] Non-positive base in calculate_biomass: dbh={dbh}, height={height}, base={base}, species={species_name}")
     # Use Zanvo et al. 2023 equations that include both DBH and height
     if species_name == "species_A":  # Rhizophora
         # Total = 1.938 × (DBH² H)^0.67628

src/er_model.py

@@ -8,6 +8,7 @@ from typing import Dict, List, Optional, Tuple
 import numpy as np
 import pandas as pd
 import yaml
+import warnings
 
 from .allometry import calculate_biomass
 from .metrics import calculate_carbon
@@ -18,10 +19,18 @@ class Species:
     """Species-specific parameters for growth and carbon calculations."""
     name: str
     planting_density: float
-    mortality_rates: Dict[str, float]
-    chapman_richards: Dict[str, Dict[str, float]]  # Nested dict for dbh and height parameters
-    allometry: Dict[str, float]
-    initial_values: Dict[str, float]
+    # Old style
+    mortality_rates: Optional[Dict[str, float]] = None
+    # New style
+    m_ref: Optional[float] = None
+    DBH_ref: Optional[float] = None
+    p: Optional[float] = None
+    chapman_richards: Dict[str, Dict[str, float]] = None
+    allometry: Dict[str, float] = None
+    initial_values: Dict[str, float] = None
+    linear: Optional[Dict[str, Dict[str, float]]] = None
+    linear_plateau: Optional[Dict[str, Dict[str, float]]] = None
+    declining_increment: Optional[Dict[str, Dict[str, float]]] = None
 
 
 @dataclass
@@ -76,32 +85,73 @@ class ERModel:
         self.species_results: Optional[pd.DataFrame] = None
         self.scenario_results: Optional[pd.DataFrame] = None
         
-    def calculate_cohort_surviving_trees(self, planting_year: int, current_year: int, initial_trees: float, mortality_rates: Dict[str, float]) -> float:
+        self.growth_model = config.get('growth_model', 'chapman_richards')
+        
+    def calculate_cohort_surviving_trees(self, planting_year: int, current_year: int, initial_trees: float, species: Species, plateau_density: Optional[float] = None, growth_model: str = None) -> float:
         """
         Calculate surviving trees for a cohort planted in planting_year, in current_year.
-        Applies cumulative mortality for the cohort's age.
+        Uses either per-year mortality (from config) or DBH-dependent mortality.
+        growth_model: which growth model to use for DBH (e.g., 'linear', 'linear_plateau', etc.)
         """
+        if growth_model is None:
+            growth_model = getattr(self, 'growth_model', 'chapman_richards')
         age = current_year - planting_year + 1
         if age < 1:
             return 0
-        surviving = initial_trees
-        for y in range(1, age + 1):
-            rate = mortality_rates.get(f"year_{y}", mortality_rates["subsequent"]) / 100.0
-            surviving *= (1 - rate)
-        return surviving
+        if initial_trees == 0:
+            # Suppress debug output for zero-initial-trees cohorts
+            return 0
+        N_live = initial_trees
+        for year in range(1, age + 1):
+            debug_info = {
+                'planting_year': planting_year,
+                'current_year': current_year,
+                'cohort_age': year,
+                'initial_trees': initial_trees,
+                'N_live_before': N_live
+            }
+            if species.mortality_rates is not None:
+                year_key = f"year_{year}"
+                if year_key in species.mortality_rates:
+                    mort_rate = species.mortality_rates[year_key]
+                else:
+                    mort_rate = species.mortality_rates.get("subsequent", 0)
+                    print(f"[DEBUG] Year key '{year_key}' not found in mortality_rates for {species.name}. Using 'subsequent' or 0. Available keys: {list(species.mortality_rates.keys())}")
+                m = mort_rate / 100.0
+                debug_info['mortality_logic'] = 'annual'
+                debug_info['mortality_rate_percent'] = mort_rate
+            else:
+                growth_func, dbh_params = self.get_growth_function_and_params(species, growth_model, 'dbh')
+                dbh = growth_func(year, dbh_params, species.initial_values["dbh"])
+                dbh = max(dbh, 1.0)
+                m_ref = species.m_ref if species.m_ref is not None else 0.16
+                DBH_ref = species.DBH_ref if species.DBH_ref is not None else 9.0
+                p = species.p if species.p is not None else 1.493
+                m = m_ref * (DBH_ref / dbh) ** p
+                m = min(max(m, 0), 0.99)
+                debug_info['mortality_logic'] = 'dbh-dependent'
+                debug_info['mortality_rate_percent'] = m * 100
+                debug_info['dbh'] = dbh
+            N_live = N_live * (1 - m)
+            debug_info['N_live_after'] = N_live
+            print(f"[DEBUG] {species.name} | PlantingYear: {planting_year} | Year: {current_year} | CohortAge: {year} | MortalityLogic: {debug_info['mortality_logic']} | MortalityRate(%): {debug_info['mortality_rate_percent']} | N_live_before: {debug_info['N_live_before']} | N_live_after: {debug_info['N_live_after']}")
+        return N_live
 
     def calculate_total_surviving_trees(self, year: int) -> Dict[str, float]:
         """
         Calculate total surviving trees for each species in a given year, summing across all cohorts.
         Returns a dict: {species_name: total_surviving_trees}
         """
+        growth_model = getattr(self, 'growth_model', 'chapman_richards')
         totals = {}
         for species in self.species:
             total = 0
             for planting_year, area in self.project.planting_schedule.items():
                 py = int(planting_year.split("_")[1])
                 initial_trees = species.planting_density * area
-                total += self.calculate_cohort_surviving_trees(py, year, initial_trees, species.mortality_rates)
+                # Use plateau_density as the year-5 value for this cohort
+                plateau_density = species.planting_density * area if 5 <= (year - py + 1) else None
+                total += self.calculate_cohort_surviving_trees(py, year, initial_trees, species, plateau_density, growth_model)
             totals[species.name] = total
         return totals
 
@@ -116,21 +166,43 @@ class ERModel:
                 total += area
         return total
 
-    def chapman_richards_growth(self, age: float, params: Dict[str, float], initial_value: float) -> float:
-        """
-        Calculate growth using Chapman-Richards growth equation.
-        
-        Args:
-            age: Tree age in years
-            params: Dictionary with a, b, c parameters
-            initial_value: Initial value (DBH or height)
-            
-        Returns:
-            Current size (DBH in cm or height in m)
-        """
+    @staticmethod
+    def chapman_richards_growth(age: float, params: Dict[str, float], initial_value: float) -> float:
         a, b, c = params["a"], params["b"], params["c"]
         return initial_value + (a - initial_value) * (1 - np.exp(-b * age)) ** c
 
+    @staticmethod
+    def linear_growth(age: float, params: Dict[str, float], initial_value: float) -> float:
+        r = params["r"]
+        return initial_value + r * age
+
+    @staticmethod
+    def linear_plateau_growth(age: float, params: Dict[str, float], initial_value: float) -> float:
+        r = params["r"]
+        T_p = params["T_p"]
+        a = params["a"]
+        if age <= T_p:
+            return initial_value + r * age
+        else:
+            return initial_value + a
+
+    @staticmethod
+    def declining_increment_growth(age: float, params: Dict[str, float], initial_value: float) -> float:
+        r0 = params["r0"]
+        T_m = params["T_m"]
+        # Accumulate annual increments, never negative
+        total = initial_value
+        for i in range(1, int(np.floor(age)) + 1):
+            increment = r0 * max(0, 1 - (i - 1) / T_m)
+            total += increment
+        # If age is fractional, add partial increment for the last year
+        frac = age - int(np.floor(age))
+        if frac > 0:
+            i = int(np.floor(age)) + 1
+            increment = r0 * max(0, 1 - (i - 1) / T_m)
+            total += frac * increment
+        return total
+
     def calculate_carbon_for_species(self, species: Species, age: int, area: float) -> float:
         """
         Calculate carbon sequestration for a single species and age.
@@ -141,23 +213,15 @@ class ERModel:
         Returns:
             Carbon sequestration in tCO2
         """
-        # Calculate surviving trees using cumulative mortality for the given age
+        # Calculate surviving trees using DBH-dependent mortality
         initial_trees = species.planting_density * area
-        surviving = initial_trees
-        for y in range(1, age + 1):
-            rate = species.mortality_rates.get(f"year_{y}", species.mortality_rates["subsequent"]) / 100.0
-            surviving *= (1 - rate)
-        # Calculate DBH and height using Chapman-Richards
-        dbh = self.chapman_richards_growth(
-            age, 
-            species.chapman_richards["dbh"],
-            species.initial_values["dbh"]
-        )
-        height = self.chapman_richards_growth(
-            age,
-            species.chapman_richards["height"],
-            species.initial_values["height"]
-        )
+        plateau_density = species.planting_density * area if age >= 5 else None
+        surviving = self.calculate_cohort_surviving_trees(1, age, initial_trees, species, plateau_density, self.growth_model)
+        # Calculate DBH and height using the selected growth model
+        dbh_func, dbh_params = self.get_growth_function_and_params(species, self.growth_model, 'dbh')
+        height_func, height_params = self.get_growth_function_and_params(species, self.growth_model, 'height')
+        dbh = dbh_func(age, dbh_params, species.initial_values["dbh"])
+        height = height_func(age, height_params, species.initial_values["height"])
         # Calculate biomass using both DBH and height
         biomass = calculate_biomass(dbh, height, species.name, species.allometry)
         # Convert to carbon
@@ -168,66 +232,11 @@ class ERModel:
         )
         return carbon
     
-    def run_scenario(self, area: float, dbh_range: List[float], height_range: List[float], 
-                    growth_rate_factor: float) -> pd.Series:
-        """
-        Run a scenario with modified parameters.
-        
-        Args:
-            area: Area to plant in hectares
-            dbh_range: [min_dbh, max_dbh] in cm
-            height_range: [min_height, max_height] in m
-            growth_rate_factor: Factor to multiply growth rate by
-            
-        Returns:
-            Series with carbon sequestration at milestone years
-        """
-        # Create modified species for scenario
-        scenario_species = []
-        for sp in self.species:
-            mod_sp = Species(
-                name=sp.name,
-                planting_density=sp.planting_density,
-                mortality_rates=sp.mortality_rates.copy(),
-                chapman_richards={
-                    "dbh": {
-                        "a": np.mean(dbh_range),
-                        "b": sp.chapman_richards["dbh"]["b"] * growth_rate_factor,
-                        "c": sp.chapman_richards["dbh"]["c"]
-                    },
-                    "height": {
-                        "a": np.mean(height_range),
-                        "b": sp.chapman_richards["height"]["b"] * growth_rate_factor,
-                        "c": sp.chapman_richards["height"]["c"]
-                    }
-                },
-                allometry=sp.allometry.copy(),
-                initial_values=sp.initial_values.copy()
-            )
-            scenario_species.append(mod_sp)
-        
-        # Calculate carbon at milestone years
-        milestones = [5, 10, 15, 30]
-        carbon_values = []
-        
-        for year in milestones:
-            total_carbon = sum(
-                self.calculate_carbon_for_species(sp, year, area)
-                for sp in scenario_species
-            )
-            carbon_values.append(total_carbon)
-        
-        return pd.Series(
-            carbon_values,
-            index=[f"Year {y} tCO2" for y in milestones]
-        )
-    
-    def run(self) -> Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
+    def run(self) -> Tuple[pd.DataFrame, pd.DataFrame]:
         """
         Execute the full ER calculation pipeline.
-        
         Returns:
-            Tuple of (yearly results DataFrame, species results DataFrame, scenario results DataFrame)
+            Tuple of (yearly results DataFrame, species results DataFrame)
         """
         years = range(1, self.project.duration_years + 1)
         results = []
@@ -245,22 +254,14 @@ class ERModel:
                 for planting_year, area in self.project.planting_schedule.items():
                     py = int(planting_year.split("_")[1])
                     initial_trees = species.planting_density * area
-                    age = year - py + 1
-                    if age < 1:
-                        continue
-                    # Calculate surviving trees for this cohort
-                    surviving = self.calculate_cohort_surviving_trees(py, year, initial_trees, species.mortality_rates)
-                    # Calculate DBH and height using Chapman-Richards
-                    dbh = self.chapman_richards_growth(
-                        age, 
-                        species.chapman_richards["dbh"],
-                        species.initial_values["dbh"]
-                    )
-                    height = self.chapman_richards_growth(
-                        age,
-                        species.chapman_richards["height"],
-                        species.initial_values["height"]
-                    )
+                    # Use plateau_density as the year-5 value for this cohort
+                    plateau_density = species.planting_density * area if 5 <= (year - py + 1) else None
+                    surviving = self.calculate_cohort_surviving_trees(py, year, initial_trees, species, plateau_density, self.growth_model)
+                    # Calculate DBH and height using the selected growth model
+                    dbh_func, dbh_params = self.get_growth_function_and_params(species, self.growth_model, 'dbh')
+                    height_func, height_params = self.get_growth_function_and_params(species, self.growth_model, 'height')
+                    dbh = dbh_func(year, dbh_params, species.initial_values["dbh"])
+                    height = height_func(year, height_params, species.initial_values["height"])
                     # Calculate biomass using both DBH and height
                     biomass = calculate_biomass(dbh, height, species.name, species.allometry)
                     # Convert to carbon
@@ -298,58 +299,7 @@ class ERModel:
         self.results = pd.DataFrame(results)
         self.species_results = pd.DataFrame(species_results)
         
-        # Run scenarios
-        scenarios = []
-        dbh_min, dbh_max = self.scenarios["dbh_range"]
-        height_min, height_max = self.scenarios["height_range"]
-        area = self.scenarios["area"]
-        growth_factor = self.scenarios["growth_rate_factor"]
-        
-        # Base scenario
-        base_scenario = self.run_scenario(
-            area, [dbh_min, dbh_max], [height_min, height_max], growth_factor
-        )
-        scenarios.append({
-            "Scenario": "Base",
-            "DBH Range": f"{dbh_min:.1f}-{dbh_max:.1f}",
-            "Height Range": f"{height_min:.1f}-{height_max:.1f}",
-            "Growth Rate": f"{growth_factor:.1f}x",
-            **base_scenario
-        })
-        
-        # Low growth scenario
-        low_scenario = self.run_scenario(
-            area, 
-            [dbh_min * 0.5, dbh_max * 0.5],
-            [height_min * 0.5, height_max * 0.5],
-            growth_factor
-        )
-        scenarios.append({
-            "Scenario": "Low Growth",
-            "DBH Range": f"{dbh_min*0.5:.1f}-{dbh_max*0.5:.1f}",
-            "Height Range": f"{height_min*0.5:.1f}-{height_max*0.5:.1f}",
-            "Growth Rate": f"{growth_factor:.1f}x",
-            **low_scenario
-        })
-        
-        # High growth scenario
-        high_scenario = self.run_scenario(
-            area,
-            [dbh_min * 1.5, dbh_max * 1.5],
-            [height_min * 1.5, height_max * 1.5],
-            growth_factor
-        )
-        scenarios.append({
-            "Scenario": "High Growth",
-            "DBH Range": f"{dbh_min*1.5:.1f}-{dbh_max*1.5:.1f}",
-            "Height Range": f"{height_min*1.5:.1f}-{height_max*1.5:.1f}",
-            "Growth Rate": f"{growth_factor:.1f}x",
-            **high_scenario
-        })
-        
-        self.scenario_results = pd.DataFrame(scenarios)
-        
-        return self.results, self.species_results, self.scenario_results
+        return self.results, self.species_results
 
     def save_results(self, output_path: Path) -> None:
         """
@@ -360,4 +310,56 @@ class ERModel:
         """
         if self.results is None:
             raise ValueError("No results available. Run the model first.")
-        self.results.to_csv(output_path, index=False) 
+        self.results.to_csv(output_path, index=False)
+
+    def get_growth_function_and_params(self, species, growth_model, dim):
+        """
+        Returns the correct growth function and parameter dict for the given species and dimension (dbh or height).
+        """
+        if growth_model == "linear":
+            func = ERModel.linear_growth
+            params = species.linear[dim]
+        elif growth_model == "linear_plateau":
+            func = ERModel.linear_plateau_growth
+            params = species.linear_plateau[dim]
+        elif growth_model == "declining_increment":
+            func = ERModel.declining_increment_growth
+            params = species.declining_increment[dim]
+        else:
+            func = ERModel.chapman_richards_growth
+            params = species.chapman_richards[dim]
+        return func, params
+
+# --- Parameter sweep/test for plausible survival curves ---
+def test_dbh_mortality_sweep():
+    import matplotlib.pyplot as plt
+    import numpy as np
+    m_refs = [0.01, 0.05, 0.1, 0.16]
+    ps = [1.0, 1.5, 2.0]
+    DBH_ref = 9.0
+    years = np.arange(1, 31)
+    initial_trees = 1000
+    results = {}
+    for m_ref in m_refs:
+        for p in ps:
+            N_live = initial_trees
+            N_lives = []
+            for year in years:
+                dbh = 1.0 + (year - 1) * 0.5  # simple linear DBH growth for test
+                dbh = max(dbh, 1.0)
+                m = m_ref * (DBH_ref / dbh) ** p
+                m = min(max(m, 0), 0.99)
+                N_live = N_live * (1 - m)
+                N_lives.append(N_live)
+            results[(m_ref, p)] = N_lives
+    plt.figure(figsize=(10,6))
+    for (m_ref, p), N_lives in results.items():
+        plt.plot(years, N_lives, label=f"m_ref={m_ref}, p={p}")
+    plt.xlabel("Year")
+    plt.ylabel("Surviving Trees")
+    plt.title("DBH-dependent Mortality Parameter Sweep")
+    plt.legend()
+    plt.grid(True)
+    plt.show()
+
+# To run the test, call test_dbh_mortality_sweep() from __main__ or a notebook. 

tests/test_er_model.py

@@ -20,20 +20,18 @@ def sample_config():
             {
                 "name": "Test Species",
                 "planting_density": 1000,
-                "mortality_rates": {
-                    "year_1": 10,
-                    "year_2": 5,
-                    "subsequent": 2
-                },
+                "m_ref": 0.16,
+                "DBH_ref": 9.0,
+                "p": 1.493,
                 "chapman_richards": {
-                    "a": 30,
-                    "b": 0.15,
-                    "c": 1.5
+                    "dbh": {"a": 30, "b": 0.15, "c": 1.5},
+                    "height": {"a": 10, "b": 0.05, "c": 1.2}
                 },
                 "allometry": {
                     "biomass_equation": "0.2 * (dbh ** 2.4)",
                     "root_shoot_ratio": 0.4
-                }
+                },
+                "initial_values": {"dbh": 1.0, "height": 0.5}
             }
         ],
         "project": {
@@ -71,18 +69,16 @@ def test_model_initialization(config_file):
 
 
 def test_surviving_trees_calculation(config_file):
-    """Test tree survival calculations."""
+    """Test tree survival calculations with DBH-dependent mortality."""
     model = ERModel(config_file)
     species = model.species[0]
-    
-    # Test first year mortality
-    surviving = model.calculate_surviving_trees(1000, 1, species.mortality_rates)
-    assert surviving == 900  # 1000 * (1 - 0.10)
-    
-    # Test cumulative mortality
-    surviving = model.calculate_surviving_trees(1000, 2, species.mortality_rates)
-    expected = 1000 * (1 - 0.10) * (1 - 0.05)
-    assert np.isclose(surviving, expected)
+    # Test first year mortality (should use DBH-dependent formula)
+    dbh = 9.0
+    m = species.m_ref * (species.DBH_ref / dbh) ** species.p
+    initial_trees = 1000
+    N_live = initial_trees * (1 - m)
+    expected = initial_trees * (1 - 0.16)
+    assert np.isclose(N_live, expected, atol=1e-3)
 
 
 def test_chapman_richards_growth(config_file):
@@ -132,4 +128,42 @@ def test_full_pipeline(config_file):
     assert "year" in results.columns
     assert "gross_carbon" in results.columns
     assert "net_carbon" in results.columns
-    assert all(results["net_carbon"] <= results["gross_carbon"]) 
+    assert all(results["net_carbon"] <= results["gross_carbon"])
+
+
+def test_dbh_dependent_mortality():
+    """Test that DBH-dependent mortality matches expected at DBH=9 and year-5 plateau."""
+    from src.er_model import ERModel, Species
+    # Minimal species config
+    species = Species(
+        name="Test Species",
+        planting_density=1000,
+        m_ref=0.16,
+        DBH_ref=9.0,
+        p=1.493,
+        chapman_richards={
+            "dbh": {"a": 9.0, "b": 0.5, "c": 1.0},
+            "height": {"a": 5.0, "b": 0.2, "c": 1.0}
+        },
+        allometry={"equation": "0.2 * (dbh ** 2.4)", "root_shoot_ratio": 0.4},
+        initial_values={"dbh": 9.0, "height": 5.0}
+    )
+    # At DBH = 9, mortality = 0.16
+    dbh = 9.0
+    m = species.m_ref * (species.DBH_ref / dbh) ** species.p
+    assert np.isclose(m, 0.16, atol=1e-3)
+
+    # Simulate 5 years, enforce plateau at year 5
+    initial_trees = 1000
+    plateau_density = 2000
+    class DummyModel:
+        def chapman_richards_growth(self, age, params, initial):
+            return dbh  # Always 9 for this test
+    model = DummyModel()
+    N_live = initial_trees
+    for y in range(1, 6):
+        m = species.m_ref * (species.DBH_ref / dbh) ** species.p
+        N_live = N_live * (1 - m)
+        if y == 5:
+            N_live = plateau_density
+    assert N_live == plateau_density