chore: UI/UX cleanup, grouped accordions, tooltips as labels, compact mortality layout, reset button

.cursor/rules/agent.md

@@ -0,0 +1,5 @@
+The agent should only request explicit user permission to complete a suggested code change if the change is large, potentially destructive, or could have significant side effects. For most routine, incremental, or clearly safe changes, the agent should proceed and apply the change without asking for additional user approval.
+
+Summary of intent:
+- Small, routine, or obviously safe changes: Apply directly, no need to ask.
+- Large, sweeping, or potentially risky changes: Ask for user confirmation before proceeding. 

dashboard/plots/__init__.py

@@ -2,14 +2,17 @@
 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
+import plotly.graph_objects 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 er_model_core.allometry import calculate_biomass
+from er_model_core.er_model import ERModel
 from pathlib import Path
+from er_model_core.growth_models.chapman_richards import chapman_richards_growth
+from er_model_core.growth_models.linear import linear_growth, linear_plateau_growth
+from er_model_core.growth_models.declining_increment import declining_increment_growth, continuous_declining_increment_growth
 
 # Helper for checking complex numbers (copied from app.py)
 def check_complex(arr, label):
@@ -24,12 +27,12 @@ def create_growth_increment_plots(config, model_type=None):
     model_type: 'chapman_richards', 'linear', 'linear_plateau', or 'declining_increment'
     """
     if model_type is None:
-        model_type = config.get('growth_model', 'chapman_richards')
+        model_type = config.get('growth_model', 'Unknown Model')
     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
+    from er_model_core.er_model import ERModel
     SPECIES_DISPLAY_NAMES = {
         'species_A': 'Rhizophora spp.',
         'species_B': 'Avicennia germinans'
@@ -40,21 +43,21 @@ 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 = [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]
+            dbh = [linear_growth(t, sp["linear"]["dbh"], initial_dbh) for t in ages]
+            height = [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]
+            dbh = [linear_plateau_growth(t, sp["linear_plateau"]["dbh"], initial_dbh) for t in ages]
+            height = [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]
+                dbh = [continuous_declining_increment_growth(t, sp["declining_increment"]["dbh"], initial_dbh) for t in ages]
+                height = [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]
+                dbh = [declining_increment_growth(t, sp["declining_increment"]["dbh"], initial_dbh) for t in ages]
+                height = [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 = [chapman_richards_growth(t, sp["chapman_richards"]["dbh"], initial_dbh) for t in ages]
+            height = [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)")
@@ -109,7 +112,7 @@ def create_all_plots(results, species_results, config):
     years = results["year"]
     fig3 = go.Figure()
     import tempfile, yaml
-    from src.er_model import ERModel
+    from er_model_core.er_model import ERModel
     with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as tmp:
         yaml.dump(config, tmp)
         tmp_path = tmp.name

dashboard/tables/__init__.py

@@ -3,7 +3,8 @@ 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
+import numpy as np
+from er_model_core.er_model import ERModel
 from pathlib import Path
 import yaml
 

{src → er_model_core}/__init__.py

@@ -2,9 +2,9 @@
 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
+from er_model_core.allometry import calculate_biomass
+from er_model_core.er_model import ERModel, Species, ProjectConfig, CarbonConfig
+from er_model_core.metrics import calculate_carbon
 
 __all__ = [
     "ERModel",

er_model_core/config_loader.py

@@ -0,0 +1,46 @@
+"""
+Configuration loading and parsing for the ER Model.
+"""
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, List, Tuple, Optional
+import yaml
+
+# Assuming these dataclasses are defined in er_model.er_model or a shared types module.
+# For now, let's duplicate them here or import them if they are easily accessible.
+# Ideally, they'd be in a place like 'er_model.types'
+# For this refactor, assuming they are in er_model.er_model and we'll import them.
+from er_model_core.types import Species, ProjectConfig, CarbonConfig
+
+def load_model_config(
+    config_path: Optional[Path] = None, 
+    config_dict: Optional[Dict] = None
+) -> Tuple[List[Species], ProjectConfig, CarbonConfig, str, bool, Dict]:
+    """
+    Loads model configuration from a YAML file or a dictionary.
+
+    Returns:
+        A tuple containing:
+            - List of Species objects
+            - ProjectConfig object
+            - CarbonConfig object
+            - Growth model name (str)
+            - Continuous growth flag (bool)
+            - The raw config dictionary
+    """
+    if config_dict is not None:
+        cfg = config_dict
+    elif config_path is not None:
+        with open(config_path) as f:
+            cfg = yaml.safe_load(f)
+    else:
+        raise ValueError("Either config_path or config_dict must be provided.")
+
+    species_list = [Species(**s) for s in cfg["species"]]
+    project_cfg = ProjectConfig(**cfg["project"])
+    carbon_cfg = CarbonConfig(**cfg["carbon"])
+    
+    growth_model_name = cfg.get('growth_model', 'chapman_richards') 
+    continuous_growth_flag = cfg.get('continuous_growth', False)
+    
+    return species_list, project_cfg, carbon_cfg, growth_model_name, continuous_growth_flag, cfg 

{src → er_model_core}/er_model.py

@@ -10,13 +10,15 @@ import pandas as pd
 import yaml
 import warnings
 
-from .allometry import calculate_biomass
-from .metrics import calculate_carbon
+from er_model_core.allometry import calculate_biomass
+from er_model_core.metrics import calculate_carbon
+from er_model_core.config_loader import load_model_config
+from er_model_core.types import Species, ProjectConfig, CarbonConfig
 
-# Growth model imports
-from .growth_models.declining_increment import declining_increment_growth, continuous_declining_increment_growth
-# from growth_models.chapman_richards import chapman_richards_growth  # ARCHIVED/NOT IN USE
-# from growth_models.linear import linear_growth, linear_plateau_growth  # ARCHIVED/NOT IN USE
+# Growth model imports - ensure all are imported
+from er_model_core.growth_models.chapman_richards import chapman_richards_growth
+from er_model_core.growth_models.linear import linear_growth, linear_plateau_growth
+from er_model_core.growth_models.declining_increment import declining_increment_growth, continuous_declining_increment_growth
 
 
 @dataclass
@@ -64,32 +66,31 @@ class ERModel:
     mortality, and carbon conversion factors.
     """
     
