mxlpy 0.21.0__py3-none-any.whl → 0.23.0__py3-none-any.whl

mxlpy/model.py

@@ -10,31 +10,159 @@ from __future__ import annotations
 import copy
 import inspect
 import itertools as it
+import logging
 from dataclasses import dataclass, field
+from queue import Empty, SimpleQueue
 from typing import TYPE_CHECKING, Self, cast
 
 import numpy as np
 import pandas as pd
+import sympy
 
 from mxlpy import fns
-from mxlpy.types import AbstractSurrogate, Array, Derived, Reaction, Readout
+from mxlpy.meta.source_tools import fn_to_sympy
+from mxlpy.meta.sympy_tools import (
+    list_of_symbols,
+    stoichiometries_to_sympy,
+)
+from mxlpy.types import (
+    AbstractSurrogate,
+    Derived,
+    InitialAssignment,
+    Parameter,
+    Reaction,
+    Readout,
+    Variable,
+)
 
 if TYPE_CHECKING:
     from collections.abc import Iterable, Mapping
     from inspect import FullArgSpec
 
+    from sympy.physics.units.quantities import Quantity
+
     from mxlpy.types import Callable, Param, RateFn, RetType
 
+LOGGER = logging.getLogger(__name__)
+
 __all__ = [
     "ArityMismatchError",
     "CircularDependencyError",
     "Dependency",
+    "Failure",
+    "LOGGER",
+    "MdText",
     "MissingDependenciesError",
     "Model",
     "ModelCache",
+    "TableView",
+    "UnitCheck",
+    "unit_of",
 ]
 
 
+def _latex_view(expr: sympy.Expr | None) -> str:
+    if expr is None:
+        return "PARSE-ERROR"
+    return f"${sympy.latex(expr)}$"
+
+
+def unit_of(expr: sympy.Expr) -> sympy.Expr:
+    """Get unit of sympy expr."""
+    return expr.as_coeff_Mul()[1]
+
+
+@dataclass
+class Failure:
+    """Unit test failure."""
+
+    expected: sympy.Expr
+    obtained: sympy.Expr
+
+    @property
+    def difference(self) -> sympy.Expr:
+        """Difference between expected and obtained unit."""
+        return self.expected / self.obtained  # type: ignore
+
+
+@dataclass
+class MdText:
+    """Generic markdown text."""
+
+    content: list[str]
+
+    def _repr_markdown_(self) -> str:
+        return "\n".join(self.content)
+
+
+@dataclass
+class UnitCheck:
+    """Container for unit check."""
+
+    per_variable: dict[str, dict[str, bool | Failure | None]]
+
+    @staticmethod
+    def _fmt_success(s: str) -> str:
+        return f"<span style='color: green'>{s}</span>"
+
+    @staticmethod
+    def _fmt_failed(s: str) -> str:
+        return f"<span style='color: red'>{s}</span>"
+
+    def correct_diff_eqs(self) -> dict[str, bool]:
+        """Get all correctly annotated reactions by variable."""
+        return {
+            var: all(isinstance(i, bool) for i in checks.values())
+            for var, checks in self.per_variable.items()
+        }
+
+    def report(self) -> MdText:
+        """Export check as markdown report."""
+        report = ["## Type check"]
+        for diff_eq, res in self.correct_diff_eqs().items():
+            txt = self._fmt_success("Correct") if res else self._fmt_failed("Failed")
+            report.append(f"\n### d{diff_eq}dt: {txt}")
+
+            if res:
+                continue
+            for k, v in self.per_variable[diff_eq].items():
+                match v:
+                    case bool():
+                        continue
+                    case None:
+                        report.append(f"\n- {k}")
+                        report.append("  - Failed to parse")
+                    case Failure(expected, obtained):
+                        report.append(f"\n- {k}")
+                        report.append(f"  - expected: {_latex_view(expected)}")
+                        report.append(f"  - obtained: {_latex_view(obtained)}")
+                        report.append(f"  - difference: {_latex_view(v.difference)}")
+
+        return MdText(report)
+
+
+@dataclass(kw_only=True, slots=True)
+class TableView:
+    """Markdown view of pandas Dataframe.
+
+    Mostly used to get nice LaTeX rendering of sympy expressions.
+    """
+
+    data: pd.DataFrame
+
+    def __repr__(self) -> str:
+        """Normal Python shell output."""
+        return self.data.to_markdown()
+
+    def _repr_markdown_(self) -> str:
+        """Fancy IPython shell output.
+
+        Looks the same as __repr__, but is handled by IPython to output
+        `IPython.display.Markdown`, so looks nice
+        """
+        return self.data.to_markdown()
+
+
 @dataclass
 class Dependency:
     """Container class for building dependency tree."""
