diff --git a/lisainstrument/instrument.py b/lisainstrument/instrument.py
index 1e07d12564886c8b6caab5db2f3b4626470a81ed..0a6bd1c539679a20bb6c4c72f68e1b2586b0178c 100755
--- a/lisainstrument/instrument.py
+++ b/lisainstrument/instrument.py
@@ -672,6 +672,76 @@ class Instrument:
         """
         return numpyfy_dask_multi(op, chunks=self.chunking_size)
 
+    def make_adaptive_shift_lagrange(
+        self,
+        order: int,
+        delay_min: float,
+        delay_max: float,
+        bc_left: ShiftBC,
+        bc_right: ShiftBC,
+    ) -> AdaptiveShiftNumpy:
+        """Create adaptive delay operator using new dask-based lagrange interpolator
+
+        Temporarily during refactoring, this provides a numpy-based interface
+        to the dask-based interpolation.
+
+        Arguments:
+            order: Order of Lagrange polynomials
+            delay_min: Minimum allowed delay [s]
+            delay_max: Maximum allowed delay [s]
+            bc_left: Left boundary treatment
+            bc_right: Right boundary treatment
+
+        Returns:
+            AdaptiveShiftNumpy instance
+        """
+        op_dyn_ = make_dynamic_shift_lagrange_dask(
+            order,
+            delay_min * self.physics_fs,
+            delay_max * self.physics_fs,
+            bc_left,
+            bc_right,
+        )
+        op_fix_ = make_fixed_shift_lagrange_dask(bc_left, bc_right, order)
+        op_dyn = self.numpyfy_dask_multi(op_dyn_)
+        op_fix = self.numpyfy_dask_multi(op_fix_)
+        return AdaptiveShiftNumpy(op_fix, op_dyn, self.physics_fs)
+
+    def make_adaptive_shift_dsp(
+        self,
+        order: int,
+        delay_min: float,
+        delay_max: float,
+        bc_left: ShiftBC,
+        bc_right: ShiftBC,
+    ) -> AdaptiveShiftNumpy:
+        """Create adaptive delay operator using daskified lagrange interpolator from dsp module
+
+        Temporarily during refactoring, this provides a numpy-based interface
+        to the dask-based interpolation.
+
+        Arguments:
+            order: Order of Lagrange polynomials
+            delay_min: Minimum allowed delay [s]
+            delay_max: Maximum allowed delay [s]
+            bc_left: Left boundary treatment
+            bc_right: Right boundary treatment
+
+        Returns:
+            AdaptiveShiftNumpy instance
+        """
+        op_dyn_ = make_dynamic_shift_dsp_dask(
+            order,
+            delay_min * self.physics_fs,
+            delay_max * self.physics_fs,
+            bc_left,
+            bc_right,
+        )
+        op_fix_ = make_fixed_shift_dsp_dask(bc_left, bc_right, order)
+        op_dyn = self.numpyfy_dask_multi(op_dyn_)
+        op_fix = self.numpyfy_dask_multi(op_fix_)
+        return AdaptiveShiftNumpy(op_fix, op_dyn, self.physics_fs)
+
     def init_delays(
         self,
         interpolation: None | tuple,
@@ -719,63 +789,35 @@ class Instrument:
                 "lagrange",
                 int(order),
             ):
-                # ~ self.interpolation_order = order
-                op_dyn_ = make_dynamic_shift_lagrange_dask(
+                self.apply_shift = self.make_adaptive_shift_lagrange(
                     order,
-                    delay_isc_min * self.physics_fs,
-                    delay_isc_max * self.physics_fs,
+                    delay_isc_min,
+                    delay_isc_max,
                     ShiftBC.ZEROPAD,
                     ShiftBC.ZEROPAD,
                 )
-                op_dyn_clock_ = make_dynamic_shift_lagrange_dask(
-                    order,
-                    -delay_clock_max * self.physics_fs,
-                    delay_clock_max * self.physics_fs,
-                    ShiftBC.FLAT,
-                    ShiftBC.FLAT,
-                )
-                op_fix_ = make_fixed_shift_lagrange_dask(
-                    ShiftBC.ZEROPAD, ShiftBC.ZEROPAD, order
-                )
-                op_dyn_clock = self.numpyfy_dask_multi(op_dyn_clock_)
-                op_dyn = self.numpyfy_dask_multi(op_dyn_)
-                op_fix = self.numpyfy_dask_multi(op_fix_)
-                self.apply_shift_clock = AdaptiveShiftNumpy(
-                    op_fix, op_dyn_clock, self.physics_fs
-                )
-                self.apply_shift = AdaptiveShiftNumpy(op_fix, op_dyn, self.physics_fs)
                 self.apply_shift_electro = self.apply_shift.fixed
+                self.apply_shift_clock = self.make_adaptive_shift_lagrange(
+                    order, -delay_clock_max, delay_clock_max, ShiftBC.FLAT, ShiftBC.FLAT
+                )
+
             case (
                 "lagrange_dsp",
                 int(order),
             ):
-                # ~ self.interpolation_order = order
-                op_dyn_ = make_dynamic_shift_dsp_dask(
+
+                self.apply_shift = self.make_adaptive_shift_dsp(
                     order,
-                    delay_isc_min * self.physics_fs,
-                    delay_isc_max * self.physics_fs,
+                    delay_isc_min,
+                    delay_isc_max,
                     ShiftBC.ZEROPAD,
                     ShiftBC.ZEROPAD,
                 )
-                op_dyn_clock_ = make_dynamic_shift_dsp_dask(
-                    order,
-                    -delay_clock_max * self.physics_fs,
-                    delay_clock_max * self.physics_fs,
-                    ShiftBC.FLAT,
-                    ShiftBC.FLAT,
-                )
-                op_fix_ = make_fixed_shift_dsp_dask(
-                    ShiftBC.ZEROPAD, ShiftBC.ZEROPAD, order
+                self.apply_shift_electro = self.apply_shift.fixed
+                self.apply_shift_clock = self.make_adaptive_shift_dsp(
+                    order, -delay_clock_max, delay_clock_max, ShiftBC.FLAT, ShiftBC.FLAT
                 )
-                op_dyn_clock = self.numpyfy_dask_multi(op_dyn_clock_)
-                op_dyn = self.numpyfy_dask_multi(op_dyn_)
-                op_fix = self.numpyfy_dask_multi(op_fix_)
 
-                self.apply_shift_clock = AdaptiveShiftNumpy(
-                    op_fix, op_dyn_clock, self.physics_fs
-                )
-                self.apply_shift = AdaptiveShiftNumpy(op_fix, op_dyn, self.physics_fs)
-                self.apply_shift_electro = self.apply_shift.fixed
             case ("lagrange", int(order)):
                 msg = (
                     "interpolation parameter tuples need 4 entries since daskification"
@@ -787,7 +829,7 @@ class Instrument:
             case _:
                 msg = f"Invalid interpolation parameters {interpolation}"
                 raise RuntimeError(msg)
-
+            # ~ self.interpolation_order =
             # ~ self.delay_isc_min = delay_isc_min
             # ~ self.delay_isc_max = delay_isc_max