Finalize modularization, clean up UI, prep for new features

dashboard/app.py

@@ -8,9 +8,6 @@ Mangrove ER Model Dashboard
 import gradio as gr
 from pathlib import Path
 from src.er_model import ERModel
-import yaml
-import tempfile
-import matplotlib.pyplot as plt
 import pandas as pd
 import numpy as np
 import plotly.graph_objs as go
@@ -18,12 +15,12 @@ from plotly.subplots import make_subplots
 import warnings
 import traceback
 from src.allometry import calculate_biomass
-import copy
+from dashboard.plots import check_complex, create_growth_increment_plots, create_all_plots
+from dashboard.tables import create_survival_table, create_biomass_table
+import yaml
+import tempfile
 
 MODEL_CONFIGS = {
-    # "Original Model": "configs/params.yaml",  # ARCHIVED/NOT IN USE
-    # "Simple Linear": "configs/linear.yaml",   # ARCHIVED/NOT IN USE
-    # "Linear Plateau": "configs/linear_plateau.yaml",  # ARCHIVED/NOT IN USE
     "Declining Increment": "configs/declining_increment.yaml"
 }
 
@@ -98,115 +95,6 @@ def run_model(config_path):
             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, species_results_fmt, survival_table)
 
-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')
-    N = config["project"]["duration_years"]
-    ages = np.arange(0, N + 1)  # 0 to N
-    ages_inc = np.arange(1, N + 1)  # 1 to N
-    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
-    use_continuous = config.get('continuous_growth', False)
-    for sp in config["species"]:
-        name = SPECIES_DISPLAY_NAMES.get(sp["name"], sp["name"])
-        initial_dbh = sp["initial_values"]["dbh"]
-        initial_height = sp["initial_values"]["height"]
-        if model_type == "linear":
-            dbh = [ERModel.linear_growth(t, sp["linear"]["dbh"], initial_dbh) for t in ages]
-            height = [ERModel.linear_growth(t, sp["linear"]["height"], initial_height) for t in ages]
-        elif model_type == "linear_plateau":
-            dbh = [ERModel.linear_plateau_growth(t, sp["linear_plateau"]["dbh"], initial_dbh) for t in ages]
-            height = [ERModel.linear_plateau_growth(t, sp["linear_plateau"]["height"], initial_height) for t in ages]
-        elif model_type == "declining_increment":
-            if use_continuous:
-                dbh = [ERModel.continuous_declining_increment_growth(t, sp["declining_increment"]["dbh"], initial_dbh) for t in ages]
-                height = [ERModel.continuous_declining_increment_growth(t, sp["declining_increment"]["height"], initial_height) for t in ages]
-            else:
-                dbh = [ERModel.declining_increment_growth(t, sp["declining_increment"]["dbh"], initial_dbh) for t in ages]
-                height = [ERModel.declining_increment_growth(t, sp["declining_increment"]["height"], initial_height) for t in ages]
-        else:
-            dbh = [ERModel.chapman_richards_growth(t, sp["chapman_richards"]["dbh"], initial_dbh) for t in ages]
-            height = [ERModel.chapman_richards_growth(t, sp["chapman_richards"]["height"], initial_height) for t in ages]
-        dbh = np.array(dbh)
-        height = np.array(height)
-        check_complex(dbh, f"{name} DBH (growth)")
-        check_complex(height, f"{name} Height (growth)")
-        dbh_inc = dbh[1:] - dbh[:-1]
-        height_inc = height[1:] - height[:-1]
-        check_complex(dbh_inc, f"{name} DBH Δ (increment)")
-        check_complex(height_inc, f"{name} Height Δ (increment)")
-        fig.add_trace(go.Scatter(x=ages, y=dbh, mode='lines', name=f"{name} DBH", legendgroup=name, line=dict(width=2)), row=1, col=1)
-        fig.add_trace(go.Scatter(x=ages, y=height, mode='lines', name=f"{name} Height", legendgroup=name, line=dict(width=2)), row=1, col=2)
-        fig.add_trace(go.Scatter(x=ages_inc, 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=ages_inc, 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_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, with and without soil)
-    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, color="blue")))
-    fig1.add_trace(go.Scatter(x=results["year"], y=results["net_carbon"], mode="lines+markers", name="Net Carbon", line=dict(width=2, color="red")))
-    if "gross_carbon_with_soil" in results.columns:
-        # For backward compatibility, but we now sum soil carbon in summary, so recalc here for plot
-        soil_cumsum = results["soil_carbon"].cumsum()
-        gross_with_soil = results["gross_carbon"] + soil_cumsum
-        net_with_soil = results["net_carbon"] + soil_cumsum
-        fig1.add_trace(go.Scatter(x=results["year"], y=gross_with_soil, mode="lines+markers", name="Gross Carbon (with Soil)", line=dict(width=2, dash="dot", color="green")))
-        fig1.add_trace(go.Scatter(x=results["year"], y=net_with_soil, mode="lines+markers", name="Net Carbon (with Soil)", line=dict(width=2, dash="dot", color="orange")))
-    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")
-
-    # 3. Biomass per tree for all species (refactored to use model.species_metrics)
-    years = results["year"]
-    fig3 = go.Figure()
-    import tempfile, yaml
-    from src.er_model import ERModel
-    with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as tmp:
-        yaml.dump(config, tmp)
-        tmp_path = tmp.name
-    model = ERModel(Path(tmp_path))
-    model.run()
-    df = model.species_metrics.copy()
-    for sp in config["species"]:
-        name = SPECIES_DISPLAY_NAMES.get(sp["name"], sp["name"])
-        # Get per-tree biomass for this species
-        sp_biomass = df[df["Species"] == sp["name"]].set_index("Year")["Biomass per Tree (kg)"]
-        # Ensure correct order and fill missing years with NaN
-        sp_biomass = sp_biomass.reindex(years)
-        fig3.add_trace(go.Scatter(x=years, y=sp_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 (kg per tree)", hovermode="x unified", template="plotly_white")
-    return (fig1, fig2, fig3)
-
 def create_summary(results, species_results, config, model):
     total_area = sum(config["project"]["planting_schedule"].values())
     final_gross = results["gross_carbon"].iloc[-1]
@@ -264,85 +152,6 @@ def create_summary(results, species_results, config, model):
     )
     return summary
 
-def create_size_table(config):
-    """
-    Returns a DataFrame with ages as rows and columns for each species and dimension (dbh, height).
-    """
-    from src.er_model import ERModel
-    ages = range(0, config["project"]["duration_years"] + 1)
-    columns = []
-    data = {}
-    for sp in config["species"]:
-        sp_disp = SPECIES_DISPLAY_NAMES.get(sp["name"], sp["name"])
-        for dim in ["dbh", "height"]:
-            col = (sp_disp, dim)
-            columns.append(col)
-            data[col] = []
-    for age in ages:
-        for sp in config["species"]:
-            sp_disp = SPECIES_DISPLAY_NAMES.get(sp["name"], sp["name"])
-            initial_dbh = sp["initial_values"]["dbh"]
-            initial_height = sp["initial_values"]["height"]
-            model_type = config.get('growth_model', 'chapman_richards')
-            use_continuous = config.get('continuous_growth', False)
-            if model_type == "linear":
-                dbh = ERModel.linear_growth(age, sp["linear"]["dbh"], initial_dbh)
-                height = ERModel.linear_growth(age, sp["linear"]["height"], initial_height)
-            elif model_type == "linear_plateau":
-                dbh = ERModel.linear_plateau_growth(age, sp["linear_plateau"]["dbh"], initial_dbh)
-                height = ERModel.linear_plateau_growth(age, sp["linear_plateau"]["height"], initial_height)
-            elif model_type == "declining_increment":
-                if use_continuous:
-                    dbh = ERModel.continuous_declining_increment_growth(age, sp["declining_increment"]["dbh"], initial_dbh)
-                    height = ERModel.continuous_declining_increment_growth(age, sp["declining_increment"]["height"], initial_height)
-                else:
-                    dbh = ERModel.declining_increment_growth(age, sp["declining_increment"]["dbh"], initial_dbh)
-                    height = ERModel.declining_increment_growth(age, sp["declining_increment"]["height"], initial_height)
-            else:
-                dbh = ERModel.chapman_richards_growth(age, sp["chapman_richards"]["dbh"], initial_dbh)
-                height = ERModel.chapman_richards_growth(age, sp["chapman_richards"]["height"], initial_height)
-            data[(sp_disp, "dbh")].append(round(dbh, 5))
-            data[(sp_disp, "height")].append(round(height, 5))
-    # Build MultiIndex columns
-    columns = pd.MultiIndex.from_tuples(columns, names=["Species", "Dimension"])
-    df = pd.DataFrame(data, index=ages)
-    df.index.name = "Age"
-    df = df[columns]  # ensure order
-    return df
-
-def pretty_table_title(title):
-    return f"<span style='font-size:1.3em; font-weight:bold'>{title}</span>"
-
-def create_biomass_debug_table(config):
-    """
-    Returns a DataFrame with years as rows and columns for each species:
-    - Surviving Trees
-    - DBH (cm)
-    - Height (m)
-    - Biomass per Tree (kg)
-    - Total Biomass (kg)
-    Uses model.species_metrics for all values.
-    """
-    from src.er_model import ERModel
-    import tempfile, 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))
-    model.run()
-    df = model.species_metrics.copy()
-    # Pivot to multi-index columns: (Species, Metric)
-    df = df.pivot(index="Year", columns="Species")
-    # Flatten columns
-    df.columns = [f"{SPECIES_DISPLAY_NAMES.get(sp, sp)}, {metric}" for metric, sp in df.columns]
-    # Format numbers
-    for col in df.columns:
-        if "Surviving Trees" in col:
-            df[col] = df[col].apply(lambda x: f"{x:,.0f}")
-        elif "Biomass" in col or "DBH" in col or "Height" in col:
-            df[col] = df[col].apply(lambda x: f"{x:,.2f}")
-    return df
-
 def hex_to_rgba(hex_color, alpha):
     hex_color = hex_color.lstrip('#')
     r, g, b = tuple(int(hex_color[i:i+2], 16) for i in (0, 2, 4))
