Beam definer

mxcubecore/HardwareObjects/abstract/AbstractBeam.py

@@ -186,12 +186,15 @@ def evaluate_beam_info(self):
         Method called if aperture, slits or focusing has been changed
         Returns: dictionary, {size_x: 0.1, size_y: 0.1, shape: BeamShape enum}
         """
-
         size_x = min(
-            self._beam_size_dict["aperture"][0], self._beam_size_dict["slits"][0]
+            self._beam_size_dict["aperture"][0],
+            self._beam_size_dict["slits"][0],
+            self._beam_size_dict["definer"][0],
         )
         size_y = min(
-            self._beam_size_dict["aperture"][1], self._beam_size_dict["slits"][1]
+            self._beam_size_dict["aperture"][1],
+            self._beam_size_dict["slits"][1],
+            self._beam_size_dict["definer"][1],
         )
 
         self._beam_width = size_x

mxcubecore/HardwareObjects/mockup/BeamDefinerMockup.py

@@ -0,0 +1,97 @@
+# encoding: utf-8
+#
+#  Project: MXCuBE
+#  https://github.com/mxcube
+#
+#  This file is part of MXCuBE software.
+#
+#  MXCuBE is free software: you can redistribute it and/or modify
+#  it under the terms of the GNU Lesser General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or
+#  (at your option) any later version.
+#
+#  MXCuBE is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public License
+#  along with MXCuBE. If not, see <http://www.gnu.org/licenses/>.
+
+"""
+BeamDefinerMockup class
+
+<object class="BeamDefinerMockup">
+    <username>beamDefiner</username>
+    <object hwrid="/beam_size_ver" role="beam_size_ver" />
+    <object hwrid="/beam_size_hor" role="beam_size_hor" />
+    <values>{"50x50": "50x50", "100x100": "100x100", "20x5": "20x5"}</values>
+    <styling>{"50x50":{100: "disable", 50: "default", 20: "normal", 10: "warning", 5: "warning"},
+        "100x100": {100: 'default',50: 'normal',20: 'normal',10: 'warning', 5: 'warning'},'20x5': {100: 'disable',50: 'disable',20: 'normal',10: 'default',5: 'normal'}, "UNKNOWN": {100: 'default',50: 'normal',20: 'normal',10: 'normal',5: 'normal'}}</styling>
+</object>
+
+
+"""
+
+from mxcubecore.BaseHardwareObjects import HardwareObject
+from mxcubecore.HardwareObjects.abstract.AbstractNState import AbstractNState
+
+
+class BeamDefinerMockup(AbstractNState):
+    def __init__(self, *args):
+        super().__init__(*args)
+        self.beam_size_hor = None
+        self.beam_size_ver = None
+        self.custom_styling = None
+    def init(self):
+        AbstractNState.init(self)
+
+        self.beam_size_hor = self.get_object_by_role("beam_size_hor")
+        self.beam_size_ver = self.get_object_by_role("beam_size_ver")
+        self.beam_size_hor.connect
+
+        self.connect(self.beam_size_hor, "valueChanged", self.motors_changed)
+        self.connect(self.beam_size_ver, "valueChanged", self.motors_changed)
+        self.get_custom_styling()
+    def motors_changed(self, value):
+        _val = self.get_value()
+        self.emit("valueChanged", _val)
+
+    def get_custom_styling(self):
+        try:
+            _ap = eval(self.get_property("styling"))
+        except:
+            print("malformed xml")
+            _ap = None
+        self.custom_styling = _ap
+        return self.custom_styling
+
+    def get_state(self):
+        """Get the device state.
+        Returns:
+            (enum 'HardwareObjectState'): Device state.
+        """
+        return self.STATES.READY
+
+    def get_value(self):
+        """Get the device value
+        Returns:
+        """
+        try:
+            hor = int(self.beam_size_hor.get_value())
+            ver = int(self.beam_size_ver.get_value())
+            _val = f"{hor}x{ver}"
+            en = self.value_to_enum(_val)
+            return en
+        except ValueError:
+            return -1
+
+    def set_value(self, val):
+        """Set the beam size.
+        Args:
+            size_x: horizontal size
+            size_y: vertical size
+        """
+        size_x, size_y = val.split("x")
+        self.beam_size_hor._move(float(size_x))
+        self.beam_size_ver._move(float(size_y))

mxcubecore/HardwareObjects/mockup/BeamMockup.py

@@ -38,8 +38,10 @@ def __init__(self, name):
 
         self._beam_size_dict["slits"] = [9999, 9999]
         self._beam_size_dict["aperture"] = [9999, 9999]
+        self._beam_size_dict["definer"] = [9999, 9999]
         self._beam_position_on_screen = [680, 512]
         self._beam_divergence = (0, 0)
+        self.beam_size_determination = None
 
     def init(self):
         AbstractBeam.init(self)
@@ -48,6 +50,7 @@ def init(self):
             self.get_property("beam_position", "[318, 238]")
         )
 
+        self.beam_size_determination = self.get_property("beam_size_determination")
         self._aperture = self.get_object_by_role("aperture")
         if self._aperture is not None:
             self.connect(
@@ -67,6 +70,14 @@ def init(self):
             sx, sy = self._slits.get_gaps()
             self._beam_size_dict["slits"] = [sx, sy]
 
+        self._beam_definer = self.get_object_by_role("beam_definer")
+        if self._beam_definer is not None:
+            self.connect(self._beam_definer, "valueChanged", self.beam_definer_changed)
+
+            _definer = self._beam_definer.get_value()
+            sx, sy = _definer.value.split("x")
+            self._beam_size_dict["definer"] = [float(sx), float(sy)]
+
         self.evaluate_beam_info()
         self.re_emit_values()
         self.emit("beamPosChanged", (self._beam_position_on_screen,))
@@ -93,6 +104,16 @@ def slits_gap_changed(self, size):
         self.evaluate_beam_info()
         self.re_emit_values()
 
+    def beam_definer_changed(self, definer):
+        if definer.value != "UNKNOWN":
+            sx, sy = definer.value.split("x")
+        else:
+            _aperture = self._aperture.get_diameter_size()
+            sx, sy = [_aperture, _aperture]
+        self._beam_size_dict["definer"] = [float(sx), float(sy)]
+        self.evaluate_beam_info()
+        self.re_emit_values()
+
     def set_beam_position_on_screen(self, beam_x, beam_y):
         """
         Sets beam mark position on screen
