assignments_to_experiments: evaluate a condition change once, at the start of its period

The converter kept a condition change's value as an expression and
substituted it wherever a switch used it, so the value was re-evaluated at
the switch with the values at that time. A condition change is evaluated
once, at the start of its period, and all changes of a period
simultaneously, with the values from before the period. E.g., with `d1 = b1
+ 0.5` at t = 2 and `b1 = 2` at t = 3, a switch to `d1` at t = 5 used 2.5
instead of 1.7; likewise with `b1 = 2` in the same condition as `d1`.

A change's value is now evaluated at the start of its period: symbols set
by an earlier condition take that value, other constant model parameters
their model values, and parameter table symbols stay. A change of a symbol
of the assignment whose value still refers to anything else, e.g. a
species, is rejected, since its value is not known there.

Found by differential testing against simulations of the original and the
converted problem.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: FFroehlich

petab/v2/converters.py

@@ -1004,12 +1004,32 @@ def changes(
         held = None
         for i_period, period in enumerate(periods):
             period_changes = self.problem.get_changes_for_period(period)
-            overrides |= {c.target_id: c.target_value for c in period_changes}
+            # a condition's changes are evaluated once, at the start of their
+            #  period, all with the values from before the period
+            overrides |= {
+                c.target_id: self._at_period_start(c.target_value, overrides)
+                for c in period_changes
+            }
             subs = self.fixed_values | {
                 s: overrides[str(s)]
                 for s in self.expr.free_symbols
                 if str(s) in overrides
             }
+            if unknown := sorted(
+                {
+                    str(x)
+                    for s in self.expr.free_symbols
+                    if str(s) in overrides
+                    for x in overrides[str(s)].free_symbols
+                }
+                - self.parameter_ids
+            ):
+                raise NotImplementedError(
+                    "Only condition changes whose values are known at the "
+                    "start of their period are supported, but in experiment "
+                    f"`{experiment.id}`, the changes of the symbols of the "
+                    f"assignment to `{self.target_id}` refer to {unknown}."
+                )
             times = self._switching_times(subs, experiment.id)
 
             if period.is_preequilibration:
@@ -1075,6 +1095,29 @@ def _model_value(self, symbol: sp.Symbol) -> float:
         """The value of the model parameter ``symbol``."""
         return self.sbml_model.getParameter(str(symbol)).getValue()
 
+    def _at_period_start(self, value: sp.Expr, overrides: dict) -> sp.Expr:
+        """The ``value`` of a change, evaluated at the start of its period.
+
+        Symbols that a condition set before take that value (``overrides``),
+        and the other constant model parameters outside the parameter table
+        their model values. Parameter table symbols stay, since no condition
+        sets them; any other symbol stays as well, since its value is not
+        known here.
+        """
+        if value is None:
+            return value
+        known = {}
+        for s in value.free_symbols:
+            if str(s) in overrides:
+                known[s] = overrides[str(s)]
+            elif (
+                str(s) not in self.parameter_ids
+                and (p := self.sbml_model.getParameter(str(s))) is not None
+                and p.getConstant()
+            ):
+                known[s] = sp.Float(p.getValue())
+        return value.xreplace(known)
+
     def _with_model_values(self, value: sp.Expr) -> sp.Expr:
         """``value`` for a change at the start of an experiment, which may
         only refer to parameter table symbols: the other symbols are constant

tests/v2/test_conversion.py

@@ -1734,3 +1734,60 @@ def test_assignments_to_experiments_slope_id_taken():
         0.0: {"k1": 0.0, "k1_slope_1": 1.0},
         10.0: {"k1": 1.0, "k1_slope_1": 0.0},
     }
+
+
+@pytest.mark.parametrize(
+    "conditions",
+    [
+        # the changes of a condition are simultaneous: `d1` takes the old `b1`
+        [(2.0, {"b1": 2.0, "d1": "b1 + 0.5"})],
+        # a change is evaluated once: `d1` keeps the `b1` of its period
+        [(2.0, {"d1": "b1 + 0.5"}), (3.0, {"b1": 2.0})],
+    ],
+)
+def test_assignments_to_experiments_change_evaluated_at_period_start(
+    conditions,
+):
+    """Test that a condition change's value is evaluated at the start of its
+    period, with the values from before the period, also when a later switch
+    uses it."""
+    problem = Problem()
+    problem.model = _switch_model(
+        "piecewise(b0, time < 5, d1)", extra="b0 = 0.3; b1 = 1.2; d1 = 1;"
+    )
+    args = [0, []]
+    for i, (t, changes) in enumerate(conditions):
+        problem.add_condition(f"c{i}", **changes)
+        args += [t, f"c{i}"]
+    problem.add_experiment("e1", *args)
+    problem.add_observable("obs_a", formula="A", noise_formula=1.0)
+    problem.add_measurement(
+        "obs_a", experiment_id="e1", time=20.0, measurement=1.0
+    )
+
+    converted = assignments_to_experiments(problem)
+
+    (switch,) = (p for p in converted["e1"].periods if p.time == 5.0)
+    (change,) = converted.get_changes_for_period(switch)
+    assert change.target_id == "k1"
+    # 1.2 + 0.5, not 2.0 + 0.5
+    assert float(change.target_value) == pytest.approx(1.7)
+
+
+def test_assignments_to_experiments_change_refers_to_species():
+    """Test that a change of a symbol of the assignment whose value refers to
+    a species, which is not known at the start of the period, is
+    rejected."""
+    problem = Problem()
+    problem.model = _switch_model(
+        "piecewise(0, time < 5, d1)", extra="d1 = 1;"
+    )
+    problem.add_condition("c1", d1="A")
+    problem.add_experiment("e1", 0, [], 2, "c1")
+    problem.add_observable("obs_a", formula="A", noise_formula=1.0)
+    problem.add_measurement(
+        "obs_a", experiment_id="e1", time=20.0, measurement=1.0
+    )
+
+    with pytest.raises(NotImplementedError, match=r"refer to \['A'\]"):
+        assignments_to_experiments(problem)