Initial commit: ER model for Nigeria mangroves

.cursor/rules/activate_env.yml

@@ -0,0 +1,9 @@
+name: Activate er-model environment
+description: Ensures the er-model conda environment is activated before running any script
+events:
+  - before_run_script
+actions:
+  - name: Activate conda environment
+    command: conda activate er-model
+    shell: true
+    continue_on_error: false 

.cursor/rules/code_quality.yml

@@ -0,0 +1,29 @@
+name: Code Quality Standards
+description: Enforces code style and quality standards for the ER model project
+events:
+  - before_save
+  - before_commit
+actions:
+  - name: Format with black
+    command: black {file}
+    shell: true
+    continue_on_error: true
+  
+  - name: Sort imports
+    command: isort {file}
+    shell: true
+    continue_on_error: true
+  
+  - name: Check type hints
+    command: mypy {file}
+    shell: true
+    continue_on_error: true
+
+globs:
+  - "**/*.py"
+
+exclude:
+  - "**/venv/**"
+  - "**/.env/**"
+  - "**/build/**"
+  - "**/dist/**" 

.cursor/rules/er_model_guidelines.md

@@ -0,0 +1,69 @@
+# Guidelines for the ER Model Python Repository
+# Scope: applies to all Python files in this project
+
+description: |
+  Provide persistent, project‑level guidance for converting the Jupyter-based ER model
+  into a lightweight, reproducible Python repo with standard environment management,
+  modular scripts, analytics dashboard, and testing. Enforces code style, structure,
+  and workflows for maintainability and clarity.
+alwaysApply: true
+globs:
+  - "**/*.py"
+
+# Environment
+- Use Miniconda/Miniforge to manage the Python environment.
+- Define all dependencies in an `environment.yml` at the project root:
+  ```yaml
+  name: er-model
+  channels:
+    - conda-forge
+  dependencies:
+    - python>=3.10
+    - pandas
+    - numpy
+    - scipy
+    - matplotlib
+    - streamlit
+    - pytest
+    - black
+    - isort
+  ```
+
+# Repository Structure
+- `src/` → core modules (e.g. `er_model.py`, `allometry.py`, `metrics.py`).
+- `scripts/` → CLI entrypoints (e.g. `run_pipeline.py`, `analyze_results.py`).
+- `dashboard/` → analytics dashboard (e.g. `app.py` for Streamlit).
+- `tests/` → pytest test suites.
+- `configs/` → default parameter YAML or JSON files.
+- `README.md` → project overview, setup, and usage.
+
+# Code Style & Quality
+- Follow PEP8 conventions; enforce with `black --check` and `isort --check`.
+- Use Python type hints on all public functions.
+- Document functions with docstrings (Google style).
+- Avoid notebooks; use scripts and modules only.
+
+# Workflow & Tooling
+- **Parameterization:** Accept inputs via a single YAML/JSON config or CLI flags.
+- **Pipeline:** `scripts/run_pipeline.py` should:
+  1. Load config or parse flags.
+  2. Execute steps in order (data load → allometry → CR growth → results).
+  3. Save outputs (CSV, figures) to `outputs/`.
+- **Testing:** Write pytest tests targeting each core function. Place them under `tests/`.
+- **Formatting checks:** Add a Git pre-commit hook to run black, isort, and pytest.
+
+# Dashboard
+- Use Streamlit in `dashboard/app.py`:
+  - Load results from `outputs/`.
+  - Provide sidebar controls for key parameters (planting density, mortality, a/b/c values).
+  - Display tables, plots, and key summary metrics.
+
+# CI/CD (optional)
+- Configure GitHub Actions to:
+  1. Create conda environment from `environment.yml`.
+  2. Run formatting checks, linting, tests.
+  3. Deploy Streamlit dashboard (if needed). 
+
+
+# conda env
+- Always activate our er-model conda environment before running commandsa

.gitignore

@@ -0,0 +1,42 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Environment
+.env
+.venv
+env/
+venv/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Project specific
+outputs/
+*.log
+.DS_Store 

.pre-commit-config.yaml

@@ -0,0 +1,27 @@
+repos:
+- repo: https://github.com/pre-commit/pre-commit-hooks
+  rev: v4.5.0
+  hooks:
+    - id: trailing-whitespace
+    - id: end-of-file-fixer
+    - id: check-yaml
+    - id: check-added-large-files
+
+- repo: https://github.com/psf/black
+  rev: 24.2.0
+  hooks:
+    - id: black
+      language_version: python3.10
+
+- repo: https://github.com/pycqa/isort
+  rev: 5.13.2
+  hooks:
+    - id: isort
+      args: ["--profile", "black"]
+
+- repo: https://github.com/pre-commit/mirrors-mypy
+  rev: v1.8.0
+  hooks:
+    - id: mypy
+      additional_dependencies: [types-all]
+      args: [--ignore-missing-imports] 

README.md

