Merge branch 'dev/main' into backup-before-filterrepo

Author: Sulimankhail

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "dt4acc"
-version = "0.0.4"
+version = "0.1.0"
 description = "digital twin for accelerators"
 authors = [  "Waheedullah Sulaiman Khail", "Pierre Schnizer"]
 license = "GPL-3.0"

src/dt4acc/core/accelerators/accelerator_manager.py

@@ -81,5 +81,4 @@ def setup_event_subscriptions(self):
         self.accelerator.on_new_twiss.subscribe(self.view.push_twiss)
         self.accelerator.on_new_orbit.subscribe(self.view.push_orbit)
 
-        self.accelerator.on_new_orbit.subscribe(self.view.push_bpms)
         self.accelerator.on_changed_value.subscribe(self.view.push_value)

src/dt4acc/core/accelerators/element_proxies.py

@@ -165,6 +165,48 @@ async def update(self, property_id: str, value, element_data):
 
         await self.on_update_finished.trigger(None)
 
+    def peek(self, property_id: str) -> float:
+        if property_id in ["K", "H", "main_strength"]:
+            return self.peek_main_strength(property_id)
+        elif property_id in ["x_kick", "y_kick"]:
+            return self.peek_kick(property_id)
+        elif property_id in ["frequency"]:
+            return self.peek_frequency()
+        else:
+            raise NotImplementedError(
+                f"handling property {property_id} not (yet) implemented"
+            )
+
+    def peek_frequency(self):
+        (element,) = self._obj
+        return element.Frequency
+
+    def peek_main_strength(self, property_id: str):
+        (element,) = self._obj
+        element_type = element.__class__.__name__
+        if element_type == "Quadrupole":
+            assert property_id in ["K", "main_strength"]
+            return element.K
+        elif element_type == "Sextupole":
+            if property_id not in ["H", "main_strength"]:
+                raise AssertionError(
+                    f"Not handling {property_id} for element {element_type}"
+                )
+            return element.H
+        else:
+            raise NotImplementedError(
+                f"main strength not implemented for element {element_type}"
+            )
+
+    def peek_kick(self, property_id: str):
+        (element,) = self._obj
+        lut = dict(x_kick=0, y_kick=1)
+        try:
+            idx = lut[property_id]
+        except KeyError as ke:
+            raise AssertionError(f"Did not expect kick {property_id}")
+        return element.KickAngle[idx]
+
 
 
 

src/dt4acc/core/bl/delay_execution.py

@@ -39,7 +39,7 @@ async def request_execution(self):
             self.pending_task.cancel()
 
         # Schedule a new execution task after the delay
