P11 develop

mxcubecore/HardwareObjects/DESY/P11Collect.py

@@ -39,24 +39,42 @@
 
 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
 
 
 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.filter_server_name = self.get_property("filterserver")
-        self.mono_server_name = self.get_property("monoserver")
+        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,26 +84,9 @@ 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,
-            self.acq_arm_cmd,
-            self.acq_on_cmd,
-            self.acq_off_cmd,
-            self.acq_window_off_cmd,
-        ]:
+        if None in [self.lower_bound_ch, self.upper_bound_ch,
+                    self.acq_arm_cmd, self.acq_on_cmd, self.acq_off_cmd,
+                    self.acq_window_off_cmd]:
             self.init_ok = False
             self.log.debug("lower_bound_ch: %s" % self.lower_bound_ch)
             self.log.debug("upper_bound_ch: %s" % self.upper_bound_ch)
@@ -95,7 +96,6 @@ def init(self):
             self.log.debug("acq_window_off_cmd: %s" % self.acq_window_off_cmd)
         else:
             self.init_ok = True
-
     @task
     def move_motors(self, motor_position_dict):
         HWR.beamline.diffractometer.wait_omega()
@@ -339,21 +339,32 @@ 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)
+                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()
+                self.lower_bound_ch.set_value(stop_angle)
+                self.upper_bound_ch.set_value(start_angle)
 
-        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,34 +385,44 @@ 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.log.debug(
-                "======= collect_characterisation  Waiting ======================================="
-            )
+            # 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
+            #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):
         """
@@ -439,12 +460,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())
 

mxcubecore/HardwareObjects/DESY/P11DetectorCover.py

@@ -197,13 +197,7 @@ 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/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
 

mxcubecore/HardwareObjects/DESY/P11ISPyBClient.py

@@ -26,8 +26,6 @@ def init(self):
             "PROPOSAL NUMBER is %s" % self.simulated_prop_number
         )
 
-        self.loginType = "user"
-
     def update_data_collection(self, mx_collection, wait=False):
         mx_collection["beamline_name"] = "P11"
         ISPyBClient.update_data_collection(self, mx_collection, wait)

mxcubecore/HardwareObjects/DESY/P11NanoDiff.py

@@ -737,9 +737,9 @@ def detector_cover_close(self, wait=True):
     def wait_detcover(self, state, timeout=60):
         start_time = time.time()
         while time.time() - start_time > timeout:
-            if state == "open" and self.detcover_hwobj.is_open():
+            if state == "open" and self.detcover_hwobj.is_open:
                 break
-            elif state == "close" and self.detcover_hwobj.is_closed():
+            elif state == "close" and self.detcover_hwobj.is_closed:
                 break
             gevent.sleep(0.5)
 
@@ -802,8 +802,8 @@ def update_phase(self, value=None):
 
         omega_pos = self.get_omega_position()
 
-        cover_open = self.detcover_hwobj.is_open()
-        cover_closed = self.detcover_hwobj.is_closed()
+        cover_open = self.detcover_hwobj.is_open
+        cover_closed = self.detcover_hwobj.is_closed
         blight_in = self.backlight_hwobj.is_in()
         blight_out = self.backlight_hwobj.is_out()
         collim = self.collimator_hwobj.get_position()

mxcubecore/HardwareObjects/DESY/P11Session.py

@@ -85,8 +85,13 @@ def info_set_defaults(self):
         self.beamtime_info["rootPath"] = PATH_FALLBACK
 
     def is_beamtime_open(self):
-        return True
-        # return self.is_writable_dir( os.path.join(PATH_BEAMTIME, self.raw_data_folder_name) )
+        self.log.debug("=========== CHECKING IF BEAMTIME ID IS OPEN... ============")
+        if self.is_writable_dir(os.path.join(PATH_BEAMTIME, self.raw_data_folder_name)):
+            self.log.debug("=========== BEAMTIME IS OPEN (/gpfs/current exists) ============")
+        else:
+            self.log.debug("=========== NO BEMTIME ID IS OPEN (check /gpfs/current) ============")
+
+        return self.is_writable_dir( os.path.join(PATH_BEAMTIME, self.raw_data_folder_name) )
 
     def is_commissioning_open(self):
         return self.is_writable_dir(
@@ -111,6 +116,9 @@ def get_current_proposal_number(self):
             info = self.get_beamtime_info()
             return info["proposalId"]
 
+    def get_beamtime_info(self):
+        return self.beamtime_info
+
     def read_beamtime_info(self):
         self.log.debug("=========== READING BEAMTIME INFO ============")
         if os.path.exists(PATH_BEAMTIME):

mxcubecore/HardwareObjects/DESY/P11Shutter.py

@@ -22,6 +22,7 @@
 import gevent
 import urllib
 from mxcubecore.HardwareObjects.abstract.AbstractShutter import AbstractShutter
+import mxcubecore.HardwareObjects.abstract.AbstractShutter as absshut
 from mxcubecore.BaseHardwareObjects import HardwareObjectState
 from enum import Enum, unique
 
@@ -85,6 +86,8 @@ def init(self):
         else:
             self.simulated_update()
 
+        self.update_state(self.STATES.READY)
+
         super(AbstractShutter, self).init()
 
     def get_value(self):
@@ -105,25 +108,39 @@ def _set_value(self, value):
         if self.simulation:
             self.simulated_opened = open_it
             self.simulated_moving = True
-            gevent.spawn(self.simul_do)
+            self.t1 = gevent.spawn(self.simul_do)
+            self.t1.link(self.do_finish) 
+            self.t1.link_exception(self.do_finish_exc) 
         else:
             if open_it:
                 self.do_open()
             else:
                 self.do_close()
             self.cmd_started = time.time()
+        self.log.debug(" ###  setting value value for shutter done")
 
     def do_open(self, timeout=3):
+        self.log.debug(" OPENING SHUTTER (web request)")
         result = urllib.request.urlopen(self.url_open, None, timeout).readlines()
+        self.log.debug(" OPENING SHUTTER (web request) retured")
 
     def do_close(self, timeout=3):
+        self.log.debug(" CLOSING SHUTTER (web request)")
         result = urllib.request.urlopen(self.url_close, None, timeout).readlines()
+        self.log.debug(" CLOSING SHUTTER (web request) retured")
 
     def simul_do(self):
+        self.log.debug("### starting simulated shutter move")
         gevent.sleep(1)
         self.simulated_moving = False
         self.log.debug("### updating simulated shutter")
         self.simulated_update()
+        self.log.debug("### ending simulated shutter move")
+
+    def do_finish(self, t=None):
+        self.log.debug("### simulated finished")
+    def do_finish_exc(self, exc=None):
+        self.log.debug("### simulated finished with exception")
 
     def update_shutter_state(self, state=None):
         """Updates shutter state 