-    def __init__(self, config_path: Path = None, config: dict = None):
+    def __init__(self, config_path: Optional[Path] = None, config: Optional[dict] = None):
         """
         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)
         """
-        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", {
+        (
+            self.species, 
+            self.project, 
+            self.carbon, 
+            self.growth_model, 
+            self.continuous_growth,
+            self.raw_config  # Storing the raw config might be useful for other parts
+        ) = load_model_config(config_path=config_path, config_dict=config)
+        
+        self.results: Optional[pd.DataFrame] = None
+        self.species_results: Optional[pd.DataFrame] = None
+        self.scenario_results: Optional[pd.DataFrame] = None
+        self.scenarios = self.raw_config.get("scenarios", {
             "area": 1000.0,
             "dbh_range": [1.0, 20.0],
             "height_range": [0.5, 12.0],
             "growth_rate_factor": 1.0
         })
-        self.results: Optional[pd.DataFrame] = None
-        self.species_results: Optional[pd.DataFrame] = None
-        self.scenario_results: Optional[pd.DataFrame] = None
-        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:
         """
@@ -170,49 +171,45 @@ class ERModel:
                 total += area
         return total
 
-    @staticmethod
-    def chapman_richards_growth(age: float, params: Dict[str, float], initial_value: float) -> float:
-        a, b, c = params["a"], params["b"], params["c"]
-        return initial_value + (a - initial_value) * (1 - np.exp(-b * age)) ** c
+    def get_growth_function_and_params(self, species: Species, growth_model_name: str, dim: str) -> Tuple[callable, Dict[str, float]]:
+        """
+        Get the growth function and its parameters for a given species, model, and dimension (dbh or height).
+        Uses self.continuous_growth to select continuous version if applicable.
+        """
+        params = species.__dict__.get(growth_model_name, {}).get(dim, {})
+        initial_value_key = f"initial_{dim}"
+        # initial_value = species.initial_values.get(dim, 0) # This was the old way, let's ensure params are complete
+
+        growth_functions = {
+            "chapman_richards": chapman_richards_growth,
+            "linear": linear_growth,
+            "linear_plateau": linear_plateau_growth,
+            "declining_increment": declining_increment_growth,
+            # Potentially add more models here
+        }
 
-    @staticmethod
-    def linear_growth(age: float, params: Dict[str, float], initial_value: float) -> float:
-        r = params["r"]
-        return initial_value + r * age
+        continuous_growth_functions = {
+            "declining_increment": continuous_declining_increment_growth,
+            # Add other continuous versions if they exist
+        }
 
-    @staticmethod
-    def linear_plateau_growth(age: float, params: Dict[str, float], initial_value: float) -> float:
-        r = params["r"]
-        T_p = params["T_p"]
-        a = params["a"]
-        if age <= T_p:
-            return initial_value + r * age
+        if self.continuous_growth and growth_model_name in continuous_growth_functions:
+            selected_func = continuous_growth_functions[growth_model_name]
+        elif growth_model_name in growth_functions:
+            selected_func = growth_functions[growth_model_name]
         else:
-            return initial_value + a
+            # Fallback or error if model name is not found
+            # For now, let's use chapman_richards as a default if self.growth_model itself isn't specific enough
+            # However, growth_model_name parameter should be the specific one.
+            warnings.warn(f"Growth model '{growth_model_name}' not found or not supported. Defaulting to chapman_richards for {species.name} {dim}. Check config.")
+            selected_func = chapman_richards_growth # Default fallback
+            params = species.chapman_richards.get(dim, {}) if species.chapman_richards else {}
 
-    @staticmethod
-    def declining_increment_growth(age: float, params: Dict[str, float], initial_value: float) -> float:
-        r0 = params["r0"]
-        T_m = params["T_m"]
-        # Accumulate annual increments, never negative
-        total = initial_value
-        for i in range(1, int(np.floor(age)) + 1):
-            increment = r0 * max(0, 1 - (i - 1) / T_m)
-            total += increment
-        # If age is fractional, add partial increment for the last year
-        frac = age - int(np.floor(age))
-        if frac > 0:
-            i = int(np.floor(age)) + 1
-            increment = r0 * max(0, 1 - (i - 1) / T_m)
-            total += frac * increment
-        return total
+        if not params:
+            warnings.warn(f"No parameters found for {growth_model_name} {dim} for species {species.name}. Growth may be incorrect.")
+            # Provide some default empty params if really needed, or let it fail if func expects them.
 
-    @staticmethod
-    def continuous_declining_increment_growth(age: float, params: Dict[str, float], initial_value: float) -> float:
-        r0 = params["r0"]
-        T_m = params["T_m"]
-        # Continuous formula: initial + r0 * (age - age^2/(2*Tm))
-        return initial_value + r0 * (age - age**2 / (2 * T_m))
+        return selected_func, params
 
     def calculate_carbon_for_species(self, species: Species, age: int, area: float, cohort_age: int) -> float:
         """