@@ -136,5 +157,55 @@ def get_available_size(self):
         aperture_list = self._aperture.get_diameter_size_list()
         return {"type": "enum", "values": aperture_list}
 
+    def get_available_definer(self):
+        if self._beam_definer is not None:
+            definer_list = [item.value for item in self._beam_definer.VALUES]
+        else:
+            return {}
+        return {"type": "enum", "values": definer_list}
+
     def set_value(self, value):
         self._aperture.set_diameter_size(value)
+
+    def set_beam_definer(self, value):
+        if self._beam_definer is not None:
+            self._beam_definer.set_value(value)
+
+    def evaluate_beam_info(self):
+        """
+        Method called if aperture, slits or focusing has been changed
+        Returns: dictionary, {size_x: 0.1, size_y: 0.1, shape: BeamShape enum}
+        """
+        if self.beam_size_determination is None:
+            # we keep the minumum
+            size_x = min(
+                self._beam_size_dict["aperture"][0],
+                self._beam_size_dict["slits"][0],
+                self._beam_size_dict["definer"][0],
+            )
+            size_y = min(
+                self._beam_size_dict["aperture"][1],
+                self._beam_size_dict["slits"][1],
+                self._beam_size_dict["definer"][1],
+            )
+        elif self.beam_size_determination == "definer":
+            size_x = self._beam_size_dict["definer"][0]
+            size_y = self._beam_size_dict["definer"][1]
+        elif self.beam_size_determination == "slits":
+            size_x = self._beam_size_dict["slits"][0]
+            size_y = self._beam_size_dict["slits"][1]
+
+        self._beam_width = size_x
+        self._beam_height = size_y
+
+        if tuple(self._beam_size_dict["aperture"]) < tuple(
+            self._beam_size_dict["slits"]
+        ):
+            self._beam_shape = BeamShape.ELIPTICAL
+        else:
+            self._beam_shape = BeamShape.RECTANGULAR
+
+        self._beam_info_dict["size_x"] = size_x
+        self._beam_info_dict["size_y"] = size_y
+        self._beam_info_dict["shape"] = self._beam_shape
+        return self._beam_info_dict

mxcubecore/HardwareObjects/mockup/MotorMockup.py

@@ -104,7 +104,6 @@ def _move(self, value):
                 )
 
                 val = val if not self._wrap_range else val % self._wrap_range
-
                 self.update_value(val)
         time.sleep(0.02)
 
@@ -118,8 +117,8 @@ def _move(self, value):
         else:
             self.update_specific_state(None)
 
+        self.update_value(value)
         return value
-    
+
     def is_moving(self):
         return ( (self.get_state() == self.STATES.BUSY ) or (self.get_state() == self.SPECIFIC_STATES.MOVING))
-