Example #1
0
def test_timeout(RE):
    from ophyd.positioner import SoftPositioner
    from ophyd.sim import SynGauss
    from ophyd import StatusBase

    mot = SoftPositioner(name='mot')
    mot.set(0)
    det = SynGauss('det', mot, 'mot', 0, 3)

    def kickoff():
        # This process should take a total of 5 seconds, but it will be
        # interrupted after 0.1 seconds via the timeout keyword passed to
        # ramp_plan below.
        yield Msg('null')
        for j in range(100):
            RE.loop.call_later(.05 * j, lambda j=j: mot.set(j))

        return StatusBase()

    def inner_plan():
        yield from trigger_and_read([det])

    g = ramp_plan(kickoff(), mot, inner_plan, period=.01, timeout=.1)

    start = time.time()
    with pytest.raises(RampFail):
        RE(g)
    stop = time.time()
    elapsed = stop - start

    # This test has a tendency to randomly fail, so we're giving it plenty of
    # time to run. 4, though much greater than 0.1, is still less than 5.
    assert .1 < elapsed < 4
Example #2
0
def test_timeout(RE):
    from ophyd.positioner import SoftPositioner
    from bluesky.examples import SynGauss
    from ophyd import StatusBase

    mot = SoftPositioner(name='mot')
    mot.set(0)
    det = SynGauss('det', mot, 'mot', 0, 3)

    def kickoff():
        yield Msg('null')
        for j in range(5):
            RE.loop.call_later(.05 * j, lambda j=j: mot.set(j))

        return StatusBase()

    def inner_plan():
        yield from trigger_and_read([det])

    g = ramp_plan(kickoff(), mot, inner_plan, period=.01, timeout=.1)

    start = time.time()
    with pytest.raises(RampFail):
        RE(g)
    stop = time.time()
    elapsed = stop - start

    assert .1 < elapsed < .2
Example #3
0
def test_timeout(RE):
    from ophyd.positioner import SoftPositioner
    from bluesky.examples import SynGauss
    from ophyd import StatusBase

    mot = SoftPositioner(name='mot')
    mot.set(0)
    det = SynGauss('det', mot, 'mot', 0, 3)

    def kickoff():
        # This process should take a total of 0.5 seconds, but it will be
        # interrupted after 0.1 seconds via the timeout keyword passed to
        # ramp_plan below.
        yield Msg('null')
        for j in range(10):
            RE.loop.call_later(.05 * j, lambda j=j: mot.set(j))

        return StatusBase()

    def inner_plan():
        yield from trigger_and_read([det])

    g = ramp_plan(kickoff(), mot, inner_plan, period=.01, timeout=.1)

    start = time.time()
    with pytest.raises(RampFail):
        RE(g)
    stop = time.time()
    elapsed = stop - start

    assert .1 < elapsed < .4
Example #4
0
def test_ramp(RE):
    from ophyd.positioner import SoftPositioner
    from ophyd import StatusBase
    from ophyd.sim import SynGauss

    tt = SoftPositioner(name='mot')
    tt.set(0)
    dd = SynGauss('det', tt, 'mot', 0, 3)

    st = StatusBase()

    def kickoff():
        yield Msg('null')
        for j, v in enumerate(np.linspace(-5, 5, 10)):
            RE.loop.call_later(.1 * j, lambda v=v: tt.set(v))
        RE.loop.call_later(1.2, st._finished)
        return st

    def inner_plan():
        yield from trigger_and_read([dd])

    g = ramp_plan(kickoff(), tt, inner_plan, period=0.08)
    db = DocCollector()
    RE.subscribe(db.insert)
    rs = RE(g)
    if RE.call_returns_result:
        uid = rs.run_start_uids[0]
    else:
        uid = rs[0]
    assert db.start[0]['uid'] == uid
    assert len(db.descriptor[uid]) == 2
    descs = {d['name']: d for d in db.descriptor[uid]}

    assert set(descs) == set(['primary', 'mot_monitor'])

    primary_events = db.event[descs['primary']['uid']]
    assert len(primary_events) > 11

    monitor_events = db.event[descs['mot_monitor']['uid']]
    # the 10 from the updates, 1 from 'run at subscription time'
    assert len(monitor_events) == 11