@@ -0,0 +1,153 @@
+# 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 (2024)
+- **Updated Allometric Equations**: Implemented Zanvo et al. (2023) species-specific equations:
+  - Rhizophora: Total = 1.938 × (DBH² H)^0.67628
+  - Avicennia: Total = 1.486 × (DBH² H)^0.55864
+
+- **Chapman-Richards Implementation**:
+  - Improved growth parameter estimation
+  - Direct use of growth rate parameter (b) instead of deriving from Tm
+  - Separate parameterization for DBH and height growth
+  - Current parameters:
+    * Rhizophora: max DBH 11.07cm, max height 12.0m
+    * Avicennia: max DBH 17.0cm, max height 8.8m
+
+- **Growth Rate Parameters**:
+  - b = 0.25 yr^-1 (independently estimated growth rate)
+  - c = 2.1 (shape parameter)
+  - Removed Tm-based calculation (previously b = ln(c)/Tm)
+
+### Dashboard Improvements
+- Added height growth visualization
+- Improved number formatting with comma separators
+- Enhanced scenario comparison features
+- Added biomass per tree tracking
+- Updated parameter input ranges
+
+### Configuration Updates
+- Restructured parameter files for clarity
+- Added detailed parameter documentation
+- Improved error handling for invalid inputs
+- Added support for scenario analysis
+
+## Features
+
+- Species-specific growth modeling using Chapman-Richards equations
+- Biomass estimation using allometric equations
+- Carbon conversion and emissions reduction calculations
+- Interactive dashboard for parameter exploration using Gradio
+- Configurable planting schedules and mortality rates
+- Scenario comparison for different DBH ranges and growth rates
+- Per-species carbon tracking and cumulative hectare calculations
+
+## Model Parameters
+
+### Species Parameters
+- **Rhizophora**
+  - Initial values: DBH = 1.0cm, Height = 0.5m
+  - Chapman-Richards parameters: a = 11.07cm, b = 0.35, c = 2.1
+  - Configurable planting density and mortality rates
+
+- **Avicennia**
+  - Initial values: DBH = 1.0cm, Height = 0.5m
+  - Chapman-Richards parameters: a = 17.0cm, b = 0.35, c = 2.1
+  - Configurable planting density and mortality rates
+
+### Carbon Parameters
+- Biomass to carbon conversion factor
+- Carbon to CO2 conversion factor
+- Buffer pool percentage
+- Leakage percentage
+- Baseline emissions rate
+
+## 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:
+   ```bash
+   conda env create -f environment.yml
+   conda activate er-model
+   ```
+
+3. Install pre-commit hooks:
+   ```bash
+   pre-commit install
+   ```
+
+## 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
+- `scripts/` - Command-line tools
+  - `run_pipeline.py` - Execute full ER calculation workflow
+  - `analyze_results.py` - Generate reports and visualizations
+- `dashboard/` - Gradio web application for interactive exploration
+- `configs/` - Default parameter files
+- `outputs/` - Generated results and figures
+- `tests/` - Test suite
+
+## Dashboard Features
+
+The interactive Gradio dashboard allows users to:
+1. Adjust species-specific parameters:
+   - Planting density (trees/ha)
+   - Year-by-year mortality rates
+2. Configure planting schedule:
+   - Area planted per year (ha)
+   - Up to 5-year planting schedule
+3. Modify carbon parameters:
+   - Buffer pool percentage
+4. Explore scenarios:
+   - Test different DBH ranges
+   - Adjust growth rate factors
+   - Compare results across 1000 ha scenarios
+5. View results:
+   - Carbon sequestration over time
+   - Milestone year comparisons
+   - Per-species carbon tracking
+   - Cumulative hectare metrics
+   - Scenario comparison tables
+
+## Usage
+
+1. Configure parameters in `configs/params.yaml`
+
+2. Run the full pipeline:
+   ```bash
+   python scripts/run_pipeline.py --config configs/params.yaml
+   ```
+
+3. Launch the dashboard:
+   ```bash
+   python dashboard/app.py
+   ```
+   This will start a Gradio server and open the dashboard in your default web browser.
+
+## Development
+
+- Code style is enforced using `black` and `isort`
+- Type hints are required for all public functions
+- Tests are written using `pytest`
+- Pre-commit hooks ensure code quality
+
+## Dependencies
+
+Key dependencies (specified in `environment.yml`):
+- numpy=1.24.3
+- pandas=2.0.3
+- gradio (latest version)
+- matplotlib
+- pyyaml
+- pytest (for development)
+
+## License
+
+[License details to be added] 

configs/params.yaml