@@ -380,8 +189,6 @@ with gr.Blocks() as demo:
 
             def update_declining_increment(y1, y2, y3, y4, y5):
                 config = update_planting_schedule(MODEL_CONFIGS["Declining Increment"], [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
@@ -391,7 +198,7 @@ with gr.Blocks() as demo:
                 summary = create_summary(results, species_results, config, model)
                 survival_table = create_survival_table(model)
                 growth_fig = create_growth_increment_plots(config, model_type="declining_increment")
-                biomass_debug_df = create_biomass_debug_table(config)
+                biomass_debug_df = create_biomass_table(config)
                 results_fmt = results.copy()
                 species_results_fmt = species_results.copy()
                 for col in results_fmt.columns:

dashboard/plots/__init__.py

@@ -0,0 +1,131 @@
+"""
+Plotting functions for the Mangrove ER Dashboard.
+"""
+# Imports will be updated as needed when moving functions from app.py 
+import plotly.graph_objs as go
+from plotly.subplots import make_subplots
+import numpy as np
+import warnings
+import traceback
+from src.allometry import calculate_biomass
+from src.er_model import ERModel
+from pathlib import Path
+
+# Helper for checking complex numbers (copied from app.py)
+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')
+    N = config["project"]["duration_years"]
+    ages = np.arange(0, N + 1)  # 0 to N
+    ages_inc = np.arange(1, N + 1)  # 1 to N
+    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
+    SPECIES_DISPLAY_NAMES = {
+        'species_A': 'Rhizophora spp.',
+        'species_B': 'Avicennia germinans'
+    }
+    use_continuous = config.get('continuous_growth', False)
+    for sp in config["species"]:
+        name = SPECIES_DISPLAY_NAMES.get(sp["name"], sp["name"])
+        initial_dbh = sp["initial_values"]["dbh"]
+        initial_height = sp["initial_values"]["height"]
+        if model_type == "linear":
+            dbh = [ERModel.linear_growth(t, sp["linear"]["dbh"], initial_dbh) for t in ages]
+            height = [ERModel.linear_growth(t, sp["linear"]["height"], initial_height) for t in ages]
+        elif model_type == "linear_plateau":
+            dbh = [ERModel.linear_plateau_growth(t, sp["linear_plateau"]["dbh"], initial_dbh) for t in ages]
+            height = [ERModel.linear_plateau_growth(t, sp["linear_plateau"]["height"], initial_height) for t in ages]
+        elif model_type == "declining_increment":
+            if use_continuous:
+                dbh = [ERModel.continuous_declining_increment_growth(t, sp["declining_increment"]["dbh"], initial_dbh) for t in ages]
+                height = [ERModel.continuous_declining_increment_growth(t, sp["declining_increment"]["height"], initial_height) for t in ages]
+            else:
+                dbh = [ERModel.declining_increment_growth(t, sp["declining_increment"]["dbh"], initial_dbh) for t in ages]
+                height = [ERModel.declining_increment_growth(t, sp["declining_increment"]["height"], initial_height) for t in ages]
+        else:
+            dbh = [ERModel.chapman_richards_growth(t, sp["chapman_richards"]["dbh"], initial_dbh) for t in ages]
+            height = [ERModel.chapman_richards_growth(t, sp["chapman_richards"]["height"], initial_height) for t in ages]
+        dbh = np.array(dbh)
+        height = np.array(height)
+        check_complex(dbh, f"{name} DBH (growth)")
+        check_complex(height, f"{name} Height (growth)")
+        dbh_inc = dbh[1:] - dbh[:-1]
+        height_inc = height[1:] - height[:-1]
+        check_complex(dbh_inc, f"{name} DBH Δ (increment)")
+        check_complex(height_inc, f"{name} Height Δ (increment)")
+        fig.add_trace(go.Scatter(x=ages, y=dbh, mode='lines', name=f"{name} DBH", legendgroup=name, line=dict(width=2)), row=1, col=1)
+        fig.add_trace(go.Scatter(x=ages, y=height, mode='lines', name=f"{name} Height", legendgroup=name, line=dict(width=2)), row=1, col=2)
+        fig.add_trace(go.Scatter(x=ages_inc, 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=ages_inc, 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_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, with and without soil)
+    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, color="blue")))
+    fig1.add_trace(go.Scatter(x=results["year"], y=results["net_carbon"], mode="lines+markers", name="Net Carbon", line=dict(width=2, color="red")))
+    if "gross_carbon_with_soil" in results.columns:
+        # For backward compatibility, but we now sum soil carbon in summary, so recalc here for plot
+        soil_cumsum = results["soil_carbon"].cumsum()
+        gross_with_soil = results["gross_carbon"] + soil_cumsum
+        net_with_soil = results["net_carbon"] + soil_cumsum
+        fig1.add_trace(go.Scatter(x=results["year"], y=gross_with_soil, mode="lines+markers", name="Gross Carbon (with Soil)", line=dict(width=2, dash="dot", color="green")))
+        fig1.add_trace(go.Scatter(x=results["year"], y=net_with_soil, mode="lines+markers", name="Net Carbon (with Soil)", line=dict(width=2, dash="dot", color="orange")))
+    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")
+
+    # 3. Biomass per tree for all species (refactored to use model.species_metrics)
+    years = results["year"]
+    fig3 = go.Figure()
+    import tempfile, yaml
+    from src.er_model import ERModel
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as tmp:
+        yaml.dump(config, tmp)
+        tmp_path = tmp.name
+    model = ERModel(Path(tmp_path))
+    model.run()
+    df = model.species_metrics.copy()
+    SPECIES_DISPLAY_NAMES = {
+        'species_A': 'Rhizophora spp.',
+        'species_B': 'Avicennia germinans'
+    }
+    for sp in config["species"]:
+        name = SPECIES_DISPLAY_NAMES.get(sp["name"], sp["name"])
+        # Get per-tree biomass for this species
+        sp_biomass = df[df["Species"] == sp["name"]].set_index("Year")["Biomass per Tree (kg)"]
+        # Ensure correct order and fill missing years with NaN
+        sp_biomass = sp_biomass.reindex(years)
+        fig3.add_trace(go.Scatter(x=years, y=sp_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 (kg per tree)", hovermode="x unified", template="plotly_white")
+    return (fig1, fig2, fig3) 

dashboard/tables/__init__.py

@@ -0,0 +1,69 @@
+"""
+Table formatting functions for the Mangrove ER Dashboard.
+"""
+# Imports will be updated as needed when moving functions from app.py 
+import pandas as pd
+from src.er_model import ERModel
+from pathlib import Path
+import yaml
+
+# Helper for pretty table titles
+def pretty_table_title(title):
+    return f"<span style='font-size:1.3em; font-weight:bold'>{title}</span>"
+
+# Table: Biomass Table (was debug table)
+def create_biomass_table(config):
+    """
+    Returns a DataFrame with years as rows and columns for each species:
+    - Surviving Trees
+    - DBH (cm)
+    - Height (m)
+    - Biomass per Tree (kg)
+    - Total Biomass (kg)
+    Uses model.species_metrics for all values.
+    """
+    import tempfile
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as tmp:
+        yaml.dump(config, tmp)
+        tmp_path = tmp.name
+    model = ERModel(Path(tmp_path))
+    model.run()
+    df = model.species_metrics.copy()
+    # Pivot to multi-index columns: (Species, Metric)
+    df = df.pivot(index="Year", columns="Species")
+    # Flatten columns
+    SPECIES_DISPLAY_NAMES = {
+        'species_A': 'Rhizophora spp.',
+        'species_B': 'Avicennia germinans'
+    }
+    df.columns = [f"{SPECIES_DISPLAY_NAMES.get(sp, sp)}, {metric}" for metric, sp in df.columns]
+    # Format numbers
+    for col in df.columns:
+        if "Surviving Trees" in col:
+            df[col] = df[col].apply(lambda x: f"{x:,.0f}")
+        elif "Biomass" in col or "DBH" in col or "Height" in col:
+            df[col] = df[col].apply(lambda x: f"{x:,.2f}")
+    return df
+
+# Table: Surviving Trees Table
+def create_survival_table(model):
+    """
+    Returns a DataFrame with years as rows and columns for each species and total surviving trees.
+    Uses model.species_metrics for all values.
+    """
+    SPECIES_DISPLAY_NAMES = {
+        'species_A': 'Rhizophora spp.',
+        'species_B': 'Avicennia germinans'
+    }
+    df = model.species_metrics.copy()
+    # Pivot to wide format: years as rows, species as columns
+    surv = df.pivot(index="Year", columns="Species", values="Surviving Trees")
+    # Rename columns to display names
+    surv.columns = [SPECIES_DISPLAY_NAMES.get(sp, sp) for sp in surv.columns]
+    # Add total surviving trees column
+    surv["Total Surviving Trees"] = surv.sum(axis=1)
+    # Format numbers
+    for col in surv.columns:
+        surv[col] = surv[col].apply(lambda x: f"{x:,.0f}")
+    surv = surv.reset_index()
+    return surv