fix Signalpath.phase(): do not modify original data in place

phase() overwrote the underlying channel arrays (y[i] *= -1) and returned
self, so rotated copies aliased the original object and negative phase
angles garbled shared data. It now returns a copy with new arrays and
uses numpy.deg2rad for arbitrary angles.
Add unittests for phase() including negative angles and non-mutation.

tests/test_Signalpath.py

@@ -0,0 +1,97 @@
+import unittest
+from datetime import datetime
+
+import numpy as np
+from damaris.data.ADC_Result import ADC_Result
+
+
+def rotate_reference(y, degrees):
+    "reference rotation of the two channels by degrees"
+    rad = np.deg2rad(degrees)
+    cos, sin = np.cos(rad), np.sin(rad)
+    return [cos * y[0] - sin * y[1], sin * y[0] + cos * y[1]]
+
+
+class TestSignalpath(unittest.TestCase):
+    @staticmethod
+    def create_adc_result():
+        x = np.arange(4, dtype="float32")
+        y = [np.array([10, 20, 30, 40], dtype="int16"),
+             np.array([15, 25, 35, 45], dtype="int16")]
+        index = [(0, 3)]
+        job_date = datetime(2023, 1, 1)
+        desc = {"key": "value"}
+        sampl_freq = 1000.0
+        job_id = 11
+        adc = ADC_Result(x, y, index, sampl_freq, desc, job_id, job_date)
+        adc.set_nChannels(2)
+        return adc
+
+    def assertRotated(self, adc, degrees):
+        rotated = adc.phase(degrees)
+        expected = rotate_reference(adc.y, degrees)
+        np.testing.assert_allclose(rotated.y[0], expected[0])
+        np.testing.assert_allclose(rotated.y[1], expected[1])
+        return rotated
+
+    def test_phase_positive_quarter_turns(self):
+        """Test phase() with 0, 90, 180 and 270 degrees."""
+        adc = self.create_adc_result()
+        for degrees in (0, 90, 180, 270):
+            self.assertRotated(adc, degrees)
+
+    def test_phase_negative_quarter_turns(self):
+        """Test phase() with negative multiples of 90 degrees."""
+        adc = self.create_adc_result()
+        for degrees in (-90, -180, -270, -360):
+            self.assertRotated(adc, degrees)
+
+    def test_phase_negative_arbitrary_angles(self):
+        """Test phase() with arbitrary (not multiple of 90) negative angles."""
+        adc = self.create_adc_result()
+        for degrees in (-45, -120, -315):
+            self.assertRotated(adc, degrees)
+
+    def test_phase_equals_equivalent_positive_angle(self):
+        """Test that negative angles give the same result as the equivalent positive angle."""
+        adc = self.create_adc_result()
+        for degrees in (-90, -45, -120):
+            np.testing.assert_allclose(adc.phase(degrees).y,
+                                       adc.phase(degrees + 360).y)
+
+    def test_phase_does_not_modify_original(self):
+        """Test that phase() leaves the original data (and its arrays) untouched."""
+        adc = self.create_adc_result()
+        original = [adc.y[0].copy(), adc.y[1].copy()]
+        for degrees in (0, 90, 180, 270, -90, -45, 45):
+            rotated = adc.phase(degrees)
+            self.assertIsNot(rotated, adc)
+            self.assertIsNot(rotated.y, adc.y)
+            for ch in (0, 1):
+                self.assertIsNot(rotated.y[ch], original[ch])
+                np.testing.assert_array_equal(adc.y[ch], original[ch])
+
+    def test_phase_result_independent(self):
+        """Test that modifying the phase-rotated copy does not affect the original."""
+        adc = self.create_adc_result()
+        rotated = adc.phase(-90)
+        rotated.y[0][:] = 9999
+        np.testing.assert_array_equal(adc.y[0], [10, 20, 30, 40])
+
+    def test_phase_chaining(self):
+        """Test that chained phase() calls add up correctly."""
+        adc = self.create_adc_result()
+        np.testing.assert_allclose(adc.phase(-90).phase(-90).y,
+                                   adc.phase(-180).y)
+        np.testing.assert_allclose(adc.phase(-90).phase(90).y,
+                                   adc.phase(0).y)
+
+    def test_phase_wrong_channel_number(self):
+        """Test the Exception raised for signalpaths with other than 2 channels."""
+        adc = self.create_adc_result()
+        adc.y.pop()
+        self.assertRaises(Exception, adc.phase, -90)
+
+
+if __name__ == "__main__":
+    unittest.main()