wip

csaxs_bec/device_configs/test_config.yaml

@@ -0,0 +1,24 @@
+galilrioesxbox:
+  description: Galil RIO for remote gain switching and slow reading ES XBox
+  deviceClass: csaxs_bec.devices.omny.galil.galil_rio.GalilRIO
+  deviceConfig:
+    host: galilrioesft.psi.ch
+  enabled: true
+  onFailure: raise
+  readOnly: false
+  readoutPriority: baseline
+  connectionTimeout: 20
+bpm1:
+  readoutPriority: baseline
+  deviceClass: csaxs_bec.devices.pseudo_devices.bpm.BPM
+  deviceConfig:
+    blade_t: galilrioesxbox.analog_in.ch0
+    blade_r: galilrioesxbox.analog_in.ch1
+    blade_b: galilrioesxbox.analog_in.ch2
+    blade_l: galilrioesxbox.analog_in.ch3
+  enabled: true
+  readOnly: false
+  softwareTrigger: true
+  needs:
+    - galilrioesxbox
+

csaxs_bec/devices/omny/shutter.py

@@ -48,7 +48,6 @@ class OMNYFastShutter(PSIDeviceBase, Device):
     def fshopen(self):
         """Open the fast shutter."""
         if self._check_if_cSAXS_shutter_exists_in_config():
-            self.shutter.put(1)
             return self.device_manager.devices["fsh"].fshopen()
         else:
             self.shutter.put(1)
@@ -56,7 +55,6 @@ class OMNYFastShutter(PSIDeviceBase, Device):
     def fshclose(self):
         """Close the fast shutter."""
         if self._check_if_cSAXS_shutter_exists_in_config():
-            self.shutter.put(0)
             return self.device_manager.devices["fsh"].fshclose()
         else:
             self.shutter.put(0)

csaxs_bec/devices/pseudo_devices/bpm.py

@@ -0,0 +1,117 @@
+import time
+
+from ophyd import Component as Cpt
+from ophyd import Kind, Signal
+from ophyd_devices.interfaces.base_classes.psi_pseudo_device_base import PSIPseudoDeviceBase
+from ophyd_devices.utils.bec_processed_signal import BECProcessedSignal
+
+
+class BPM(PSIPseudoDeviceBase):
+    """BPM positioner pseudo device."""
+
+    # Blade signals, a,b,c,d
+    top = Cpt(
+        BECProcessedSignal, name="top", model_config=None, kind=Kind.config, doc="... top blade"
+    )
+    right = Cpt(
+        BECProcessedSignal, name="right", model_config=None, kind=Kind.config, doc="... right blade"
+    )
+    bot = Cpt(
+        BECProcessedSignal, name="bot", model_config=None, kind=Kind.config, doc="... bot blade"
+    )
+    left = Cpt(
+        BECProcessedSignal, name="left", model_config=None, kind=Kind.config, doc="... left blade"
+    )
+
+    # Virtual signals
+    pos_x = Cpt(
+        BECProcessedSignal, name="pos_x", model_config=None, kind=Kind.config, doc="... pos_x"
+    )
+    pos_y = Cpt(
+        BECProcessedSignal, name="pos_y", model_config=None, kind=Kind.config, doc="... pos_y"
+    )
+    diagonal = Cpt(
+        BECProcessedSignal, name="diagonal", model_config=None, kind=Kind.config, doc="... diagonal"
+    )
+    intensity = Cpt(
+        BECProcessedSignal,
+        name="intensity",
+        model_config=None,
+        kind=Kind.config,
+        doc="... intensity",
+    )
+
+    def __init__(
+        self,
+        name,
+        blade_t: str,
+        blade_r: str,
+        blade_b: str,
+        blade_l: str,
+        device_manager=None,
+        **kwargs,
+    ):
+        super().__init__(name=name, device_manager=device_manager, **kwargs)
+        # Get all blade signal objects from utility method
+        signal_t = self.top.get_device_object_from_bec(
+            object_name=blade_t, signal_name=self.name, device_manager=device_manager
+        )
+        signal_r = self.right.get_device_object_from_bec(
+            object_name=blade_r, signal_name=self.name, device_manager=device_manager
+        )
+        signal_b = self.bot.get_device_object_from_bec(
+            object_name=blade_b, signal_name=self.name, device_manager=device_manager
+        )
+        signal_l = self.left.get_device_object_from_bec(
+            object_name=blade_l, signal_name=self.name, device_manager=device_manager
+        )
+
+        # Set compute methods for blade signals and virtual signals
+        self.top.set_compute_method(self._compute_blade_signal, signal=signal_t)
+        self.right.set_compute_method(self._compute_blade_signal, signal=signal_r)
+        self.bot.set_compute_method(self._compute_blade_signal, signal=signal_b)
+        self.left.set_compute_method(self._compute_blade_signal, signal=signal_l)
+
+        self.intensity.set_compute_method(
+            self._compute_intensity, top=self.top, right=self.right, bot=self.bot, left=self.left
+        )
+        self.pos_x.set_compute_method(
+            self._compute_pos_x, left=self.left, top=self.top, right=self.right, bot=self.bot
+        )
+        self.pos_y.set_compute_method(
+            self._compute_pos_y, left=self.left, top=self.top, right=self.right, bot=self.bot
+        )
+        self.diagonal.set_compute_method(
+            self._compute_diagonal, left=self.left, top=self.top, right=self.right, bot=self.bot
+        )
+
+    def _compute_blade_signal(self, signal: Signal) -> float:
+        return signal.get()
+
+    def _compute_intensity(self, top: Signal, right: Signal, bot: Signal, left: Signal) -> float:
+        intensity = top.get() + right.get() + bot.get() + left.get()
+        return intensity
+
+    def _compute_pos_x(self, left: Signal, top: Signal, right: Signal, bot: Signal) -> float:
+        sum_left = left.get() + top.get()
+        sum_right = right.get() + bot.get()
+        sum_total = sum_left + sum_right
+        if sum_total == 0:
+            return 0.0
+        return (sum_left - sum_right) / sum_total
+
+    def _compute_pos_y(self, left: Signal, top: Signal, right: Signal, bot: Signal) -> float:
+        sum_top = top.get() + right.get()
+        sum_bot = bot.get() + left.get()
+        sum_total = sum_top + sum_bot
+        if sum_total == 0:
+            return 0.0
+        return (sum_top - sum_bot) / sum_total
+
+    def _compute_diagonal(self, left: Signal, top: Signal, right: Signal, bot: Signal) -> float:
+        sum_diag1 = left.get() + right.get()
+        sum_diag2 = top.get() + bot.get()
+        sum_total = sum_diag1 + sum_diag2
+        if sum_total == 0:
+            return 0.0
+        return (sum_diag1 - sum_diag2) / sum_total

csaxs_bec/devices/pseudo_devices/dlpca200_settings.py

@@ -0,0 +1 @@
+# from ophyd