@@ -0,0 +1,76 @@
+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   # %
+      subsequent: 1.5  # %
+    chapman_richards:
+      dbh:
+        a: 11.07  # asymptotic maximum DBH (cm)
+        b: 0.25   # growth rate parameter (yr^-1)
+        c: 2.1    # shape parameter
+      height:
+        a: 12.0   # asymptotic maximum height (m)
+        b: 0.25   # growth rate parameter (yr^-1)
+        c: 2.1    # shape parameter
+    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   # %
+      subsequent: 1.5  # %
+    chapman_richards:
+      dbh:
+        a: 17.0   # asymptotic maximum DBH (cm)
+        b: 0.25   # growth rate parameter (yr^-1)
+        c: 2.1    # shape parameter
+      height:
+        a: 8.8    # asymptotic maximum height (m)
+        b: 0.25   # growth rate parameter (yr^-1)
+        c: 2.1    # shape parameter
+    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: 2000  # 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: 15    # risk buffer
+  leakage_percentage: 0    # no leakage assumed
+  baseline_emissions: 0    # tCO2/ha/year
+
+# Note: b parameter is calculated using b = ln(c) / Tm
+# For both species:
+# - Tm = 6 years
+# - c = 2.1
+# Therefore: b = ln(2.1) / 6 ≈ 0.35 
+
+scenarios:
+  area: 1000.0  # ha
+  dbh_range: [1.0, 25.0]  # cm
+  height_range: [0.5, 15.0]  # m
+  growth_rate_factor: 1.0 

dashboard/app.py