@@ -340,69 +337,9 @@ class ERModel:
 
     def save_results(self, output_path: Path) -> None:
         """
-        Save results to CSV file.
-        
-        Args:
-            output_path: Path to save the results CSV
+        Save the main results DataFrame to a CSV file.
         """
         if self.results is None:
-            raise ValueError("No results available. Run the model first.")
-        self.results.to_csv(output_path, index=False)
-
-    def get_growth_function_and_params(self, species, growth_model, dim):
-        """
-        Returns the correct growth function and parameter dict for the given species and dimension (dbh or height).
-        """
-        if growth_model == "linear":
-            # from growth_models.linear import linear_growth
-            func = None  # ARCHIVED/NOT IN USE
-            params = species.linear[dim]
-        elif growth_model == "linear_plateau":
-            # from growth_models.linear import linear_plateau_growth
-            func = None  # ARCHIVED/NOT IN USE
-            params = species.linear_plateau[dim]
-        elif growth_model == "declining_increment":
-            if getattr(self, 'continuous_growth', False):
-                func = continuous_declining_increment_growth
-            else:
-                func = declining_increment_growth
-            params = species.declining_increment[dim]
-        else:
-            # from growth_models.chapman_richards import chapman_richards_growth
-            func = None  # ARCHIVED/NOT IN USE
-            params = species.chapman_richards[dim]
-        return func, params
-
-# --- Parameter sweep/test for plausible survival curves ---
-def test_dbh_mortality_sweep():
-    import matplotlib.pyplot as plt
-    import numpy as np
-    m_refs = [0.01, 0.05, 0.1, 0.16]
-    ps = [1.0, 1.5, 2.0]
-    DBH_ref = 9.0
-    years = np.arange(1, 31)
-    initial_trees = 1000
-    results = {}
-    for m_ref in m_refs:
-        for p in ps:
-            N_live = initial_trees
-            N_lives = []
-            for year in years:
-                dbh = 1.0 + (year - 1) * 0.5  # simple linear DBH growth for test
-                dbh = max(dbh, 1.0)
-                m = m_ref * (DBH_ref / dbh) ** p
-                m = min(max(m, 0), 0.99)
-                N_live = N_live * (1 - m)
-                N_lives.append(N_live)
-            results[(m_ref, p)] = N_lives
-    plt.figure(figsize=(10,6))
-    for (m_ref, p), N_lives in results.items():
-        plt.plot(years, N_lives, label=f"m_ref={m_ref}, p={p}")
-    plt.xlabel("Year")
-    plt.ylabel("Surviving Trees")
-    plt.title("DBH-dependent Mortality Parameter Sweep")
-    plt.legend()
-    plt.grid(True)
-    plt.show()
-
-# To run the test, call test_dbh_mortality_sweep() from __main__ or a notebook. 
+            raise ValueError("Results have not been calculated yet. Run model.run() first.")
+        output_path.parent.mkdir(parents=True, exist_ok=True)
+        self.results.to_csv(output_path, index=False) 

