nbs-bl 0.2.0__py3-none-any.whl

nbs_bl/detectors.py

@@ -0,0 +1,89 @@
+from .help import add_to_func_list
+from .beamline import GLOBAL_BEAMLINE
+
+
+def get_active_detectors():
+    return GLOBAL_BEAMLINE.detectors.active
+
+
+@add_to_func_list
+def activate_detector(det_or_name, role=None):
+    """Activate a detector so that is is measured by default
+
+    Parameters
+    ----------
+    det_or_name : device or str
+        Either a device, or the name of a device in the global
+        detector buffer
+
+    """
+    # Todo: take a list
+    GLOBAL_BEAMLINE.detectors.activate(det_or_name, role)
+
+
+@add_to_func_list
+def list_detectors(verbose=False):
+    """List all global detectors, optionally provide text descriptions
+
+    Parameters
+    ----------
+    describe : Bool
+        If True, print the text description of each detector
+
+    """
+
+    def textFunction(group, key, device):
+        text = f"{key}: {device.name}; {group.status[key]}"
+        return text
+
+    GLOBAL_BEAMLINE.detectors.describe(verbose, textFunction)
+
+
+@add_to_func_list
+def disable_detector(det_or_name):
+    """Disable a detector so that it is not measured, and will not be activated
+
+    Parameters
+    ----------
+    det_or_name : device or str
+        Either a device, or the name of a device in the global
+        detector buffer
+
+    """
+    GLOBAL_BEAMLINE.detectors.disable(det_or_name)
+
+
+@add_to_func_list
+def enable_detector(det_or_name, activate=True):
+    """Enable a detector so that it can be activated
+
+    Parameters
+    ----------
+    det_or_name : device or str
+        Either a device, or the name of a device in the global
+        detector buffer
+    activate : Bool
+        If True, also activate the detector when it is enabled
+    """
+
+    GLOBAL_BEAMLINE.detectors.enable(det_or_name, activate)
+
+
+@add_to_func_list
+def deactivate_detector(det_or_name):
+    """Deactivate a detector so that it is not measured by default
+
+    Parameters
+    ----------
+    det_or_name : device or str
+        Either a device, or the name of a device in the global
+        detector buffer
+
+    """
+
+    GLOBAL_BEAMLINE.detectors.deactivate(det_or_name)
+
+
+@add_to_func_list
+def activate_detector_set(name):
+    GLOBAL_BEAMLINE.detectors.activate_set(name)

nbs_bl/devices/__init__.py

@@ -0,0 +1,12 @@
+from .detectors import ophScalar
+from .motors import (
+    FlyableMotor,
+    DeadbandEpicsMotor,
+    DeadbandPVPositioner,
+    DeadbandMixin,
+    PseudoSingle,
+    FlyerMixin,
+)
+from .shutters import EPS_Shutter, ShutterSet
+from .slits import Slits
+from .sampleholders import Manipulator1AxBase, Manipulator4AxBase

nbs_bl/devices/detectors.py

