Dashboard cleanup: remove per-hectare chart, improve table formatting, clarify table names and titles

configs/declining_increment.yaml

@@ -71,6 +71,7 @@ carbon:
   buffer_percentage: 20    # risk buffer
   leakage_percentage: 0    # no leakage assumed
   baseline_emissions: 0    # tCO2/ha/year
+  soil_carbon_per_ha_per_year: 1.0  # tCO2/ha/year, added annually
 
 scenarios:
   area: 1000.0  # ha

dashboard/app.py

@@ -17,6 +17,8 @@ import plotly.graph_objs as go
 from plotly.subplots import make_subplots
 import warnings
 import traceback
+from src.allometry import calculate_biomass
+import copy
 
 MODEL_CONFIGS = {
     "Original Model": "configs/params.yaml",
@@ -45,22 +47,24 @@ def create_survival_table(model):
     """
     years = range(1, model.project.duration_years + 1)
     data = {"Year": []}
-    species_names = [SPECIES_DISPLAY_NAMES.get(s.name, s.name) for s in model.species]
-    for name in species_names:
+    # Use internal names for lookup, but display friendly names
+    internal_names = [s.name for s in model.species]
+    display_names = [SPECIES_DISPLAY_NAMES.get(s.name, s.name) for s in model.species]
+    for name in display_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)
+        for internal, display in zip(internal_names, display_names):
+            val = totals.get(internal, 0)
+            data[display].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"]:
+    for name in display_names + ["Total Surviving Trees"]:
         df[name] = df[name].apply(lambda x: f"{x:,.0f}")
     return df
 
@@ -116,7 +120,9 @@ def create_growth_increment_plots(config, model_type=None):
     """
     if model_type is None:
         model_type = config.get('growth_model', 'chapman_richards')
-    years = np.arange(1, config["project"]["duration_years"] + 1)
+    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)
@@ -125,44 +131,33 @@ def create_growth_increment_plots(config, model_type=None):
         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]
+            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_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]
+            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":
-            dbh_params = sp["declining_increment"]["dbh"]
-            height_params = sp["declining_increment"]["height"]
             if use_continuous:
-                dbh = [ERModel.continuous_declining_increment_growth(t, dbh_params, initial_dbh) for t in years]
-                height = [ERModel.continuous_declining_increment_growth(t, height_params, initial_height) for t in years]
+                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, 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 = [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 = np.diff(np.insert(dbh, 0, dbh[0]))
-        height_inc = np.diff(np.insert(height, 0, height[0]))
+        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=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.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)
@@ -179,10 +174,17 @@ def create_all_plots(results, species_results, config):
     for col in ["gross_carbon", "net_carbon"]:
         arr = np.array(results[col])
         check_complex(arr, f"results['{col}']")
-    # 1. Carbon curve (gross and net)
+    # 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)))
-    fig1.add_trace(go.Scatter(x=results["year"], y=results["net_carbon"], mode="lines+markers", name="Net Carbon", line=dict(width=2)))
+    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)
@@ -202,6 +204,7 @@ def create_all_plots(results, species_results, config):
         name = SPECIES_DISPLAY_NAMES.get(sp["name"], sp["name"])
         initial_dbh = sp["initial_values"]["dbh"]
         initial_height = sp["initial_values"]["height"]
+        use_continuous = config.get('continuous_growth', False)
         if growth_model == "linear":
             dbh_params = sp["linear"]["dbh"]
             height_params = sp["linear"]["height"]
@@ -215,8 +218,12 @@ def create_all_plots(results, species_results, config):
         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]
+            if use_continuous:
+                dbh = [ERModel.continuous_declining_increment_growth(t, dbh_params, initial_dbh) for t in years]
+                height = [ERModel.continuous_declining_increment_growth(t, height_params, initial_height) for t in years]
+            else:
+                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"]
@@ -241,10 +248,18 @@ 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]
+    # Sum soil carbon over all years
+    total_soil_carbon = results["soil_carbon"].sum()
+    final_gross_soil = final_gross + total_soil_carbon
+    final_net_soil = final_net + total_soil_carbon
     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
+    gross_carbon_per_ha_soil = final_gross_soil / total_area if total_area > 0 else 0
+    net_carbon_per_ha_soil = final_net_soil / total_area if total_area > 0 else 0
     annual_net_per_ha = net_carbon_per_ha / years if years > 0 else 0
+    annual_net_per_ha_soil = net_carbon_per_ha_soil / years if years > 0 else 0
+    soil_carbon_val = config["carbon"].get("soil_carbon_per_ha_per_year", 0)
     # Milestone years
     def get_val(col, idx):
         return results[col].iloc[idx] if len(results) > idx else 0
@@ -256,6 +271,8 @@ def create_summary(results, species_results, config, model):
     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