@@ -0,0 +1,404 @@
+"""
+Gradio dashboard for exploring ER model results and parameters.
+"""
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+import gradio as gr
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import yaml
+
+from src.er_model import ERModel
+
+
+def load_config(config_path: Path = Path("configs/params.yaml")) -> dict:
+    """Load and parse YAML configuration."""
+    with open(config_path) as f:
+        return yaml.safe_load(f)
+
+
+def run_model(config: dict) -> Tuple[pd.DataFrame, pd.DataFrame, pd.DataFrame]:
+    """Run model with current parameters."""
+    # Save temporary config
+    temp_config = Path("configs/temp_config.yaml")
+    with open(temp_config, "w") as f:
+        yaml.dump(config, f)
+    
+    # Run model and cleanup
+    model = ERModel(temp_config)
+    results, species_results, scenario_results = model.run()
+    temp_config.unlink()
+    
+    return results, species_results, scenario_results
+
+
+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 create_plots_and_tables(
+    results: pd.DataFrame,
+    species_results: pd.DataFrame,
+    scenario_results: pd.DataFrame
+) -> 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)))
+    
+    # Milestone years plot
+    milestones = [5, 10, 15, 20, 25, 30]
+    milestone_data = results[results["year"].isin(milestones)]
+    
+    fig2 = plt.figure(figsize=(10, 6))
+    ax2 = fig2.add_subplot(111)
+    width = 0.35
+    x = np.arange(len(milestones))
+    ax2.bar(x - width/2, milestone_data["gross_carbon"], width, label="Gross Carbon")
+    ax2.bar(x + width/2, milestone_data["net_carbon"], width, label="Net Carbon")
+    ax2.set_xticks(x)
+    ax2.set_xticklabels(milestones)
+    ax2.set_xlabel("Year")
+    ax2.set_ylabel("Carbon (tCO2)")
+    ax2.set_title("Carbon Sequestration at Milestone Years")
+    ax2.legend()
+    # Format y-axis with comma separator
+    ax2.yaxis.set_major_formatter(plt.FuncFormatter(lambda x, p: format_number(x)))
+
+    # New biomass per tree plot
+    fig3 = plt.figure(figsize=(10, 6))
+    ax3 = fig3.add_subplot(111)
+    
+    # Load config to get planting densities
+    config = load_config()
+    rhiz_density = config["species"][0]["planting_density"]  # Rhizophora density
+    avic_density = config["species"][1]["planting_density"]  # Avicennia density
+    
+    # Extract biomass per tree data from species_results
+    years = species_results.index
+    
+    # Get species column names (first two columns after 'Year' should be the species)
+    species_cols = [col for col in species_results.columns if 'tCO2' in col]
+    if len(species_cols) >= 2:
+        rhiz_col = species_cols[0]  # First species column
+        avic_col = species_cols[1]  # Second species column
+        
+        # Calculate biomass per tree using actual planting densities
+        rhiz_biomass = species_results[rhiz_col].astype(float) / (results["area_year_1"].iloc[0] * rhiz_density)
+        avic_biomass = species_results[avic_col].astype(float) / (results["area_year_1"].iloc[0] * avic_density)
+        
+        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()
+
+    # Calculate total area from planting schedule
+    total_area = sum(float(v) for k, v in results.iloc[-1].items() if k.startswith("area_year"))
+    
+    # Get final year carbon 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
+    else:
+        gross_carbon_per_ha = 0
+        net_carbon_per_ha = 0
+    
+    # Create summary text with formatted numbers
+    summary = f"""
+Results Summary:
+---------------
+Total Years: {len(results)}
+Total Area Planted: {format_number(total_area)} ha
+Total Gross Carbon: {format_number(final_gross)} tCO2
+Total Net Carbon: {format_number(final_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
+"""
+    
+    # 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)
+    
+    # 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, species_table, 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,
+    scenario_area: float = 1000.0,
+    dbh_range_min: float = 1.0,
+    dbh_range_max: float = 25.0,
+    height_range_min: float = 0.5,
+    height_range_max: float = 15.0,
+    growth_rate_factor: float = 1.0,
+) -> 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 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 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
+    
+    # Add scenario parameters
+    config["scenarios"] = {
+        "area": scenario_area,
+        "dbh_range": [dbh_range_min, dbh_range_max],
+        "height_range": [height_range_min, height_range_max],
+        "growth_rate_factor": growth_rate_factor
+    }
+    
+    # Run model and create plots/tables
+    results, species_results, scenario_results = run_model(config)
+    return create_plots_and_tables(results, species_results, scenario_results)
+
+
+def main():
+    """Launch the Gradio interface."""
+    config = load_config()
+    
+    # Extract default values
+    rhiz_defaults = config["species"][0]
+    avic_defaults = config["species"][1]
+    planting_defaults = config["project"]["planting_schedule"]
+    carbon_defaults = config["carbon"]
+    scenario_defaults = config.get("scenarios", {
+        "area": 1000.0,
+        "dbh_range": [1.0, 25.0],
+        "height_range": [0.5, 15.0],
+        "growth_rate_factor": 1.0
+    })
+    
+    # Create interface
+    with gr.Blocks(title="ER Model Dashboard", theme=gr.themes.Soft()) as interface:
+        gr.Markdown("# ER Model Dashboard")
+        gr.Markdown("Explore carbon sequestration results and test different parameters")
+        
+        with gr.Row():
+            with gr.Column():
+                # Rhizophora parameters
+                gr.Markdown("### Rhizophora Parameters")
+                rhiz_density = gr.Slider(
+                    minimum=100,
+                    maximum=10000,
+                    value=rhiz_defaults["planting_density"],
+                    label="Planting Density (trees/ha)"
+                )
+                rhiz_mort_1 = gr.Slider(0, 100, rhiz_defaults["mortality_rates"]["year_1"], label="Year 1 Mortality (%)")
+                rhiz_mort_2 = gr.Slider(0, 100, rhiz_defaults["mortality_rates"]["year_2"], label="Year 2 Mortality (%)")
+                rhiz_mort_3 = gr.Slider(0, 100, rhiz_defaults["mortality_rates"]["year_3"], label="Year 3 Mortality (%)")
+                rhiz_mort_4 = gr.Slider(0, 100, rhiz_defaults["mortality_rates"]["year_4"], label="Year 4 Mortality (%)")
+                rhiz_mort_5 = gr.Slider(0, 100, rhiz_defaults["mortality_rates"]["year_5"], label="Year 5 Mortality (%)")
+                
+            with gr.Column():
+                # Avicennia parameters
+                gr.Markdown("### Avicennia Parameters")
+                avic_density = gr.Slider(
+                    minimum=100,
+                    maximum=10000,
+                    value=avic_defaults["planting_density"],
+                    label="Planting Density (trees/ha)"
+                )
+                avic_mort_1 = gr.Slider(0, 100, avic_defaults["mortality_rates"]["year_1"], label="Year 1 Mortality (%)")
+                avic_mort_2 = gr.Slider(0, 100, avic_defaults["mortality_rates"]["year_2"], label="Year 2 Mortality (%)")
+                avic_mort_3 = gr.Slider(0, 100, avic_defaults["mortality_rates"]["year_3"], label="Year 3 Mortality (%)")
+                avic_mort_4 = gr.Slider(0, 100, avic_defaults["mortality_rates"]["year_4"], label="Year 4 Mortality (%)")
+                avic_mort_5 = gr.Slider(0, 100, avic_defaults["mortality_rates"]["year_5"], label="Year 5 Mortality (%)")
+        
+        with gr.Row():
+            with gr.Column():
+                # Planting schedule
+                gr.Markdown("### Planting Schedule")
+                year_1_area = gr.Slider(0, 1000, planting_defaults["year_1"], label="Year 1 Area (ha)")
+                year_2_area = gr.Slider(0, 1000, planting_defaults["year_2"], label="Year 2 Area (ha)")
+                year_3_area = gr.Slider(0, 1000, planting_defaults["year_3"], label="Year 3 Area (ha)")
+                year_4_area = gr.Slider(0, 1000, planting_defaults["year_4"], label="Year 4 Area (ha)")
+                year_5_area = gr.Slider(0, 1000, planting_defaults["year_5"], label="Year 5 Area (ha)")
+                
+            with gr.Column():
+                # Carbon parameters
+                gr.Markdown("### Carbon Parameters")
+                buffer_percentage = gr.Slider(
+                    minimum=0,
+                    maximum=30,
+                    value=carbon_defaults["buffer_percentage"],
+                    label="Buffer Percentage (%)"
+                )
+                
+                # Scenario parameters
+                gr.Markdown("### Scenario Parameters")
+                scenario_area = gr.Slider(
+                    minimum=100,
+                    maximum=2000,
+                    value=scenario_defaults["area"],
+                    label="Scenario Area (ha)"
+                )
+                dbh_range_min = gr.Slider(
+                    minimum=0.5,
+                    maximum=10,
+                    value=scenario_defaults["dbh_range"][0],
+                    label="Min DBH (cm)"
+                )
+                dbh_range_max = gr.Slider(
+                    minimum=10,
+                    maximum=30,
+                    value=scenario_defaults["dbh_range"][1],
+                    label="Max DBH (cm)"
+                )
+                height_range_min = gr.Slider(
+                    minimum=0.5,
+                    maximum=5,
+                    value=scenario_defaults["height_range"][0],
+                    label="Min Height (m)"
+                )
+                height_range_max = gr.Slider(
+                    minimum=5,
+                    maximum=20,
+                    value=scenario_defaults["height_range"][1],
+                    label="Max Height (m)"
+                )
+                growth_rate_factor = gr.Slider(
+                    minimum=0.5,
+                    maximum=2.0,
+                    value=scenario_defaults["growth_rate_factor"],
+                    label="Growth Rate Factor"
+                )
+        
+        # Outputs
+        with gr.Row():
+            plot1 = gr.Plot(label="Carbon Sequestration Over Time")
+            plot2 = gr.Plot(label="Milestone Years")
+        
+        with gr.Row():
+            plot3 = gr.Plot(label="Total Biomass per Tree")
+        
+        summary = gr.Textbox(label="Summary", lines=10)
+        
+        with gr.Row():
+            species_table = gr.Dataframe(
+                label="Per Species Carbon Change & Cumulative Hectares",
+                headers=["Year", "Rhizophora tCO2", "Avicennia tCO2", "Total tCO2", "Cumulative ha", "tCO2/ha"]
+            )
+            scenario_table = gr.Dataframe(
+                label="Scenario Comparison",
+                headers=["Scenario", "DBH Range", "Height Range", "Growth Rate", "Year 5 tCO2", "Year 10 tCO2", "Year 15 tCO2", "Year 30 tCO2"]
+            )
+        
+        # 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, scenario_area, dbh_range_min, dbh_range_max,
+            height_range_min, height_range_max, growth_rate_factor
+        ]
+        
+        outputs = [plot1, plot2, plot3, summary, species_table, scenario_table]
+        
+        # Initialize with default values
+        interface.load(
+            fn=update_model,
+            inputs=inputs,
+            outputs=outputs,
+        )
+        
+        # Update on any change
+        for inp in inputs:
+            inp.change(
+                fn=update_model,
+                inputs=inputs,
+                outputs=outputs
+            )
+    
+    # Launch interface
+    interface.launch(share=False)
+
+
+if __name__ == "__main__":
+    main() 