@@ -0,0 +1,154 @@
+from ophyd import Device, Component as Cpt, EpicsSignal, Signal
+from ophyd.status import DeviceStatus
+import threading
+from queue import Queue, Empty
+import time
+import numpy as np
+
+
+class ScalarBase(Device):
+    exposure_time = Cpt(Signal, value=1, name="exposure_time", kind="config")
+    mean = Cpt(Signal, name="", value=0, kind="hinted")
+    median = Cpt(Signal, name="median", value=0, kind="omitted")
+    std = Cpt(Signal, name="std", value=0, kind="omitted")
+    npts = Cpt(Signal, name="points", value=0, kind="omitted")
+    sum = Cpt(Signal, name="sum", value=0, kind="omitted")
+    rescale = Cpt(Signal, value=1, name="rescale", kind="config")
+    offset = Cpt(Signal, value=0, name="offset", kind="config")
+    gain = Cpt(Signal, value=1, name="gain", kind="config")
+
+    def __init__(self, *args, rescale=1, **kwargs):
+        self._flying = False
+        self._measuring = False
+        self._reading = False
+        self._flyer_buffer = []
+        self._flyer_time_buffer = []
+        super().__init__(*args, **kwargs)
+        self.mean.name = self.name
+        self.rescale.set(rescale).wait(timeout=60)
+        if "gain" in kwargs:
+            self.gain.set(kwargs["gain"]).wait(timeout=60)
+
+    def kickoff(self):
+        self._flyer_buffer = []
+        self._flyer_time_buffer = []
+        self._flyer_timestamp_buffer = []
+        self._flyer_queue = Queue()
+        kickoff_st = DeviceStatus(device=self)
+        kickoff_st.set_finished()
+        self._flying = True
+        if not self._measuring:
+            self.target.subscribe(self._aggregate, run=False)
+            self._measuring = True
+
+        return kickoff_st
+
+    def stage(self):
+        self._secret_buffer = []
+        self._secret_time_buffer = []
+        self._buffer = []
+        self._time_buffer = []
+        self._reading = True
+        if not self._measuring:
+            self.target.subscribe(self._aggregate, run=False)
+            self._measuring = True
+        return super().stage()
+
+    def unstage(self):
+        if self._measuring:
+            self.target.clear_sub(self._aggregate)
+            self._measuring = False
+        self._reading = False
+        return super().unstage()
+
+    def set_exposure(self, exp_time):
+        self.exposure_time.set(exp_time).wait(timeout=60)
+
+    def _aggregate(self, value, **kwargs):
+        scale_value = value * self.rescale.get() - self.offset.get()
+        t = time.time()
+        if self._reading:
+            self._buffer.append(scale_value)
+            self._time_buffer.append(t)
+        if self._flying:
+            event = dict()
+            event["time"] = t
+            event["data"] = dict()
+            event["timestamps"] = dict()
+            event["data"][self.name] = scale_value
+            event["timestamps"][self.name] = kwargs.get("timestamp", t)
+            self._flyer_buffer.append(scale_value)
+            self._flyer_time_buffer.append(t)
+            self._flyer_timestamp_buffer.append(kwargs.get("timestamp", t))
+            self._flyer_queue.put(event)
+
+    def _acquire(self, status):
+        self._buffer = []
+        self._time_buffer = []
+        time.sleep(self.exposure_time.get())
+        if len(self._buffer) == 0:
+            ntry = 10
+            n = 0
+            while len(self._buffer) < 1:
+                time.sleep(0.1 * self.exposure_time.get())
+                n += 1
+                if n > ntry:
+                    break
+        buf = np.array(self._buffer)
+        tbuf = np.array(self._time_buffer[: len(buf)])
+        if len(buf) == 0:
+            self.mean.put(np.nan)
+            self.median.put(np.nan)
+            self.std.put(np.nan)
+            self.npts.put(0)
+            self.sum.put(np.nan)
+
+        else:
+            self.mean.put(np.mean(buf))
+            self.median.put(np.median(buf))
+            self.std.put(np.std(buf))
+            self.npts.put(len(buf))
+            self.sum.put(np.sum(buf))
+        self._secret_buffer.append(buf)
+        self._secret_time_buffer.append(tbuf)
+        status.set_finished()
+        return
+
+    def trigger(self):
+        status = DeviceStatus(self)
+        threading.Thread(target=self._acquire, args=(status,), daemon=True).start()
+        return status
+
+    def collect(self):
+        events = []
+        while True:
+            try:
+                e = self._flyer_queue.get_nowait()
+                events.append(e)
+            except Empty:
+                break
+        yield from events
+
+    def complete(self):
+        self._flying = False
+        if self._measuring:
+            self.target.clear_sub(self._aggregate)
+            self._measuring = False
+        completion_status = DeviceStatus(self)
+        completion_status.set_finished()
+        return completion_status
+
+    def describe_collect(self):
+        dd = dict(
+            {self.name: {"source": self.target.pvname, "dtype": "number", "shape": []}}
+        )
+        return {self.name + "_monitor": dd}
+
+    def get_plot_hints(self):
+        return [self.mean.name]
+
+
+class ophScalar(ScalarBase):
+    """Generic Scalar.  Give full path to target PV during object creation"""
+
+    target = Cpt(EpicsSignal, "", kind="omitted")

