P11 develop

mxcubecore/HardwareObjects/DESY/P11Collect.py

@@ -39,9 +39,18 @@
 
 from mxcubecore.Command.Tango import DeviceProxy
 
+import gevent
+import time
+import numpy as np
+import logging
+import os
+import sys
+import math
+import h5py
 
 import triggerUtils
 
+from tango import DeviceProxy, DevState
 
 FILE_TIMEOUT = 5
 
@@ -50,13 +59,20 @@ class P11Collect(AbstractCollect):
     def __init__(self, *args):
         super(P11Collect, self).__init__(*args)
 
+    def init(self):
+
+        super(P11Collect, self).init()
+
+        # os.system("/opt/xray/bin/adxv -socket -colors Gray -rings &")
+
+        # os.system("/bin/bash /gpfs/local/shared/MXCuBE/STRELA/start_viewer_zmq.sh")
+
         self.default_speed = self.get_property("omega_default_speed", 130)
-        self.turnback_time = self.get_property("turnback_time", 0.1)
+        self.turnback_time = self.get_property("turnback_time", 0.3)
         self.filter_server_name = self.get_property("filterserver")
         self.mono_server_name = self.get_property("monoserver")
         self.filter_server = DeviceProxy(self.filter_server_name)
         self.mono_server = DeviceProxy(self.mono_server_name)
-        self.diffr = HWR.beamline.diffractometer
 
         self.lower_bound_ch = self.get_channel_object("acq_lower_bound")
         self.upper_bound_ch = self.get_channel_object("acq_upper_bound")
@@ -66,18 +82,6 @@ def __init__(self, *args):
         self.acq_off_cmd = self.get_command_object("acq_off")
         self.acq_window_off_cmd = self.get_command_object("acq_window_off")
 