environment.yml

@@ -0,0 +1,20 @@
+name: er-model
+channels:
+  - conda-forge
+dependencies:
+  - python=3.10
+  - numpy=1.24.3
+  - pandas=2.0.3
+  - scipy=1.12.0
+  - matplotlib=3.8.2
+  - pyyaml=6.0.1
+  - click=8.1.7
+  - pip=24.0
+  - pytest=7.4.4
+  - black=24.1.1
+  - isort=5.13.2
+  - pre-commit=3.6.0
+  - pip:
+    - gradio==3.50.2
+    - fastapi==0.95.2
+    - pydantic==1.10.13 

scripts/run_pipeline.py

@@ -0,0 +1,60 @@
+#!/usr/bin/env python
+"""
+Main pipeline script for running the ER model calculations.
+"""
+import sys
+from pathlib import Path
+
+# Add the project root to the Python path
+sys.path.append(str(Path(__file__).parent.parent))
+
+import click
+
+from src.er_model import ERModel
+
+
+@click.command()
+@click.option(
+    "--config",
+    type=click.Path(exists=True, path_type=Path),
+    required=True,
+    help="Path to YAML configuration file",
+)
+@click.option(
+    "--output",
+    type=click.Path(path_type=Path),
+    default=Path("outputs/results.csv"),
+    help="Path to save results CSV",
+)
+def main(config: Path, output: Path) -> None:
+    """Run the ER model pipeline."""
+    # Create output directory if it doesn't exist
+    output.parent.mkdir(parents=True, exist_ok=True)
+    
+    # Initialize and run model
+    model = ERModel(config)
+    results, species_results, scenario_results = model.run()
+    
+    # Save results
+    model.save_results(output)
+    
+    # Save additional results
+    species_output = output.parent / "species_results.csv"
+    scenario_output = output.parent / "scenario_results.csv"
+    species_results.to_csv(species_output, index=False)
+    scenario_results.to_csv(scenario_output, index=False)
+    
+    # Print summary
+    print("\nResults Summary:")
+    print("-" * 40)
+    print(f"Total years: {len(results)}")
+    print(f"Total gross carbon: {results['gross_carbon'].sum():.2f} tCO2")
+    print(f"Total net carbon: {results['net_carbon'].sum():.2f} tCO2")
+    print(f"\nResults saved to:")
+    print(f"- Main results: {output}")
+    print(f"- Species results: {species_output}")
+    print(f"- Scenario results: {scenario_output}")
+
+
+if __name__ == "__main__":
+    main() 