+    avg_annual_gross_soil = final_gross_soil / years if years > 0 else 0
+    avg_annual_net_soil = final_net_soil / years if years > 0 else 0
     # Surviving trees at milestones
     milestones = [5, 10, 20, 30]
     survival_lines = []
@@ -272,16 +289,146 @@ def create_summary(results, species_results, config, model):
         per_ha_lines.append(f"{SPECIES_DISPLAY_NAMES.get(k, 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"
+        f"Soil Carbon:\n-----------\nSoil carbon added: {soil_carbon_val} tCO2/ha/year\nTotal soil carbon added over project: {total_soil_carbon:,.0f} tCO2\n\n"
+        f"Carbon Sequestration (Biomass Only):\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"Carbon Sequestration (With Soil Carbon):\n-------------------\nTotal Gross Carbon (Year {years}): {final_gross_soil:,.0f} tCO2\nTotal Net Carbon (Year {years}): {final_net_soil:,.0f} tCO2\nAverage Annual Gross: {avg_annual_gross_soil:,.0f} tCO2/yr\nAverage Annual Net: {avg_annual_net_soil:,.0f} tCO2/yr\n\n"
+        f"Milestone Years (Biomass Only):\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"
+        + f"\n\nPer Hectare Metrics (Year {years}):\n-----------------------------\nGross Carbon per ha (biomass only): {gross_carbon_per_ha:,.0f} tCO2/ha\nNet Carbon per ha (biomass only): {net_carbon_per_ha:,.0f} tCO2/ha\nGross Carbon per ha (with soil): {gross_carbon_per_ha_soil:,.0f} tCO2/ha\nNet Carbon per ha (with soil): {net_carbon_per_ha_soil:,.0f} tCO2/ha\nAverage Annual Net per ha (biomass only): {annual_net_per_ha:,.2f} tCO2/ha/yr\nAverage Annual Net per ha (with soil): {annual_net_per_ha_soil:,.2f} tCO2/ha/yr\n"
     )
     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 cohort-level growth (age = year - planting_year + 1).
