testing of sensitivity analysis

Author: matthiaskoenig

release-notes/0.4.0.md

@@ -7,5 +7,6 @@ following changes:
 ## Features & fixes
 * Fixed logging issue (#184)
 * Support for Morris global sensitivity analysis (#179)
+* Testing of sensitivity analysis (#185)
 
 Your pymetadata team

src/sbmlsim/sensitivity/__init__.py

@@ -21,6 +21,7 @@
     AnalysisGroup,
 )
 from .parameters import (
+    ParameterType,
     SensitivityParameter,
 )
 from .sensitivity_fast import FASTSensitivityAnalysis
@@ -30,6 +31,7 @@
 from .sensitivity_morris import MorrisSensitivityAnalysis
 
 __all__ = [
+    "ParameterType",
     "SensitivityParameter",
     "SensitivityAnalysis",
     "SensitivitySimulation",

src/sbmlsim/sensitivity/parameters.py

@@ -1,4 +1,5 @@
 """Tools and helpers to handle parameters for sensitivity analysis."""
+
 from __future__ import annotations
 
 from enum import Enum
@@ -16,6 +17,7 @@
 
 class ParameterType(str, Enum):
     """Types of model parameters."""
+
     DATA = "data"
     SCALING = "scaling"
     NA = "na"
@@ -24,6 +26,7 @@ class ParameterType(str, Enum):
 
 class SensitivityParameter(BaseModel):
     """Parameter for SensitivityAnalysis."""
+
     model_config = ConfigDict(use_enum_values=True)
 
     uid: str
@@ -39,13 +42,14 @@ def __hash__(self):
         return hash(self.uid)
 
     @staticmethod
-    def parameters_set_bounds(parameters: Iterable[SensitivityParameter],
-                              bounds: Iterable[tuple]) -> None:
+    def parameters_set_bounds(
+        parameters: Iterable[SensitivityParameter], bounds: Iterable[tuple]
+    ) -> None:
         """Set bounds for sensitivity analysis."""
 
         parameters_d = {p.uid: p for p in parameters}
 
-        for (key, lb, ub, ptype) in bounds:
+        for key, lb, ub, ptype in bounds:
             if key not in parameters_d:
                 console.print(f"unused bounds definition: {key} = [{lb}, {ub}]")
             else:
@@ -55,20 +59,22 @@ def parameters_set_bounds(parameters: Iterable[SensitivityParameter],
                 p.type = ptype
 
     @staticmethod
-    def parameters_to_df(parameters: Iterable[SensitivityParameter],
-                         sort: bool = True) -> pd.DataFrame:
+    def parameters_to_df(
+        parameters: Iterable[SensitivityParameter], sort: bool = True
+    ) -> pd.DataFrame:
         """Create parameter table from parameters."""
         items = []
         for item in parameters:
             d_item = item.model_dump()
             # better printing of type
-            d_item["type"] = d_item["type"].value
+            # d_item["type"] = d_item["type"].value
             items.append(d_item)
 
         df = pd.DataFrame(items)
         if sort:
-            df.sort_values(by=["type", "uid"], ascending=True, inplace=True,
-                           ignore_index=True)
+            df.sort_values(
+                by=["type", "uid"], ascending=True, inplace=True, ignore_index=True
+            )
         return df
 
     @classmethod
@@ -79,12 +85,10 @@ def parameter_to_latex(
     ) -> None:
         """Latex parameter table."""
         df = cls.parameters_to_df(parameters)
-        tex_str = df.to_latex(
-            None, index=False, float_format="{:.3g}".format
-        )
+        tex_str = df.to_latex(None, index=False, float_format="{:.3g}".format)
         tex_str = tex_str.replace("_", r"\_")
 
-        with open(tex_path, 'w') as f:
+        with open(tex_path, "w") as f:
             f.write(tex_str)
 
     @staticmethod
@@ -122,7 +126,8 @@ def parameter_from_sbase(sbase: libsbml.SBase) -> SensitivityParameter:
             # handle the species concentration
             ruid = uid
             if (sbase.getTypeCode() == libsbml.SpeciesType) and (
-                sbase.getHasOnlySubstanceUnits()):
+                sbase.getHasOnlySubstanceUnits()
+            ):
                 ruid = f"[{uid}]"
 
             value = r.getValue(ruid)
@@ -171,13 +176,15 @@ def parameter_from_sbase(sbase: libsbml.SBase) -> SensitivityParameter:
                 elif s.isSetInitialAmount() and np.isnan(s.getInitialAmount()):
                     exclude_ids.add(sid)
                 elif s.isSetInitialConcentration() and np.isnan(
-                    s.getInitialConcentration()):
+                    s.getInitialConcentration()
+                ):
                     exclude_ids.add(sid)
             if exclude_zero:
                 if s.isSetInitialAmount() and np.isclose(s.getInitialAmount(), 0.0):
                     exclude_ids.add(sid)
                 elif s.isSetInitialConcentration() and np.isclose(
-                    s.getInitialConcentration(), 0.0):
+                    s.getInitialConcentration(), 0.0
+                ):
                     exclude_ids.add(sid)
 
             if s.getConstant() is True or s.getBoundaryCondition() is True:

tests/sensitivity/test_analysis.py

@@ -0,0 +1,127 @@
+from dataclasses import asdict
+
+from sbmlsim.sensitivity import SensitivityOutput, AnalysisGroup
+
+
+# -----------------------------------------------------------------------------
+# SensitivityOutput
+# -----------------------------------------------------------------------------
+
+
+def test_sensitivity_output_creation() -> None:
+    out = SensitivityOutput(
+        uid="auc_plasma",
+        name="AUC plasma",
+        unit="mg*h/L",
+    )
+
+    assert out.uid == "auc_plasma"
+    assert out.name == "AUC plasma"
+    assert out.unit == "mg*h/L"
+
+
+def test_sensitivity_output_unit_optional() -> None:
+    out = SensitivityOutput(
+        uid="cmax",
+        name="Cmax",
+        unit=None,
+    )
+
+    assert out.unit is None
+
+
+def test_sensitivity_output_equality() -> None:
+    o1 = SensitivityOutput("auc", "AUC", "mg*h/L")
+    o2 = SensitivityOutput("auc", "AUC", "mg*h/L")
+
+    assert o1 == o2
+
+
+def test_sensitivity_output_asdict() -> None:
+    out = SensitivityOutput("auc", "AUC", "mg*h/L")
+
+    d = asdict(out)
+
+    assert d == {
+        "uid": "auc",
+        "name": "AUC",
+        "unit": "mg*h/L",
+    }
+
+
+# -----------------------------------------------------------------------------
+# AnalysisGroup
+# -----------------------------------------------------------------------------
+
+
+def test_analysis_group_creation() -> None:
+    group = AnalysisGroup(
+        uid="renal_impairment",
+        name="Renal impairment",
+        changes={"GFR": 0.5, "CLr": 0.6},
+        color="blue",
+    )
+
+    assert group.uid == "renal_impairment"
+    assert group.name == "Renal impairment"
+    assert group.changes == {"GFR": 0.5, "CLr": 0.6}
+    assert group.color == "blue"
+
+
+def test_analysis_group_color_optional() -> None:
+    group = AnalysisGroup(
+        uid="baseline",
+        name="Baseline",
+        changes={},
+        color=None,
+    )
+
+    assert group.color is None
+
+
+def test_analysis_group_changes_mutable() -> None:
+    group = AnalysisGroup(
+        uid="test",
+        name="Test",
+        changes={"k1": 1.0},
+        color=None,
+    )
+
+    group.changes["k2"] = 2.0
+
+    assert group.changes == {"k1": 1.0, "k2": 2.0}
+
+
+def test_analysis_group_equality() -> None:
+    g1 = AnalysisGroup(
+        uid="hepatic",
+        name="Hepatic impairment",
+        changes={"CL": 0.7},
+        color="red",
+    )
+    g2 = AnalysisGroup(
+        uid="hepatic",
+        name="Hepatic impairment",
+        changes={"CL": 0.7},
+        color="red",
+    )
+
+    assert g1 == g2
+
+
+def test_analysis_group_asdict() -> None:
+    group = AnalysisGroup(
+        uid="dose_up",
+        name="Dose increase",
+        changes={"Dose": 2.0},
+        color="green",
+    )
+
+    d = asdict(group)
+
+    assert d == {
+        "uid": "dose_up",
+        "name": "Dose increase",
+        "changes": {"Dose": 2.0},
+        "color": "green",
+    }

tests/sensitivity/test_parameters.py

@@ -0,0 +1,122 @@
+import math
+
+import pandas as pd
+import pytest
+
+from sbmlsim.sensitivity import ParameterType, SensitivityParameter
+
+
+# -----------------------------------------------------------------------------
+# Fixtures
+# -----------------------------------------------------------------------------
+
+
+@pytest.fixture
+def simple_parameters():
+    return [
+        SensitivityParameter(
+            uid="k1",
+            name="rate constant 1",
+            value=1.0,
+            type=ParameterType.NA,
+        ),
+        SensitivityParameter(
+            uid="k2",
+            name="rate constant 2",
+            value=2.0,
+            type=ParameterType.NA,
+        ),
+    ]
+
+
+# -----------------------------------------------------------------------------
+# Basic model behavior
+# -----------------------------------------------------------------------------
+
+
+def test_parameter_type_enum_values():
+    assert ParameterType.DATA.value == "data"
+    assert ParameterType.SCALING.value == "scaling"
+    assert ParameterType.NA.value == "na"
+    assert ParameterType.FIT.value == "fitted"
+
+
+def test_sensitivity_parameter_defaults():
+    p = SensitivityParameter(uid="p1", name="param")
+
+    assert p.uid == "p1"
+    assert p.name == "param"
+    assert math.isnan(p.value)
+    assert math.isnan(p.lower_bound)
+    assert math.isnan(p.upper_bound)
+    assert p.unit is None
+    assert p.type == ParameterType.NA
+    assert p.reference == ""
+
+
+def test_hash_is_based_on_uid():
+    p1 = SensitivityParameter(uid="x", name="a")
+    p2 = SensitivityParameter(uid="x", name="b")
+    p3 = SensitivityParameter(uid="y", name="a")
+
+    assert hash(p1) == hash(p2)
+    assert hash(p1) != hash(p3)
+
+
+# -----------------------------------------------------------------------------
+# Bounds handling
+# -----------------------------------------------------------------------------
+
+
+def test_parameters_set_bounds(simple_parameters):
+    bounds = [
+        ("k1", 0.1, 10.0, ParameterType.FIT),
+        ("k2", 1.0, 5.0, ParameterType.SCALING),
+    ]
+
+    SensitivityParameter.parameters_set_bounds(simple_parameters, bounds)
+
+    p1, p2 = simple_parameters
+
+    assert p1.lower_bound == 0.1
+    assert p1.upper_bound == 10.0
+    assert p1.type == ParameterType.FIT
+
+    assert p2.lower_bound == 1.0
+    assert p2.upper_bound == 5.0
+    assert p2.type == ParameterType.SCALING
+
+
+def test_parameters_to_df(simple_parameters):
+    df = SensitivityParameter.parameters_to_df(simple_parameters, sort=False)
+
+    assert isinstance(df, pd.DataFrame)
+    assert set(df.columns) == {
+        "uid",
+        "name",
+        "value",
+        "lower_bound",
+        "upper_bound",
+        "unit",
+        "type",
+        "reference",
+    }
+
+    assert len(df) == 2
+    assert df.loc[0, "type"] == "na"
+
+
+def test_parameter_to_latex_creates_file(tmp_path):
+    params = [
+        SensitivityParameter(uid="k_cat", name="k_cat", value=1.23456),
+    ]
+
+    tex_path = tmp_path / "params.tex"
+    SensitivityParameter.parameter_to_latex(tex_path, params)
+
+    assert tex_path.exists()
+
+    content = tex_path.read_text()
+    assert "\\begin{tabular}" in content
+    assert "k\\_cat" in content  # underscore escaped
+    assert "1.23" in content  # formatted float