-        self.latest_frames = 1
-        self.acq_speed = 1.0
-        self.init_ok = False
-        self.latest_h5_filename = "TEST_master.h5"
-
-    def init(self):
-        super(P11Collect, self).init()
-
-        # os.system("/opt/xray/bin/adxv -socket -colors Gray -rings &")
-
-        # os.system("/bin/bash /gpfs/local/shared/MXCuBE/STRELA/start_viewer_zmq.sh")
-
         if None in [
             self.lower_bound_ch,
             self.upper_bound_ch,
@@ -201,6 +205,11 @@ def data_collection_hook(self):
                 # Filepath to the EDNA processing
                 # filepath = os.path.join(basepath,"%s_%d" % (prefix, runno))
 
+                # setting up xds_dir for characterisation (used there internally to create dirs)
+                self.current_dc_parameters["xds_dir"] = os.path.join(
+                    basepath, "%s_%d" % (prefix, runno)
+                )
+
                 self.log.debug(
                     "======= CURRENT FILEPATH: "
                     + str(filepath)
@@ -282,23 +291,24 @@ def data_collection_hook(self):
                 # os.system("/opt/dectris/albula/4.0/bin/albula "+self.latest_h5_filename +" &")
                 # os.system("adxv "+self.latest_h5_filename +" &")
 
+                # TODO: Remove for now creation of the snapshots and processing html.
                 # Open index_html
-                os.system("firefox /gpfs/current/processed/index.html")
+                # os.system("firefox /gpfs/current/processed/index.html")
 
                 # Create diffraction snapshots
-                for i in range(nframes):
-                    os.system(
-                        "python3 /gpfs/local/shared/MXCuBE/hdf5tools/albula_api/generate_image.py --input "
-                        + self.latest_h5_filename
-                        + " --output "
-                        + os.path.join(
-                            basepath, prefix, "screening_" + str(runno).zfill(3)
-                        )
-                        + "/"
-                        + " --image_number "
-                        + str(i + 1)
-                    )
-
+            #                for i in range(nframes):
+            #                    os.system(
+            #                        "python3 /gpfs/local/shared/MXCuBE/hdf5tools/albula_api/generate_image.py --input "
+            #                        + self.latest_h5_filename
+            #                        + " --output "
+            #                        + os.path.join(
+            #                            basepath, prefix, "screening_" + str(runno).zfill(3)
+            #                        )
+            #                        + "/"
+            #                        + " --image_number "
+            #                        + str(i + 1)
+            #                    )
+            #
             else:
                 self.collect_std_collection(start_angle, stop_angle)
                 self.generate_xds_template()
@@ -307,21 +317,21 @@ def data_collection_hook(self):
                 # os.system("killall albula")
                 # os.system("/opt/dectris/albula/4.0/bin/albula "+self.latest_h5_filename +" &")
 
-                # Open index_html
-                os.system("firefox /gpfs/current/processed/index.html")
-
-                # Create diffraction snapshots
-                os.system(
-                    "python3 /gpfs/local/shared/MXCuBE/hdf5tools/albula_api/generate_image.py --input "
-                    + self.latest_h5_filename
-                    + " --output "
-                    + os.path.join(
-                        basepath, prefix, "rotational_" + str(runno).zfill(3)
-                    )
-                    + "/"
-                    + " --image_number 1"
-                )
-
+        #                # Open index_html
+        #                os.system("firefox /gpfs/current/processed/index.html")
+        #
+        #                # Create diffraction snapshots
+        #                os.system(
+        #                    "python3 /gpfs/local/shared/MXCuBE/hdf5tools/albula_api/generate_image.py --input "
+        #                    + self.latest_h5_filename
+        #                    + " --output "
+        #                    + os.path.join(
+        #                        basepath, prefix, "rotational_" + str(runno).zfill(3)
+        #                    )
+        #                    + "/"
+        #                    + " --image_number 1"
+        #                )
+        #
         except RuntimeError:
             self.log.error(traceback.format_exc())
         finally:
@@ -339,21 +349,28 @@ def collect_std_collection(self, start_angle, stop_angle):
         :param stop_angle: The stop_angle parameter is the final angle at which the collection should
         stop
         """
+        HWR.beamline.diffractometer.wait_omega()
 
-        self.omega_mv(start_angle, self.default_speed)
+        start_pos = start_angle - self.turnback_time * self.acq_speed
+        stop_pos = stop_angle + self.turnback_time * self.acq_speed
 
         self.log.debug("#COLLECT# Running OMEGA through the std acquisition")
         if start_angle <= stop_angle:
             self.lower_bound_ch.set_value(start_angle)
             self.upper_bound_ch.set_value(stop_angle)
+
         else:
             self.lower_bound_ch.set_value(stop_angle)
             self.upper_bound_ch.set_value(start_angle)
-        self.acq_arm_cmd()
 
-        final_pos = stop_angle + self.acq_speed * self.turnback_time
-
-        self.omega_mv(final_pos, self.acq_speed)
+        self.omega_mv(start_pos, self.default_speed)
+        self.acq_arm_cmd()
+        self.omega_mv(stop_pos, self.acq_speed)
+        time.sleep(0.5)
+        self.acq_off_cmd()
+        self.acq_window_off_cmd()
+        self.omega_mv(stop_angle, self.acq_speed)
+        HWR.beamline.diffractometer.wait_omega()
 
     def collect_characterisation(
         self, start_angle, img_range, nimages, angle_inc, exp_time
@@ -374,35 +391,49 @@ def collect_characterisation(
 
         diffr = HWR.beamline.diffractometer
 
-        self.log.debug("#COLLECT# Running OMEGA through the char acquisition")
+        self.log.debug(
+            "#COLLECT# Running OMEGA through the characteristation acquisition"
+        )
 
         self.omega_mv(start_angle, self.default_speed)
 
         for img_no in range(nimages):
             print("collecting image %s" % img_no)
             start_at = start_angle + angle_inc * img_no
             stop_angle = start_at + img_range * 1.0
+            # print("======= CHARACTERISATION Adding angle and range to the header...")
+            # Add start angle to the header
+            # detector = HWR.beamline.detector
+            # detector.set_eiger_start_angle(start_at)
+
+            # Add angle increment to the header
+            # detector.set_eiger_angle_increment(angle_inc)
+
             print("collecting image %s, angle %f" % (img_no, start_at))
 
             if start_at >= stop_angle:
-                init_pos = start_at - self.acq_speed * self.turnback_time
+                init_pos = start_at  # - self.acq_speed * self.turnback_time
                 # init_pos = start_at - 1.5
             else:
-                init_pos = start_at + self.acq_speed * self.turnback_time
+                init_pos = start_at  # + self.acq_speed * self.turnback_time
                 # init_pos = start_at + 1.5
-            self.omega_mv(init_pos, self.default_speed)
-            self.collect_std_collection(start_angle, stop_angle)
 
-            diffr.set_omega_velocity(self.default_speed)
-            self.acq_window_off_cmd()
-            self.acq_off_cmd()
+            # self.omega_mv(init_pos, self.default_speed)
+            self.collect_std_collection(start_at, stop_angle)
+
+            # This part goes to standard collection. Otherwise it produces phantom openings.
+            # diffr.set_omega_velocity(self.default_speed)
+            # self.acq_window_off_cmd()
+            # self.acq_off_cmd()
             self.log.debug(
                 "======= collect_characterisation  Waiting ======================================="
             )
 
             # Let adxv know whether it is
             # self.adxv_notify(self.latest_h5_filename,img_no+1)
 
+            # time.sleep(1)
+
     def adxv_notify(self, image_filename, image_num=1):
         """
         The `adxv_notify` function sends a notification to an ADXV to load an image file and
@@ -439,12 +470,17 @@ def acquisition_cleanup(self):
         try:
             diffr = HWR.beamline.diffractometer
             detector = HWR.beamline.detector
-            diffr.set_omega_velocity(self.default_speed)
-            self.acq_window_off_cmd()
+            detector.stop_acquisition()
+            diffr.wait_omega()
+            # =================
+            # It is probably already finished in a standard collection.
             self.acq_off_cmd()
+            self.acq_window_off_cmd()
+            # ==================
+            diffr.set_omega_velocity(self.default_speed)
             self.log.debug("#COLLECT# Closing detector cover")
             diffr.detector_cover_close(wait=True)
-            detector.stop_acquisition()
+
         except RuntimeError:
             self.log.error(traceback.format_exc())
 
@@ -509,7 +545,7 @@ def add_h5_info(self, h5file):
                     del h5fd[node]
             h5fd.close()
 
-        except RuntimeError as err_msg:
+        except RuntimeWarning as err_msg:
             self.log.debug("Error while adding info to HDF5 file (%s)" % str(err_msg))
             self.log.debug(traceback.format_exc())
 

mxcubecore/HardwareObjects/DESY/P11DetectorCover.py

@@ -44,13 +44,14 @@ class P11DetectorCover(AbstractShutter):
 
     @unique
     class BaseValueEnum(Enum):
-     """Defines only the compulsory values."""
-     OPEN = "OPEN"
-     CLOSED = "CLOSED"
-     MOVING = "MOVING"
-     UNKNOWN = "UNKNOWN"
-
-    VALUES=BaseValueEnum
+        """Defines only the compulsory values."""
+
+        OPEN = "OPEN"
+        CLOSED = "CLOSED"
+        MOVING = "MOVING"
+        UNKNOWN = "UNKNOWN"
+
+    VALUES = BaseValueEnum
 
     def __init__(self, name):
 
@@ -196,14 +197,8 @@ def simulated_update(self):
 
         self.update_value(value)
         return value
-
-    def is_open(self):
-        """Check if the shutter is open.
-        Returns:
-            (bool): True if open, False otherwise.
-        """
-        return self.get_value() == self.VALUES.OPEN
 
+    @property
     def is_closed(self):
         """Check if the shutter is closed.
         Returns:

mxcubecore/HardwareObjects/DESY/P11EDNACharacterisation.py

@@ -47,6 +47,23 @@ def __init__(self, name):
         self.edna_default_file = None
         self.start_edna_command = None
 
+    def _run_edna(self, input_file, results_file, process_directory):
+        """Starts EDNA"""
+        msg = "Starting EDNA characterisation using xml file %s" % input_file
+        logging.getLogger("queue_exec").info(msg)
+
+        args = (self.start_edna_command, input_file, results_file, process_directory)
+        # subprocess.call("%s %s %s %s" % args, shell=True)
+
+        # Test run DESY
+        self.edna_maxwell(process_directory, input_file, results_file)
+
+        self.result = None
+        if os.path.exists(results_file):
+            self.result = XSDataResultMXCuBE.parseFile(results_file)
+
+        return self.result
+
     def edna_maxwell(self, process_directory, inputxml, outputxml):
         """
         The function `edna_maxwell` is used to execute a command on a remote cluster using SSH and SBATCH.
@@ -105,6 +122,12 @@ def edna_maxwell(self, process_directory, inputxml, outputxml):
             )
         )
 