+    """
+    from src.er_model import ERModel
+    from src.allometry import calculate_biomass
+    years = range(1, config["project"]["duration_years"] + 1)
+    data = {}
+    for sp in config["species"]:
+        sp_disp = SPECIES_DISPLAY_NAMES.get(sp["name"], sp["name"])
+        data[(sp_disp, "Surviving Trees")] = []
+        data[(sp_disp, "DBH (cm)")] = []
+        data[(sp_disp, "Height (m)")] = []
+        data[(sp_disp, "Biomass per Tree (kg)")] = []
+        data[(sp_disp, "Total Biomass (kg)")] = []
+    model = ERModel(config=config)
+    for year in years:
+        for sp in config["species"]:
+            sp_disp = SPECIES_DISPLAY_NAMES.get(sp["name"], sp["name"])
+            total_surviving = 0
+            total_biomass = 0
+            total_dbh = 0
+            total_height = 0
+            total_biomass_per_tree = 0
+            n_cohorts = 0
+            for planting_year, area in config["project"]["planting_schedule"].items():
+                py = int(planting_year.split("_")[1])
+                cohort_age = year - py + 1
+                if cohort_age < 1:
+                    continue
+                initial_trees = sp["planting_density"] * area
+                plateau_density = sp["planting_density"] * area if cohort_age >= 5 else None
+                surviving = model.calculate_cohort_surviving_trees(1, cohort_age, initial_trees, model.species[0], plateau_density, model.growth_model)
+                dbh_func, dbh_params = model.get_growth_function_and_params(model.species[0], model.growth_model, 'dbh')
+                height_func, height_params = model.get_growth_function_and_params(model.species[0], model.growth_model, 'height')
+                dbh = dbh_func(cohort_age, dbh_params, sp["initial_values"]["dbh"])
+                height = height_func(cohort_age, height_params, sp["initial_values"]["height"])
+                biomass_per_tree = calculate_biomass(dbh, height, sp["name"], sp["allometry"])
+                total_surviving += surviving
+                total_dbh += dbh * surviving
+                total_height += height * surviving
+                total_biomass_per_tree += biomass_per_tree * surviving
+                total_biomass += biomass_per_tree * surviving
+                n_cohorts += surviving
+            if total_surviving > 0:
+                avg_dbh = total_dbh / total_surviving
+                avg_height = total_height / total_surviving
+                avg_biomass_per_tree = total_biomass_per_tree / total_surviving
+            else:
+                avg_dbh = 0
+                avg_height = 0
+                avg_biomass_per_tree = 0
+            data[(sp_disp, "Surviving Trees")].append(total_surviving)
+            data[(sp_disp, "DBH (cm)")].append(avg_dbh)
+            data[(sp_disp, "Height (m)")].append(avg_height)
+            data[(sp_disp, "Biomass per Tree (kg)")].append(avg_biomass_per_tree)
+            data[(sp_disp, "Total Biomass (kg)")].append(total_biomass)
+    columns = pd.MultiIndex.from_tuples(list(data.keys()))
+    df = pd.DataFrame({col: data[col] for col in columns}, index=range(1, config["project"]["duration_years"] + 1))
+    df.index.name = "Year"
+    # 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))
+    return f'rgba({r},{g},{b},{alpha})'
+
 with gr.Blocks() as demo:
     gr.Markdown("# Mangrove ER Model Dashboard\nDeclining Increment Model Only")
     with gr.Tabs():
@@ -303,10 +450,14 @@ with gr.Blocks() as demo:
                 carbon_plot = gr.Plot()
                 biomass_plot = gr.Plot()
                 annual_plot = gr.Plot()
+            # Add new growth/increment curves plot
+            growth_plot = gr.Plot(label="Growth & Increment Curves (DBH/Height)")
             summary_box = gr.Textbox(label="Summary", lines=12)
             results_box = gr.Dataframe(label="Project Results (Annual)")
             species_box = gr.Dataframe(label="Species Results (Annual)")
             survival_box = gr.Dataframe(label="Surviving Trees Table")
+            # Replace size_table with biomass debug table
+            biomass_debug_table = gr.Dataframe(label="Biomass Table (inputs & outputs per year)")
 
             def update_declining_increment(y1, y2, y3, y4, y5):
                 config = update_planting_schedule(MODEL_CONFIGS["Declining Increment"], [y1, y2, y3, y4, y5])
@@ -320,6 +471,8 @@ with gr.Blocks() as demo:
                 plots = create_all_plots(results, species_results, config)
                 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)
                 results_fmt = results.copy()
                 species_results_fmt = species_results.copy()
                 for col in results_fmt.columns:
@@ -328,21 +481,23 @@ with gr.Blocks() as demo:
                 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[0], plots[2], plots[1], summary, results_fmt, species_results_fmt, survival_table
+                return plots[0], plots[2], plots[1], growth_fig, summary, results_fmt, species_results_fmt, survival_table, biomass_debug_df
 
             update_btn.click(
                 update_declining_increment,
                 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]
+                outputs=[carbon_plot, biomass_plot, annual_plot, growth_plot, summary_box, results_box, species_box, survival_box, biomass_debug_table]
             )
 
             # Show initial results
-            c, b, a, summary, r, s, surv = update_declining_increment(2500, 2500, 0, 0, 0)
+            c, b, a, g, summary, r, s, surv, biomass_debug_df = update_declining_increment(2500, 2500, 0, 0, 0)
             carbon_plot.value = c
             biomass_plot.value = b
             annual_plot.value = a
+            growth_plot.value = g
             summary_box.value = summary
             results_box.value = r
             species_box.value = s
             survival_box.value = surv
+            biomass_debug_table.value = biomass_debug_df
     demo.launch(share=True) 

src/er_model.py

@@ -48,6 +48,7 @@ class CarbonConfig:
     buffer_percentage: float
     leakage_percentage: float
     baseline_emissions: float
+    soil_carbon_per_ha_per_year: float = 0.0
 
 
 class ERModel:
@@ -58,34 +59,32 @@ class ERModel:
     mortality, and carbon conversion factors.
     """
     
-    def __init__(self, config_path: Path):
+    def __init__(self, config_path: Path = None, config: dict = None):
         """
-        Initialize the model from a YAML configuration file.
-        
+        Initialize the model from a YAML configuration file or a config dict.
         Args:
             config_path: Path to the YAML configuration file
+            config: Config dict (optional)
         """
-        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", {
+        if config is not None:
+            cfg = config
+        else:
+            with open(config_path) as f:
+                cfg = yaml.safe_load(f)
+        self.species = [Species(**s) for s in cfg["species"]]
+        self.project = ProjectConfig(**cfg["project"])
+        self.carbon = CarbonConfig(**cfg["carbon"])
+        self.scenarios = cfg.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
-        
-        self.growth_model = config.get('growth_model', 'chapman_richards')
+        self.growth_model = cfg.get('growth_model', 'chapman_richards')
+        self.continuous_growth = cfg.get('continuous_growth', False)
         
     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:
         """
@@ -210,35 +209,34 @@ class ERModel:
         # Continuous formula: initial + r0 * (age - age^2/(2*Tm))
         return initial_value + r0 * (age - age**2 / (2 * T_m))
 
-    def calculate_carbon_for_species(self, species: Species, age: int, area: float) -> float:
+    def calculate_carbon_for_species(self, species: Species, age: int, area: float, cohort_age: int) -> float:
         """
