L2SS-572: rename delays methods

tangostationcontrol/tangostationcontrol/beam/delays.py

@@ -61,14 +61,14 @@ class Delays:
 
         return True
 
-    def convert(self, direction, antenna_absolute_itrf: list([float])):
+    def delays(self, direction, antenna_absolute_itrf: list([float])):
         """ Get the delays for a direction and *absolute* antenna positions.
         
             Returns delays[antenna]. """
 
-        return self.convert_bulk([direction], numpy.array(antenna_absolute_itrf) - self.reference_itrf).flatten()
+        return self.delays_bulk([direction], numpy.array(antenna_absolute_itrf) - self.reference_itrf).flatten()
 
-    def convert_bulk(self, directions: numpy.ndarray, antenna_relative_itrfs: numpy.ndarray) -> numpy.ndarray:
+    def delays_bulk(self, directions: numpy.ndarray, antenna_relative_itrfs: numpy.ndarray) -> numpy.ndarray:
         """ Get the delays for each direction and each *relative* antenna position.
         
             Returns delays[antenna][direction]. """

tangostationcontrol/tangostationcontrol/devices/sdp/digitalbeam.py

@@ -165,7 +165,7 @@ class DigitalBeam(beam_device):
         d.set_measure_time(timestamp)
 
         # calculate the delays based on the set reference position, the set time and now the set direction and antenna positions
-        delays = d.convert_bulk(pointing_direction, self.relative_input_positions)
+        delays = d.delays_bulk(pointing_direction, self.relative_input_positions)
 
         return delays
 

tangostationcontrol/tangostationcontrol/test/beam/test_delays.py

@@ -144,7 +144,7 @@ class TestDelays(base.TestCase):
 
         self.assertAlmostEqual(0.1, delays[0], 6, f"delays[0] = {delays[0]}")
 
-    def test_convert_bulk(self):
+    def test_delays_bulk(self):
         d = Delays([0, 0, 0])
         timestamp = datetime.datetime(2022, 3, 1, 0, 0, 0) # timestamp does not actually matter, but casacore doesn't know that.
         d.set_measure_time(timestamp)
@@ -153,19 +153,19 @@ class TestDelays(base.TestCase):
         positions = numpy.array([[i,2,3] for i in range(5)])
         directions = numpy.array([["J2000", f"{i}deg", f"{i}deg"] for i in range(90)])
 
-        bulk_result = d.convert_bulk(directions, positions)
+        bulk_result = d.delays_bulk(directions, positions)
 
         # verify parallellisation along direction axis
         for i, single_dir in enumerate(directions):
-            single_dir_result = d.convert_bulk([single_dir], positions)
+            single_dir_result = d.delays_bulk([single_dir], positions)
             numpy.testing.assert_almost_equal(single_dir_result[:, 0], bulk_result[:, i], 4)
 
         # verify parallellisation along position axis
         for i, single_pos in enumerate(positions):
-            single_pos_result = d.convert_bulk(directions, [single_pos])
+            single_pos_result = d.delays_bulk(directions, [single_pos])
             numpy.testing.assert_almost_equal(single_pos_result[0, :], bulk_result[i, :], 4)
 
-    def test_convert_bulk_speed(self):
+    def test_delays_bulk_speed(self):
         d = Delays([0, 0, 0])
         timestamp = datetime.datetime(2022, 3, 1, 0, 0, 0) # timestamp does not actually matter, but casacore doesn't know that.
         d.set_measure_time(timestamp)
@@ -176,6 +176,6 @@ class TestDelays(base.TestCase):
         count = 10
         before = time.monotonic_ns()
         for _ in range(count):
-            _ = d.convert_bulk(directions, positions)
+            _ = d.delays_bulk(directions, positions)
         after = time.monotonic_ns()
-        logging.error(f"convert_bulk averaged {(after - before)/count/1e6} ms to convert 488 directions for 96 antennas.")
+        logging.error(f"delays bulk averaged {(after - before)/count/1e6} ms to convert 488 directions for 96 antennas.")