+        print(
+            '{ssh:s} "{sbatch:s} --wrap \\"{cmd:s}"\\"'.format(
+                ssh=ssh, sbatch=sbatch, cmd=cmd
+            )
+        )
+
         os.system(
             '{ssh:s} "{sbatch:s} --wrap \\"{cmd:s}"\\"'.format(
                 ssh=ssh, sbatch=sbatch, cmd=cmd
@@ -236,15 +259,24 @@ def input_from_params(self, data_collection, char_params):
         acquisition_parameters = data_collection.acquisitions[0].acquisition_parameters
         path_template = data_collection.acquisitions[0].path_template
 
+        # Make sure there is a proper path conversion between different mount points
+        print(
+            "======= Characterisation path template ====", path_template.directory
+        )  # /gpfs/current/raw
+
         image_dir = path_template.directory.replace(
             "/gpfs/current", triggerUtils.get_beamtime_metadata()[2]
         )
 
+        print(image_dir)
+
         path_str = os.path.join(image_dir, path_template.get_image_file_name())
+        print(path_template.xds_dir)
 
         characterisation_dir = path_template.xds_dir.replace(
             "/autoprocessing_", "/characterisation_"
         )
+
         os.makedirs(characterisation_dir, mode=0o755, exist_ok=True)
 
         for img_num in range(int(acquisition_parameters.num_images)):

mxcubecore/HardwareObjects/DESY/P11FastShutter.py

@@ -67,9 +67,11 @@ def init(self):
     def get_value(self):
         return self.update_fast_shutter()
 
+    @property
     def is_open(self):
         return self.get_value() == self.VALUES.OPEN
 
+    @property
     def is_closed(self):
         return self.get_value() == self.VALUES.CLOSED