er_model_core/types.py

@@ -0,0 +1,36 @@
+from dataclasses import dataclass
+from typing import Dict, Optional
+
+@dataclass
+class Species:
+    """Species-specific parameters for growth and carbon calculations."""
+    name: str
+    planting_density: float
+    # Old style
+    mortality_rates: Optional[Dict[str, float]] = None
+    # New style
+    m_ref: Optional[float] = None
+    DBH_ref: Optional[float] = None
+    p: Optional[float] = None
+    chapman_richards: Dict[str, Dict[str, float]] = None
+    allometry: Dict[str, float] = None
+    initial_values: Dict[str, float] = None
+    linear: Optional[Dict[str, Dict[str, float]]] = None
+    linear_plateau: Optional[Dict[str, Dict[str, float]]] = None
+    declining_increment: Optional[Dict[str, Dict[str, float]]] = None
+
+@dataclass
+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
+    soil_carbon_per_ha_per_year: float = 0.0 

requirements.txt

@@ -1,5 +1,8 @@
+click>=8.1.7
 gradio>=3.41.2
-pandas>=1.5.3
-numpy>=1.23.0
+matplotlib>=3.8.2
+numpy>=1.26.3
+pandas>=2.2.0
 plotly>=5.0.0
-pyyaml
+pyyaml>=6.0.1
+scipy>=1.12.0

scripts/run_pipeline.py

