Add time interpolation to mpc data

pyomo/contrib/mpc/data/series_data.py

@@ -155,7 +155,7 @@ def get_data_at_time(self, time=None, tolerance=0.0):
             indices = indices[0]
         return self.get_data_at_time_indices(indices)
 
-    def get_interpolated_data_at_time(self, time=None):
+    def get_interpolated_data(self, time=None, tolerance=0.0):
         """
         Returns the data associated with the provided time point or points by
         linear interpolation.
@@ -164,6 +164,9 @@ def get_interpolated_data_at_time(self, time=None):
         ----------
         time: Float or iterable
             The time point or points corresponding to returned data.
+        tolerance: float
+            Tolerance used when checking if time points are inside the data
+            range.
 
         Returns
         -------
@@ -181,6 +184,9 @@ def get_interpolated_data_at_time(self, time=None):
         is_iterable = _is_iterable(time)
         if not is_iterable:
             time = [time]
+        for t in time:
+            if t > self._time[-1] + tolerance or t < self._time[0] - tolerance:
+                raise RuntimeError("Requesting interpolation outside data range.")
         idxs = _get_time_index_vec(time, self._time)
         data = {}
         for cuid in self._data:

pyomo/contrib/mpc/data/tests/test_series_data.py

@@ -126,26 +126,55 @@ def test_get_data_at_time_with_tolerance(self):
         with self.assertRaisesRegex(RuntimeError, msg):
             new_data = data.get_data_at_time(-0.01, tolerance=1e-3)
 
-    def test_get_data_at_time_with_interpolate(self):
+    def test_get_data_interpolate(self):
         m = self._make_model()
         data_dict = {m.var[:, "A"]: [1, 2, 3], m.var[:, "B"]: [2, 4, 6]}
         data = TimeSeriesData(data_dict, m.time)
-        new_data = data.get_interpolated_data_at_time(0.05)
+        new_data = data.get_interpolated_data(0.05)
         self.assertEqual(ScalarData({m.var[:, "A"]: 1.5, m.var[:, "B"]: 3}), new_data)
 
         t1 = 0.05
-        new_data = data.get_interpolated_data_at_time([t1])
+        new_data = data.get_interpolated_data([t1])
         self.assertEqual(
             TimeSeriesData({m.var[:, "A"]: [1.5], m.var[:, "B"]: [3]}, [t1]), new_data
         )
 
         new_t = [0.05, 0.15]
-        new_data = data.get_interpolated_data_at_time(new_t)
+        new_data = data.get_interpolated_data(new_t)
         self.assertEqual(
             TimeSeriesData({m.var[:, "A"]: [1.5, 2.5], m.var[:, "B"]: [3, 5]}, new_t),
             new_data,
         )
 
+    def test_get_data_interpolate_range_check(self):
+        m = self._make_model()
+        data_dict = {m.var[:, "A"]: [1, 2, 3], m.var[:, "B"]: [2, 4, 6]}
+        data = TimeSeriesData(data_dict, m.time)
+        msg = "Requesting interpolation outside data range."
+        with self.assertRaisesRegex(RuntimeError, msg):
+            new_data = data.get_interpolated_data(0.2 + 1e-6)
+        with self.assertRaisesRegex(RuntimeError, msg):
+            new_data = data.get_interpolated_data(0.0 - 1e-6)
+        new_data = data.get_interpolated_data(0.2 + 1e-6, tolerance=1e-5)
+        self.assertAlmostEqual(new_data.get_data_from_key(m.var[:, "A"]), 3, 4)
+        self.assertAlmostEqual(new_data.get_data_from_key(m.var[:, "B"]), 6, 4)
+
+        t1 = 0.2 + 1e-6
+        with self.assertRaisesRegex(RuntimeError, msg):
+            new_data = data.get_interpolated_data([t1])
+        new_data = data.get_interpolated_data([t1], tolerance=1e-5)
+        self.assertAlmostEqual(new_data.get_data_from_key(m.var[:, "A"])[0], 3, 4)
+        self.assertAlmostEqual(new_data.get_data_from_key(m.var[:, "B"])[0], 6, 4)
+
+        new_t = [0.0 - 1e-6, 0.2 + 1e-6]
+        with self.assertRaisesRegex(RuntimeError, msg):
+            new_data = data.get_interpolated_data(new_t)
+        new_data = data.get_interpolated_data(new_t, tolerance=1e-5)
+        self.assertAlmostEqual(new_data.get_data_from_key(m.var[:, "A"])[0], 1, 4)
+        self.assertAlmostEqual(new_data.get_data_from_key(m.var[:, "B"])[0], 2, 4)
+        self.assertAlmostEqual(new_data.get_data_from_key(m.var[:, "A"])[1], 3, 4)
+        self.assertAlmostEqual(new_data.get_data_from_key(m.var[:, "B"])[1], 6, 4)
+
     def test_to_serializable(self):
         m = self._make_model()
         data_dict = {m.var[:, "A"]: [1, 2, 3], m.var[:, "B"]: [2, 4, 6]}