Example #5
0
def test_ramp(RE, db):
    from ophyd.positioner import SoftPositioner
    from ophyd import StatusBase
    from bluesky.examples import SynGauss

    tt = SoftPositioner(name='mot')
    tt.set(0)
    dd = SynGauss('det', tt, 'mot', 0, 3)

    st = StatusBase()

    def kickoff():
        yield Msg('null')
        for j, v in enumerate(np.linspace(-5, 5, 10)):
            RE.loop.call_later(.1 * j, lambda v=v: tt.set(v))
        RE.loop.call_later(1.2, st._finished)
        return st

    def inner_plan():
        yield from trigger_and_read([dd])

    g = ramp_plan(kickoff(), tt, inner_plan, period=0.08)
    RE.subscribe('all', db.mds.insert)
    RE.msg_hook = MsgCollector()
    rs_uid, = RE(g)
    hdr = db[-1]
    assert hdr.start.uid == rs_uid
    assert len(hdr.descriptors) == 2

    assert set([d['name'] for d in hdr.descriptors]) == \
        set(['primary', 'mot_monitor'])

    primary_events = list(db.get_events(hdr, stream_name='primary'))
    assert len(primary_events) > 11

    monitor_events = list(db.get_events(hdr, stream_name='mot_monitor'))
    assert len(monitor_events) == 10
Example #6
0
def test_ramp(RE, db):
    from ophyd.positioner import SoftPositioner
    from ophyd import StatusBase
    from bluesky.examples import SynGauss

    tt = SoftPositioner(name="mot")
    tt.set(0)
    dd = SynGauss("det", tt, "mot", 0, 3)

    st = StatusBase()

    def kickoff():
        yield Msg("null")
        for j, v in enumerate(np.linspace(-5, 5, 25)):
            RE.loop.call_later(0.05 * j, lambda v=v: tt.set(v))
        RE.loop.call_later(0.05 * 30, st._finished)
        return st

    def inner_plan():
        yield from trigger_and_read([dd])

    g = ramp_plan(kickoff(), tt, inner_plan, period=0.04)
    RE.subscribe("all", db.mds.insert)
    RE.msg_hook = MsgCollector()
    rs_uid, = RE(g)
    hdr = db[-1]
    assert hdr.start.uid == rs_uid
    assert len(hdr.descriptors) == 2

    assert set([d["name"] for d in hdr.descriptors]) == set(["primary", "mot-monitor"])

    primary_events = list(db.get_events(hdr, stream_name="primary"))
    assert len(primary_events) > 27

    monitor_events = list(db.get_events(hdr, stream_name="mot-monitor"))
    assert len(monitor_events) == 25
Example #7
0
class SimEvrScan:
    _motor = motor1
    _evr = SoftPositioner(name='EVR:TDES')
    _RE = RunEngine({})
    _scan_id = None

    @property
    def scan_id(self):
        return self._scan_id

    @scan_id.setter
    def scan_id(self, uid):
        self._scan_id = uid

    def start(self, evr_start, evr_stop, evr_steps, motor_start, motor_stop,
              motor_steps):
        """Set TDES, then scan the x motor"""
        return grid_scan([det1], self._evr, evr_start, evr_stop, evr_steps,
                         self._motor, motor_start, motor_stop, motor_steps)
Example #8
0
# def ramp_plan(go_plan, monitor_sig, inner_plan_func,
# take_pre_data=True, timeout=None, period=None, md=None)
from databroker import Broker
from bluesky.plans import ramp_plan
from bluesky.plan_stubs import trigger_and_read
from bluesky import Msg
from bluesky.utils import RampFail
import numpy as np
import time

from ophyd.positioner import SoftPositioner
from ophyd import StatusBase
from ophyd.sim import SynGauss

tt = SoftPositioner(name='mot')
tt.set(0)
dd = SynGauss('det', tt, 'mot', 0, 3)

st = StatusBase()


def kickoff():
    yield Msg('null')
    for j, v in enumerate(np.linspace(-2, 2, 10)):
        RE.loop.call_later(.1 * j, lambda v=v: tt.set(v))
    RE.loop.call_later(1.2, st._finished)
    return st


def inner_plan():