@@ -133,9 +150,13 @@ def update_shutter_state(self, state=None):
         if state is None:
             state = self.chan_state.get_value()
 
+        self.log.debug(" SHUTTER state changed")
+
         if state[0] == 3:
+            self.log.debug(" P11SHUTTER IS OPEN")
             value = self.VALUES.OPEN
         else:
+            self.log.debug(" P11SHUTTER IS CLOSED")
             value = self.VALUES.CLOSED
 
         # else:
@@ -146,6 +167,7 @@ def update_shutter_state(self, state=None):
 
         self.update_value(value)
 
+        self.log.debug("  update shutter state done")
         return value
 
     def simulated_update(self):

mxcubecore/HardwareObjects/ISPyBClient.py

@@ -8,6 +8,7 @@
 from pprint import pformat
 from collections import namedtuple
 from datetime import datetime
+import warnings
 
 try:
     from urlparse import urljoin

mxcubecore/HardwareObjects/MotorsNPosition.py

@@ -121,7 +121,7 @@ def load_positions(self):
     def get_position_list(self):
         return list(self._positions.keys())
 
-    def get_properties_(self, position_index, property_name):
+    def get_properties(self, position_index, property_name):
         """
              returns property with name property_name for position_index 
              if position_index is None returns OrderedDict with property_name for all positions
@@ -161,7 +161,7 @@ def set_position(self, posname):
         posidx = -1
         for name in self._positions:
             posidx += 1
-            if posname == self.get_properties_(posidx, "posname"):
+            if posname == self.get_properties(posidx, "posname"):
                 self._set_value(posidx)
                 return