@@ -185,8 +313,6 @@ def _sort_dependencies(
         SortError: If circular dependencies are detected
 
     """
-    from queue import Empty, SimpleQueue
-
     _check_if_is_sortable(available, elements)
 
     order = []
@@ -248,12 +374,13 @@ class ModelCache:
 
     """
 
+    order: list[str]  # mostly for debug purposes
     var_names: list[str]
     dyn_order: list[str]
+    base_parameter_values: dict[str, float]
     all_parameter_values: dict[str, float]
     stoich_by_cpds: dict[str, dict[str, float]]
     dyn_stoich_by_cpds: dict[str, dict[str, Derived]]
-    dxdt: pd.Series
     initial_conditions: dict[str, float]
 
 
@@ -274,9 +401,9 @@ class Model:
 
     """
 
-    _ids: dict[str, str] = field(default_factory=dict)
-    _variables: dict[str, float | Derived] = field(default_factory=dict)
-    _parameters: dict[str, float] = field(default_factory=dict)
+    _ids: dict[str, str] = field(default_factory=dict, repr=False)
+    _variables: dict[str, Variable] = field(default_factory=dict)
+    _parameters: dict[str, Parameter] = field(default_factory=dict)
     _derived: dict[str, Derived] = field(default_factory=dict)
     _readouts: dict[str, Readout] = field(default_factory=dict)
     _reactions: dict[str, Reaction] = field(default_factory=dict)
@@ -300,11 +427,32 @@ class Model:
             ModelCache: An instance of ModelCache containing the initialized cache data.
 
         """
-        all_parameter_values: dict[str, float] = self._parameters.copy()
-        all_parameter_names: set[str] = set(all_parameter_values)
+        parameter_names = set(self._parameters)
+        all_parameter_names = set(parameter_names)  # later include static derived
+
+        base_parameter_values: dict[str, float] = {
+            k: val
+            for k, v in self._parameters.items()
+            if not isinstance(val := v.value, InitialAssignment)
+        }
+        base_variable_values: dict[str, float] = {
+            k: init
+            for k, v in self._variables.items()
+            if not isinstance(init := v.initial_value, InitialAssignment)
+        }
+        initial_assignments: dict[str, InitialAssignment] = {
+            k: init
+            for k, v in self._variables.items()
+            if isinstance(init := v.initial_value, InitialAssignment)
+        } | {
+            k: init
+            for k, v in self._parameters.items()
+            if isinstance(init := v.value, InitialAssignment)
+        }
 
         # Sanity checks
         for name, el in it.chain(
+            initial_assignments.items(),
             self._derived.items(),
             self._reactions.items(),
             self._readouts.items(),
@@ -313,17 +461,17 @@ class Model:
                 raise ArityMismatchError(name, el.fn, el.args)
 
         # Sort derived & reactions
+        available = (
+            set(base_parameter_values)
+            | set(base_variable_values)
+            | set(self._data)
+            | {"time"}
+        )
         to_sort = (
-            self._derived
-            | self._reactions
-            | self._surrogates
-            | {k: v for k, v in self._variables.items() if isinstance(v, Derived)}
+            initial_assignments | self._derived | self._reactions | self._surrogates
         )
         order = _sort_dependencies(
-            available=all_parameter_names
-            | {k for k, v in self._variables.items() if not isinstance(v, Derived)}
-            | set(self._data)
-            | {"time"},
+            available=available,
             elements=[
                 Dependency(name=k, required=set(v.args), provided={k})
                 if not isinstance(v, AbstractSurrogate)
@@ -335,10 +483,7 @@ class Model:
         # Calculate all values once, including dynamic ones
         # That way, we can make initial conditions dependent on e.g. rates
         dependent = (
-            all_parameter_values
-            | self._data
-            | {k: v for k, v in self._variables.items() if not isinstance(v, Derived)}
-            | {"time": 0.0}
+            base_parameter_values | base_variable_values | self._data | {"time": 0.0}
         )
         for name in order:
             to_sort[name].calculate_inpl(name, dependent)
@@ -349,7 +494,7 @@ class Model:
         for name in order:
             if name in self._reactions or name in self._surrogates:
                 dyn_order.append(name)
-            elif name in self._variables:
+            elif name in self._variables or name in self._parameters:
                 static_order.append(name)
             else:
                 derived = self._derived[name]
@@ -390,27 +535,27 @@ class Model:
                         d_static[rxn_name] = factor
 
         var_names = self.get_variable_names()
-        dxdt = pd.Series(np.zeros(len(var_names), dtype=float), index=var_names)
-
         initial_conditions: dict[str, float] = {
-            k: v for k, v in self._variables.items() if not isinstance(v, Derived)
+            k: cast(float, dependent[k]) for k in self._variables
         }
+        all_parameter_values = dict(base_parameter_values)
         for name in static_order:
             if name in self._variables:
-                initial_conditions[name] = cast(float, dependent[name])
-            elif name in self._derived:
+                continue  # handled in initial_conditions above
+            if name in self._parameters or name in self._derived:
                 all_parameter_values[name] = cast(float, dependent[name])
             else:
                 msg = "Unknown target for static derived variable."
                 raise KeyError(msg)
 
         self._cache = ModelCache(
+            order=order,
             var_names=var_names,
             dyn_order=dyn_order,
+            base_parameter_values=base_parameter_values,
             all_parameter_values=all_parameter_values,
             stoich_by_cpds=stoich_by_compounds,
             dyn_stoich_by_cpds=dyn_stoich_by_compounds,
-            dxdt=dxdt,
             initial_conditions=initial_conditions,
         )
         return self._cache
@@ -465,29 +610,103 @@ class Model:
         del self._ids[name]
 
     ##########################################################################
-    # Parameters
+    # Parameters - views
     ##########################################################################
 
+    @property
+    def parameters(self) -> TableView:
+        """Return view of parameters."""
+        index = list(self._parameters.keys())
+        data = []
+        for name, el in self._parameters.items():
+            if isinstance(init := el.value, InitialAssignment):
+                value_str = _latex_view(
+                    fn_to_sympy(
+                        init.fn,
+                        origin=name,
+                        model_args=list_of_symbols(init.args),
+                    )
+                )
+            else:
+                value_str = str(init)
+            data.append(
+                {
+                    "value": value_str,
+                    "unit": _latex_view(unit) if (unit := el.unit) is not None else "",
+                    # "source": ...,
+                }
+            )
+        return TableView(data=pd.DataFrame(data, index=index))
+
+    def get_raw_parameters(self, *, as_copy: bool = True) -> dict[str, Parameter]:
+        """Returns the parameters of the model."""
+        if as_copy:
+            return copy.deepcopy(self._parameters)
+        return self._parameters
+
+    def get_parameter_values(self) -> dict[str, float]:
+        """Returns the parameters of the model.
+
+        Examples:
+            >>> model.parameters
+                {"k1": 0.1, "k2": 0.2}
+
+        Returns:
+            parameters: A dictionary where the keys are parameter names (as strings)
+                  and the values are parameter values (as floats).
+
+        """
+        if (cache := self._cache) is None:
+            cache = self._create_cache()
+        return cache.base_parameter_values
+
+    def get_parameter_names(self) -> list[str]:
+        """Retrieve the names of the parameters.
+
+        Examples:
+            >>> model.get_parameter_names()
+                ['k1', 'k2']
+
+        Returns:
+            parametes: A list containing the names of the parameters.
+
+        """
+        return list(self._parameters)
+
+    #####################################
+    # Parameters - create
+    #####################################
+
     @_invalidate_cache
-    def add_parameter(self, name: str, value: float) -> Self:
+    def add_parameter(
+        self,
+        name: str,
+        value: float | InitialAssignment,
+        unit: sympy.Expr | None = None,
+        source: str | None = None,
+    ) -> Self:
         """Adds a parameter to the model.
 
         Examples:
             >>> model.add_parameter("k1", 0.1)
 
         Args:
-            name (str): The name of the parameter.
-            value (float): The value of the parameter.
+            name: The name of the parameter.
+            value: The value of the parameter.
+            unit: unit of the parameter
+            source: source of the information given
 
         Returns:
             Self: The instance of the model with the added parameter.
 
         """
         self._insert_id(name=name, ctx="parameter")
-        self._parameters[name] = value
+        self._parameters[name] = Parameter(value=value, unit=unit, source=source)
         return self
 
-    def add_parameters(self, parameters: dict[str, float]) -> Self:
+    def add_parameters(
+        self, parameters: Mapping[str, float | Parameter | InitialAssignment]
+    ) -> Self:
         """Adds multiple parameters to the model.
 
         Examples:
@@ -502,36 +721,15 @@ class Model:
 
         """
         for k, v in parameters.items():
-            self.add_parameter(k, v)
+            if isinstance(v, Parameter):
+                self.add_parameter(k, v.value, unit=v.unit, source=v.source)
+            else:
+                self.add_parameter(k, v)
         return self
 
-    @property
-    def parameters(self) -> dict[str, float]:
-        """Returns the parameters of the model.
-
-        Examples:
-            >>> model.parameters
-                {"k1": 0.1, "k2": 0.2}
-
-        Returns:
-            parameters: A dictionary where the keys are parameter names (as strings)
-                  and the values are parameter values (as floats).
-
-        """
-        return self._parameters.copy()
-
-    def get_parameter_names(self) -> list[str]:
-        """Retrieve the names of the parameters.
-
-        Examples:
-            >>> model.get_parameter_names()
-                ['k1', 'k2']
-
-        Returns:
-            parametes: A list containing the names of the parameters.
-
-        """
-        return list(self._parameters)
+    #####################################
+    # Parameters - delete
+    #####################################
 
     @_invalidate_cache
     def remove_parameter(self, name: str) -> Self:
@@ -568,8 +766,19 @@ class Model:
             self.remove_parameter(name)
         return self
 
+    #####################################
+    # Parameters - update
+    #####################################
+
     @_invalidate_cache
-    def update_parameter(self, name: str, value: float) -> Self:
+    def update_parameter(
+        self,
+        name: str,
+        value: float | InitialAssignment | None = None,
+        *,
+        unit: sympy.Expr | None = None,
+        source: str | None = None,
+    ) -> Self:
         """Update the value of a parameter.
 
         Examples:
@@ -578,6 +787,8 @@ class Model:
         Args:
             name: The name of the parameter to update.
             value: The new value for the parameter.
+            unit: Unit of the parameter
+            source: Source of the information
 
         Returns:
             Self: The instance of the class with the updated parameter.
@@ -587,12 +798,21 @@ class Model:
 
         """
         if name not in self._parameters:
-            msg = f"'{name}' not found in parameters"
+            msg = f"{name!r} not found in parameters"
             raise KeyError(msg)
-        self._parameters[name] = value
+
+        parameter = self._parameters[name]
+        if value is not None:
+            parameter.value = value
+        if unit is not None:
+            parameter.unit = unit
+        if source is not None:
+            parameter.source = source
         return self
 
-    def update_parameters(self, parameters: dict[str, float]) -> Self:
+    def update_parameters(
+        self, parameters: Mapping[str, float | Parameter | InitialAssignment]
+    ) -> Self:
         """Update multiple parameters of the model.
 
         Examples:
@@ -606,7 +826,10 @@ class Model:
 
         """
         for k, v in parameters.items():
-            self.update_parameter(k, v)
+            if isinstance(v, Parameter):
+                self.update_parameter(k, value=v.value, unit=v.unit, source=v.source)
+            else:
+                self.update_parameter(k, v)
         return self
 
     def scale_parameter(self, name: str, factor: float) -> Self:
@@ -623,7 +846,17 @@ class Model:
             Self: The instance of the class with the updated parameter.
 
         """
-        return self.update_parameter(name, self._parameters[name] * factor)
+        old = self._parameters[name].value
+        if isinstance(old, InitialAssignment):
+            LOGGER.warning("Overwriting initial assignment %s", name)
+            if (cache := self._cache) is None:
+                cache = self._create_cache()
+
+            return self.update_parameter(
+                name, cache.all_parameter_values[name] * factor
+            )
+
+        return self.update_parameter(name, old * factor)
 
     def scale_parameters(self, parameters: dict[str, float]) -> Self:
         """Scales the parameters of the model.
@@ -667,7 +900,7 @@ class Model:
             Self: The instance of the model with the parameter converted to a variable.
 
         """
-        value = self._parameters[name] if initial_value is None else initial_value
+        value = self._parameters[name].value if initial_value is None else initial_value
         self.remove_parameter(name)
         self.add_variable(name, value)
 
@@ -708,7 +941,7 @@ class Model:
     ##########################################################################
 
     @property
-    def variables(self) -> dict[str, float | Derived]:
+    def variables(self) -> TableView:
         """Returns a copy of the variables dictionary.
 
         Examples:
@@ -722,10 +955,79 @@ class Model:
             dict[str, float]: A copy of the variables dictionary.
 
         """
-        return self._variables.copy()
+        index = list(self._variables.keys())
+        data = []
+        for name, el in self._variables.items():
+            if isinstance(init := el.initial_value, InitialAssignment):
+                value_str = _latex_view(
+                    fn_to_sympy(
+                        init.fn,
+                        origin=name,
+                        model_args=list_of_symbols(init.args),
+                    )
+                )
+            else:
+                value_str = str(init)
+            data.append(
+                {
+                    "value": value_str,
+                    "unit": _latex_view(unit) if (unit := el.unit) is not None else "",
+                    # "source"
+                }
+            )
+        return TableView(data=pd.DataFrame(data, index=index))
+
+    def get_raw_variables(self, *, as_copy: bool = True) -> dict[str, Variable]:
+        """Retrieve the initial conditions of the model.
+
+        Examples:
+            >>> model.get_initial_conditions()
+                {"x1": 1.0, "x2": 2.0}
+
+        Returns:
+            initial_conditions: A dictionary where the keys are variable names and the values are their initial conditions.
+
+        """
+        if as_copy:
+            return copy.deepcopy(self._variables)
+        return self._variables
+
+    def get_initial_conditions(self) -> dict[str, float]:
+        """Retrieve the initial conditions of the model.
+
+        Examples:
+            >>> model.get_initial_conditions()
+                {"x1": 1.0, "x2": 2.0}
+
+        Returns:
+            initial_conditions: A dictionary where the keys are variable names and the values are their initial conditions.
+
+        """
+        if (cache := self._cache) is None:
+            cache = self._create_cache()
+        return cache.initial_conditions
+
+    def get_variable_names(self) -> list[str]:
+        """Retrieve the names of all variables.
+
+        Examples:
+            >>> model.get_variable_names()
+                ["x1", "x2"]
+
+        Returns:
+            variable_names: A list containing the names of all variables.
+
+        """
+        return list(self._variables)
 
     @_invalidate_cache
-    def add_variable(self, name: str, initial_condition: float | Derived) -> Self:
+    def add_variable(
+        self,
+        name: str,
+        initial_value: float | InitialAssignment,
+        unit: sympy.Expr | None = None,
+        source: str | None = None,
+    ) -> Self:
         """Adds a variable to the model with the given name and initial condition.
 
         Examples:
@@ -733,17 +1035,23 @@ class Model:
 
         Args:
             name: The name of the variable to add.
-            initial_condition: The initial condition value for the variable.
+            initial_value: The initial condition value for the variable.
+            unit: unit of the variable
+            source: source of the information given
 
         Returns:
             Self: The instance of the model with the added variable.
 
         """
         self._insert_id(name=name, ctx="variable")
-        self._variables[name] = initial_condition
+        self._variables[name] = Variable(
+            initial_value=initial_value, unit=unit, source=source
+        )
         return self
 
-    def add_variables(self, variables: Mapping[str, float | Derived]) -> Self:
+    def add_variables(
+        self, variables: Mapping[str, float | Variable | InitialAssignment]
+    ) -> Self:
         """Adds multiple variables to the model with their initial conditions.
 
         Examples:
@@ -757,8 +1065,16 @@ class Model:
             Self: The instance of the model with the added variables.
 
         """
-        for name, y0 in variables.items():
-            self.add_variable(name=name, initial_condition=y0)
+        for name, v in variables.items():
+            if isinstance(v, Variable):
+                self.add_variable(
+                    name=name,
+                    initial_value=v.initial_value,
+                    unit=v.unit,
+                    source=v.source,
+                )
+            else:
+                self.add_variable(name=name, initial_value=v)
         return self
 
     @_invalidate_cache
@@ -797,7 +1113,13 @@ class Model:
         return self
 
     @_invalidate_cache
-    def update_variable(self, name: str, initial_condition: float | Derived) -> Self:
+    def update_variable(
+        self,
+        name: str,
+        initial_value: float | InitialAssignment,
+        unit: sympy.Expr | None = None,
+        source: str | None = None,
+    ) -> Self:
         """Updates the value of a variable in the model.
 
         Examples:
@@ -805,7 +1127,9 @@ class Model:
 
         Args:
             name: The name of the variable to update.
-            initial_condition: The initial condition or value to set for the variable.
+            initial_value: The initial condition or value to set for the variable.
+            unit: Unit of the variable
+            source: Source of the information
 
         Returns:
             Self: The instance of the model with the updated variable.
@@ -814,10 +1138,20 @@ class Model:
         if name not in self._variables:
             msg = f"'{name}' not found in variables"
             raise KeyError(msg)
-        self._variables[name] = initial_condition
+
+        variable = self._variables[name]
+
+        if initial_value is not None:
+            variable.initial_value = initial_value
+        if unit is not None:
+            variable.unit = unit
+        if source is not None:
+            variable.source = source
         return self
 
-    def update_variables(self, variables: Mapping[str, float | Derived]) -> Self:
+    def update_variables(
+        self, variables: Mapping[str, float | Variable | InitialAssignment]
+    ) -> Self:
         """Updates multiple variables in the model.
 
         Examples:
@@ -831,37 +1165,17 @@ class Model:
 
         """
         for k, v in variables.items():
-            self.update_variable(k, v)
+            if isinstance(v, Variable):
+                self.update_variable(
+                    k,
+                    initial_value=v.initial_value,
+                    unit=v.unit,
+                    source=v.source,
+                )
+            else:
+                self.update_variable(k, v)
         return self
 
-    def get_variable_names(self) -> list[str]:
-        """Retrieve the names of all variables.
-
-        Examples:
-            >>> model.get_variable_names()
-                ["x1", "x2"]
-
-        Returns:
-            variable_names: A list containing the names of all variables.
-
-        """
-        return list(self._variables)
-
-    def get_initial_conditions(self) -> dict[str, float]:
-        """Retrieve the initial conditions of the model.
-
-        Examples:
-            >>> model.get_initial_conditions()
-                {"x1": 1.0, "x2": 2.0}
-
-        Returns:
-            initial_conditions: A dictionary where the keys are variable names and the values are their initial conditions.
-
-        """
-        if (cache := self._cache) is None:
-            cache = self._create_cache()
-        return cache.initial_conditions
-
     def make_variable_static(self, name: str, value: float | None = None) -> Self:
         """Converts a variable to a static parameter.
 
@@ -881,8 +1195,12 @@ class Model:
             Self: The instance of the class for method chaining.
 
         """
-        value_or_derived = self._variables[name] if value is None else value
+        value_or_derived = (
+            self._variables[name].initial_value if value is None else value
+        )
         self.remove_variable(name)
+
+        # FIXME: better handling of unit
         if isinstance(value_or_derived, Derived):
             self.add_derived(name, value_or_derived.fn, args=value_or_derived.args)
         else:
@@ -905,8 +1223,8 @@ class Model:
     ##########################################################################
 
     @property
-    def derived(self) -> dict[str, Derived]:
-        """Returns a copy of the derived quantities.
+    def derived(self) -> TableView:
+        """Returns a view of the derived quantities.
 
         Examples:
             >>> model.derived
@@ -917,10 +1235,30 @@ class Model:
             dict[str, Derived]: A copy of the derived dictionary.
 
         """
-        return self._derived.copy()
+        index = list(self._derived.keys())
+        data = [
+            {
+                "value": _latex_view(
+                    fn_to_sympy(
+                        el.fn,
+                        origin=name,
+                        model_args=list_of_symbols(el.args),
+                    )
+                ),
+                "unit": _latex_view(unit) if (unit := el.unit) is not None else "",
+            }
+            for name, el in self._derived.items()
+        ]
 
-    @property
-    def derived_variables(self) -> dict[str, Derived]:
+        return TableView(data=pd.DataFrame(data, index=index))
+
+    def get_raw_derived(self, *, as_copy: bool = True) -> dict[str, Derived]:
+        """Get copy of derived values."""
+        if as_copy:
+            return copy.deepcopy(self._derived)
+        return self._derived
+
+    def get_derived_variables(self) -> dict[str, Derived]:
         """Returns a dictionary of derived variables.
 
         Examples:
@@ -940,8 +1278,7 @@ class Model:
 
         return {k: v for k, v in derived.items() if k not in cache.all_parameter_values}
 
-    @property
-    def derived_parameters(self) -> dict[str, Derived]:
+    def get_derived_parameters(self) -> dict[str, Derived]:
         """Returns a dictionary of derived parameters.
 
         Examples:
@@ -966,6 +1303,7 @@ class Model:
         fn: RateFn,
         *,
         args: list[str],
+        unit: sympy.Expr | None = None,
     ) -> Self:
         """Adds a derived attribute to the model.
 
@@ -976,13 +1314,14 @@ class Model:
             name: The name of the derived attribute.
             fn: The function used to compute the derived attribute.
             args: The list of arguments to be passed to the function.
+            unit: Unit of the derived value
 
         Returns:
             Self: The instance of the model with the added derived attribute.
 
         """
         self._insert_id(name=name, ctx="derived")
-        self._derived[name] = Derived(fn=fn, args=args)
+        self._derived[name] = Derived(fn=fn, args=args, unit=unit)
         return self
 
     def get_derived_parameter_names(self) -> list[str]:
@@ -996,7 +1335,7 @@ class Model:
             A list of names of the derived parameters.
 
         """
-        return list(self.derived_parameters)
+        return list(self.get_derived_parameters())
 
     def get_derived_variable_names(self) -> list[str]:
         """Retrieve the names of derived variables.
@@ -1009,7 +1348,7 @@ class Model:
             A list of names of derived variables.
 
         """
-        return list(self.derived_variables)
+        return list(self.get_derived_variables())
 
     @_invalidate_cache
     def update_derived(
@@ -1018,6 +1357,7 @@ class Model:
         fn: RateFn | None = None,
         *,
         args: list[str] | None = None,
+        unit: sympy.Expr | None = None,
     ) -> Self:
         """Updates the derived function and its arguments for a given name.
 
@@ -1026,16 +1366,21 @@ class Model:
 
         Args:
             name: The name of the derived function to update.
-            fn: The new derived function. If None, the existing function is retained. Defaults to None.
-            args: The new arguments for the derived function. If None, the existing arguments are retained. Defaults to None.
+            fn: The new derived function. If None, the existing function is retained.
+            args: The new arguments for the derived function. If None, the existing arguments are retained.
+            unit: Unit of the derived value
 
         Returns:
             Self: The instance of the class with the updated derived function and arguments.
 
         """
         der = self._derived[name]
-        der.fn = der.fn if fn is None else fn
-        der.args = der.args if args is None else args
+        if fn is not None:
+            der.fn = fn
+        if args is not None:
+            der.args = args
+        if unit is not None:
+            der.unit = unit
         return self
 
     @_invalidate_cache
@@ -1061,7 +1406,27 @@ class Model:
     ###########################################################################
 
     @property
-    def reactions(self) -> dict[str, Reaction]:
+    def reactions(self) -> TableView:
+        """Get view of reactions."""
+        index = list(self._reactions.keys())
+        data = [
+            {
+                "value": _latex_view(
+                    fn_to_sympy(
+                        rxn.fn,
+                        origin=name,
+                        model_args=list_of_symbols(rxn.args),
+                    )
+                ),
+                "stoichiometry": stoichiometries_to_sympy(name, rxn.stoichiometry),
+                "unit": _latex_view(unit) if (unit := rxn.unit) is not None else "",
+                # "source"
+            }
+            for name, rxn in self._reactions.items()
+        ]
+        return TableView(data=pd.DataFrame(data, index=index))
+
+    def get_raw_reactions(self, *, as_copy: bool = True) -> dict[str, Reaction]:
         """Retrieve the reactions in the model.
 
         Examples:
@@ -1072,7 +1437,9 @@ class Model:
             dict[str, Reaction]: A deep copy of the reactions dictionary.
 
         """
-        return copy.deepcopy(self._reactions)
+        if as_copy:
+            return copy.deepcopy(self._reactions)
+        return self._reactions
 
     def get_stoichiometries(
         self, variables: dict[str, float] | None = None, time: float = 0.0
@@ -1091,7 +1458,7 @@ class Model:
         """
         if (cache := self._cache) is None:
             cache = self._create_cache()
-        args = self.get_dependent(variables=variables, time=time)
+        args = self.get_args(variables=variables, time=time)
 
         stoich_by_cpds = copy.deepcopy(cache.stoich_by_cpds)
         for cpd, stoich in cache.dyn_stoich_by_cpds.items():
@@ -1121,7 +1488,7 @@ class Model:
         """
         if (cache := self._cache) is None:
             cache = self._create_cache()
-        args = self.get_dependent(variables=variables, time=time)
+        args = self.get_args(variables=variables, time=time)
 
         stoich = copy.deepcopy(cache.stoich_by_cpds[variable])
         for rxn, derived in cache.dyn_stoich_by_cpds.get(variable, {}).items():
@@ -1155,6 +1522,8 @@ class Model:
         *,
         args: list[str],
         stoichiometry: Mapping[str, float | str | Derived],
+        unit: sympy.Expr | None = None,
+        # source: str | None = None,
     ) -> Self:
         """Adds a reaction to the model.
 
@@ -1170,6 +1539,7 @@ class Model:
             fn: The function representing the reaction.
             args: A list of arguments for the reaction function.
             stoichiometry: The stoichiometry of the reaction, mapping species to their coefficients.
+            unit: Unit of the rate
 
         Returns:
             Self: The instance of the model with the added reaction.
@@ -1181,7 +1551,12 @@ class Model:
             k: Derived(fn=fns.constant, args=[v]) if isinstance(v, str) else v
             for k, v in stoichiometry.items()
         }
-        self._reactions[name] = Reaction(fn=fn, stoichiometry=stoich, args=args)
+        self._reactions[name] = Reaction(
+            fn=fn,
+            stoichiometry=stoich,
+            args=args,
+            unit=unit,
+        )
         return self
 
     def get_reaction_names(self) -> list[str]:
@@ -1205,6 +1580,7 @@ class Model:
         *,
         args: list[str] | None = None,
         stoichiometry: Mapping[str, float | Derived | str] | None = None,
+        unit: sympy.Expr | None = None,
     ) -> Self:
         """Updates the properties of an existing reaction in the model.
 
@@ -1220,6 +1596,7 @@ class Model:
             fn: The new function for the reaction. If None, the existing function is retained.
             args: The new arguments for the reaction. If None, the existing arguments are retained.
             stoichiometry: The new stoichiometry for the reaction. If None, the existing stoichiometry is retained.
+            unit: Unit of the reaction
 
         Returns:
             Self: The instance of the model with the updated reaction.
@@ -1235,6 +1612,7 @@ class Model:
             }
             rxn.stoichiometry = stoich
         rxn.args = rxn.args if args is None else args
+        rxn.unit = rxn.unit if unit is None else unit
         return self
 
     @_invalidate_cache
@@ -1285,7 +1663,14 @@ class Model:
     # Think of something like NADPH / (NADP + NADPH) as a proxy for energy state
     ##########################################################################
 
-    def add_readout(self, name: str, fn: RateFn, *, args: list[str]) -> Self:
+    def add_readout(
+        self,
+        name: str,
+        fn: RateFn,
+        *,
+        args: list[str],
+        unit: sympy.Expr | None = None,
+    ) -> Self:
         """Adds a readout to the model.
 
         Examples:
@@ -1298,13 +1683,14 @@ class Model:
             name: The name of the readout.
             fn: The function to be used for the readout.
             args: The list of arguments for the function.
+            unit: Unit of the readout
 
         Returns:
             Self: The instance of the model with the added readout.
 
         """
         self._insert_id(name=name, ctx="readout")
-        self._readouts[name] = Readout(fn=fn, args=args)
+        self._readouts[name] = Readout(fn=fn, args=args, unit=unit)
         return self
 
     def get_readout_names(self) -> list[str]:
@@ -1320,6 +1706,12 @@ class Model:
         """
         return list(self._readouts)
 
+    def get_raw_readouts(self, *, as_copy: bool = True) -> dict[str, Readout]:
+        """Get copy of readouts in the model."""
+        if as_copy:
+            return copy.deepcopy(self._readouts)
+        return self._readouts
+
     def remove_readout(self, name: str) -> Self:
         """Remove a readout by its name.
 
@@ -1428,6 +1820,38 @@ class Model:
         self._surrogates.pop(name)
         return self
 
+    def get_raw_surrogates(
+        self, *, as_copy: bool = True
+    ) -> dict[str, AbstractSurrogate]:
+        """Get direct copies of model surrogates."""
+        if as_copy:
+            return copy.deepcopy(self._surrogates)
+        return self._surrogates
+
+    def get_surrogate_output_names(
+        self,
+        *,
+        include_fluxes: bool = True,
+    ) -> list[str]:
+        """Return output names by surrogates.
+
+        Optionally filter out the names of which surrogate outfluxes are actually
+        fluxes / reactions rather than variables.
+
+        Args:
+            include_fluxes: whether to also include outputs which are reaction
+                            names
+
+        """
+        names = []
+        if include_fluxes:
+            for i in self._surrogates.values():
+                names.extend(i.outputs)
+        else:
+            for i in self._surrogates.values():
+                names.extend(x for x in i.outputs if x not in i.stoichiometries)
+        return names
+
     def get_surrogate_reaction_names(self) -> list[str]:
         """Return reaction names by surrogates."""
         names = []
@@ -1464,7 +1888,42 @@ class Model:
     # - readouts
     ##########################################################################
 
-    def _get_dependent(
+    def get_arg_names(
+        self,
+        *,
+        include_time: bool,
+        include_variables: bool,
+        include_parameters: bool,
+        include_derived_parameters: bool,
+        include_derived_variables: bool,
+        include_reactions: bool,
+        include_surrogate_variables: bool,
+        include_surrogate_fluxes: bool,
+        include_readouts: bool,
+    ) -> list[str]:
+        """Get names of all kinds of model components."""
+        names = []
+        if include_time:
+            names.append("time")
+        if include_variables:
+            names.extend(self.get_variable_names())
+        if include_parameters:
+            names.extend(self.get_parameter_names())
+        if include_derived_variables:
+            names.extend(self.get_derived_variable_names())
+        if include_derived_parameters:
+            names.extend(self.get_derived_parameter_names())
+        if include_reactions:
+            names.extend(self.get_reaction_names())
+        if include_surrogate_variables:
+            names.extend(self.get_surrogate_output_names(include_fluxes=False))
+        if include_surrogate_fluxes:
+            names.extend(self.get_surrogate_reaction_names())
+        if include_readouts:
+            names.extend(self.get_readout_names())
+        return names
+
+    def _get_args(
         self,
         variables: dict[str, float],
         time: float = 0.0,
@@ -1474,7 +1933,7 @@ class Model:
         """Generate a dictionary of model components dependent on other components.
 
         Examples:
-            >>> model._get_dependent({"x1": 1.0, "x2": 2.0}, time=0.0)
+            >>> model._get_args({"x1": 1.0, "x2": 2.0}, time=0.0)
                 {"x1": 1.0, "x2": 2.0, "k1": 0.1, "time": 0.0}
 
         Args:
@@ -1502,11 +1961,19 @@ class Model:
 
         return cast(dict[str, float], args)
 
-    def get_dependent(
+    def get_args(
         self,
         variables: dict[str, float] | None = None,
         time: float = 0.0,
         *,
+        include_time: bool = True,
+        include_variables: bool = True,
+        include_parameters: bool = True,
+        include_derived_parameters: bool = True,
+        include_derived_variables: bool = True,
+        include_reactions: bool = True,
+        include_surrogate_variables: bool = True,
+        include_surrogate_fluxes: bool = True,
         include_readouts: bool = False,
     ) -> pd.Series:
         """Generate a pandas Series of arguments for the model.
@@ -1514,20 +1981,28 @@ class Model:
         Examples:
             # Using initial conditions
             >>> model.get_args()
-                {"x1": 1.get_dependent, "x2": 2.0, "k1": 0.1, "time": 0.0}
+                {"x1": 1.get_args, "x2": 2.0, "k1": 0.1, "time": 0.0}
 
             # With custom concentrations
-            >>> model.get_dependent({"x1": 1.0, "x2": 2.0})
+            >>> model.get_args({"x1": 1.0, "x2": 2.0})
                 {"x1": 1.0, "x2": 2.0, "k1": 0.1, "time": 0.0}
 
             # With custom concentrations and time
-            >>> model.get_dependent({"x1": 1.0, "x2": 2.0}, time=1.0)
+            >>> model.get_args({"x1": 1.0, "x2": 2.0}, time=1.0)
                 {"x1": 1.0, "x2": 2.0, "k1": 0.1, "time": 1.0}
 
         Args:
             variables: A dictionary where keys are the names of the concentrations and values are their respective float values.
-            time: The time point at which the arguments are generated (default is 0.0).
-            include_readouts: Whether to include readouts in the arguments (default is False).
+            time: The time point at which the arguments are generated.
+            include_time: Whether to include the time as an argument
+            include_variables: Whether to include variables
+            include_parameters: Whether to include parameters
+            include_derived_parameters: Whether to include derived parameters
+            include_derived_variables: Whether to include derived variables
+            include_reactions: Whether to include reactions
+            include_surrogate_variables: Whether to include derive variables obtained from surrogate
+            include_surrogate_fluxes: Whether to include surrogate fluxes
+            include_readouts: Whether to include readouts
 
         Returns:
             A pandas Series containing the generated arguments with float dtype.
@@ -1535,111 +2010,62 @@ class Model:
         """
         if (cache := self._cache) is None:
             cache = self._create_cache()
-
-        args = self._get_dependent(
+        raw = self._get_args(
             variables=self.get_initial_conditions() if variables is None else variables,
             time=time,
             cache=cache,
         )
-
         if include_readouts:
             for name, ro in self._readouts.items():  # FIXME: order?
-                ro.calculate_inpl(name, args)
-
-        return pd.Series(args, dtype=float)
+                ro.calculate_inpl(name, raw)
+        args = pd.Series(raw, dtype=float)
+        return args.loc[
+            self.get_arg_names(
+                include_time=include_time,
+                include_variables=include_variables,
+                include_parameters=include_parameters,
+                include_derived_parameters=include_derived_parameters,
+                include_derived_variables=include_derived_variables,
+                include_reactions=include_reactions,
+                include_surrogate_variables=include_surrogate_variables,
+                include_surrogate_fluxes=include_surrogate_fluxes,
+                include_readouts=include_readouts,
+            )
+        ]
 
-    def get_dependent_time_course(
+    def _get_args_time_course(
         self,
-        variables: pd.DataFrame,
         *,
-        include_readouts: bool = False,
-    ) -> pd.DataFrame:
-        """Generate a DataFrame containing time course arguments for model evaluation.
-
-        Examples:
-            >>> model.get_dependent_time_course(
-            ...     pd.DataFrame({"x1": [1.0, 2.0], "x2": [2.0, 3.0]}
-            ... )
-                pd.DataFrame({
-                    "x1": [1.0, 2.0],
-                    "x2": [2.0, 3.0],
-                    "k1": [0.1, 0.1],
-                    "time": [0.0, 1.0]},
-                )
-
-        Args:
-            variables: A DataFrame containing concentration data with time as the index.
-            include_readouts: If True, include readout variables in the resulting DataFrame.
-
-        Returns:
-            A DataFrame containing the combined concentration data, parameter values,
-            derived variables, and optionally readout variables, with time as an additional column.
+        variables: pd.DataFrame,
+        include_readouts: bool,
+    ) -> dict[float, dict[str, float]]:
+        if (cache := self._cache) is None:
+            cache = self._create_cache()
 
-        """
-        args = {
-            time: self.get_dependent(
+        args_by_time = {}
+        for time, values in variables.iterrows():
+            args = self._get_args(
                 variables=values.to_dict(),
                 time=cast(float, time),
-                include_readouts=include_readouts,
+                cache=cache,
             )
-            for time, values in variables.iterrows()
-        }
-
-        return pd.DataFrame(args, dtype=float).T
-
-    ##########################################################################
-    # Get args
-    ##########################################################################
-
-    def get_args(
-        self,
-        variables: dict[str, float] | None = None,
-        time: float = 0.0,
-        *,
-        include_derived: bool = True,
-        include_readouts: bool = False,
-    ) -> pd.Series:
-        """Generate a pandas Series of arguments for the model.
-
-        Examples:
-            # Using initial conditions
-            >>> model.get_args()
-                {"x1": 1.0, "x2": 2.0, "k1": 0.1, "time": 0.0}
-
-            # With custom concentrations
-            >>> model.get_args({"x1": 1.0, "x2": 2.0})
-                {"x1": 1.0, "x2": 2.0, "k1": 0.1, "time": 0.0}
-
-            # With custom concentrations and time
-            >>> model.get_args({"x1": 1.0, "x2": 2.0}, time=1.0)
-                {"x1": 1.0, "x2": 2.0, "k1": 0.1, "time": 1.0}
-
-        Args:
-            variables: A dictionary where keys are the names of the concentrations and values are their respective float values.
-            time: The time point at which the arguments are generated.
-            include_derived: Whether to include derived variables in the arguments.
-            include_readouts: Whether to include readouts in the arguments.
-
-        Returns:
-            A pandas Series containing the generated arguments with float dtype.
-
-        """
-        names = self.get_variable_names()
-        if include_derived:
-            names.extend(self.get_derived_variable_names())
-        if include_readouts:
-            names.extend(self._readouts)
-
-        args = self.get_dependent(
-            variables=variables, time=time, include_readouts=include_readouts
-        )
-        return args.loc[names]
+            if include_readouts:
+                for name, ro in self._readouts.items():  # FIXME: order?
+                    ro.calculate_inpl(name, args)
+            args_by_time[time] = args
+        return args_by_time
 
     def get_args_time_course(
         self,
         variables: pd.DataFrame,
         *,
-        include_derived: bool = True,
+        include_variables: bool = True,
+        include_parameters: bool = True,
+        include_derived_parameters: bool = True,
+        include_derived_variables: bool = True,
+        include_reactions: bool = True,
+        include_surrogate_variables: bool = True,
+        include_surrogate_fluxes: bool = True,
         include_readouts: bool = False,
     ) -> pd.DataFrame:
         """Generate a DataFrame containing time course arguments for model evaluation.
@@ -1657,22 +2083,42 @@ class Model:
 
         Args:
             variables: A DataFrame containing concentration data with time as the index.
-            include_derived: Whether to include derived variables in the arguments.
-            include_readouts: If True, include readout variables in the resulting DataFrame.
+            include_variables: Whether to include variables
+            include_parameters: Whether to include parameters
+            include_derived_parameters: Whether to include derived parameters
+            include_derived_variables: Whether to include derived variables
+            include_reactions: Whether to include reactions
+            include_surrogate_variables: Whether to include variables derived from surrogates
+            include_surrogate_fluxes: Whether to include surrogate fluxes
+            include_readouts: Whether to include readouts
 
         Returns:
             A DataFrame containing the combined concentration data, parameter values,
             derived variables, and optionally readout variables, with time as an additional column.
 
         """
-        names = self.get_variable_names()
-        if include_derived:
-            names.extend(self.get_derived_variable_names())
-
-        args = self.get_dependent_time_course(
-            variables=variables, include_readouts=include_readouts
-        )
-        return args.loc[:, names]
+        args = pd.DataFrame(
+            self._get_args_time_course(
+                variables=variables,
+                include_readouts=include_readouts,
+            ),
+            dtype=float,
+        ).T
+
+        return args.loc[
+            :,
+            self.get_arg_names(
+                include_time=False,
+                include_variables=include_variables,
+                include_parameters=include_parameters,
+                include_derived_parameters=include_derived_parameters,
+                include_derived_variables=include_derived_variables,
+                include_reactions=include_reactions,
+                include_surrogate_variables=include_surrogate_variables,
+                include_surrogate_fluxes=include_surrogate_fluxes,
+                include_readouts=include_readouts,
+            ),
+        ]
 
     ##########################################################################
     # Get fluxes
@@ -1706,16 +2152,19 @@ class Model:
             Fluxes: A pandas Series containing the fluxes for each reaction.
 
         """
-        names = self.get_reaction_names()
-        for surrogate in self._surrogates.values():
-            names.extend(surrogate.stoichiometries)
-
-        args = self.get_dependent(
+        return self.get_args(
             variables=variables,
             time=time,
+            include_time=False,
+            include_variables=False,
+            include_parameters=False,
+            include_derived_parameters=False,
+            include_derived_variables=False,
+            include_reactions=True,
+            include_surrogate_variables=False,
+            include_surrogate_fluxes=True,
             include_readouts=False,
         )
-        return args.loc[names]
 
     def get_fluxes_time_course(self, variables: pd.DataFrame) -> pd.DataFrame:
         """Generate a time course of fluxes for the given reactions and surrogates.
@@ -1725,7 +2174,9 @@ class Model:
                 pd.DataFrame({"v1": [0.1, 0.2], "v2": [0.2, 0.3]})
 
         This method calculates the fluxes for each reaction in the model using the provided
-        arguments and combines them with the outputs from the surrogates to create a complete
+        arguments and combines them wit      names: list[str] = self.get_reaction_names()
+        for surrogate in self._surrogates.values():
+            names.extend(surrogate.stoichiometries)h the outputs from the surrogates to create a complete
         time course of fluxes.
 
         Args:
@@ -1739,21 +2190,23 @@ class Model:
                           the index of the input arguments.
 
         """
-        names = self.get_reaction_names()
-        for surrogate in self._surrogates.values():
-            names.extend(surrogate.stoichiometries)
-
-        variables = self.get_dependent_time_course(
+        return self.get_args_time_course(
             variables=variables,
+            include_variables=False,
+            include_parameters=False,
+            include_derived_parameters=False,
+            include_derived_variables=False,
+            include_reactions=True,
+            include_surrogate_variables=False,
+            include_surrogate_fluxes=True,
             include_readouts=False,
         )
-        return variables.loc[:, names]
 
     ##########################################################################
     # Get rhs
     ##########################################################################
 
-    def __call__(self, /, time: float, variables: Array) -> Array:
+    def __call__(self, /, time: float, variables: Iterable[float]) -> tuple[float, ...]:
         """Simulation version of get_right_hand_side.
 
         Examples:
@@ -1761,7 +2214,7 @@ class Model:
                 np.array([0.1, 0.2])
 
         Warning: Swaps t and y!
-        This can't get kw-only args, as the integrators call it with pos-only
+        This can't get kw args, as the integrators call it with pos-only
 
         Args:
             time: The current time point.
@@ -1781,14 +2234,13 @@ class Model:
                 strict=True,
             )
         )
-        dependent: dict[str, float] = self._get_dependent(
+        dependent: dict[str, float] = self._get_args(
             variables=vars_d,
             time=time,
             cache=cache,
         )
 
-        dxdt = cache.dxdt
-        dxdt[:] = 0
+        dxdt = dict.fromkeys(cache.var_names, 0.0)
         for k, stoc in cache.stoich_by_cpds.items():
             for flux, n in stoc.items():
                 dxdt[k] += n * dependent[flux]
@@ -1796,7 +2248,7 @@ class Model:
             for flux, dv in sd.items():
                 n = dv.calculate(dependent)
                 dxdt[k] += n * dependent[flux]
-        return cast(Array, dxdt.to_numpy())
+        return tuple(dxdt[i] for i in cache.var_names)
 
     def get_right_hand_side(
         self,
@@ -1829,7 +2281,7 @@ class Model:
         if (cache := self._cache) is None:
             cache = self._create_cache()
         var_names = self.get_variable_names()
-        dependent = self._get_dependent(
+        dependent = self._get_args(
             variables=self.get_initial_conditions() if variables is None else variables,
             time=time,
             cache=cache,
@@ -1844,3 +2296,52 @@ class Model:
                 n = dv.fn(*(dependent[i] for i in dv.args))
                 dxdt[k] += n * dependent[flux]
         return dxdt
+
+    ##########################################################################
+    # Check units
+    ##########################################################################
+
+    def check_units(self, time_unit: Quantity) -> UnitCheck:
+        """Check unit consistency per differential equation and reaction."""
+        units_per_fn = {}
+        for name, rxn in self._reactions.items():
+            unit_per_arg = {}
+            for arg in rxn.args:
+                if (par := self._parameters.get(arg)) is not None:
+                    unit_per_arg[sympy.Symbol(arg)] = par.unit
+                elif (var := self._variables.get(arg)) is not None:
+                    unit_per_arg[sympy.Symbol(arg)] = var.unit
+                else:
+                    raise NotImplementedError
+
+            symbolic_fn = fn_to_sympy(
+                rxn.fn,
+                origin="unit-checking",
+                model_args=list_of_symbols(rxn.args),
+            )
+            units_per_fn[name] = None
+            if symbolic_fn is None:
+                continue
+            if any(i is None for i in unit_per_arg.values()):
+                continue
+            units_per_fn[name] = symbolic_fn.subs(unit_per_arg)
+
+        check_per_variable = {}
+        for name, var in self._variables.items():
+            check_per_rxn = {}
+
+            if (var_unit := var.unit) is None:
+                break
+
+            for rxn in self.get_stoichiometries_of_variable(name):
+                if (rxn_unit := units_per_fn.get(rxn)) is None:
+                    check_per_rxn[rxn] = None
+                elif unit_of(rxn_unit) == var_unit / time_unit:  # type: ignore
+                    check_per_rxn[rxn] = True
+                else:
+                    check_per_rxn[rxn] = Failure(
+                        expected=unit_of(rxn_unit),
+                        obtained=var_unit / time_unit,  # type: ignore
+                    )
+            check_per_variable[name] = check_per_rxn
+        return UnitCheck(check_per_variable)