@@ -4,14 +4,13 @@ Main pipeline script for running the ER model calculations.
 """
 import sys
 from pathlib import Path
+import yaml
+import click
+from er_model_core.er_model import ERModel
 
 # 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(

setup.py

@@ -3,7 +3,8 @@ from setuptools import find_packages, setup
 setup(
     name="er_model",
     version="0.1.0",
-    packages=find_packages(),
+    package_dir={'': 'er_model_core'},
+    packages=find_packages(where='er_model_core'),
     install_requires=[
         "pandas>=2.2.0",
         "numpy>=1.26.3",

tests/test_er_model.py

@@ -6,10 +6,11 @@ from pathlib import Path
 import numpy as np
 import pytest
 import yaml
+import pandas as pd
 
-from src.allometry import calculate_biomass
-from src.er_model import ERModel, Species
-from src.metrics import calculate_carbon
+from er_model_core.allometry import calculate_biomass
+from er_model_core.er_model import ERModel, Species
+from er_model_core.metrics import calculate_carbon
 
 
 @pytest.fixture
@@ -133,7 +134,7 @@ def test_full_pipeline(config_file):
 
 def test_dbh_dependent_mortality():
     """Test that DBH-dependent mortality matches expected at DBH=9 and year-5 plateau."""
-    from src.er_model import ERModel, Species
+    from er_model_core.er_model import ERModel, Species
     # Minimal species config
     species = Species(
         name="Test Species",
@@ -171,7 +172,7 @@ def test_dbh_dependent_mortality():
 
 def test_allometric_equation_species_A_B():
     """Test Zanvo et al. 2023 allometric equations for both species."""
-    from src.allometry import calculate_biomass
+    from er_model_core.allometry import calculate_biomass
     # Test values
     dbh = 10.0  # cm
     height = 5.0  # m
@@ -182,4 +183,73 @@ def test_allometric_equation_species_A_B():
     # 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}" 
+    assert np.isclose(result_B, expected_B, rtol=1e-6), f"species_B: got {result_B}, expected {expected_B}"
+
+    # Test with a known allometry to check biomass calculation linkage
+    from er_model_core.allometry import calculate_biomass
+    
+    # Basic check that biomass is positive for reasonable inputs
+    # ... existing code ...
+
+    # Re-import ERModel and Species for this specific test to ensure clean state if needed
+    from er_model_core.er_model import ERModel, Species
+    model = ERModel(config=config_dict)
+    results_df, species_results_df = model.run()
+
+    # ... existing code ...
+
+    # ... existing code ... 
+
+# --- Parameter sweep/test for plausible survival curves (moved from er_model.py) ---
+def test_dbh_mortality_sweep():
+    import matplotlib.pyplot as plt
+    import numpy as np
+    m_refs = [0.01, 0.05, 0.1, 0.16]
+    ps = [1.0, 1.5, 2.0]
+    DBH_ref = 9.0
+    years = np.arange(1, 31)
+    initial_trees = 1000
+    results = {}
+    for m_ref in m_refs:
+        for p in ps:
+            N_live = initial_trees
+            N_lives = []
+            for year in years:
+                # This test requires a simplified DBH growth for its internal logic.
+                # It does not use the main ERModel's growth functions directly.
+                dbh_test_growth = 1.0 + (year - 1) * 0.5  # simple linear DBH growth for test
+                dbh = max(dbh_test_growth, 1.0)
+                
+                # Mortality calculation as per ERModel logic being tested
+                m = m_ref * (DBH_ref / dbh) ** p
+                m = min(max(m, 0), 0.99) 
+                N_live = N_live * (1 - m)
+                N_lives.append(N_live)
+            results[(m_ref, p)] = N_lives
+
+    # This test originally had plotting. For automated tests, assertions are better.
+    # If visual inspection is needed, this part can be run in a notebook.
+    # For now, let's assert that the number of trees is non-increasing.
+    for (m_ref, p), N_lives_curve in results.items():
+        for i in range(len(N_lives_curve) - 1):
+            assert N_lives_curve[i+1] <= N_lives_curve[i], f"Mortality sweep {m_ref, p}: Trees increased from {N_lives_curve[i]} to {N_lives_curve[i+1]}"
+        assert N_lives_curve[-1] < initial_trees, f"Mortality sweep {m_ref, p}: No mortality occurred or trees increased."
+
+    # plt.figure(figsize=(10,6))
+    # for (m_ref, p), N_lives_plot in results.items():
+    #     plt.plot(years, N_lives_plot, label=f"m_ref={m_ref}, p={p}")
+    # plt.xlabel("Year")
+    # plt.ylabel("Surviving Trees")
+    # plt.title("DBH-dependent Mortality Parameter Sweep")
+    # plt.legend()
+    # plt.grid(True)
+    # To save plot instead of showing:
+    # output_dir = Path(__file__).parent.parent / "outputs" / "test_plots"
+    # output_dir.mkdir(parents=True, exist_ok=True)
+    # plt.savefig(output_dir / "dbh_mortality_sweep.png")
+    # plt.close()
+    print("test_dbh_mortality_sweep completed basic assertions.")
+
+# If you want to run this specific test and see the plot (e.g., during development):
+# if __name__ == "__main__":
+#     test_dbh_mortality_sweep() # You would need to handle imports for ERModel parts if called directly here