-        Calculate carbon sequestration for a single species and age.
+        Calculate carbon sequestration for a single species, cohort, and cohort age.
         Args:
             species: Species parameters
-            age: Age of trees in years
+            age: Project year (not used for growth)
             area: Planted area in hectares
+            cohort_age: Age of this cohort (years since planting)
         Returns:
             Carbon sequestration in tCO2
         """
-        # Calculate surviving trees using DBH-dependent mortality
+        if cohort_age < 1:
+            return 0
         initial_trees = species.planting_density * area
-        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
+        plateau_density = species.planting_density * area if cohort_age >= 5 else None
+        surviving = self.calculate_cohort_surviving_trees(1, cohort_age, initial_trees, species, plateau_density, self.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
+        dbh = dbh_func(cohort_age, dbh_params, species.initial_values["dbh"])
+        height = height_func(cohort_age, height_params, species.initial_values["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(self) -> Tuple[pd.DataFrame, pd.DataFrame]:
         """
         Execute the full ER calculation pipeline.
@@ -248,64 +246,49 @@ class ERModel:
         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 = self.calculate_cumulative_area(year)
-            
-            # Calculate for each planting cohort and species
             for species in self.species:
                 species_carbon = 0
                 for planting_year, area in self.project.planting_schedule.items():
                     py = int(planting_year.split("_")[1])
-                    initial_trees = species.planting_density * area
-                    # 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
-                    carbon = calculate_carbon(
-                        biomass * surviving,
-                        self.carbon.biomass_to_carbon,
-                        self.carbon.carbon_to_co2
-                    )
+                    cohort_age = year - py + 1
+                    if cohort_age < 1:
+                        continue
+                    # Use correct cohort age for all calculations
+                    carbon = self.calculate_carbon_for_species(species, year, area, cohort_age)
                     species_carbon += carbon
                 total_carbon += species_carbon
-                # Track per-species carbon
                 species_key = f"{species.name} tCO2"
                 species_year_results[species_key] = species_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
-            
+            # Add soil carbon if present
+            soil_carbon = 0
+            if hasattr(self.carbon, 'soil_carbon_per_ha_per_year'):
+                soil_carbon = self.carbon.soil_carbon_per_ha_per_year * cumulative_area
+            gross_carbon_with_soil = gross_carbon + soil_carbon
+            net_carbon_with_soil = net_carbon + soil_carbon
             year_results.update({
                 "gross_carbon": gross_carbon,
                 "net_carbon": net_carbon,
-                "cumulative_area": cumulative_area
+                "cumulative_area": cumulative_area,
+                "gross_carbon_with_soil": gross_carbon_with_soil,
+                "net_carbon_with_soil": net_carbon_with_soil,
+                "soil_carbon": soil_carbon
             })
-            
             results.append(year_results)
             species_results.append(species_year_results)
-        
         self.results = pd.DataFrame(results)
         self.species_results = pd.DataFrame(species_results)
-        
         return self.results, self.species_results
 
     def save_results(self, output_path: Path) -> None:
@@ -330,7 +313,10 @@ class ERModel:
             func = ERModel.linear_plateau_growth
             params = species.linear_plateau[dim]
         elif growth_model == "declining_increment":
-            func = ERModel.declining_increment_growth
+            if getattr(self, 'continuous_growth', False):
+                func = ERModel.continuous_declining_increment_growth
+            else:
+                func = ERModel.declining_increment_growth
             params = species.declining_increment[dim]
         else:
             func = ERModel.chapman_richards_growth

tests/test_er_model.py

@@ -166,4 +166,20 @@ def test_dbh_dependent_mortality():
         N_live = N_live * (1 - m)
         if y == 5:
             N_live = plateau_density
-    assert N_live == plateau_density 
+    assert N_live == plateau_density
+
+
+def test_allometric_equation_species_A_B():
+    """Test Zanvo et al. 2023 allometric equations for both species."""
+    from src.allometry import calculate_biomass
+    # Test values
+    dbh = 10.0  # cm
+    height = 5.0  # m
+    # species_A (Rhizophora spp.)
+    expected_A = 1.938 * (dbh**2 * height)**0.67628
+    result_A = calculate_biomass(dbh, height, "species_A", {})
+    assert np.isclose(result_A, expected_A, rtol=1e-6), f"species_A: got {result_A}, expected {expected_A}"
+    # species_B (Avicennia germinans)
+    expected_B = 1.486 * (dbh**2 * height)**0.55864
+    result_B = calculate_biomass(dbh, height, "species_B", {})
+    assert np.isclose(result_B, expected_B, rtol=1e-6), f"species_B: got {result_B}, expected {expected_B}"