nbs_bl/devices/motors.py

@@ -0,0 +1,242 @@
+from queue import Queue, Empty
+import time
+from datetime import datetime
+import threading
+
+from ophyd import EpicsMotor, Signal, PositionerBase, Device
+from ophyd.pv_positioner import PVPositioner
+from ophyd import Component as Cpt
+from ophyd.status import wait as status_wait, DeviceStatus
+from ophyd import PseudoSingle as _PS
+
+
+class FlyerMixin:
+
+    def __init__(self, *args, **kwargs):
+        self._ready_to_fly = False
+        self._fly_move_st = None
+        self._default_time_resolution = 0.1
+        self._time_resolution = None
+        super().__init__(*args, **kwargs)
+
+    # Flyer motor methods
+    def preflight(self, start, stop, speed=None, time_resolution=None):
+        self._old_velocity = self.velocity.get()
+        self._flyer_stop = stop
+        st = self.move(start)
+        if speed is None:
+            speed = self._old_velocity
+        self.velocity.set(speed).wait()
+        if time_resolution is not None:
+            self._time_resolution = time_resolution
+        else:
+            self._time_resolution = self._default_time_resolution
+        self._last_readback_value = start
+        self._ready_to_fly = True
+        return st
+
+    def fly(self):
+        """
+        Should be called after all detectors start flying, so that we don't lose data
+        """
+        if not self._ready_to_fly:
+            self._fly_move_st = DeviceStatus(device=self)
+            self._fly_move_st.set_finished(success=False)
+        else:
+            self._fly_move_st = self.move(self._flyer_stop, wait=False)
+            self._flying = True
+            self._ready_to_fly = False
+        return self._fly_move_st
+
+    def land(self):
+        if self._fly_move_st.done:
+            self.velocity.set(self._old_velocity).wait()
+            self._flying = False
+            self._time_resolution = None
+
+    # Flyer detector methods for readback
+    def kickoff(self):
+        kickoff_st = DeviceStatus(device=self)
+        self._flyer_queue = Queue()
+        self._measuring = True
+        self._flyer_buffer = []
+        threading.Thread(target=self._aggregate, daemon=True).start()
+        # self.user_readback.subscribe(self._aggregate, run=False)
+        kickoff_st.set_finished()
+        return kickoff_st
+
+    def _aggregate(self):
+        name = self.user_readback.name
+        while self._measuring:
+            t = time.time()
+            rb = self.user_readback.read()
+            value = rb[name]["value"]
+            ts = rb[name]["timestamp"]
+            self._flyer_buffer.append(value)
+            event = dict()
+            event["time"] = t
+            event["data"] = dict()
+            event["timestamps"] = dict()
+            event["data"][name] = value
+            event["timestamps"][name] = ts
+            self._flyer_queue.put(event)
+            time.sleep(self._time_resolution)
+        return
+
+    def collect(self):
+        events = []
+        while True:
+            try:
+                e = self._flyer_queue.get_nowait()
+                events.append(e)
+            except Empty:
+                break
+        yield from events
+
+    def complete(self):
+        if self._measuring:
+            # self.user_readback.clear_sub(self._aggregate)
+            self._measuring = False
+        completion_status = DeviceStatus(self)
+        completion_status.set_finished()
+        self._time_resolution = None
+        return completion_status
+
+    def describe_collect(self):
+        if hasattr(self, "user_readback"):
+            readback = self.user_readback
+        else:
+            readback = self.readback
+            
+        dd = dict(
+            {
+                readback.name: {
+                    "source": readback.pvname,
+                    "dtype": "number",
+                    "shape": [],
+                }
+            }
+        )   
+        return {self.name + "_monitor": dd}
+
+
+class DeadbandMixin(Device, PositionerBase):
+    """
+    Should be the leftmost class in the inheritance list so that it grabs move first!
+
+    Must be combined with either EpicsMotor or PVPositioner, or some other class
+    that has a done_value attribute
+
+    An EpicsMotor subclass that has an absolute tolerance for moves.
+    If the readback is within tolerance of the setpoint, the MoveStatus
+    is marked as finished, even if the motor is still settling.
+
+    This prevents motors with long, but irrelevant, settling times from
+    adding overhead to scans.
+    """
+
+    tolerance = Cpt(Signal, value=-1, kind="config")
+    move_latch = Cpt(Signal, value=0, kind="omitted")
+
+    def __init__(self, *args, tolerance=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        if tolerance is not None:
+            self.tolerance.put(tolerance)
+
+    def _done_moving(self, success=True, timestamp=None, value=None, **kwargs):
+        """Call when motion has completed.  Runs ``SUB_DONE`` subscription."""
+        if self.move_latch.get():
+            #print(f"{timestamp} {datetime.today().time().isoformat()} [{self.name}]: marked done")
+            if success:
+                self._run_subs(sub_type=self.SUB_DONE, timestamp=timestamp, value=value)
+
+            self._run_subs(
+                sub_type=self._SUB_REQ_DONE, success=success, timestamp=timestamp
+            )
+            self._reset_sub(self._SUB_REQ_DONE)
+            self.move_latch.put(0)
+
+    def move(self, position, wait=True, **kwargs):
+        tolerance = self.tolerance.get()
+
+        if tolerance < 0:
+            self.move_latch.put(1)
+            return super().move(position, wait=wait, **kwargs)
+        else:
+            status = super().move(position, wait=False, **kwargs)
+            setpoint = position
+            done_value = getattr(self, "done_value", 1)
+
+            def check_deadband(value, timestamp, **kwargs):
+                if abs(value - setpoint) < tolerance:
+                    #print(f"{timestamp} {datetime.today().time().isoformat()} [{self.name}]: {value} within {tolerance} of {setpoint}")
+                    self._done_moving(
+                        timestamp=timestamp, success=True, value=done_value
+                    )
+                else:
+                    pass
+                    # print(f"{timestamp}: {self.name}, {value} not within {tolerance} of {setpoint}")
+
+            def clear_deadband(*args, **kwargs):
+                # print(f"{timestamp}: Ran deadband clear for {self.name}")
+                self.clear_sub(check_deadband, event_type=self.SUB_READBACK)
+
+            self.subscribe(clear_deadband, event_type=self._SUB_REQ_DONE, run=False)
+            self.move_latch.put(1)
+            self.subscribe(check_deadband, event_type=self.SUB_READBACK, run=True)
+
+            try:
+                if wait:
+                    status_wait(status)
+            except KeyboardInterrupt:
+                self.stop()
+                raise
+
+            return status
+
+
+class DeadbandEpicsMotor(DeadbandMixin, EpicsMotor):
+    """
+    An EpicsMotor subclass that has an absolute tolerance for moves.
+    If the readback is within tolerance of the setpoint, the MoveStatus
+    is marked as finished, even if the motor is still settling.
+
+    This prevents motors with long, but irrelevant, settling times from
+    adding overhead to scans.
+
+    This class is designed to be subclassed.
+    """
+
+    pass
+
+
+class DeadbandPVPositioner(DeadbandMixin, PVPositioner):
+    """
+    A PVPositioner subclass that has an absolute tolerance for moves.
+    If the readback is within tolerance of the setpoint, the MoveStatus
+    is marked as finished, even if the motor is still settling.
+
+    This prevents motors with long, but irrelevant, settling times from
+    adding overhead to scans.
+
+    This class is designed to be subclassed.
+    """
+
+    pass
+
+
+class FlyableMotor(EpicsMotor, FlyerMixin):
+    pass
+
+
+class PseudoSingle(_PS):
+    """
+    A PseudoSingle subclass that casts positions to a float in order to ensure
+    that motor values don't get interpreted as int by Bluesky/Tiled.
+
+    If the first motor value is an int (i.e, 700 eV for the mono), Tiled will
+    try to cast all subsequent motor positions to an int as well.
+    """
+
+    def move(self, position, *args, **kwargs):
+        return super().move(float(position), *args, **kwargs)