-        self.pending_task = asyncio.create_task(self._delayed_execution())
+        self.pending_task = asyncio.create_task(self._delayed_execution(), name="delayed-execution")
 
     async def _delayed_execution(self):
         """

src/dt4acc/core/interfaces/view_interface.py

@@ -0,0 +1,9 @@
+from abc import ABCMeta, abstractmethod
+
+
+class ViewInterface(metaclass=ABCMeta):
+    @abstractmethod
+    async def push(self, data):
+        """
+        """
+        raise NotImplementedError("use base class instead")

src/dt4acc/core/model/twiss.py

@@ -40,4 +40,11 @@ def get_plane(self, plane: Planes):
         elif plane == Planes.y:
             return self.y
         else:
-            raise AssertionError("How could I end up here")
+            raise AssertionError("How could I end up here")
+
+@dataclass
+class TuneData:
+    """extracted tune data for the tune device
+    """
+    x: float
+    y: float

src/dt4acc/core/utils/periodic_publisher.py

@@ -0,0 +1,41 @@
+import asyncio
+import itertools
+
+from .logger import get_logger
+from ..interfaces.view_interface import ViewInterface
+
+#: use a "singleton", even if the name is not unique it should still work
+counter = itertools.count()
+logger = get_logger()
+
+class PeriodicPublisher:
+    """
+
+    Todo:
+        find a better name for it?
+        Its rather a periodic publisher proxy
+
+        It is expected to be triggered from outside
+    """
+    def __init__(self, view: ViewInterface, name: str):
+        """
+
+        Todo:
+            view should cohere to a protocol or interface
+        """
+        self.view = view
+        self.data = None
+        self.name = name
+
+    def set_data(self, data):
+        self.data = data
+
+    async def publish(self):
+        """
+        Expect that publish is called in parallel, thus just return stat object
+        """
+        #  name=f"publish-data-{self.name}-{next(counter)}"
+        if self.data is None:
+            logger.warning(f"{self.__class__.__name__}(name={self.name}), self.data is None, thus not publishing data")
+            return
+        return await self.view.push(self.data)

src/dt4acc/core/views/shared_view.py

@@ -23,7 +23,7 @@ def get_view_instance():
     if server_type == "tango":
         from ...custom_tango.views.calculation_result_view import ResultView
     elif server_type == "epics":
-        from ...custom_epics.views.calculation_result_view import ResultView
+        from ...custom_epics.views.result_view import ResultView
     else:
         raise ValueError(f"Unsupported server type: {server_type}")
 

src/dt4acc/custom_epics/ioc/handlers.py

@@ -1,15 +1,15 @@
 from bact_twin_architecture.bl.command_rewriter import CommandRewriter
 # from dt4acc.custom_epics.ioc.liasion_translation_manager import build_managers
-from p4p.client.asyncio import Context
 
 from .liasion_translation_manager import build_managers
+from ..utils.context_proxy import ContextProxy
 from ...core.accelerators.pyat_accelerator import setup_accelerator
 from ...core.command import UpdateManager
 from ...core.utils.logger import get_logger
 
 logger = get_logger()
 
-ctx = Context("pva")  # Create a context for EPICS PVA (PV Access)
+ctx = ContextProxy("pva")  # Create a context for EPICS PVA (PV Access)
 
 #: todo replace soon by database service
 

src/dt4acc/custom_epics/ioc/pv_setup.py

@@ -3,7 +3,6 @@
     LatticeElementPropertyID,
     DevicePropertyID,
 )
-from p4p.asLib.yacc import start
 
 from .handlers import handle_device_update, update_manager
 from ..data.constants import config, special_pvs, cavity_names
@@ -113,10 +112,10 @@ def add_pc_pvs(builder, pc_name, prefix):
         DevicePropertyID(device_name=pc_name, property="set_current")
     )
     start_val = np.asarray(vals).mean()
-    rdbk = builder.aOut(f"{pc_name}:rdbk", initial_value=start_val)
+    rdbk = builder.aOut(f"{pc_name}:rdbk", initial_value=start_val, PREC=2)
 
     async def handle_pc_update(device_id: str, property_id: str, value: float):
-        logger.debug("%s:%s updating setpoint val=%s", device_id, property_id, value)
+        logger.warning("%s:%s updating setpoint val=%s", device_id, property_id, value)
         r = await handle_device_update(
             device_id=device_id, property_id=property_id, value=value
         )
@@ -128,6 +127,7 @@ async def handle_pc_update(device_id: str, property_id: str, value: float):
         f"{pc_name}:set",
         initial_value=start_val,
         on_update=lambda val: handle_pc_update(pc_name, "set_current", val),
+        PREC = 2,
     )
 
 
@@ -147,6 +147,12 @@ def initialize_orbit_pvs(builder):
     builder.aOut(f"beam:orbit:found", initial_value=0)
 
 
+def initialize_tune_pvs(builder):
+    for axis in ["x", "y"]:
+        builder.aOut(f"TUNECC:{axis}", initial_value=0.0, PREC=9)
+    builder.longOut(f"TUNECC:count", initial_value=0)
+
+
 def initialize_twiss_pvs(builder):
     """
     Initializes PVs for Twiss parameters, which describe beam optics.