setup.py

@@ -0,0 +1,16 @@
+from setuptools import find_packages, setup
+
+setup(
+    name="er_model",
+    version="0.1.0",
+    packages=find_packages(),
+    install_requires=[
+        "pandas>=2.2.0",
+        "numpy>=1.26.3",
+        "scipy>=1.12.0",
+        "matplotlib>=3.8.2",
+        "pyyaml>=6.0.1",
+        "click>=8.1.7",
+    ],
+    python_requires=">=3.10",
+) 

src/__init__.py

@@ -0,0 +1,16 @@
+"""
+ER Model package for calculating carbon sequestration in mangrove projects.
+"""
+
+from .allometry import calculate_biomass
+from .er_model import ERModel, Species, ProjectConfig, CarbonConfig
+from .metrics import calculate_carbon
+
+__all__ = [
+    "ERModel",
+    "Species",
+    "ProjectConfig",
+    "CarbonConfig",
+    "calculate_biomass",
+    "calculate_carbon",
+] 

src/allometry.py

@@ -0,0 +1,31 @@
+"""
+Allometric equations for converting tree measurements to biomass.
+"""
+from typing import Dict
+
+
+def calculate_biomass(dbh: float, height: float, species_name: str, params: Dict[str, float]) -> float:
+    """
+    Calculate total tree biomass using species-specific allometric equations from Zanvo et al. 2023.
+    
+    Args:
+        dbh: Diameter at breast height (cm)
+        height: Tree height (m)
+        species_name: Name of the species ("species_A" for Rhizophora, "species_B" for Avicennia)
+        params: Dictionary containing allometric parameters
+        
+    Returns:
+        Total tree biomass (above + below ground) in kg
+    """
+    # 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
+        total_biomass = 1.938 * (dbh**2 * height)**0.67628
+    elif species_name == "species_B":  # Avicennia
+        # Total = 1.486 × (DBH² H)^0.55864
+        total_biomass = 1.486 * (dbh**2 * height)**0.55864
+    else:
+        # Use a conservative generic equation if species not recognized
+        total_biomass = 1.712 * (dbh**2 * height)**0.61746
+    
+    return total_biomass 

src/er_model.py

@@ -0,0 +1,331 @@
+"""
+Core implementation of the Emissions Reduction (ER) model for mangrove projects.
+"""
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+import yaml
+
+from .allometry import calculate_biomass
+from .metrics import calculate_carbon
+
+
+@dataclass
+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]
+
+
+@dataclass
+class ProjectConfig:
+    """Project configuration parameters."""
+    duration_years: int
+    planting_schedule: Dict[str, float]
+
+
+@dataclass
+class CarbonConfig:
+    """Carbon conversion and adjustment parameters."""
+    biomass_to_carbon: float
+    carbon_to_co2: float
+    buffer_percentage: float
+    leakage_percentage: float
+    baseline_emissions: float
+
+
+class ERModel:
+    """
+    Emissions Reduction Model for mangrove projects.
+    
+    Calculates carbon sequestration over time based on tree growth,
+    mortality, and carbon conversion factors.
+    """
+    
+    def __init__(self, config_path: Path):
+        """
+        Initialize the model from a YAML configuration file.
+        
+        Args:
+            config_path: Path to the YAML configuration file
+        """
+        with open(config_path) as f:
+            config = yaml.safe_load(f)
+            
+        self.species = [Species(**s) for s in config["species"]]
+        self.project = ProjectConfig(**config["project"])
+        self.carbon = CarbonConfig(**config["carbon"])
+        
+        # Store scenario parameters if provided
+        self.scenarios = config.get("scenarios", {
+            "area": 1000.0,
+            "dbh_range": [1.0, 20.0],
+            "height_range": [0.5, 12.0],
+            "growth_rate_factor": 1.0
+        })
+        
+        # Initialize results storage
+        self.results: Optional[pd.DataFrame] = None
+        self.species_results: Optional[pd.DataFrame] = None
+        self.scenario_results: Optional[pd.DataFrame] = None
+        
+    def calculate_surviving_trees(self, initial_trees: float, year: int, 
+                                mortality_rates: Dict[str, float]) -> float:
+        """
+        Calculate surviving trees for a given year based on mortality rates.
+        
+        Args:
+            initial_trees: Initial number of trees planted
+            year: Years since planting (1-based)
+            mortality_rates: Dictionary of mortality rates by year
+            
+        Returns:
+            Number of surviving trees
+        """
+        surviving = initial_trees
+        
+        for y in range(1, year + 1):
+            rate = mortality_rates.get(f"year_{y}", 
+                                    mortality_rates["subsequent"]) / 100.0
+            surviving *= (1 - rate)
+            
+        return surviving
+    
+    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)
+        """
+        a, b, c = params["a"], params["b"], params["c"]
+        return initial_value + (a - initial_value) * (1 - np.exp(-b * age)) ** c
+
+    def calculate_carbon_for_species(self, species: Species, age: int, area: float) -> float:
+        """
+        Calculate carbon sequestration for a single species and age.
+        
+        Args:
+            species: Species parameters
+            age: Age of trees in years
+            area: Planted area in hectares
+            
+        Returns:
+            Carbon sequestration in tCO2
+        """
+        # Calculate surviving trees
+        initial_trees = species.planting_density * area
+        surviving = self.calculate_surviving_trees(
+            initial_trees, age, 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"]
+        )
+        
+        # Calculate biomass using both DBH and height
+        biomass = calculate_biomass(dbh, height, species.name, species.allometry)
+        
+        # Convert to carbon
+        carbon = calculate_carbon(
+            biomass * surviving,
+            self.carbon.biomass_to_carbon,
+            self.carbon.carbon_to_co2
+        )
+        
+        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]:
+        """
+        Execute the full ER calculation pipeline.
+        
+        Returns:
+            Tuple of (yearly results DataFrame, species results DataFrame, scenario results DataFrame)
+        """
+        years = range(1, self.project.duration_years + 1)
+        results = []
+        species_results = []
+        
+        for year in years:
+            year_results = {"year": year}
+            species_year_results = {"Year": year}
+            total_carbon = 0
+            cumulative_area = 0
+            
+            # Calculate for each planting cohort and species
+            for planting_year, area in self.project.planting_schedule.items():
+                py = int(planting_year.split("_")[1])
+                if py > year:
+                    continue
+                
+                cumulative_area += area
+                age = year - py + 1
+                
+                for species in self.species:
+                    carbon = self.calculate_carbon_for_species(species, age, area)
+                    total_carbon += carbon
+                    
+                    # Track per-species carbon
+                    species_key = f"{species.name} tCO2"
+                    species_year_results[species_key] = species_year_results.get(species_key, 0) + carbon
+            
+            # Add total carbon and area metrics
+            species_year_results["Total tCO2"] = total_carbon
+            species_year_results["Cumulative ha"] = cumulative_area
+            species_year_results["tCO2/ha"] = total_carbon / cumulative_area if cumulative_area > 0 else 0
+            
+            # Apply adjustments for main results
+            gross_carbon = total_carbon
+            net_carbon = gross_carbon * (1 - self.carbon.buffer_percentage / 100)
+            net_carbon -= self.carbon.leakage_percentage / 100 * gross_carbon
+            net_carbon -= self.carbon.baseline_emissions * cumulative_area
+            
+            year_results.update({
+                "gross_carbon": gross_carbon,
+                "net_carbon": net_carbon,
+                f"area_year_{year}": area if f"year_{year}" in self.project.planting_schedule else 0
+            })
+            
+            results.append(year_results)
+            species_results.append(species_year_results)
+        
+        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
+
+    def save_results(self, output_path: Path) -> None:
+        """
+        Save results to CSV file.
+        
+        Args:
+            output_path: Path to save the results CSV
+        """
+        if self.results is None:
+            raise ValueError("No results available. Run the model first.")
+        self.results.to_csv(output_path, index=False) 

src/metrics.py

@@ -0,0 +1,106 @@
+"""
+Carbon sequestration metrics calculations.
+"""
+from typing import Dict, List, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+
+
+def calculate_carbon(biomass: float, carbon_fraction: float, co2_conversion: float) -> float:
+    """
+    Convert biomass to carbon dioxide equivalent.
+    
+    Args:
+        biomass: Total biomass in kg
+        carbon_fraction: Fraction of biomass that is carbon
+        co2_conversion: Conversion factor from C to CO2
+        
+    Returns:
+        Carbon dioxide equivalent in tonnes
+    """
+    # Convert kg biomass to tonnes CO2
+    carbon = biomass * carbon_fraction  # kg C
+    co2 = carbon * co2_conversion  # kg CO2
+    tonnes_co2 = co2 / 1000.0  # tonnes CO2
+    
+    return tonnes_co2
+
+
+def calculate_milestone_metrics(
+    carbon_series: pd.Series,
+    milestones: List[int] = [5, 10, 15, 20, 25, 30]
+) -> Dict[str, float]:
+    """
+    Calculate carbon metrics at milestone years.
+    
+    Args:
+        carbon_series: Series of carbon values indexed by year
+        milestones: List of milestone years to report
+        
+    Returns:
+        Dictionary of milestone metrics
+    """
+    metrics = {}
+    for year in milestones:
+        if year in carbon_series.index:
+            metrics[f"Year_{year}"] = carbon_series[year]
+    return metrics
+
+
+def calculate_per_hectare_metrics(
+    carbon: float,
+    area: float,
+    buffer_pct: float = 0.0,
+    leakage_pct: float = 0.0,
+    baseline: float = 0.0
+) -> Tuple[float, float]:
+    """
+    Calculate per-hectare carbon metrics with deductions.
+    
+    Args:
+        carbon: Gross carbon in tCO2
+        area: Area in hectares
+        buffer_pct: Buffer pool percentage
+        leakage_pct: Leakage percentage
+        baseline: Baseline emissions in tCO2/ha/yr
+        
+    Returns:
+        Tuple of (gross_per_ha, net_per_ha)
+    """
+    if area <= 0:
+        return 0.0, 0.0
+        
+    gross_per_ha = carbon / area
+    
+    # Apply deductions
+    net_carbon = carbon * (1 - buffer_pct/100) * (1 - leakage_pct/100)
+    net_carbon -= baseline * area
+    net_per_ha = max(0, net_carbon / area)
+    
+    return gross_per_ha, net_per_ha
+
+
+def calculate_scenario_metrics(
+    base_carbon: float,
+    scenario_carbon: float,
+    area: float
+) -> Dict[str, float]:
+    """
+    Calculate comparison metrics between base and scenario.
+    
+    Args:
+        base_carbon: Base scenario carbon in tCO2
+        scenario_carbon: Alternative scenario carbon in tCO2
+        area: Area in hectares
+        
+    Returns:
+        Dictionary of comparison metrics
+    """
+    metrics = {
+        "Absolute_Difference": scenario_carbon - base_carbon,
+        "Percent_Difference": ((scenario_carbon - base_carbon) / base_carbon * 100 
+                             if base_carbon > 0 else 0),
+        "Per_Hectare_Difference": (scenario_carbon - base_carbon) / area if area > 0 else 0
+    }
+    return metrics 

tests/test_er_model.py

@@ -0,0 +1,135 @@
+"""
+Tests for the ER model implementation.
+"""
+from pathlib import Path
+
+import numpy as np
+import pytest
+import yaml
+
+from src.allometry import calculate_biomass
+from src.er_model import ERModel, Species
+from src.metrics import calculate_carbon
+
+
+@pytest.fixture
+def sample_config():
+    """Create a minimal test configuration."""
+    return {
+        "species": [
+            {
+                "name": "Test Species",
+                "planting_density": 1000,
+                "mortality_rates": {
+                    "year_1": 10,
+                    "year_2": 5,
+                    "subsequent": 2
+                },
+                "chapman_richards": {
+                    "a": 30,
+                    "b": 0.15,
+                    "c": 1.5
+                },
+                "allometry": {
+                    "biomass_equation": "0.2 * (dbh ** 2.4)",
+                    "root_shoot_ratio": 0.4
+                }
+            }
+        ],
+        "project": {
+            "duration_years": 5,
+            "planting_schedule": {
+                "year_1": 100
+            }
+        },
+        "carbon": {
+            "biomass_to_carbon": 0.47,
+            "carbon_to_co2": 3.67,
+            "buffer_percentage": 15,
+            "leakage_percentage": 0,
+            "baseline_emissions": 0
+        }
+    }
+
+
+@pytest.fixture
+def config_file(tmp_path, sample_config):
+    """Create a temporary config file."""
+    config_path = tmp_path / "test_config.yaml"
+    with open(config_path, "w") as f:
+        yaml.dump(sample_config, f)
+    return config_path
+
+
+def test_model_initialization(config_file):
+    """Test that the model initializes correctly from config."""
+    model = ERModel(config_file)
+    assert len(model.species) == 1
+    assert model.species[0].name == "Test Species"
+    assert model.project.duration_years == 5
+    assert model.carbon.biomass_to_carbon == 0.47
+
+
+def test_surviving_trees_calculation(config_file):
+    """Test tree survival calculations."""
+    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)
+
+
+def test_chapman_richards_growth(config_file):
+    """Test DBH calculations using Chapman-Richards equation."""
+    model = ERModel(config_file)
+    species = model.species[0]
+    
+    # Test initial growth
+    dbh = model.chapman_richards_dbh(0, species.chapman_richards)
+    assert dbh == 0
+    
+    # Test asymptotic behavior
+    dbh = model.chapman_richards_dbh(100, species.chapman_richards)
+    assert np.isclose(dbh, species.chapman_richards["a"], rtol=0.01)
+
+
+def test_biomass_calculation():
+    """Test biomass calculations from DBH."""
+    params = {
+        "biomass_equation": "0.2 * (dbh ** 2.4)",
+        "root_shoot_ratio": 0.4
+    }
+    
+    biomass = calculate_biomass(10, params)
+    expected_agb = 0.2 * (10 ** 2.4)
+    expected_total = expected_agb * (1 + 0.4)
+    assert np.isclose(biomass, expected_total)
+
+
+def test_carbon_calculation():
+    """Test carbon conversion calculations."""
+    biomass = 1000  # kg
+    biomass_to_carbon = 0.47
+    carbon_to_co2 = 3.67
+    
+    co2 = calculate_carbon(biomass, biomass_to_carbon, carbon_to_co2)
+    expected = (1000 * 0.47 * 3.67) / 1000  # Convert to metric tons
+    assert np.isclose(co2, expected)
+
+
+def test_full_pipeline(config_file):
+    """Test the complete model pipeline."""
+    model = ERModel(config_file)
+    results = model.run()
+    
+    assert len(results) == 5  # Duration years
+    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"])