diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 984d8ef..5805b75 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -21,7 +21,7 @@ jobs: strategy: matrix: runs-on: ["ubuntu-latest"] # can add windows-latest, macos-latest - python-version: ["3.10", "3.11"] + python-version: ["3.11", "3.12"] include: # Include one that runs in the dev environment - runs-on: "ubuntu-latest" diff --git a/Dockerfile b/Dockerfile index c4404ec..bc6aa5d 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,6 +1,6 @@ # The devcontainer should use the developer target and run as root with podman # or docker with user namespaces. -ARG PYTHON_VERSION=3.11 +ARG PYTHON_VERSION=3.12 FROM python:${PYTHON_VERSION} as developer # Add any system dependencies for the developer/build environment here diff --git a/src/p99_bluesky/devices/epics/andor2_controller.py b/src/p99_bluesky/devices/epics/andor2_controller.py index 989c3d9..a4f4e06 100644 --- a/src/p99_bluesky/devices/epics/andor2_controller.py +++ b/src/p99_bluesky/devices/epics/andor2_controller.py @@ -1,6 +1,6 @@ import asyncio -from ophyd_async.core import DetectorControl, DetectorTrigger +from ophyd_async.core import DetectorController, DetectorTrigger from ophyd_async.core._detector import TriggerInfo from ophyd_async.epics import adcore from ophyd_async.epics.adcore import ( @@ -16,16 +16,16 @@ ) -class Andor2Controller(DetectorControl): +class Andor2Controller(DetectorController): """ Andor 2 controller """ _supported_trigger_types = { - DetectorTrigger.internal: Andor2TriggerMode.internal, - DetectorTrigger.constant_gate: Andor2TriggerMode.ext_trigger, - DetectorTrigger.variable_gate: Andor2TriggerMode.ext_FVP, + DetectorTrigger.INTERNAL: Andor2TriggerMode.INTERNAL, + DetectorTrigger.CONSTANT_GATE: Andor2TriggerMode.EXT_TRIGGER, + DetectorTrigger.VARIABLE_GATE: Andor2TriggerMode.EXT_FVP, } def __init__( @@ -51,9 +51,11 @@ async def prepare(self, trigger_info: TriggerInfo): await asyncio.gather( self._drv.trigger_mode.set(self._get_trigger_mode(trigger_info.trigger)), self._drv.num_images.set( - 999_999 if trigger_info.number == 0 else trigger_info.number + 999_999 + if trigger_info.total_number_of_triggers == 0 + else trigger_info.total_number_of_triggers ), - self._drv.image_mode.set(ImageMode.multiple), + self._drv.image_mode.set(ImageMode.MULTIPLE), ) async def arm(self) -> None: diff --git a/src/p99_bluesky/devices/epics/andor3_controller.py b/src/p99_bluesky/devices/epics/andor3_controller.py index 8531bdc..9056799 100644 --- a/src/p99_bluesky/devices/epics/andor3_controller.py +++ b/src/p99_bluesky/devices/epics/andor3_controller.py @@ -1,7 +1,7 @@ import asyncio from ophyd_async.core import ( - DetectorControl, + DetectorController, DetectorTrigger, ) from ophyd_async.core._detector import TriggerInfo @@ -19,16 +19,16 @@ ) -class Andor3Controller(DetectorControl): +class Andor3Controller(DetectorController): """ Andor 3 controller """ _supported_trigger_types = { - DetectorTrigger.internal: Andor3TriggerMode.internal, - DetectorTrigger.constant_gate: Andor3TriggerMode.ext_trigger, - DetectorTrigger.variable_gate: Andor3TriggerMode.ext_exposure, + DetectorTrigger.INTERNAL: Andor3TriggerMode.INTERNAL, + DetectorTrigger.CONSTANT_GATE: Andor3TriggerMode.EXT_TRIGGER, + DetectorTrigger.VARIABLE_GATE: Andor3TriggerMode.EXT_EXPOSURE, } def __init__( @@ -54,9 +54,11 @@ async def prepare(self, trigger_info: TriggerInfo): await asyncio.gather( self._drv.trigger_mode.set(self._get_trigger_mode(trigger_info.trigger)), self._drv.num_images.set( - 999_999 if trigger_info.number == 0 else trigger_info.number + 999_999 + if trigger_info.total_number_of_triggers == 0 + else trigger_info.total_number_of_triggers ), - self._drv.image_mode.set(ImageMode.fixed), + self._drv.image_mode.set(ImageMode.FIXED), ) async def arm(self) -> None: diff --git a/src/p99_bluesky/devices/epics/drivers/andor2_driver.py b/src/p99_bluesky/devices/epics/drivers/andor2_driver.py index 52c28a7..6ee3e1b 100644 --- a/src/p99_bluesky/devices/epics/drivers/andor2_driver.py +++ b/src/p99_bluesky/devices/epics/drivers/andor2_driver.py @@ -1,40 +1,34 @@ -from enum import Enum - +from ophyd_async.core import StrictEnum from ophyd_async.epics.adcore._core_io import ADBaseIO -from ophyd_async.epics.signal import ( +from ophyd_async.epics.core import ( epics_signal_r, epics_signal_rw, epics_signal_rw_rbv, ) -class Andor2TriggerMode(str, Enum): - internal = "Internal" - ext_trigger = "External" - ext_start = "External Start" - ext_exposure = "External Exposure" - ext_FVP = "External FVP" - soft = "Software" - - -class ImageMode(str, Enum): - single = "Single" - multiple = "Multiple" - continuous = "Continuous" - fast_kinetics = "Fast Kinetics" - - -class ADBaseDataType(str, Enum): - UInt16 = "UInt16" - UInt32 = "UInt32" - b1 = "" - b2 = "" - b3 = "" - b4 = "" - b5 = "" - b6 = "" - Float32 = "Float32" - Float64 = "Float64" +class Andor2TriggerMode(StrictEnum): + INTERNAL = "Internal" + EXT_TRIGGER = "External" + EXT_START = "External Start" + EXT_EXPOSURE = "External Exposure" + EXT_FVP = "External FVP" + SOFT = "Software" + + +class ImageMode(StrictEnum): + SINGLE = "Single" + MULTIPLE = "Multiple" + CONTINUOUS = "Continuous" + FAST_KINETICS = "Fast Kinetics" + + +class ADBaseDataType(StrictEnum): + UINT16 = "UInt16" + UINT32 = "UInt32" + B1 = "" + FLOAT32 = "Float32" + FLOAT64 = "Float64" class Andor2DriverIO(ADBaseIO): diff --git a/src/p99_bluesky/devices/epics/drivers/andor3_driver.py b/src/p99_bluesky/devices/epics/drivers/andor3_driver.py index 2e9ff67..dcf04fe 100644 --- a/src/p99_bluesky/devices/epics/drivers/andor3_driver.py +++ b/src/p99_bluesky/devices/epics/drivers/andor3_driver.py @@ -1,20 +1,19 @@ -from enum import Enum - +from ophyd_async.core import StrictEnum from ophyd_async.epics.adcore._core_io import ADBaseIO -from ophyd_async.epics.signal import epics_signal_rw, epics_signal_rw_rbv +from ophyd_async.epics.core import epics_signal_rw, epics_signal_rw_rbv -class Andor3TriggerMode(str, Enum): - internal = "Internal" - ext_start = "External Start" - ext_exposure = "External Exposure" - soft = "Software" - ext_trigger = "External" +class Andor3TriggerMode(StrictEnum): + INTERNAL = "Internal" + EXT_START = "External Start" + EXT_EXPOSURE = "External Exposure" + SOFT = "Software" + EXT_TRIGGER = "External" -class ImageMode(str, Enum): - fixed = "Fixed" - continuous = "Continuous" +class ImageMode(StrictEnum): + FIXED = "Fixed" + CONTINUOUS = "Continuous" class Andor3DriverIO(ADBaseIO): diff --git a/src/p99_bluesky/devices/p99/sample_stage.py b/src/p99_bluesky/devices/p99/sample_stage.py index b8610e1..fb4caa2 100644 --- a/src/p99_bluesky/devices/p99/sample_stage.py +++ b/src/p99_bluesky/devices/p99/sample_stage.py @@ -1,7 +1,5 @@ -from enum import Enum - -from ophyd_async.core import Device -from ophyd_async.epics.signal import epics_signal_rw +from ophyd_async.core import Device, StrictEnum +from ophyd_async.epics.core import epics_signal_rw class SampleAngleStage(Device): @@ -16,23 +14,23 @@ def __init__(self, prefix: str, name: str): super().__init__(name=name) -class p99StageSelections(str, Enum): - Empty = "Empty" - Mn5um = "Mn 5um" - Fe = "Fe (empty)" - Co5um = "Co 5um" - Ni5um = "Ni 5um" - Cu5um = "Cu 5um" - Zn5um = "Zn 5um" - Zr = "Zr (empty)" - Mo = "Mo (empty)" - Rh = "Rh (empty)" - Pd = "Pd (empty)" - Ag = "Ag (empty)" - Cd25um = "Cd 25um" - W = "W (empty)" - Pt = "Pt (empty)" - User = "User" +class p99StageSelections(StrictEnum): + EMPTY = "EMPTY" + MN5UM = "MN 5UM" + FE = "FE (EMPTY)" + CO5UM = "CO 5UM" + NI5UM = "NI 5UM" + CU5UM = "CU 5UM" + ZN5UM = "ZN 5UM" + ZR = "ZR (EMPTY)" + MO = "MO (EMPTY)" + RH = "RH (EMPTY)" + PD = "PD (EMPTY)" + AG = "AG (EMPTY)" + CD25UM = "CD 25UM" + W = "W (EMPTY)" + PT = "PT (EMPTY)" + USER = "USER" class FilterMotor(Device): diff --git a/src/p99_bluesky/plans/ad_plans.py b/src/p99_bluesky/plans/ad_plans.py index 8199d35..b73cb89 100644 --- a/src/p99_bluesky/plans/ad_plans.py +++ b/src/p99_bluesky/plans/ad_plans.py @@ -11,7 +11,7 @@ def takeImg( det: Andor2Ad | Andor3Ad, exposure: float, n_img: int = 1, - det_trig: DetectorTrigger = DetectorTrigger.internal, + det_trig: DetectorTrigger = DetectorTrigger.INTERNAL, ) -> MsgGenerator: """ Bare minimum to take an image using prepare plan with full detector control @@ -20,7 +20,7 @@ def takeImg( grp = short_uid("prepare") deadtime: float = det.controller.get_deadtime(exposure) tigger_info = TriggerInfo( - number=n_img, + number_of_triggers=n_img, trigger=det_trig, deadtime=deadtime, livetime=exposure, diff --git a/src/p99_bluesky/plans/fast_scan.py b/src/p99_bluesky/plans/fast_scan.py index b2214e4..91a0ff0 100644 --- a/src/p99_bluesky/plans/fast_scan.py +++ b/src/p99_bluesky/plans/fast_scan.py @@ -229,9 +229,9 @@ def inner_fast_scan_1d( yield from bps.prepare(motor, fly_info, group=grp, wait=True) yield from bps.wait(group=grp) yield from bps.kickoff(motor, group=grp, wait=True) - - done = yield from bps.complete(motor) LOGGER.info(f"flying motor = {motor.name} at speed = {motor_speed}") + done = yield from bps.complete(motor) + yield from bps.trigger_and_read(dets + [motor]) while not done.done: yield from bps.trigger_and_read(dets + [motor]) yield from bps.checkpoint() diff --git a/tests/conftest.py b/tests/conftest.py index f1a807d..0c25751 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -14,9 +14,8 @@ FilenameProvider, StaticFilenameProvider, StaticPathProvider, - callback_on_mock_put, - set_mock_value, ) +from ophyd_async.testing import callback_on_mock_put, set_mock_value from super_state_machine.errors import TransitionError from p99_bluesky.devices import Andor2Ad, Andor3Ad diff --git a/tests/epics/soft_ioc/softsignal.py b/tests/epics/soft_ioc/softsignal.py index 0e2163c..414d648 100644 --- a/tests/epics/soft_ioc/softsignal.py +++ b/tests/epics/soft_ioc/softsignal.py @@ -19,22 +19,22 @@ def soft_mbb(prefix: str, name: str, *option): # temp = builder.mbbIn(readback_name, initial_value=0) builder.mbbOut( name, - "Empty", - "Mn 5um", - "Fe (empty)", - "Co 5um", - "Ni 5um", - "Cu 5um", - "Zn 5um", - "Zr (empty)", - "Mo (empty)", - "Rh (empty)", - "Pd (empty)", - "Ag (empty)", - "Cd 25um", - "W (empty)", - "Pt (empty)", - "User", + "EMPTY", + "MN 5UM", + "FE (EMPTY)", + "CO 5UM", + "NI 5UM", + "CU 5UM", + "ZN 5UM", + "ZR (EMPTY)", + "MO (EMPTY)", + "RH (EMPTY)", + "PD (EMPTY)", + "AG (EMPTY)", + "CD 25UM", + "W (EMPTY)", + "PT (EMPTY)", + "USER", ) diff --git a/tests/epics/test_andor2_controller.py b/tests/epics/test_andor2_controller.py index ca67272..1f47139 100644 --- a/tests/epics/test_andor2_controller.py +++ b/tests/epics/test_andor2_controller.py @@ -5,9 +5,9 @@ DetectorTrigger, DeviceCollector, TriggerInfo, - set_mock_value, ) from ophyd_async.epics.adcore import ImageMode +from ophyd_async.testing import set_mock_value from p99_bluesky.devices.epics.andor2_controller import Andor2Controller from p99_bluesky.devices.epics.drivers.andor2_driver import ( @@ -27,15 +27,17 @@ async def Andor(RE) -> Andor2Controller: async def test_Andor_controller(RE, Andor: Andor2Controller): with patch("ophyd_async.core.wait_for_value", return_value=None): - await Andor.prepare(trigger_info=TriggerInfo(number=1, livetime=0.002)) + await Andor.prepare( + trigger_info=TriggerInfo(number_of_triggers=1, livetime=0.002) + ) await Andor.arm() driver = Andor._drv set_mock_value(driver.accumulate_period, 1) assert await driver.num_images.get_value() == 1 - assert await driver.image_mode.get_value() == ImageMode.multiple - assert await driver.trigger_mode.get_value() == Andor2TriggerMode.internal + assert await driver.image_mode.get_value() == ImageMode.MULTIPLE + assert await driver.trigger_mode.get_value() == Andor2TriggerMode.INTERNAL assert await driver.acquire.get_value() is True assert await driver.acquire_time.get_value() == 0.002 assert Andor.get_deadtime(2) == 2 + 0.1 @@ -49,6 +51,6 @@ async def test_Andor_controller(RE, Andor: Andor2Controller): with patch("ophyd_async.core.wait_for_value", return_value=None): await Andor.disarm() with pytest.raises(ValueError): - Andor._get_trigger_mode(DetectorTrigger.edge_trigger) + Andor._get_trigger_mode(DetectorTrigger.EDGE_TRIGGER) assert await driver.acquire.get_value() is False diff --git a/tests/epics/test_andor3_ controller.py b/tests/epics/test_andor3_controller.py similarity index 82% rename from tests/epics/test_andor3_ controller.py rename to tests/epics/test_andor3_controller.py index cfbc975..8f2b973 100644 --- a/tests/epics/test_andor3_ controller.py +++ b/tests/epics/test_andor3_controller.py @@ -26,14 +26,16 @@ async def Andor(RE) -> Andor3Controller: async def test_Andor3_controller(RE, Andor: Andor3Controller): with patch("ophyd_async.core.wait_for_value", return_value=None): - await Andor.prepare(trigger_info=TriggerInfo(number=1, livetime=0.002)) + await Andor.prepare( + trigger_info=TriggerInfo(number_of_triggers=1, livetime=0.002) + ) await Andor.arm() driver = Andor._drv assert await driver.num_images.get_value() == 1 - assert await driver.image_mode.get_value() == ImageMode.fixed - assert await driver.trigger_mode.get_value() == Andor3TriggerMode.internal + assert await driver.image_mode.get_value() == ImageMode.FIXED + assert await driver.trigger_mode.get_value() == Andor3TriggerMode.INTERNAL assert await driver.acquire.get_value() is True assert await driver.acquire_time.get_value() == 0.002 assert Andor.get_deadtime(2) == 2 + 0.1 @@ -42,6 +44,6 @@ async def test_Andor3_controller(RE, Andor: Andor3Controller): with patch("ophyd_async.core.wait_for_value", return_value=None): await Andor.disarm() with pytest.raises(ValueError): - Andor._get_trigger_mode(DetectorTrigger.edge_trigger) + Andor._get_trigger_mode(DetectorTrigger.EDGE_TRIGGER) assert await driver.acquire.get_value() is False diff --git a/tests/jupyter_tests/stagetest.ipynb b/tests/jupyter_tests/stagetest.ipynb index 2de1b87..82c8de3 100644 --- a/tests/jupyter_tests/stagetest.ipynb +++ b/tests/jupyter_tests/stagetest.ipynb @@ -1,497 +1,497 @@ { - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "80438dca-48cb-4cad-ac8c-014295bc27de", - "metadata": {}, - "outputs": [], - "source": [ - "import asyncio\n", - "from enum import Enum\n", - "\n", - "from bluesky import RunEngine\n", - "from bluesky.callbacks.best_effort import BestEffortCallback\n", - "from bluesky.plans import count\n", - "from ophyd_async.core import Device, DeviceCollector\n", - "from ophyd_async.epics.signal import (\n", - " epics_signal_rw,\n", - ")\n", - "\n", - "loop = asyncio.get_event_loop()\n", - "bec = BestEffortCallback()\n", - "RE = RunEngine({})" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "70f8f818-4c6a-4c34-9359-92dc89e82797", - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "\n", - "os.chdir(\"/scratch/wvx67826/p99_bluesky/src/\")" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "ae7eac0a-426d-415e-bdac-5969031daa29", - "metadata": {}, - "outputs": [], - "source": [ - "from p99_bluesky.devices.p99.sample_stage import SampleAngleStage\n", - "from p99_bluesky.devices.stages import ThreeAxisStage\n" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "ebc11af5-e80d-4ca9-bf0e-5df624ebad4e", - "metadata": {}, - "outputs": [], - "source": [ - "with DeviceCollector():\n", - " sample_angle_stage = SampleAngleStage('BL99P-MO-STAGE-01:',name = \"sample_angle_stage\")\n", - "#result = asyncio.create_task(x.connect())" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "9f883f21-476c-40a1-a147-a8284393dc8c", - "metadata": {}, - "outputs": [], - "source": [ - "result1 = asyncio.create_task(sample_angle_stage.theta.user_setpoint.get_value())\n", - "result2 = asyncio.create_task(sample_angle_stage.roll.read())\n", - "result3 = asyncio.create_task(sample_angle_stage.pitch.read())" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "0dd54914-edce-495f-9eed-06765d738dfb", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " result=0.11> \n", - " result={'sample_angle_stage-roll': {'alarm_severity': 0, 'timestamp': 1713795070.808041, 'value': 0.11}}> \n", - " result={'sample_angle_stage-pitch': {'alarm_severity': 0, 'timestamp': 1713795070.808041, 'value': 0.11}}> \n", - "\n" - ] - } - ], - "source": [ - "print(result1,\"\\n\",result2,\"\\n\",result3,\"\\n\", )\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "605b12c0-6d4f-4c76-a7c4-f8df737d38df", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "set()" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "asyncio.all_tasks(sample_angle_stage.roll.set(0.12))\n", - "asyncio.all_tasks(sample_angle_stage.theta.set(0.21))\n", - "asyncio.all_tasks(sample_angle_stage.pitch.set(0.11))" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "f2743323-d81a-4cb8-9a35-97f374868082", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " result=0.11> \n", - "\n", - " result={'sample_angle_stage-roll': {'alarm_severity': 0, 'timestamp': 1713795070.808041, 'value': 0.11}}> \n", - "\n", - " result={'sample_angle_stage-pitch': {'alarm_severity': 0, 'timestamp': 1713795070.808041, 'value': 0.11}}>\n" - ] - } - ], - "source": [ - "print (result1,\"\\n\\n\",result2 ,\"\\n\\n\",result3)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "1cf68ff7-2638-4a07-ba53-babe59fc4129", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "Transient Scan ID: 1 Time: 2024-04-23 11:20:09\n", - "Persistent Unique Scan ID: 'f2a9f7f5-5b81-42d7-81b5-02c539ccc36c'\n", - "New stream: 'primary'\n", - "+-----------+------------+-------------------------+--------------------------+--------------------------+\n", - "| seq_num | time | sample_angle_stage-roll | sample_angle_stage-pitch | sample_angle_stage-theta |\n", - "+-----------+------------+-------------------------+--------------------------+--------------------------+\n", - "| 1 | 11:20:09.9 | 0.110 | 0.110 | 0.110 |\n", - "| 2 | 11:20:10.5 | 0.110 | 0.110 | 0.110 |\n", - "| 3 | 11:20:11.0 | 0.110 | 0.110 | 0.110 |\n", - "| 4 | 11:20:11.5 | 0.110 | 0.110 | 0.110 |\n", - "| 5 | 11:20:12.1 | 0.110 | 0.110 | 0.110 |\n", - "+-----------+------------+-------------------------+--------------------------+--------------------------+\n", - "generator count ['f2a9f7f5'] (scan num: 1)\n", - "\n", - "\n", - "\n" - ] + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "80438dca-48cb-4cad-ac8c-014295bc27de", + "metadata": {}, + "outputs": [], + "source": [ + "import asyncio\n", + "from enum import Enum\n", + "\n", + "from bluesky import RunEngine\n", + "from bluesky.callbacks.best_effort import BestEffortCallback\n", + "from bluesky.plans import count\n", + "from ophyd_async.core import Device, DeviceCollector\n", + "from ophyd_async.epics.core import (\n", + " epics_signal_rw,\n", + ")\n", + "\n", + "loop = asyncio.get_event_loop()\n", + "bec = BestEffortCallback()\n", + "RE = RunEngine({})" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "70f8f818-4c6a-4c34-9359-92dc89e82797", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "\n", + "os.chdir(\"/scratch/wvx67826/p99_bluesky/src/\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ae7eac0a-426d-415e-bdac-5969031daa29", + "metadata": {}, + "outputs": [], + "source": [ + "from p99_bluesky.devices.p99.sample_stage import SampleAngleStage\n", + "from p99_bluesky.devices.stages import ThreeAxisStage\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ebc11af5-e80d-4ca9-bf0e-5df624ebad4e", + "metadata": {}, + "outputs": [], + "source": [ + "with DeviceCollector():\n", + " sample_angle_stage = SampleAngleStage('BL99P-MO-STAGE-01:',name = \"sample_angle_stage\")\n", + "#result = asyncio.create_task(x.connect())" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9f883f21-476c-40a1-a147-a8284393dc8c", + "metadata": {}, + "outputs": [], + "source": [ + "result1 = asyncio.create_task(sample_angle_stage.theta.user_setpoint.get_value())\n", + "result2 = asyncio.create_task(sample_angle_stage.roll.read())\n", + "result3 = asyncio.create_task(sample_angle_stage.pitch.read())" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0dd54914-edce-495f-9eed-06765d738dfb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " result=0.11> \n", + " result={'sample_angle_stage-roll': {'alarm_severity': 0, 'timestamp': 1713795070.808041, 'value': 0.11}}> \n", + " result={'sample_angle_stage-pitch': {'alarm_severity': 0, 'timestamp': 1713795070.808041, 'value': 0.11}}> \n", + "\n" + ] + } + ], + "source": [ + "print(result1,\"\\n\",result2,\"\\n\",result3,\"\\n\", )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "605b12c0-6d4f-4c76-a7c4-f8df737d38df", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "set()" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "asyncio.all_tasks(sample_angle_stage.roll.set(0.12))\n", + "asyncio.all_tasks(sample_angle_stage.theta.set(0.21))\n", + "asyncio.all_tasks(sample_angle_stage.pitch.set(0.11))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "f2743323-d81a-4cb8-9a35-97f374868082", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " result=0.11> \n", + "\n", + " result={'sample_angle_stage-roll': {'alarm_severity': 0, 'timestamp': 1713795070.808041, 'value': 0.11}}> \n", + "\n", + " result={'sample_angle_stage-pitch': {'alarm_severity': 0, 'timestamp': 1713795070.808041, 'value': 0.11}}>\n" + ] + } + ], + "source": [ + "print (result1,\"\\n\\n\",result2 ,\"\\n\\n\",result3)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "1cf68ff7-2638-4a07-ba53-babe59fc4129", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "Transient Scan ID: 1 Time: 2024-04-23 11:20:09\n", + "Persistent Unique Scan ID: 'f2a9f7f5-5b81-42d7-81b5-02c539ccc36c'\n", + "New stream: 'primary'\n", + "+-----------+------------+-------------------------+--------------------------+--------------------------+\n", + "| seq_num | time | sample_angle_stage-roll | sample_angle_stage-pitch | sample_angle_stage-theta |\n", + "+-----------+------------+-------------------------+--------------------------+--------------------------+\n", + "| 1 | 11:20:09.9 | 0.110 | 0.110 | 0.110 |\n", + "| 2 | 11:20:10.5 | 0.110 | 0.110 | 0.110 |\n", + "| 3 | 11:20:11.0 | 0.110 | 0.110 | 0.110 |\n", + "| 4 | 11:20:11.5 | 0.110 | 0.110 | 0.110 |\n", + "| 5 | 11:20:12.1 | 0.110 | 0.110 | 0.110 |\n", + "+-----------+------------+-------------------------+--------------------------+--------------------------+\n", + "generator count ['f2a9f7f5'] (scan num: 1)\n", + "\n", + "\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "('f2a9f7f5-5b81-42d7-81b5-02c539ccc36c',)" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "RE(count([sample_angle_stage.theta,sample_angle_stage.roll, sample_angle_stage.pitch],5),bec)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "f65fd05f-b63c-4811-be05-d1e58ce4f849", + "metadata": {}, + "outputs": [], + "source": [ + "result1 = asyncio.create_task(sample_angle_stage.roll.read_configuration())\n", + "result2 = asyncio.create_task(sample_angle_stage.roll.read_configuration())\n", + "result3 = asyncio.create_task(sample_angle_stage.roll.read_configuration())" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "ad0de76c-07ff-4447-bfdc-6b78d7b07407", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " result={'sample_angle...oll-motor_egu': {'alarm_severity': 0, 'timestamp': 1713867603.179117, 'value': 'deg'}}> \n", + "\n", + " result={'sample_angle...oll-motor_egu': {'alarm_severity': 0, 'timestamp': 1713867603.179117, 'value': 'deg'}}> \n", + "\n", + " result={'sample_angle...oll-motor_egu': {'alarm_severity': 0, 'timestamp': 1713867603.179117, 'value': 'deg'}}>\n" + ] + } + ], + "source": [ + "print (result1,\"\\n\\n\",result2 ,\"\\n\\n\",result3)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "ef9ffc5a-0699-4294-973a-6db735e030fb", + "metadata": {}, + "outputs": [], + "source": [ + "xyz_pv = 'BL99P-MO-STAGE-02:'" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "4151692f-6e0a-481e-8c20-231102195440", + "metadata": {}, + "outputs": [], + "source": [ + "with DeviceCollector():\n", + " sample_xyz_stage =ThreeAxisStage(xyz_pv,\"sample_xyz_stage\")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "4caf40db-813a-4711-9118-20852cc6e8e5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + ">" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sample_xyz_stage.x.setpoint = epics_signal_rw(float, xyz_pv + \"X\")\n", + "sample_xyz_stage.y.setpoint = epics_signal_rw(float, xyz_pv + \"Y\")\n", + "sample_xyz_stage.z.setpoint = epics_signal_rw(float, xyz_pv + \"Z\")\n", + "asyncio.create_task(sample_xyz_stage.x.connect())\n", + "asyncio.create_task(sample_xyz_stage.y.connect())\n", + "asyncio.create_task(sample_xyz_stage.z.connect())" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "97dda366-5958-4ebd-ae8e-100a62484c2a", + "metadata": {}, + "outputs": [], + "source": [ + "result1 = asyncio.create_task(sample_xyz_stage.x.read())\n", + "result2 = asyncio.create_task(sample_xyz_stage.y.read())\n", + "result3 = asyncio.create_task(sample_xyz_stage.z.read())" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "856e61a5-17b2-484a-9015-7d0165f77954", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " result={'sample_xyz_stage-x': {'alarm_severity': 0, 'timestamp': 1713544462.026615, 'value': 0.1}}> \n", + " result={'sample_xyz_stage-y': {'alarm_severity': 0, 'timestamp': 1713523982.943115, 'value': 1.0}}> \n", + " result={'sample_xyz_stage-z': {'alarm_severity': 0, 'timestamp': 1713863967.087072, 'value': 0.30000000000000004}}> \n", + "\n" + ] + } + ], + "source": [ + "print(result1,\"\\n\",result2,\"\\n\",result3,\"\\n\", )" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "8ab4358e-6545-4cbd-9abf-edcd6a44fc1c", + "metadata": {}, + "outputs": [], + "source": [ + "result1 = asyncio.create_task(sample_xyz_stage.x.read_configuration())\n", + "result2 = asyncio.create_task(sample_xyz_stage.y.read_configuration())\n", + "result3 = asyncio.create_task(sample_xyz_stage.z.read_configuration())" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "7c103aa1-5a73-4af8-a4f2-acee293ae4e1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " result={'sample_xyz_stage-x-units': {'alarm_severity': 0, 'timestamp': 1713544462.026615, 'value': 'mm'}, 'sample_xyz_stage-x-velocity': {'alarm_severity': 0, 'timestamp': 1713544462.026615, 'value': 1.8}}> \n", + " result={'sample_xyz_stage-y-units': {'alarm_severity': 0, 'timestamp': 1713523982.943115, 'value': 'mm'}, 'sample_xyz_stage-y-velocity': {'alarm_severity': 0, 'timestamp': 1713523982.943115, 'value': 1.8}}> \n", + " result={'sample_xyz_stage-z-units': {'alarm_severity': 0, 'timestamp': 1713863967.087072, 'value': 'mm'}, 'sample_xyz_stage-z-velocity': {'alarm_severity': 0, 'timestamp': 1713863967.087072, 'value': 1.8}}> \n", + "\n" + ] + } + ], + "source": [ + "print(result1,\"\\n\",result2,\"\\n\",result3,\"\\n\", )" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "5fb12f5e-9181-4cad-89a3-d8a9d483e19e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "Transient Scan ID: 2 Time: 2024-04-23 11:20:37\n", + "Persistent Unique Scan ID: 'b1be5d2d-7b39-4161-bcb1-a9c7f0626c20'\n", + "New stream: 'primary'\n", + "+-----------+------------+--------------------+--------------------+--------------------+\n", + "| seq_num | time | sample_xyz_stage-x | sample_xyz_stage-z | sample_xyz_stage-y |\n", + "+-----------+------------+--------------------+--------------------+--------------------+\n", + "| 1 | 11:20:38.0 | 0.100 | 0.300 | 1.000 |\n", + "| 2 | 11:20:38.5 | 0.100 | 0.300 | 1.000 |\n", + "| 3 | 11:20:39.0 | 0.100 | 0.300 | 1.000 |\n", + "+-----------+------------+--------------------+--------------------+--------------------+\n", + "generator count ['b1be5d2d'] (scan num: 2)\n", + "\n", + "\n", + "\n" + ] + }, + { + "data": { + "text/plain": [ + "('b1be5d2d-7b39-4161-bcb1-a9c7f0626c20',)" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "RE(count([sample_xyz_stage.x, sample_xyz_stage.y, sample_xyz_stage.z ],3),bec)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "8f1eb115-9551-442d-b8ab-f15fb2822cf7", + "metadata": {}, + "outputs": [], + "source": [ + "class p99StageSelections(str, Enum):\n", + " Empty = (\"Empty\",)\n", + " Mn5um = (\"Mn 5um\",)\n", + " Fe = (\"Fe (empty)\",)\n", + " Co5um = (\"Co 5um\",)\n", + " Ni5um = (\"Ni 5um\",)\n", + " Cu5um = (\"Cu 5um\",)\n", + " Zn5um = (\"Zn 5um\",)\n", + " Zr = (\"Zr (empty)\",)\n", + " Mo = (\"Mo (empty)\",)\n", + " Rh = (\"Rh (empty)\",)\n", + " Pd = (\"Pd (empty)\",)\n", + " Ag = (\"Ag (empty)\",)\n", + " Cd25um = (\"Cd 25um\",)\n", + " W = (\"W (empty)\",)\n", + " Pt = (\"Pt (empty)\",)\n", + " User = (\"User\",)\n", + "\n", + "class FilterMotor(Device):\n", + " def __init__(self, prefix: str, name: str):\n", + " self.user_setpoint = epics_signal_rw(p99StageSelections, 'BL99P-MO-STAGE-02:MP:SELECT')\n", + " super().__init__(name=name)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "2ff7ba42-ed16-4b76-a374-aeb8f640fcb8", + "metadata": {}, + "outputs": [], + "source": [ + "with DeviceCollector():\n", + " filterWheel = FilterMotor('BL99P-MO-STAGE-02:MP:SELECT', \"filterWheel\")" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "7d16a08c-4013-4d2e-a9da-f960bb2dca53", + "metadata": {}, + "outputs": [], + "source": [ + "result1= asyncio.gather(filterWheel.user_setpoint.set(p99StageSelections.Co5um))\n", + "result2 = asyncio.create_task(filterWheel.user_setpoint.read())" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "18f2ef02-73f2-40a3-b198-fb39c1977d5b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "<_GatheringFuture finished result=[None]> \n", + " result={'filterWheel-user_setpoint': {'alarm_severity': 0, 'timestamp': 1713867676.347262, 'value': }}> \n", + "\n" + ] + } + ], + "source": [ + "print(result1,\"\\n\",result2,\"\\n\" )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "57d15cfb-03a5-429a-869c-4990ff2df202", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } }, - { - "data": { - "text/plain": [ - "('f2a9f7f5-5b81-42d7-81b5-02c539ccc36c',)" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "RE(count([sample_angle_stage.theta,sample_angle_stage.roll, sample_angle_stage.pitch],5),bec)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "f65fd05f-b63c-4811-be05-d1e58ce4f849", - "metadata": {}, - "outputs": [], - "source": [ - "result1 = asyncio.create_task(sample_angle_stage.roll.read_configuration())\n", - "result2 = asyncio.create_task(sample_angle_stage.roll.read_configuration())\n", - "result3 = asyncio.create_task(sample_angle_stage.roll.read_configuration())" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "ad0de76c-07ff-4447-bfdc-6b78d7b07407", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " result={'sample_angle...oll-motor_egu': {'alarm_severity': 0, 'timestamp': 1713867603.179117, 'value': 'deg'}}> \n", - "\n", - " result={'sample_angle...oll-motor_egu': {'alarm_severity': 0, 'timestamp': 1713867603.179117, 'value': 'deg'}}> \n", - "\n", - " result={'sample_angle...oll-motor_egu': {'alarm_severity': 0, 'timestamp': 1713867603.179117, 'value': 'deg'}}>\n" - ] - } - ], - "source": [ - "print (result1,\"\\n\\n\",result2 ,\"\\n\\n\",result3)" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "ef9ffc5a-0699-4294-973a-6db735e030fb", - "metadata": {}, - "outputs": [], - "source": [ - "xyz_pv = 'BL99P-MO-STAGE-02:'" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "4151692f-6e0a-481e-8c20-231102195440", - "metadata": {}, - "outputs": [], - "source": [ - "with DeviceCollector():\n", - " sample_xyz_stage =ThreeAxisStage(xyz_pv,\"sample_xyz_stage\")" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "4caf40db-813a-4711-9118-20852cc6e8e5", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - ">" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "sample_xyz_stage.x.setpoint = epics_signal_rw(float, xyz_pv + \"X\")\n", - "sample_xyz_stage.y.setpoint = epics_signal_rw(float, xyz_pv + \"Y\")\n", - "sample_xyz_stage.z.setpoint = epics_signal_rw(float, xyz_pv + \"Z\")\n", - "asyncio.create_task(sample_xyz_stage.x.connect())\n", - "asyncio.create_task(sample_xyz_stage.y.connect())\n", - "asyncio.create_task(sample_xyz_stage.z.connect())" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "97dda366-5958-4ebd-ae8e-100a62484c2a", - "metadata": {}, - "outputs": [], - "source": [ - "result1 = asyncio.create_task(sample_xyz_stage.x.read())\n", - "result2 = asyncio.create_task(sample_xyz_stage.y.read())\n", - "result3 = asyncio.create_task(sample_xyz_stage.z.read())" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "856e61a5-17b2-484a-9015-7d0165f77954", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " result={'sample_xyz_stage-x': {'alarm_severity': 0, 'timestamp': 1713544462.026615, 'value': 0.1}}> \n", - " result={'sample_xyz_stage-y': {'alarm_severity': 0, 'timestamp': 1713523982.943115, 'value': 1.0}}> \n", - " result={'sample_xyz_stage-z': {'alarm_severity': 0, 'timestamp': 1713863967.087072, 'value': 0.30000000000000004}}> \n", - "\n" - ] - } - ], - "source": [ - "print(result1,\"\\n\",result2,\"\\n\",result3,\"\\n\", )" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "8ab4358e-6545-4cbd-9abf-edcd6a44fc1c", - "metadata": {}, - "outputs": [], - "source": [ - "result1 = asyncio.create_task(sample_xyz_stage.x.read_configuration())\n", - "result2 = asyncio.create_task(sample_xyz_stage.y.read_configuration())\n", - "result3 = asyncio.create_task(sample_xyz_stage.z.read_configuration())" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "7c103aa1-5a73-4af8-a4f2-acee293ae4e1", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - " result={'sample_xyz_stage-x-units': {'alarm_severity': 0, 'timestamp': 1713544462.026615, 'value': 'mm'}, 'sample_xyz_stage-x-velocity': {'alarm_severity': 0, 'timestamp': 1713544462.026615, 'value': 1.8}}> \n", - " result={'sample_xyz_stage-y-units': {'alarm_severity': 0, 'timestamp': 1713523982.943115, 'value': 'mm'}, 'sample_xyz_stage-y-velocity': {'alarm_severity': 0, 'timestamp': 1713523982.943115, 'value': 1.8}}> \n", - " result={'sample_xyz_stage-z-units': {'alarm_severity': 0, 'timestamp': 1713863967.087072, 'value': 'mm'}, 'sample_xyz_stage-z-velocity': {'alarm_severity': 0, 'timestamp': 1713863967.087072, 'value': 1.8}}> \n", - "\n" - ] - } - ], - "source": [ - "print(result1,\"\\n\",result2,\"\\n\",result3,\"\\n\", )" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "5fb12f5e-9181-4cad-89a3-d8a9d483e19e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "Transient Scan ID: 2 Time: 2024-04-23 11:20:37\n", - "Persistent Unique Scan ID: 'b1be5d2d-7b39-4161-bcb1-a9c7f0626c20'\n", - "New stream: 'primary'\n", - "+-----------+------------+--------------------+--------------------+--------------------+\n", - "| seq_num | time | sample_xyz_stage-x | sample_xyz_stage-z | sample_xyz_stage-y |\n", - "+-----------+------------+--------------------+--------------------+--------------------+\n", - "| 1 | 11:20:38.0 | 0.100 | 0.300 | 1.000 |\n", - "| 2 | 11:20:38.5 | 0.100 | 0.300 | 1.000 |\n", - "| 3 | 11:20:39.0 | 0.100 | 0.300 | 1.000 |\n", - "+-----------+------------+--------------------+--------------------+--------------------+\n", - "generator count ['b1be5d2d'] (scan num: 2)\n", - "\n", - "\n", - "\n" - ] - }, - { - "data": { - "text/plain": [ - "('b1be5d2d-7b39-4161-bcb1-a9c7f0626c20',)" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "RE(count([sample_xyz_stage.x, sample_xyz_stage.y, sample_xyz_stage.z ],3),bec)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "8f1eb115-9551-442d-b8ab-f15fb2822cf7", - "metadata": {}, - "outputs": [], - "source": [ - "class p99StageSelections(str, Enum):\n", - " Empty = (\"Empty\",)\n", - " Mn5um = (\"Mn 5um\",)\n", - " Fe = (\"Fe (empty)\",)\n", - " Co5um = (\"Co 5um\",)\n", - " Ni5um = (\"Ni 5um\",)\n", - " Cu5um = (\"Cu 5um\",)\n", - " Zn5um = (\"Zn 5um\",)\n", - " Zr = (\"Zr (empty)\",)\n", - " Mo = (\"Mo (empty)\",)\n", - " Rh = (\"Rh (empty)\",)\n", - " Pd = (\"Pd (empty)\",)\n", - " Ag = (\"Ag (empty)\",)\n", - " Cd25um = (\"Cd 25um\",)\n", - " W = (\"W (empty)\",)\n", - " Pt = (\"Pt (empty)\",)\n", - " User = (\"User\",)\n", - "\n", - "class FilterMotor(Device):\n", - " def __init__(self, prefix: str, name: str):\n", - " self.user_setpoint = epics_signal_rw(p99StageSelections, 'BL99P-MO-STAGE-02:MP:SELECT')\n", - " super().__init__(name=name)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "2ff7ba42-ed16-4b76-a374-aeb8f640fcb8", - "metadata": {}, - "outputs": [], - "source": [ - "with DeviceCollector():\n", - " filterWheel = FilterMotor('BL99P-MO-STAGE-02:MP:SELECT', \"filterWheel\")" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "7d16a08c-4013-4d2e-a9da-f960bb2dca53", - "metadata": {}, - "outputs": [], - "source": [ - "result1= asyncio.gather(filterWheel.user_setpoint.set(p99StageSelections.Co5um))\n", - "result2 = asyncio.create_task(filterWheel.user_setpoint.read())" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "18f2ef02-73f2-40a3-b198-fb39c1977d5b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "<_GatheringFuture finished result=[None]> \n", - " result={'filterWheel-user_setpoint': {'alarm_severity': 0, 'timestamp': 1713867676.347262, 'value': }}> \n", - "\n" - ] - } - ], - "source": [ - "print(result1,\"\\n\",result2,\"\\n\" )" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "57d15cfb-03a5-429a-869c-4990ff2df202", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/tests/jupyter_tests/stream.ipynb b/tests/jupyter_tests/stream.ipynb index da67628..dee7352 100644 --- a/tests/jupyter_tests/stream.ipynb +++ b/tests/jupyter_tests/stream.ipynb @@ -1,279 +1,279 @@ { - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "abfac095-8a7c-46a1-aee1-697c4ac427f8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import os \n", - "os.chdir(\"/workspaces/p99-bluesky/tests/\")\n", - "\n", - "import asyncio\n", - "import subprocess, os\n", - "from bluesky.run_engine import RunEngine\n", - "from ophyd_async.core import DeviceCollector\n", - "from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw\n", - "from ophyd_async.core.signal import observe_value, wait_for_value\n", - "from p99_bluesky.devices.p99.sample_stage import (\n", - " FilterMotor,\n", - " SampleAngleStage,\n", - " p99StageSelections,\n", - ")\n", - "from p99_bluesky.plans.fast_scan import fast_scan_1d, fast_scan_grid\n", - "from p99_bluesky.plans.stxm import stxm_fast,get_velocity_and_step_size\n", - "from soft_motor import SoftThreeAxisStage\n", - "from bluesky.run_engine import RunEngine\n", - "from bluesky.callbacks.best_effort import BestEffortCallback\n", - "from bluesky.plans import count, scan \n", - "from ophyd.sim import noisy_det, det1,det2,det3\n", - "from ophyd.sim import motor\n", - "bec = BestEffortCallback()\n", - "RE = RunEngine({})\n", - "from databroker import Broker\n", - "from bluesky.utils import Msg\n", - "db = Broker.named('temp')\n", - "RE.subscribe(db.insert)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "e0564fb7-d0ba-4119-9bc5-ab8fd5fee8cd", - "metadata": {}, - "outputs": [], - "source": [ - "def simple_scan_saving(det, motor,det1):\n", - " yield Msg(\"open_run\")\n", - " yield Msg(\"declare_stream\", None, motor, det, det1, name=\"primary\")\n", - " yield Msg(\"create\", name=\"primary\")\n", - " yield Msg(\"set\", motor, 5)\n", - " yield Msg(\"read\", motor)\n", - " yield Msg(\"trigger\", det)\n", - " yield Msg(\"read\", det)\n", - " yield Msg(\"read\", det1)\n", - " yield Msg(\"save\")\n", - " yield Msg(\"close_run\")" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "16fdb2df-4e20-44dd-b076-99cf36e687b6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "\n", - "Transient Scan ID: 5 Time: 2024-07-04 12:58:11\n", - "Persistent Unique Scan ID: 'bba38f0c-0c31-43a0-aeae-fed843e6ea26'\n", - "New stream: 'primary'\n", - "+-----------+------------+------------+------------+------------+\n", - "| seq_num | time | det2 | noisy_det | motor |\n", - "+-----------+------------+------------+------------+------------+\n" - ] + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "abfac095-8a7c-46a1-aee1-697c4ac427f8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import os \n", + "os.chdir(\"/workspaces/p99-bluesky/tests/\")\n", + "\n", + "import asyncio\n", + "import subprocess, os\n", + "from bluesky.run_engine import RunEngine\n", + "from ophyd_async.core import DeviceCollector\n", + "from ophyd_async.epics.core import epics_signal_r, epics_signal_rw\n", + "from ophyd_async.core.signal import observe_value, wait_for_value\n", + "from p99_bluesky.devices.p99.sample_stage import (\n", + " FilterMotor,\n", + " SampleAngleStage,\n", + " p99StageSelections,\n", + ")\n", + "from p99_bluesky.plans.fast_scan import fast_scan_1d, fast_scan_grid\n", + "from p99_bluesky.plans.stxm import stxm_fast,get_velocity_and_step_size\n", + "from soft_motor import SoftThreeAxisStage\n", + "from bluesky.run_engine import RunEngine\n", + "from bluesky.callbacks.best_effort import BestEffortCallback\n", + "from bluesky.plans import count, scan \n", + "from ophyd.sim import noisy_det, det1,det2,det3\n", + "from ophyd.sim import motor\n", + "bec = BestEffortCallback()\n", + "RE = RunEngine({})\n", + "from databroker import Broker\n", + "from bluesky.utils import Msg\n", + "db = Broker.named('temp')\n", + "RE.subscribe(db.insert)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e0564fb7-d0ba-4119-9bc5-ab8fd5fee8cd", + "metadata": {}, + "outputs": [], + "source": [ + "def simple_scan_saving(det, motor,det1):\n", + " yield Msg(\"open_run\")\n", + " yield Msg(\"declare_stream\", None, motor, det, det1, name=\"primary\")\n", + " yield Msg(\"create\", name=\"primary\")\n", + " yield Msg(\"set\", motor, 5)\n", + " yield Msg(\"read\", motor)\n", + " yield Msg(\"trigger\", det)\n", + " yield Msg(\"read\", det)\n", + " yield Msg(\"read\", det1)\n", + " yield Msg(\"save\")\n", + " yield Msg(\"close_run\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "16fdb2df-4e20-44dd-b076-99cf36e687b6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "Transient Scan ID: 5 Time: 2024-07-04 12:58:11\n", + "Persistent Unique Scan ID: 'bba38f0c-0c31-43a0-aeae-fed843e6ea26'\n", + "New stream: 'primary'\n", + "+-----------+------------+------------+------------+------------+\n", + "| seq_num | time | det2 | noisy_det | motor |\n", + "+-----------+------------+------------+------------+------------+\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Run aborted\n", + "Traceback (most recent call last):\n", + " File \"/venv/lib/python3.11/site-packages/bluesky/run_engine.py\", line 1522, in _run\n", + " msg = self._plan_stack[-1].throw(stashed_exception or resp)\n", + " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", + " File \"/tmp/ipykernel_1071954/2290841470.py\", line 10, in simple_scan_saving\n", + " yield Msg(\"read\", det1)\n", + " File \"/venv/lib/python3.11/site-packages/bluesky/run_engine.py\", line 1607, in _run\n", + " new_response = await coro(msg)\n", + " ^^^^^^^^^^^^^^^\n", + " File \"/venv/lib/python3.11/site-packages/bluesky/run_engine.py\", line 1902, in _read\n", + " await current_run.read(msg, ret)\n", + " File \"/venv/lib/python3.11/site-packages/bluesky/bundlers.py\", line 314, in read\n", + " raise ValueError(\n", + "ValueError: Data keys (field names) from SynGauss(prefix='', name='noisy_det', read_attrs=['val'], configuration_attrs=['Imax', 'center', 'sigma', 'noise', 'noise_multiplier']) collide with those from SynGauss(prefix='', name='noisy_det', read_attrs=['val'], configuration_attrs=['Imax', 'center', 'sigma', 'noise', 'noise_multiplier']). The colliding keys are {'noisy_det'}\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-----------+------------+------------+------------+------------+\n", + "generator simple_scan_saving ['bba38f0c'] (scan num: 5)\n", + "LivePlot did not get any data that corresponds to the x axis. time\n", + "LivePlot did not get any data that corresponds to the y axis. det2\n", + "LivePlot did not get any data that corresponds to the x axis. time\n", + "LivePlot did not get any data that corresponds to the y axis. noisy_det\n", + "LivePlot did not get any data that corresponds to the x axis. time\n", + "LivePlot did not get any data that corresponds to the y axis. motor\n", + "\n", + "\n", + "\n" + ] + }, + { + "ename": "ValueError", + "evalue": "Data keys (field names) from SynGauss(prefix='', name='noisy_det', read_attrs=['val'], configuration_attrs=['Imax', 'center', 'sigma', 'noise', 'noise_multiplier']) collide with those from SynGauss(prefix='', name='noisy_det', read_attrs=['val'], configuration_attrs=['Imax', 'center', 'sigma', 'noise', 'noise_multiplier']). The colliding keys are {'noisy_det'}", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[11], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mRE\u001b[49m\u001b[43m(\u001b[49m\u001b[43msimple_scan_saving\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdet2\u001b[49m\u001b[43m,\u001b[49m\u001b[43mmotor\u001b[49m\u001b[43m,\u001b[49m\u001b[43mnoisy_det\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43mbec\u001b[49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/venv/lib/python3.11/site-packages/bluesky/run_engine.py:918\u001b[0m, in \u001b[0;36mRunEngine.__call__\u001b[0;34m(self, *args, **metadata_kw)\u001b[0m\n\u001b[1;32m 914\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_blocking_event\u001b[38;5;241m.\u001b[39mset()\n\u001b[1;32m 916\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_task_fut\u001b[38;5;241m.\u001b[39madd_done_callback(set_blocking_event)\n\u001b[0;32m--> 918\u001b[0m plan_return \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_resume_task\u001b[49m\u001b[43m(\u001b[49m\u001b[43minit_func\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m_build_task\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 920\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_interrupted:\n\u001b[1;32m 921\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m RunEngineInterrupted(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpause_msg) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n", + "File \u001b[0;32m/venv/lib/python3.11/site-packages/bluesky/run_engine.py:1057\u001b[0m, in \u001b[0;36mRunEngine._resume_task\u001b[0;34m(self, init_func)\u001b[0m\n\u001b[1;32m 1053\u001b[0m \u001b[38;5;66;03m# if the main task exception is not None, re-raise\u001b[39;00m\n\u001b[1;32m 1054\u001b[0m \u001b[38;5;66;03m# it (unless it is a canceled error)\u001b[39;00m\n\u001b[1;32m 1055\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (exc \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 1056\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(exc, _RunEnginePanic)):\n\u001b[0;32m-> 1057\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc\n\u001b[1;32m 1058\u001b[0m \u001b[38;5;66;03m# Only try to get a result if there wasn't an error,\u001b[39;00m\n\u001b[1;32m 1059\u001b[0m \u001b[38;5;66;03m# (other than a cancelled error)\u001b[39;00m\n\u001b[1;32m 1060\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m exc \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", + "File \u001b[0;32m/venv/lib/python3.11/site-packages/bluesky/run_engine.py:1687\u001b[0m, in \u001b[0;36mRunEngine._run\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1685\u001b[0m exit_reason \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mstr\u001b[39m(err)\n\u001b[1;32m 1686\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlog\u001b[38;5;241m.\u001b[39mexception(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mRun aborted\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m-> 1687\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m err\n\u001b[1;32m 1688\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 1689\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m exit_reason:\n", + "File \u001b[0;32m/venv/lib/python3.11/site-packages/bluesky/run_engine.py:1522\u001b[0m, in \u001b[0;36mRunEngine._run\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1519\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (stashed_exception \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(resp, \u001b[38;5;167;01mException\u001b[39;00m)):\n\u001b[1;32m 1520\u001b[0m \u001b[38;5;66;03m# throw the exception at the current plan\u001b[39;00m\n\u001b[1;32m 1521\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1522\u001b[0m msg \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_plan_stack[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m.\u001b[39mthrow(stashed_exception \u001b[38;5;129;01mor\u001b[39;00m resp)\n\u001b[1;32m 1523\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 1524\u001b[0m \u001b[38;5;66;03m# The current plan did not handle it,\u001b[39;00m\n\u001b[1;32m 1525\u001b[0m \u001b[38;5;66;03m# maybe the next plan (if any) would like\u001b[39;00m\n\u001b[1;32m 1526\u001b[0m \u001b[38;5;66;03m# to try\u001b[39;00m\n\u001b[1;32m 1527\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_plan_stack\u001b[38;5;241m.\u001b[39mpop()\n", + "Cell \u001b[0;32mIn[10], line 10\u001b[0m, in \u001b[0;36msimple_scan_saving\u001b[0;34m(det, motor, det1)\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[38;5;28;01myield\u001b[39;00m Msg(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mread\u001b[39m\u001b[38;5;124m\"\u001b[39m, det)\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01myield\u001b[39;00m Msg(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mread\u001b[39m\u001b[38;5;124m\"\u001b[39m, det1)\n\u001b[0;32m---> 10\u001b[0m \u001b[38;5;28;01myield\u001b[39;00m Msg(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mread\u001b[39m\u001b[38;5;124m\"\u001b[39m, det1)\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01myield\u001b[39;00m Msg(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msave\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 12\u001b[0m \u001b[38;5;28;01myield\u001b[39;00m Msg(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mclose_run\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", + "File \u001b[0;32m/venv/lib/python3.11/site-packages/bluesky/run_engine.py:1607\u001b[0m, in \u001b[0;36mRunEngine._run\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1602\u001b[0m \u001b[38;5;66;03m# try to finally run the command the user asked for\u001b[39;00m\n\u001b[1;32m 1603\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1604\u001b[0m \u001b[38;5;66;03m# this is one of two places that 'async'\u001b[39;00m\n\u001b[1;32m 1605\u001b[0m \u001b[38;5;66;03m# exceptions (coming in via throw) can be\u001b[39;00m\n\u001b[1;32m 1606\u001b[0m \u001b[38;5;66;03m# raised\u001b[39;00m\n\u001b[0;32m-> 1607\u001b[0m new_response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m coro(msg)\n\u001b[1;32m 1609\u001b[0m \u001b[38;5;66;03m# special case `CancelledError` and let the outer\u001b[39;00m\n\u001b[1;32m 1610\u001b[0m \u001b[38;5;66;03m# exception block deal with it.\u001b[39;00m\n\u001b[1;32m 1611\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m asyncio\u001b[38;5;241m.\u001b[39mCancelledError:\n", + "File \u001b[0;32m/venv/lib/python3.11/site-packages/bluesky/run_engine.py:1902\u001b[0m, in \u001b[0;36mRunEngine._read\u001b[0;34m(self, msg)\u001b[0m\n\u001b[1;32m 1900\u001b[0m \u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m\n\u001b[1;32m 1901\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1902\u001b[0m \u001b[38;5;28;01mawait\u001b[39;00m current_run\u001b[38;5;241m.\u001b[39mread(msg, ret)\n\u001b[1;32m 1904\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m ret\n", + "File \u001b[0;32m/venv/lib/python3.11/site-packages/bluesky/bundlers.py:314\u001b[0m, in \u001b[0;36mRunBundler.read\u001b[0;34m(self, msg, reading)\u001b[0m\n\u001b[1;32m 312\u001b[0m known_keys \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_describe_cache[read_obj]\u001b[38;5;241m.\u001b[39mkeys()\n\u001b[1;32m 313\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mset\u001b[39m(known_keys) \u001b[38;5;241m&\u001b[39m cur_keys:\n\u001b[0;32m--> 314\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 315\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mData keys (field names) from \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mobj\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[38;5;124m \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 316\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcollide with those from \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mread_obj\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[38;5;124m. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 317\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe colliding keys are \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mset\u001b[39m(known_keys)\u001b[38;5;250m \u001b[39m\u001b[38;5;241m&\u001b[39m\u001b[38;5;250m \u001b[39mcur_keys\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 318\u001b[0m )\n\u001b[1;32m 320\u001b[0m \u001b[38;5;66;03m# add this object to the cache of things we have read\u001b[39;00m\n\u001b[1;32m 321\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_objs_read\u001b[38;5;241m.\u001b[39mappend(obj)\n", + "\u001b[0;31mValueError\u001b[0m: Data keys (field names) from SynGauss(prefix='', name='noisy_det', read_attrs=['val'], configuration_attrs=['Imax', 'center', 'sigma', 'noise', 'noise_multiplier']) collide with those from SynGauss(prefix='', name='noisy_det', read_attrs=['val'], configuration_attrs=['Imax', 'center', 'sigma', 'noise', 'noise_multiplier']). The colliding keys are {'noisy_det'}" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf8AAAXnCAYAAABCO3BbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB8zElEQVR4nOzde3iU5YH//89MjoLNRCBkCCYc+kUTFEkbIITSUk00Cn4lgitkUZBm5dcuIEuQmiiFYg/Ruii4qPmyW0utRChqaaE0FgKilQgYqJzxUCUcnASMmQhIEjLP7w8uxs6SxBBmMhnv9+u65qq5534y9/3o7jsz80xisyzLEgAAMIY92AsAAAAdi/gDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGCYkIv/M888o759+yo6Olrp6enavn17q/NXr16t5ORkRUdHa9CgQVq/fv1Fcw4cOKA77rhDDodDXbt21dChQ1VZWRmoLQAAEFQhFf9Vq1YpPz9fCxYs0M6dOzV48GBlZ2erurq62flbt25Vbm6u8vLytGvXLuXk5CgnJ0d79+71zvnwww81cuRIJScn6/XXX9fu3bv1k5/8RNHR0R21LQAAOpQtlP6wT3p6uoYOHaqlS5dKkjwejxITEzVz5kwVFBRcNH/ChAk6ffq01q1b5x0bPny4UlNTVVxcLEmaOHGiIiIi9Lvf/a5jNgEAQJCFB3sBbdXQ0KCKigoVFhZ6x+x2u7KyslReXt7sMeXl5crPz/cZy87O1po1aySd/+Hhz3/+s3784x8rOztbu3btUr9+/VRYWKicnJwW11JfX6/6+nrv1x6PRzU1NerevbtsNlv7NwkAMJplWfr888+VkJAguz1wL86HTPxPnjyppqYmxcfH+4zHx8fr4MGDzR7jcrmane9yuSRJ1dXVOnXqlB577DH9/Oc/1+OPP67S0lKNGzdOmzdv1qhRo5r9vkVFRVq4cKEfdgUAwMWOHDmiq6++OmDfP2TiHwgej0eSNHbsWM2ePVuSlJqaqq1bt6q4uLjF+BcWFvq8ouB2u5WUlKQjR44oJiYm8AsHAHwt1dXVKTExUd/4xjcC+jghE/8ePXooLCxMVVVVPuNVVVVyOp3NHuN0Olud36NHD4WHh2vgwIE+c1JSUvS3v/2txbVERUUpKirqovGYmBjiDwC4bIF+CzlkrvaPjIxUWlqaysrKvGMej0dlZWXKyMho9piMjAyf+ZK0YcMG7/zIyEgNHTpUhw4d8pnz3nvvqU+fPn7eAQAAnUPIPPOXpPz8fE2ZMkVDhgzRsGHDtHjxYp0+fVpTp06VJE2ePFm9e/dWUVGRJGnWrFkaNWqUFi1apDFjxmjlypV65513tGzZMu/3nDt3riZMmKDvfe97uvHGG1VaWqq1a9fq9ddfD8YWAQAIuJCK/4QJE3TixAnNnz9fLpdLqampKi0t9V7UV1lZ6XN15IgRI1RSUqJ58+bp4Ycf1oABA7RmzRpdf/313jl33nmniouLVVRUpAceeEDXXnutXnnlFY0cObLD9wcAQEcIqc/5d1Z1dXVyOBxyu9285w8Al8nj8aihoSHYywiYyMjIFj/G11E9Caln/gCAr7eGhgZ99NFH3k9jfR3Z7Xb169dPkZGRQVsD8QcAdAqWZemTTz5RWFiYEhMTA/pLboLF4/Ho+PHj+uSTT5SUlBS0XwxH/AEAncK5c+d05swZJSQkqEuXLsFeTsDExcXp+PHjOnfunCIiIoKyhq/fj1UAgJDU1NQkSUF9ObwjXNjfhf0GA/EHAHQqX/e/kdIZ9kf8AQAwDPEHAMAwxB8AgMvw05/+VDabzeeWnJwc7GW1iqv9AQC4TNddd502btzo/To8vHPntXOvDgBgLMuy9EVjcK6IvyIi7JIuzAsPD2/xL8x2RsQfANApfdHYpIHzXwvKY+9/NFtdItueyPfff18JCQmKjo5WRkaGioqKlJSUFMAVXh7e8wcA4DKkp6dr+fLlKi0t1XPPPaePPvpI3/3ud/X5558He2kt4pk/AKBTuiIiTPsfzQ7aY7fVbbfd5v3nG264Qenp6erTp49+//vfKy8vLxDLu2zEHwDQKdlstkt66b2ziI2N1TXXXKMPPvgg2EtpES/7AwDgR6dOndKHH36oXr16BXspLSL+AABchgcffFBbtmzRxx9/rK1bt+rOO+9UWFiYcnNzg720FoXe6ykAAHQiR48eVW5urj799FPFxcVp5MiRevvttxUXFxfspbWI+AMAcBlWrlwZ7CVcMl72BwDAMMQfAADDEH8AAAxD/AEAMAzxBwB0KpZlBXsJAdUZ9kf8AQCdQljY+V+p29DQEOSVBNaF/V3YbzDwUT8AQKcQHh6uLl266MSJE4qIiJDd/vV7furxeHTixAl16dJF4eHBSzDxBwB0CjabTb169dJHH32kw4cPB3s5AWO325WUlCSbzRa0NRB/AECnERkZqQEDBnytX/qPjIwM+qsaxB8A0KnY7XZFR0cHexlfa1+/N1QAAECriD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYJufg/88wz6tu3r6Kjo5Wenq7t27e3On/16tVKTk5WdHS0Bg0apPXr17c494c//KFsNpsWL17s51UDANB5hFT8V61apfz8fC1YsEA7d+7U4MGDlZ2drerq6mbnb926Vbm5ucrLy9OuXbuUk5OjnJwc7d2796K5f/jDH/T2228rISEh0NsAACCoQir+Tz75pO6//35NnTpVAwcOVHFxsbp06aLnn3++2flLlizRrbfeqrlz5yolJUU/+9nP9O1vf1tLly71mXfs2DHNnDlTK1asUEREREdsBQCAoAmZ+Dc0NKiiokJZWVneMbvdrqysLJWXlzd7THl5uc98ScrOzvaZ7/F4dO+992ru3Lm67rrr2rSW+vp61dXV+dwAAAgVIRP/kydPqqmpSfHx8T7j8fHxcrlczR7jcrm+cv7jjz+u8PBwPfDAA21eS1FRkRwOh/eWmJh4CTsBACC4Qib+gVBRUaElS5Zo+fLlstlsbT6usLBQbrfbezty5EgAVwkAgH+FTPx79OihsLAwVVVV+YxXVVXJ6XQ2e4zT6Wx1/ptvvqnq6molJSUpPDxc4eHhOnz4sObMmaO+ffu2uJaoqCjFxMT43AAACBUhE//IyEilpaWprKzMO+bxeFRWVqaMjIxmj8nIyPCZL0kbNmzwzr/33nu1e/du/f3vf/feEhISNHfuXL322muB2wwAAEEUHuwFXIr8/HxNmTJFQ4YM0bBhw7R48WKdPn1aU6dOlSRNnjxZvXv3VlFRkSRp1qxZGjVqlBYtWqQxY8Zo5cqVeuedd7Rs2TJJUvfu3dW9e3efx4iIiJDT6dS1117bsZsDAKCDhFT8J0yYoBMnTmj+/PlyuVxKTU1VaWmp96K+yspK2e1fvpgxYsQIlZSUaN68eXr44Yc1YMAArVmzRtdff32wtgAAQNDZLMuygr2IUFdXVyeHwyG32837/wCAduuonoTMe/4AAMA/iD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGCbk4v/MM8+ob9++io6OVnp6urZv397q/NWrVys5OVnR0dEaNGiQ1q9f772vsbFRDz30kAYNGqSuXbsqISFBkydP1vHjxwO9DQAAgiak4r9q1Srl5+drwYIF2rlzpwYPHqzs7GxVV1c3O3/r1q3Kzc1VXl6edu3apZycHOXk5Gjv3r2SpDNnzmjnzp36yU9+op07d+rVV1/VoUOHdMcdd3TktgAA6FA2y7KsYC+irdLT0zV06FAtXbpUkuTxeJSYmKiZM2eqoKDgovkTJkzQ6dOntW7dOu/Y8OHDlZqaquLi4mYfY8eOHRo2bJgOHz6spKSkNq2rrq5ODodDbrdbMTEx7dgZAAAd15OQeebf0NCgiooKZWVlecfsdruysrJUXl7e7DHl5eU+8yUpOzu7xfmS5Ha7ZbPZFBsb2+Kc+vp61dXV+dwAAAgVIRP/kydPqqmpSfHx8T7j8fHxcrlczR7jcrkuaf7Zs2f10EMPKTc3t9WfuIqKiuRwOLy3xMTES9wNAADBEzLxD7TGxkbdfffdsixLzz33XKtzCwsL5Xa7vbcjR4500CoBALh84cFeQFv16NFDYWFhqqqq8hmvqqqS0+ls9hin09mm+RfCf/jwYW3atOkr32eJiopSVFRUO3YBAEDwhcwz/8jISKWlpamsrMw75vF4VFZWpoyMjGaPycjI8JkvSRs2bPCZfyH877//vjZu3Kju3bsHZgMAAHQSIfPMX5Ly8/M1ZcoUDRkyRMOGDdPixYt1+vRpTZ06VZI0efJk9e7dW0VFRZKkWbNmadSoUVq0aJHGjBmjlStX6p133tGyZcsknQ//XXfdpZ07d2rdunVqamryXg/QrVs3RUZGBmejAAAEUEjFf8KECTpx4oTmz58vl8ul1NRUlZaWei/qq6yslN3+5YsZI0aMUElJiebNm6eHH35YAwYM0Jo1a3T99ddLko4dO6Y//elPkqTU1FSfx9q8ebO+//3vd8i+AADoSCH1Of/Ois/5AwD8gc/5AwCAgCD+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYpl3xP3r0qE6dOnXReGNjo954443LXhQAAAicS4r/J598omHDhqlPnz6KjY3V5MmTfX4IqKmp0Y033uj3RQIAAP+5pPgXFBTIbrdr27ZtKi0t1f79+3XjjTfqs88+886xLMvviwQAAP5zSfHfuHGjnn76aQ0ZMkRZWVl666231KtXL910002qqamRJNlstoAsFAAA+Mclxd/tduuqq67yfh0VFaVXX31Vffv21Y033qjq6mq/LxAAAPjXJcW/f//+2r17t89YeHi4Vq9erf79++v222/36+IAAID/XVL8b7vtNi1btuyi8Qs/AKSmpvKePwAAnZzNuoRanzt3TmfOnFFMTEyL9x87dkx9+vTx2wJDQV1dnRwOh9xud4vnBgCAr9JRPbmkZ/7h4eGKiYnRo48+qjNnzlx0f2Njo37729/6bXHNeeaZZ9S3b19FR0crPT1d27dvb3X+6tWrlZycrOjoaA0aNEjr16/3ud+yLM2fP1+9evXSFVdcoaysLL3//vuB3AIAAEHVrl/ys3DhwmZ/yc+ZM2e0cOHCy15US1atWqX8/HwtWLBAO3fu1ODBg5Wdnd3ihYZbt25Vbm6u8vLytGvXLuXk5CgnJ0d79+71zvnVr36lp59+WsXFxdq2bZu6du2q7OxsnT17NmD7AAAgmC7pZf8L7Ha7qqqqFBcX5zO+adMmTZgwQSdOnPDbAv9Zenq6hg4dqqVLl0qSPB6PEhMTNXPmTBUUFFw0f8KECTp9+rTWrVvnHRs+fLhSU1NVXFwsy7KUkJCgOXPm6MEHH5R0/hMN8fHxWr58uSZOnNimdfGyPwDAHzrly/5XXXWVunXrJpvNpmuuuUbdunXz3hwOh26++WbdfffdAVloQ0ODKioqlJWV5R2z2+3KyspSeXl5s8eUl5f7zJek7Oxs7/yPPvpILpfLZ47D4VB6enqL31OS6uvrVVdX53MDACBUhF/K5MWLF8uyLP3gBz/QwoUL5XA4vPdFRkaqb9++ysjI8PsiJenkyZNqampSfHy8z3h8fLwOHjzY7DEul6vZ+S6Xy3v/hbGW5jSnqKgooG9vAAAQSJcU/ylTpkiS+vXrp+985zsKD7+kw782CgsLlZ+f7/26rq5OiYmJQVwRAABt164L/kaNGqXDhw9r3rx5ys3N9V5w95e//EX79u3z6wIv6NGjh8LCwlRVVeUzXlVVJafT2ewxTqez1fkX/vdSvqd0/jcbxsTE+NwAAAgV7Yr/li1bNGjQIG3btk2vvvqq98r/d999VwsWLPDrAi+IjIxUWlqaysrKvGMej0dlZWUtvtWQkZHhM1+SNmzY4J3fr18/OZ1Onzl1dXXatm1bwN6+AAAg6Kx2GD58uLVo0SLLsizryiuvtD788EPLsixr27ZtVu/evdvzLdtk5cqVVlRUlLV8+XJr//791rRp06zY2FjL5XJZlmVZ9957r1VQUOCd/9Zbb1nh4eHWf/7nf1oHDhywFixYYEVERFh79uzxznnssces2NhY649//KO1e/dua+zYsVa/fv2sL774os3rcrvdliTL7Xb7b7MAAON0VE/a9ab9nj17VFJSctF4z549dfLkycv8caRlFz5GOH/+fLlcLqWmpqq0tNR7wV5lZaXs9i9fzBgxYoRKSko0b948PfzwwxowYIDWrFmj66+/3jvnxz/+sU6fPq1p06aptrZWI0eOVGlpqaKjowO2DwAAgqldn/O/+uqr9fvf/14jRozQN77xDb377rvq37+//vCHP+jBBx/Uhx9+GIi1dlp8zh8A4A+d8nP+F0ycOFEPPfSQXC6XbDabPB6P3nrrLT344IOaPHmyv9cIAAD8qF3x/+Uvf6nk5GQlJibq1KlTGjhwoL773e9qxIgRmjdvnr/XCAAA/KhdL/tfcOTIEe3Zs0enTp3St771LQ0YMMCfawsZvOwPAPCHjupJmy/4++dfatOct99+2/vPTz75ZPtXBAAAAqrN8d+1a5fP1zt37tS5c+d07bXXSpLee+89hYWFKS0tzb8rBAAAftXm+G/evNn7z08++aS+8Y1v6Le//a2uuuoqSdJnn32mqVOn6rvf/a7/VwkAAPymXe/59+7dW3/961913XXX+Yzv3btXt9xyi44fP+63BYYC3vMHAPhDp/6oX11dnU6cOHHR+IkTJ/T5559f9qIAAEDgtCv+d955p6ZOnapXX31VR48e1dGjR/XKK68oLy9P48aN8/caAQCAH7Xr1/sWFxfrwQcf1L/+67+qsbHx/DcKD1deXp6eeOIJvy4QAAD412V9zv/06dPeX+X7zW9+U127dvXbwkIJ7/kDAPyh033Ovzldu3bVDTfc4K+1AACADtCu9/wBAEDoIv4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYJiQiX9NTY0mTZqkmJgYxcbGKi8vT6dOnWr1mLNnz2r69Onq3r27rrzySo0fP15VVVXe+999913l5uYqMTFRV1xxhVJSUrRkyZJAbwUAgKAKmfhPmjRJ+/bt04YNG7Ru3Tq98cYbmjZtWqvHzJ49W2vXrtXq1au1ZcsWHT9+XOPGjfPeX1FRoZ49e+rFF1/Uvn379Mgjj6iwsFBLly4N9HYAAAgam2VZVrAX8VUOHDiggQMHaseOHRoyZIgkqbS0VKNHj9bRo0eVkJBw0TFut1txcXEqKSnRXXfdJUk6ePCgUlJSVF5eruHDhzf7WNOnT9eBAwe0adOmNq+vrq5ODodDbrdbMTEx7dghAAAd15OQeOZfXl6u2NhYb/glKSsrS3a7Xdu2bWv2mIqKCjU2NiorK8s7lpycrKSkJJWXl7f4WG63W926dWt1PfX19aqrq/O5AQAQKkIi/i6XSz179vQZCw8PV7du3eRyuVo8JjIyUrGxsT7j8fHxLR6zdetWrVq16ivfTigqKpLD4fDeEhMT274ZAACCLKjxLygokM1ma/V28ODBDlnL3r17NXbsWC1YsEC33HJLq3MLCwvldru9tyNHjnTIGgEA8IfwYD74nDlzdN9997U6p3///nI6naqurvYZP3funGpqauR0Ops9zul0qqGhQbW1tT7P/quqqi46Zv/+/crMzNS0adM0b968r1x3VFSUoqKivnIeAACdUVDjHxcXp7i4uK+cl5GRodraWlVUVCgtLU2StGnTJnk8HqWnpzd7TFpamiIiIlRWVqbx48dLkg4dOqTKykplZGR45+3bt0833XSTpkyZol/84hd+2BUAAJ1bSFztL0m33XabqqqqVFxcrMbGRk2dOlVDhgxRSUmJJOnYsWPKzMzUCy+8oGHDhkmSfvSjH2n9+vVavny5YmJiNHPmTEnn39uXzr/Uf9NNNyk7O1tPPPGE97HCwsLa9EPJBVztDwDwh47qSVCf+V+KFStWaMaMGcrMzJTdbtf48eP19NNPe+9vbGzUoUOHdObMGe/YU0895Z1bX1+v7OxsPfvss977X375ZZ04cUIvvviiXnzxRe94nz599PHHH3fIvgAA6Ggh88y/M+OZPwDAH/icPwAACAjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYUIm/jU1NZo0aZJiYmIUGxurvLw8nTp1qtVjzp49q+nTp6t79+668sorNX78eFVVVTU799NPP9XVV18tm82m2traAOwAAIDOIWTiP2nSJO3bt08bNmzQunXr9MYbb2jatGmtHjN79mytXbtWq1ev1pYtW3T8+HGNGzeu2bl5eXm64YYbArF0AAA6FZtlWVawF/FVDhw4oIEDB2rHjh0aMmSIJKm0tFSjR4/W0aNHlZCQcNExbrdbcXFxKikp0V133SVJOnjwoFJSUlReXq7hw4d75z733HNatWqV5s+fr8zMTH322WeKjY1t8/rq6urkcDjkdrsVExNzeZsFABiro3oSEs/8y8vLFRsb6w2/JGVlZclut2vbtm3NHlNRUaHGxkZlZWV5x5KTk5WUlKTy8nLv2P79+/Xoo4/qhRdekN3ettNRX1+vuro6nxsAAKEiJOLvcrnUs2dPn7Hw8HB169ZNLperxWMiIyMvegYfHx/vPaa+vl65ubl64oknlJSU1Ob1FBUVyeFweG+JiYmXtiEAAIIoqPEvKCiQzWZr9Xbw4MGAPX5hYaFSUlJ0zz33XPJxbrfbezty5EiAVggAgP+FB/PB58yZo/vuu6/VOf3795fT6VR1dbXP+Llz51RTUyOn09nscU6nUw0NDaqtrfV59l9VVeU9ZtOmTdqzZ49efvllSdKFyx969OihRx55RAsXLmz2e0dFRSkqKqotWwQAoNMJavzj4uIUFxf3lfMyMjJUW1uriooKpaWlSTofbo/Ho/T09GaPSUtLU0REhMrKyjR+/HhJ0qFDh1RZWamMjAxJ0iuvvKIvvvjCe8yOHTv0gx/8QG+++aa++c1vXu72AADolIIa/7ZKSUnRrbfeqvvvv1/FxcVqbGzUjBkzNHHiRO+V/seOHVNmZqZeeOEFDRs2TA6HQ3l5ecrPz1e3bt0UExOjmTNnKiMjw3ul//8O/MmTJ72PdylX+wMAEEpCIv6StGLFCs2YMUOZmZmy2+0aP368nn76ae/9jY2NOnTokM6cOeMde+qpp7xz6+vrlZ2drWeffTYYywcAoNMIic/5d3Z8zh8A4A98zh8AAAQE8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAw4RM/GtqajRp0iTFxMQoNjZWeXl5OnXqVKvHnD17VtOnT1f37t115ZVXavz48aqqqrpo3vLly3XDDTcoOjpaPXv21PTp0wO1DQAAgi5k4j9p0iTt27dPGzZs0Lp16/TGG29o2rRprR4ze/ZsrV27VqtXr9aWLVt0/PhxjRs3zmfOk08+qUceeUQFBQXat2+fNm7cqOzs7EBuBQCAoLJZlmUFexFf5cCBAxo4cKB27NihIUOGSJJKS0s1evRoHT16VAkJCRcd43a7FRcXp5KSEt11112SpIMHDyolJUXl5eUaPny4PvvsM/Xu3Vtr165VZmZmu9dXV1cnh8Mht9utmJiYdn8fAIDZOqon4QH7zn5UXl6u2NhYb/glKSsrS3a7Xdu2bdOdd9550TEVFRVqbGxUVlaWdyw5OVlJSUne+G/YsEEej0fHjh1TSkqKPv/8c40YMUKLFi1SYmJii+upr69XfX2992u32y3p/L80AADa60JHAv28PCTi73K51LNnT5+x8PBwdevWTS6Xq8VjIiMjFRsb6zMeHx/vPeYf//iHPB6PfvnLX2rJkiVyOByaN2+ebr75Zu3evVuRkZHNfu+ioiItXLjwovHWfmAAAKCtPv30UzkcjoB9/6DGv6CgQI8//nircw4cOBCwx/d4PGpsbNTTTz+tW265RZL00ksvyel0avPmzS2+919YWKj8/Hzv17W1terTp48qKysD+i8rFNTV1SkxMVFHjhzhLRBxPv4Z5+JLnAtfnI8vud1uJSUlqVu3bgF9nKDGf86cObrvvvtandO/f385nU5VV1f7jJ87d041NTVyOp3NHud0OtXQ0KDa2lqfZ/9VVVXeY3r16iVJGjhwoPf+uLg49ejRQ5WVlS2uKSoqSlFRUReNOxwO4//DvSAmJoZz8U84H1/iXHyJc+GL8/Eluz2w1+MHNf5xcXGKi4v7ynkZGRmqra1VRUWF0tLSJEmbNm2Sx+NRenp6s8ekpaUpIiJCZWVlGj9+vCTp0KFDqqysVEZGhiTpO9/5jnf86quvlnT+I4UnT55Unz59Lnt/AAB0RiHxUb+UlBTdeuutuv/++7V9+3a99dZbmjFjhiZOnOi90v/YsWNKTk7W9u3bJZ1/Fp6Xl6f8/Hxt3rxZFRUVmjp1qjIyMjR8+HBJ0jXXXKOxY8dq1qxZ2rp1q/bu3aspU6YoOTlZN954Y9D2CwBAIIVE/CVpxYoVSk5OVmZmpkaPHq2RI0dq2bJl3vsbGxt16NAhnTlzxjv21FNP6fbbb9f48eP1ve99T06nU6+++qrP933hhReUnp6uMWPGaNSoUYqIiFBpaakiIiLavLaoqCgtWLCg2bcCTMO58MX5+BLn4kucC1+cjy911LkIic/5AwAA/wmZZ/4AAMA/iD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhiD8AAIYh/gAAGIb4AwBgGOIPAIBhQi7+zzzzjPr27avo6Gilp6dr+/btrc5fvXq1kpOTFR0drUGDBmn9+vUXzTlw4IDuuOMOORwOde3aVUOHDlVlZWWgtgAAQFCFVPxXrVql/Px8LViwQDt37tTgwYOVnZ2t6urqZudv3bpVubm5ysvL065du5STk6OcnBzt3bvXO+fDDz/UyJEjlZycrNdff127d+/WT37yE0VHR3fUtgAA6FA2y7KsYC+irdLT0zV06FAtXbpUkuTxeJSYmKiZM2eqoKDgovkTJkzQ6dOntW7dOu/Y8OHDlZqaquLiYknSxIkTFRERod/97ncdswkAAIIsPNgLaKuGhgZVVFSosLDQO2a325WVlaXy8vJmjykvL1d+fr7PWHZ2ttasWSPp/A8Pf/7zn/XjH/9Y2dnZ2rVrl/r166fCwkLl5OS0uJb6+nrV19d7v/Z4PKqpqVH37t1ls9nav0kAgNEsy9Lnn3+uhIQE2e2Be3E+ZOJ/8uRJNTU1KT4+3mc8Pj5eBw8ebPYYl8vV7HyXyyVJqq6u1qlTp/TYY4/p5z//uR5//HGVlpZq3Lhx2rx5s0aNGtXs9y0qKtLChQv9sCsAAC525MgRXX311QH7/iET/0DweDySpLFjx2r27NmSpNTUVG3dulXFxcUtxr+wsNDnFQW3262kpCQdOXJEMTExgV84AOBrqa6uTomJifrGN74R0McJmfj36NFDYWFhqqqq8hmvqqqS0+ls9hin09nq/B49eig8PFwDBw70mZOSkqK//e1vLa4lKipKUVFRF43HxMQQfwDAZQv0W8ghc7V/ZGSk0tLSVFZW5h3zeDwqKytTRkZGs8dkZGT4zJekDRs2eOdHRkZq6NChOnTokM+c9957T3369PHzDgAA6BxC5pm/JOXn52vKlCkaMmSIhg0bpsWLF+v06dOaOnWqJGny5Mnq3bu3ioqKJEmzZs3SqFGjtGjRIo0ZM0YrV67UO++8o2XLlnm/59y5czVhwgR973vf04033qjS0lKtXbtWr7/+ejC2CABAwIVU/CdMmKATJ05o/vz5crlcSk1NVWlpqfeivsrKSp+rI0eMGKGSkhLNmzdPDz/8sAYMGKA1a9bo+uuv98658847VVxcrKKiIj3wwAO69tpr9corr2jkyJEdvj8AADpCSH3Ov7Oqq6uTw+GQ2+3mPX8AuEwej0cNDQ3BXkbAREZGtvgxvo7qSUg98wcAfL01NDToo48+8n4a6+vIbrerX79+ioyMDNoaiD8AoFOwLEuffPKJwsLClJiYGNBfchMsHo9Hx48f1yeffKKkpKSg/WI44g8A6BTOnTunM2fOKCEhQV26dAn2cgImLi5Ox48f17lz5xQRERGUNXz9fqwCAISkpqYmSQrqy+Ed4cL+Luw3GIg/AKBT+br/jZTOsD/iDwCAYYg/AACGIf4AAFyGn/70p7LZbD635OTkYC+rVVztDwDAZbruuuu0ceNG79fh4Z07r517dQAAY1mWpS8ag3NF/BURYZd0YV54eHiLf2G2MyL+AIBO6YvGJg2c/1pQHnv/o9nqEtn2RL7//vtKSEhQdHS0MjIyVFRUpKSkpACu8PLwnj8AAJchPT1dy5cvV2lpqZ577jl99NFH+u53v6vPP/882EtrEc/8AQCd0hURYdr/aHbQHrutbrvtNu8/33DDDUpPT1efPn30+9//Xnl5eYFY3mUj/gCATslms13SS++dRWxsrK655hp98MEHwV5Ki3jZHwAAPzp16pQ+/PBD9erVK9hLaRHxBwDgMjz44IPasmWLPv74Y23dulV33nmnwsLClJubG+yltSj0Xk8BAKATOXr0qHJzc/Xpp58qLi5OI0eO1Ntvv624uLhgL61FxB8AgMuwcuXKYC/hkvGyPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwCgU7EsK9hLCKjOsD/iDwDoFMLCzv9K3YaGhiCvJLAu7O/CfoOBj/oBADqF8PBwdenSRSdOnFBERITs9q/f81OPx6MTJ06oS5cuCg8PXoKJPwCgU7DZbOrVq5c++ugjHT58ONjLCRi73a6kpCTZbLagrYH4AwA6jcjISA0YMOBr/dJ/ZGRk0F/VIP4AgE7FbrcrOjo62Mv4Wvv6vaECAABaRfwBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADBMyMX/mWeeUd++fRUdHa309HRt37691fmrV69WcnKyoqOjNWjQIK1fv77FuT/84Q9ls9m0ePFiP68aAIDOI6Tiv2rVKuXn52vBggXauXOnBg8erOzsbFVXVzc7f+vWrcrNzVVeXp527dqlnJwc5eTkaO/evRfN/cMf/qC3335bCQkJgd4GAABBFVLxf/LJJ3X//fdr6tSpGjhwoIqLi9WlSxc9//zzzc5fsmSJbr31Vs2dO1cpKSn62c9+pm9/+9taunSpz7xjx45p5syZWrFihSIiIjpiKwAABE3IxL+hoUEVFRXKysryjtntdmVlZam8vLzZY8rLy33mS1J2drbPfI/Ho3vvvVdz587Vdddd16a11NfXq66uzucGAECoCJn4nzx5Uk1NTYqPj/cZj4+Pl8vlavYYl8v1lfMff/xxhYeH64EHHmjzWoqKiuRwOLy3xMTES9gJAADBFTLxD4SKigotWbJEy5cvl81ma/NxhYWFcrvd3tuRI0cCuEoAAPwrZOLfo0cPhYWFqaqqyme8qqpKTqez2WOcTmer8998801VV1crKSlJ4eHhCg8P1+HDhzVnzhz17du3xbVERUUpJibG5wYAQKgImfhHRkYqLS1NZWVl3jGPx6OysjJlZGQ0e0xGRobPfEnasGGDd/69996r3bt36+9//7v3lpCQoLlz5+q1114L3GYAAAii8GAv4FLk5+drypQpGjJkiIYNG6bFixfr9OnTmjp1qiRp8uTJ6t27t4qKiiRJs2bN0qhRo7Ro0SKNGTNGK1eu1DvvvKNly5ZJkrp3767u3bv7PEZERIScTqeuvfbajt0cAAAdJKTiP2HCBJ04cULz58+Xy+VSamqqSktLvRf1VVZWym7/8sWMESNGqKSkRPPmzdPDDz+sAQMGaM2aNbr++uuDtQUAAILOZlmWFexFhLq6ujo5HA653W7e/wcAtFtH9SRk3vMHAAD+QfwBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDAhF/9nnnlGffv2VXR0tNLT07V9+/ZW569evVrJycmKjo7WoEGDtH79eu99jY2NeuihhzRo0CB17dpVCQkJmjx5so4fPx7obQAAEDQhFf9Vq1YpPz9fCxYs0M6dOzV48GBlZ2erurq62flbt25Vbm6u8vLytGvXLuXk5CgnJ0d79+6VJJ05c0Y7d+7UT37yE+3cuVOvvvqqDh06pDvuuKMjtwUAQIeyWZZlBXsRbZWenq6hQ4dq6dKlkiSPx6PExETNnDlTBQUFF82fMGGCTp8+rXXr1nnHhg8frtTUVBUXFzf7GDt27NCwYcN0+PBhJSUltWlddXV1cjgccrvdiomJacfOAADouJ6EzDP/hoYGVVRUKCsryztmt9uVlZWl8vLyZo8pLy/3mS9J2dnZLc6XJLfbLZvNptjY2Bbn1NfXq66uzucGAECoCJn4nzx5Uk1NTYqPj/cZj4+Pl8vlavYYl8t1SfPPnj2rhx56SLm5ua3+xFVUVCSHw+G9JSYmXuJuAAAInpCJf6A1Njbq7rvvlmVZeu6551qdW1hYKLfb7b0dOXKkg1YJAMDlCw/2AtqqR48eCgsLU1VVlc94VVWVnE5ns8c4nc42zb8Q/sOHD2vTpk1f+T5LVFSUoqKi2rELAACCL2Se+UdGRiotLU1lZWXeMY/Ho7KyMmVkZDR7TEZGhs98SdqwYYPP/Avhf//997Vx40Z17949MBsAAKCTCJln/pKUn5+vKVOmaMiQIRo2bJgWL16s06dPa+rUqZKkyZMnq3fv3ioqKpIkzZo1S6NGjdKiRYs0ZswYrVy5Uu+8846WLVsm6Xz477rrLu3cuVPr1q1TU1OT93qAbt26KTIyMjgbBQAggEIq/hMmTNCJEyc0f/58uVwupaamqrS01HtRX2Vlpez2L1/MGDFihEpKSjRv3jw9/PDDGjBggNasWaPrr79eknTs2DH96U9/kiSlpqb6PNbmzZv1/e9/v0P2BQBARwqpz/l3VnzOHwDgD3zOHwAABATxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMEy74h8WFqbq6uqLxj/99FOFhYVd9qIAAEDgtCv+lmU1O15fX6/IyMjLWhAAAAis8EuZ/PTTT0uSbDab/ud//kdXXnml976mpia98cYbSk5O9u8KAQCAX11S/J966ilJ55/5FxcX+7zEHxkZqb59+6q4uNi/KwQAAH51SfH/6KOPJEk33nijXn31VV111VUBWRQAAAicdr3nv3nzZl111VVqaGjQoUOHdO7cOX+vCwAABEi74v/FF18oLy9PXbp00XXXXafKykpJ0syZM/XYY4/5dYEAAMC/2hX/goICvfvuu3r99dcVHR3tHc/KytKqVav8tjgAAOB/l/Se/wVr1qzRqlWrNHz4cNlsNu/4ddddpw8//NBviwMAAP7Xrmf+J06cUM+ePS8aP336tM8PAwAAoPNpV/yHDBmiP//5z96vLwT/f/7nf5SRkeGflQEAgIBo18v+v/zlL3Xbbbdp//79OnfunJYsWaL9+/dr69at2rJli7/XCAAA/Khdz/xHjhypv//97zp37pwGDRqkv/71r+rZs6fKy8uVlpbm7zUCAAA/slkt/aJ+tFldXZ0cDofcbrdiYmKCvRwAQIjqqJ60+WX/urq6Nn9TAggAQOfV5vjHxsa2+Ur+pqamdi8IAAAEVpvjv3nzZu8/f/zxxyooKNB9993nvbq/vLxcv/3tb1VUVOT/VQIAAL9p13v+mZmZ+rd/+zfl5ub6jJeUlGjZsmV6/fXX/bW+kMB7/gAAf+ionrTrav/y8nINGTLkovEhQ4Zo+/btl70oAAAQOO2Kf2Jiov77v//7ovH/+Z//UWJi4mUvCgAABE67fsnPU089pfHjx+svf/mL0tPTJUnbt2/X+++/r1deecWvCwQAAP7Vrmf+o0eP1vvvv6877rhDNTU1qqmp0f/9v/9X7733nkaPHu3vNQIAAD8K6C/5+fd//3c9+uij6tGjR6AeolPggj8AgD906gv+2urFF1+8pF8OBAAAAi+g8ec3BwMA0PkENP6B8Mwzz6hv376Kjo5Wenr6V360cPXq1UpOTlZ0dLQGDRqk9evX+9xvWZbmz5+vXr166YorrlBWVpbef//9QG4BAICgCqn4r1q1Svn5+VqwYIF27typwYMHKzs7W9XV1c3O37p1q3Jzc5WXl6ddu3YpJydHOTk52rt3r3fOr371Kz399NMqLi7Wtm3b1LVrV2VnZ+vs2bMdtS0AADpUQC/4+8Y3vqF3331X/fv398v3S09P19ChQ7V06VJJksfjUWJiombOnKmCgoKL5k+YMEGnT5/WunXrvGPDhw9XamqqiouLZVmWEhISNGfOHD344IOSJLfbrfj4eC1fvlwTJ05s07q44A8A4A9fiwv+/KmhoUEVFRXKysryjtntdmVlZam8vLzZY8rLy33mS1J2drZ3/kcffSSXy+Uzx+FwKD09vcXvKUn19fWqq6vzuQEAECoCGv977rnHbz+5nDx5Uk1NTYqPj/cZj4+Pl8vlavYYl8vV6vwL/3sp31OSioqK5HA4vDd+qyEAIJS0K/59+/bVo48+qsrKylbnPffcc1/Lz/gXFhbK7XZ7b0eOHAn2kgAAaLN2xf8//uM/9Oqrr6p///66+eabtXLlStXX1/t7bT569OihsLAwVVVV+YxXVVXJ6XQ2e4zT6Wx1/oX/vZTvKUlRUVGKiYnxuQEAECraHf+///3v2r59u1JSUjRz5kz16tVLM2bM0M6dO/29RklSZGSk0tLSVFZW5h3zeDwqKytTRkZGs8dkZGT4zJekDRs2eOf369dPTqfTZ05dXZ22bdvW4vcEACDkWX7Q0NBgLV682IqKirLsdrs1ePBg69e//rXl8Xj88e29Vq5caUVFRVnLly+39u/fb02bNs2KjY21XC6XZVmWde+991oFBQXe+W+99ZYVHh5u/ed//qd14MABa8GCBVZERIS1Z88e75zHHnvMio2Ntf74xz9au3fvtsaOHWv169fP+uKLL9q8LrfbbUmy3G63/zYLADBOR/WkXX/V74LGxkb94Q9/0G9+8xtt2LBBw4cPV15eno4ePaqHH35YGzduVElJiX9+StH5j+6dOHFC8+fPl8vlUmpqqkpLS70X7FVWVspu//LFjBEjRqikpETz5s3Tww8/rAEDBmjNmjW6/vrrvXN+/OMf6/Tp05o2bZpqa2s1cuRIlZaWKjo62m/rBgCgM2nX5/x37typ3/zmN3rppZdkt9s1efJk/du//ZuSk5O9c/bu3auhQ4fqiy++8OuCOyM+5w8A8IeO6km7nvkPHTpUN998s5577jnl5OQoIiLiojn9+vVr8y/JAQAAHadd8f/HP/6hPn36tDqna9eu+s1vftOuRQEAgMBp19X+drtdR48e9X69fft2/cd//IeWLVvmt4UBAIDAaFf8//Vf/1WbN2+WdP635N18883avn27HnnkET366KN+XSAAAPCvdsV/7969GjZsmCTp97//va6//npt3bpVK1as0PLly/25PgAA4Gftin9jY6OioqIkSRs3btQdd9whSUpOTtYnn3ziv9UBAAC/a1f8r7vuOhUXF+vNN9/Uhg0bdOutt0qSjh8/ru7du/t1gQAAwL/aFf/HH39c/+///T99//vfV25urgYPHixJ+tOf/uR9OwAAAHRO7folP5LU1NSkuro6XXXVVd6xjz/+WF26dFHPnj39tsBQwC/5AQD4Q6f+JT+SFBYW5hN+6fyf+gUAAJ1bm+P/7W9/W2VlZbrqqqv0rW99SzabrcW5gfrLfgAA4PK1Of5jx471XuGfk5MTqPUAAIAAa/d7/vgS7/kDAPyh07/nL0kVFRU6cOCApPMf//vWt77ll0UBAIDAaVf8q6urNXHiRL3++uuKjY2VJNXW1urGG2/UypUrFRcX5881AgAAP2rX5/xnzpypzz//XPv27VNNTY1qamq0d+9e1dXV6YEHHvD3GgEAgB+16z1/h8OhjRs3aujQoT7j27dv1y233KLa2lp/rS8k8J4/AMAfOqon7Xrm7/F4FBERcdF4RESEPB7PZS8KAAAETrvif9NNN2nWrFk6fvy4d+zYsWOaPXu2MjMz/bY4AADgf+2K/9KlS1VXV6e+ffvqm9/8pr75zW+qb9++qqur03/913/5e40AAMCP2nW1f2Jionbu3KmysjLvR/1SUlKUlZXl18UBAAD/a/cv+SkrK1NZWZmqq6svep//+eef98viQgUX/AEA/KFT/5KfhQsX6tFHH9WQIUPUq1evVn/PPwAA6FzaFf/i4mItX75c9957r7/XAwAAAqxdF/w1NDRoxIgR/l4LAADoAO2K/7/927+ppKTE32sBAAAdoF0v+589e1bLli3Txo0bdcMNN1z0C3+efPJJvywOAAD4X7viv3v3bqWmpkqS9u7d63MfF/8BANC5tSv+mzdv9vc6AABAB2nXe/4AACB0EX8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAwTMvGvqanRpEmTFBMTo9jYWOXl5enUqVOtHnP27FlNnz5d3bt315VXXqnx48erqqrKe/+7776r3NxcJSYm6oorrlBKSoqWLFkS6K0AABBUIRP/SZMmad++fdqwYYPWrVunN954Q9OmTWv1mNmzZ2vt2rVavXq1tmzZouPHj2vcuHHe+ysqKtSzZ0+9+OKL2rdvnx555BEVFhZq6dKlgd4OAABBY7Msywr2Ir7KgQMHNHDgQO3YsUNDhgyRJJWWlmr06NE6evSoEhISLjrG7XYrLi5OJSUluuuuuyRJBw8eVEpKisrLyzV8+PBmH2v69Ok6cOCANm3a1Ob11dXVyeFwyO12KyYmph07BACg43oSEs/8y8vLFRsb6w2/JGVlZclut2vbtm3NHlNRUaHGxkZlZWV5x5KTk5WUlKTy8vIWH8vtdqtbt26trqe+vl51dXU+NwAAQkVIxN/lcqlnz54+Y+Hh4erWrZtcLleLx0RGRio2NtZnPD4+vsVjtm7dqlWrVn3l2wlFRUVyOBzeW2JiYts3AwBAkAU1/gUFBbLZbK3eDh482CFr2bt3r8aOHasFCxbolltuaXVuYWGh3G6393bkyJEOWSMAAP4QHswHnzNnju67775W5/Tv319Op1PV1dU+4+fOnVNNTY2cTmezxzmdTjU0NKi2ttbn2X9VVdVFx+zfv1+ZmZmaNm2a5s2b95XrjoqKUlRU1FfOAwCgMwpq/OPi4hQXF/eV8zIyMlRbW6uKigqlpaVJkjZt2iSPx6P09PRmj0lLS1NERITKyso0fvx4SdKhQ4dUWVmpjIwM77x9+/bppptu0pQpU/SLX/zCD7sCAKBzC4mr/SXptttuU1VVlYqLi9XY2KipU6dqyJAhKikpkSQdO3ZMmZmZeuGFFzRs2DBJ0o9+9COtX79ey5cvV0xMjGbOnCnp/Hv70vmX+m+66SZlZ2friSee8D5WWFhYm34ouYCr/QEA/tBRPQnqM/9LsWLFCs2YMUOZmZmy2+0aP368nn76ae/9jY2NOnTokM6cOeMde+qpp7xz6+vrlZ2drWeffdZ7/8svv6wTJ07oxRdf1Isvvugd79Onjz7++OMO2RcAAB0tZJ75d2Y88wcA+AOf8wcAAAFB/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMEzIxL+mpkaTJk1STEyMYmNjlZeXp1OnTrV6zNmzZzV9+nR1795dV155pcaPH6+qqqpm53766ae6+uqrZbPZVFtbG4AdAADQOYRM/CdNmqR9+/Zpw4YNWrdund544w1Nmzat1WNmz56ttWvXavXq1dqyZYuOHz+ucePGNTs3Ly9PN9xwQyCWDgBAp2KzLMsK9iK+yoEDBzRw4EDt2LFDQ4YMkSSVlpZq9OjROnr0qBISEi46xu12Ky4uTiUlJbrrrrskSQcPHlRKSorKy8s1fPhw79znnntOq1at0vz585WZmanPPvtMsbGxbV5fXV2dHA6H3G63YmJiLm+zAABjdVRPQuKZf3l5uWJjY73hl6SsrCzZ7XZt27at2WMqKirU2NiorKws71hycrKSkpJUXl7uHdu/f78effRRvfDCC7Lb23Y66uvrVVdX53MDACBUhET8XS6Xevbs6TMWHh6ubt26yeVytXhMZGTkRc/g4+PjvcfU19crNzdXTzzxhJKSktq8nqKiIjkcDu8tMTHx0jYEAEAQBTX+BQUFstlsrd4OHjwYsMcvLCxUSkqK7rnnnks+zu12e29HjhwJ0AoBAPC/8GA++Jw5c3Tfffe1Oqd///5yOp2qrq72GT937pxqamrkdDqbPc7pdKqhoUG1tbU+z/6rqqq8x2zatEl79uzRyy+/LEm6cPlDjx499Mgjj2jhwoXNfu+oqChFRUW1ZYsAAHQ6QY1/XFyc4uLivnJeRkaGamtrVVFRobS0NEnnw+3xeJSent7sMWlpaYqIiFBZWZnGjx8vSTp06JAqKyuVkZEhSXrllVf0xRdfeI/ZsWOHfvCDH+jNN9/UN7/5zcvdHgAAnVJQ499WKSkpuvXWW3X//feruLhYjY2NmjFjhiZOnOi90v/YsWPKzMzUCy+8oGHDhsnhcCgvL0/5+fnq1q2bYmJiNHPmTGVkZHiv9P/fgT958qT38S7lan8AAEJJSMRfklasWKEZM2YoMzNTdrtd48eP19NPP+29v7GxUYcOHdKZM2e8Y0899ZR3bn19vbKzs/Xss88GY/kAAHQaIfE5/86Oz/kDAPyBz/kDAICAIP4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYBjiDwCAYYg/AACGIf4AABiG+AMAYJiQiX9NTY0mTZqkmJgYxcbGKi8vT6dOnWr1mLNnz2r69Onq3r27rrzySo0fP15VVVUXzVu+fLluuOEGRUdHq2fPnpo+fXqgtgEAQNCFTPwnTZqkffv2acOGDVq3bp3eeOMNTZs2rdVjZs+erbVr12r16tXasmWLjh8/rnHjxvnMefLJJ/XII4+ooKBA+/bt08aNG5WdnR3IrQAAEFQ2y7KsYC/iqxw4cEADBw7Ujh07NGTIEElSaWmpRo8eraNHjyohIeGiY9xut+Li4lRSUqK77rpLknTw4EGlpKSovLxcw4cP12effabevXtr7dq1yszMbPf66urq5HA45Ha7FRMT0+7vAwAwW0f1JDxg39mPysvLFRsb6w2/JGVlZclut2vbtm268847LzqmoqJCjY2NysrK8o4lJycrKSnJG/8NGzbI4/Ho2LFjSklJ0eeff64RI0Zo0aJFSkxMbHE99fX1qq+v937tdrslnf+XBgBAe13oSKCfl4dE/F0ul3r27OkzFh4erm7dusnlcrV4TGRkpGJjY33G4+Pjvcf84x//kMfj0S9/+UstWbJEDodD8+bN080336zdu3crMjKy2e9dVFSkhQsXXjTe2g8MAAC01aeffiqHwxGw7x/U+BcUFOjxxx9vdc6BAwcC9vgej0eNjY16+umndcstt0iSXnrpJTmdTm3evLnF9/4LCwuVn5/v/bq2tlZ9+vRRZWVlQP9lhYK6ujolJibqyJEjvAUizsc/41x8iXPhi/PxJbfbraSkJHXr1i2gjxPU+M+ZM0f33Xdfq3P69+8vp9Op6upqn/Fz586ppqZGTqez2eOcTqcaGhpUW1vr8+y/qqrKe0yvXr0kSQMHDvTeHxcXpx49eqiysrLFNUVFRSkqKuqicYfDYfx/uBfExMRwLv4J5+NLnIsvcS58cT6+ZLcH9nr8oMY/Li5OcXFxXzkvIyNDtbW1qqioUFpamiRp06ZN8ng8Sk9Pb/aYtLQ0RUREqKysTOPHj5ckHTp0SJWVlcrIyJAkfec73/GOX3311ZLOf6Tw5MmT6tOnz2XvDwCAzigkPuqXkpKiW2+9Vffff7+2b9+ut956SzNmzNDEiRO9V/ofO3ZMycnJ2r59u6Tzz8Lz8vKUn5+vzZs3q6KiQlOnTlVGRoaGDx8uSbrmmms0duxYzZo1S1u3btXevXs1ZcoUJScn68YbbwzafgEACKSQiL8krVixQsnJycrMzNTo0aM1cuRILVu2zHt/Y2OjDh06pDNnznjHnnrqKd1+++0aP368vve978npdOrVV1/1+b4vvPCC0tPTNWbMGI0aNUoREREqLS1VREREm9cWFRWlBQsWNPtWgGk4F744H1/iXHyJc+GL8/GljjoXIfE5fwAA4D8h88wfAAD4B/EHAMAwxB8AAMMQfwAADEP8AQAwDPEHAMAwxB8AAMMQfwAADEP8AQAwDPEHAMAwxB8AAMMQfwAADEP8AQAwTMjF/5lnnlHfvn0VHR2t9PR0bd++vdX5q1evVnJysqKjozVo0CCtX7/+ojkHDhzQHXfcIYfDoa5du2ro0KGqrKwM1BYAAAiqkIr/qlWrlJ+frwULFmjnzp0aPHiwsrOzVV1d3ez8rVu3Kjc3V3l5edq1a5dycnKUk5OjvXv3eud8+OGHGjlypJKTk/X6669r9+7d+slPfqLo6OiO2hYAAB3KZlmWFexFtFV6erqGDh2qpUuXSpI8Ho8SExM1c+ZMFRQUXDR/woQJOn36tNatW+cdGz58uFJTU1VcXCxJmjhxoiIiIvS73/2uYzYBAECQhQd7AW3V0NCgiooKFRYWesfsdruysrJUXl7e7DHl5eXKz8/3GcvOztaaNWsknf/h4c9//rN+/OMfKzs7W7t27VK/fv1UWFionJycFtdSX1+v+vp679cej0c1NTXq3r27bDZb+zcJADCaZVn6/PPPlZCQILs9cC/Oh0z8T548qaamJsXHx/uMx8fH6+DBg80e43K5mp3vcrkkSdXV1Tp16pQee+wx/fznP9fjjz+u0tJSjRs3Tps3b9aoUaOa/b5FRUVauHChH3YFAMDFjhw5oquvvjpg3z9k4h8IHo9HkjR27FjNnj1bkpSamqqtW7equLi4xfgXFhb6vKLgdruVlJSkI0eOKCYmJvALBwB8LdXV1SkxMVHf+MY3Avo4IRP/Hj16KCwsTFVVVT7jVVVVcjqdzR7jdDpbnd+jRw+Fh4dr4MCBPnNSUlL0t7/9rcW1REVFKSoq6qLxmJgY4g8AuGyBfgs5ZK72j4yMVFpamsrKyrxjHo9HZWVlysjIaPaYjIwMn/mStGHDBu/8yMhIDR06VIcOHfKZ895776lPnz5+3gEAAJ1DyDzzl6T8/HxNmTJFQ4YM0bBhw7R48WKdPn1aU6dOlSRNnjxZvXv3VlFRkSRp1qxZGjVqlBYtWqQxY8Zo5cqVeuedd7Rs2TLv95w7d64mTJig733ve7rxxhtVWlqqtWvX6vXXXw/GFgEACLiQiv+ECRN04sQJzZ8/Xy6XS6mpqSotLfVe1FdZWelzdeSIESNUUlKiefPm6eGHH9aAAQO0Zs0aXX/99d45d955p4qLi1VUVKQHHnhA1157rV555RWNHDmyw/cHAEBHCKnP+XdWdXV1cjgccrvdvOcPAJepqalJjY2NwV5GwERERCgsLKzZ+zqqJyH1zB8A8PV26tQpHT16VF/n56U2m01XX321rrzyyqCtgfgDADqFpqYmHT16VF26dFFcXNzX8pemWZalEydO6OjRoxowYECLrwAEGvEHAHQKjY2NsixLcXFxuuKKK4K9nICJi4vTxx9/rMbGxqDFP2Q+6gcAMMPX8Rn/P+sM+yP+AAAYhvgDAGAY4g8AgGGIPwAAl+GnP/2pbDabzy05OTnYy2oVV/sDAHCZrrvuOm3cuNH7dXh4585r514dAMBYlmXpi8amoDz2FRFhl3RVfnh4eIt/YbYzIv4AgE7pi8YmDZz/WlAee/+j2eoS2fZEvv/++0pISFB0dLQyMjJUVFSkpKSkAK7w8vCePwAAlyE9PV3Lly9XaWmpnnvuOX300Uf67ne/q88//zzYS2sRz/wBAJ3SFRFh2v9odtAeu61uu+027z/fcMMNSk9PV58+ffT73/9eeXl5gVjeZSP+AIBOyWazXdJL751FbGysrrnmGn3wwQfBXkqLeNkfAAA/OnXqlD788EP16tUr2EtpEfEHAOAyPPjgg9qyZYs+/vhjbd26VXfeeafCwsKUm5sb7KW1KPReTwEAoBM5evSocnNz9emnnyouLk4jR47U22+/rbi4uGAvrUXEHwCAy7By5cpgL+GS8bI/AACGIf4AABiG+AMAYBjiDwCAYYg/AKBTsSwr2EsIqM6wP+IPAOgUwsLO/0rdhoaGIK8ksC7s78J+g4GP+gEAOoXw8HB16dJFJ06cUEREhOz2r9/zU4/HoxMnTqhLly4KDw9egok/AKBTsNls6tWrlz766CMdPnw42MsJGLvdrqSkJNlstqCtgfgDADqNyMhIDRgw4Gv90n9kZGTQX9Ug/gCATsVutys6OjrYy/ha+/q9oQIAAFpF/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMEzIxf+ZZ55R3759FR0drfT0dG3fvr3V+atXr1ZycrKio6M1aNAgrV+/vsW5P/zhD2Wz2bR48WI/rxoAgM4jpOK/atUq5efna8GCBdq5c6cGDx6s7OxsVVdXNzt/69atys3NVV5ennbt2qWcnBzl5ORo7969F839wx/+oLffflsJCQmB3gYAAEEVUvF/8skndf/992vq1KkaOHCgiouL1aVLFz3//PPNzl+yZIluvfVWzZ07VykpKfrZz36mb3/721q6dKnPvGPHjmnmzJlasWKFIiIiOmIrAAAETcjEv6GhQRUVFcrKyvKO2e12ZWVlqby8vNljysvLfeZLUnZ2ts98j8eje++9V3PnztV1113XprXU19errq7O5wYAQKgImfifPHlSTU1Nio+P9xmPj4+Xy+Vq9hiXy/WV8x9//HGFh4frgQceaPNaioqK5HA4vLfExMRL2AkAAMEVMvEPhIqKCi1ZskTLly+XzWZr83GFhYVyu93e25EjRwK4SgAA/Ctk4t+jRw+FhYWpqqrKZ7yqqkpOp7PZY5xOZ6vz33zzTVVXVyspKUnh4eEKDw/X4cOHNWfOHPXt27fFtURFRSkmJsbnBgBAqAiZ+EdGRiotLU1lZWXeMY/Ho7KyMmVkZDR7TEZGhs98SdqwYYN3/r333qvdu3fr73//u/eWkJCguXPn6rXXXgvcZgAACKLwYC/gUuTn52vKlCkaMmSIhg0bpsWLF+v06dOaOnWqJGny5Mnq3bu3ioqKJEmzZs3SqFGjtGjRIo0ZM0YrV67UO++8o2XLlkmSunfvru7du/s8RkREhJxOp6699tqO3RwAAB0kpOI/YcIEnThxQvPnz5fL5VJqaqpKS0u9F/VVVlbKbv/yxYwRI0aopKRE8+bN08MPP6wBAwZozZo1uv7664O1BQAAgs5mWZYV7EWEurq6OjkcDrndbt7/BwC0W0f1JGTe8wcAAP5B/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMMQfAADDEH8AAAxD/AEAMAzxBwDAMCEX/2eeeUZ9+/ZVdHS00tPTtX379lbnr169WsnJyYqOjtagQYO0fv16732NjY166KGHNGjQIHXt2lUJCQmaPHmyjh8/HuhtAAAQNCEV/1WrVik/P18LFizQzp07NXjwYGVnZ6u6urrZ+Vu3blVubq7y8vK0a9cu5eTkKCcnR3v37pUknTlzRjt37tRPfvIT7dy5U6+++qoOHTqkO+64oyO3BQBAh7JZlmUFexFtlZ6erqFDh2rp0qWSJI/Ho8TERM2cOVMFBQUXzZ8wYYJOnz6tdevWeceGDx+u1NRUFRcXN/sYO3bs0LBhw3T48GElJSW1aV11dXVyOBxyu92KiYlpx84AAOi4noTMM/+GhgZVVFQoKyvLO2a325WVlaXy8vJmjykvL/eZL0nZ2dktzpckt9stm82m2NjYFufU19errq7O5wYAQKgImfifPHlSTU1Nio+P9xmPj4+Xy+Vq9hiXy3VJ88+ePauHHnpIubm5rf7EVVRUJIfD4b0lJiZe4m4AAAiekIl/oDU2Nuruu++WZVl67rnnWp1bWFgot9vtvR05cqSDVgkAwOULD/YC2qpHjx4KCwtTVVWVz3hVVZWcTmezxzidzjbNvxD+w4cPa9OmTV/5PktUVJSioqLasQsAAIIvZJ75R0ZGKi0tTWVlZd4xj8ejsrIyZWRkNHtMRkaGz3xJ2rBhg8/8C+F///33tXHjRnXv3j0wGwAAoJMImWf+kpSfn68pU6ZoyJAhGjZsmBYvXqzTp09r6tSpkqTJkyerd+/eKioqkiTNmjVLo0aN0qJFizRmzBitXLlS77zzjpYtWybpfPjvuusu7dy5U+vWrVNTU5P3eoBu3bopMjIyOBsFACCAQir+EyZM0IkTJzR//ny5XC6lpqaqtLTUe1FfZWWl7PYvX8wYMWKESkpKNG/ePD388MMaMGCA1qxZo+uvv16SdOzYMf3pT3+SJKWmpvo81ubNm/X973+/Q/YFAEBHCqnP+XdWfM4fAOAPfM4fAAAEBPEHAMAwxB8AAMMQfwAADEP8AQAwDPEHAMAwxB8AAMMQfwAADEP8AQAwDPEHAMAwxB8AAMMQfwAADEP8AQAwDPEHAMAwxB8AAMMQfwAADEP8AQAwDPEHAMAwxB8AAMMQfwAADEP8AQAwDPEHAMAwxB8AAMMQfwAADEP8AQAwDPEHAMAwxB8AAMMQfwAADEP8AQAwDPEHAMAwxB8AAMMQfwAADEP8AQAwDPEHAMAwxB8AAMMQfwAADEP8AQAwDPEHAMAwxB8AAMMQfwAADEP8AQAwDPEHAMAwxB8AAMMQfwAADEP8AQAwDPEHAMAwxB8AAMMQfwAADEP8AQAwDPEHAMAwxB8AAMMQfwAADEP8AQAwzCXHv7GxUZmZmXr//fcDsR4AABBglxz/iIgI7d69OxBrAQAAHaBdL/vfc889+vWvf+3vtQAAgA4Q3p6Dzp07p+eff14bN25UWlqaunbt6nP/k08+6ZfFAQAA/2tX/Pfu3atvf/vbkqT33nvP5z6bzXb5qwIAAAHTrvhv3rzZ3+sAAAAd5LI/6nf06FEdPXrUH2sBAAAdoF3x93g8evTRR+VwONSnTx/16dNHsbGx+tnPfiaPx+PvNQIAAD9q18v+jzzyiH7961/rscce03e+8x1J0t/+9jf99Kc/1dmzZ/WLX/zCr4sEAAD+Y7Msy7rUgxISElRcXKw77rjDZ/yPf/yj/v3f/13Hjh3z2wJDQV1dnRwOh9xut2JiYoK9HABAiOqonrTrZf+amholJydfNJ6cnKyamprLXhQAAAicdsV/8ODBWrp06UXjS5cu1eDBgy97UQAAIHDa9Z7/r371K40ZM0YbN25URkaGJKm8vFxHjhzR+vXr/bpAAADgX+165j9q1Ci99957uvPOO1VbW6va2lqNGzdOhw4d0ne/+11/r9HHM888o759+yo6Olrp6enavn17q/NXr16t5ORkRUdHa9CgQRf9cGJZlubPn69evXrpiiuuUFZWFn+0CADw9Wa1w+HDhy2Px9PifYGycuVKKzIy0nr++eetffv2Wffff78VGxtrVVVVNTv/rbfessLCwqxf/epX1v79+6158+ZZERER1p49e7xzHnvsMcvhcFhr1qyx3n33XeuOO+6w+vXrZ33xxRdtXpfb7bYkWW63+7L3CAAwV0f1pF1X+4eFhemTTz5Rz549fcY//fRT9ezZU01NTX760cRXenq6hg4d6r3ewOPxKDExUTNnzlRBQcFF8ydMmKDTp09r3bp13rHhw4crNTVVxcXFsixLCQkJmjNnjh588EFJktvtVnx8vJYvX66JEye2aV1c7Q8A8IdOfbW/ZVnN/g7/U6dOKTo6+rIX1ZyGhgZVVFQoKyvLO2a325WVlaXy8vJmjykvL/eZL0nZ2dne+R999JFcLpfPHIfDofT09Ba/pyTV19errq7O5wYAQKi4pAv+8vPzJZ3/4z0/+clP1KVLF+99TU1N2rZtm1JTU/26wAtOnjyppqYmxcfH+4zHx8fr4MGDzR7jcrmane9yubz3XxhraU5zioqKtHDhwkveAwAAncElxX/Xrl2Szj/z37NnjyIjI733RUZGavDgwd6Xz7/OCgsLvT8ISedfpklMTAziigAAaLtLiv+Fv+Y3depULVmypEPf3+7Ro4fCwsJUVVXlM15VVSWn09nsMU6ns9X5F/63qqpKvXr18pnT2isYUVFRioqKas82AAAIuna95/+b3/zGG/6O+qt+kZGRSktLU1lZmXfM4/GorKzM+7sG/reMjAyf+ZK0YcMG7/x+/frJ6XT6zKmrq9O2bdta/J4AAIS6kPqrfvn5+frv//5v/fa3v9WBAwf0ox/9SKdPn9bUqVMlSZMnT1ZhYaF3/qxZs1RaWqpFixbp4MGD+ulPf6p33nlHM2bMkHT+2oX/+I//0M9//nP96U9/0p49ezR58mQlJCQoJycnYPsAACCYQuqv+k2YMEEnTpzQ/Pnz5XK5lJqaqtLSUu8Fe5WVlbLbv/x5ZsSIESopKdG8efP08MMPa8CAAVqzZo2uv/5675wf//jHOn36tKZNm6ba2lqNHDlSpaWlAfvUAgAAwcZf9fMDPucPAPCHTv05f/6qHwAAoYu/6gcAgGH8+lf9Kisr9Ze//MWvCwQAAP7V7r/qd+jQIY0bN87nr/q99957Af+rfgAA4PK064I/STp79qx2796t6urqiz7e978vBPy644I/AIA/dFRP2vWyf2lpqSZPnqxPP/1U//tnB5vNFrC/6gcAAC5fu172nzlzpv7lX/5Fx48fl8fj8bkRfgAAOrd2xb+qqkr5+fkX/TU8AADQ+bUr/nfddZdef/11Py8FAAB0hHZd8HfmzBn9y7/8i+Li4jRo0CBFRET43P/AAw/4bYGhgAv+AAD+0Kkv+HvppZf017/+VdHR0Xr99ddls9m899lsNuPiDwBAKGn3H/ZZuHChCgoKfP6QDgAA6PzaVe6GhgZNmDCB8AMAEILaVe8pU6Zo1apV/l4LAADoAO162b+pqUm/+tWv9Nprr+mGG2646IK/J5980i+LAwAA/teu+O/Zs0ff+ta3JEl79+71ue+fL/4DAACdT7viv3nzZn+vAwAAdBCu2AMAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAw4RM/GtqajRp0iTFxMQoNjZWeXl5OnXqVKvHnD17VtOnT1f37t115ZVXavz48aqqqvLe/+677yo3N1eJiYm64oorlJKSoiVLlgR6KwAABFXIxH/SpEnat2+fNmzYoHXr1umNN97QtGnTWj1m9uzZWrt2rVavXq0tW7bo+PHjGjdunPf+iooK9ezZUy+++KL27dunRx55RIWFhVq6dGmgtwMAQNDYLMuygr2Ir3LgwAENHDhQO3bs0JAhQyRJpaWlGj16tI4ePaqEhISLjnG73YqLi1NJSYnuuusuSdLBgweVkpKi8vJyDR8+vNnHmj59ug4cOKBNmza1eX11dXVyOBxyu92KiYlpxw4BAOi4noTEM//y8nLFxsZ6wy9JWVlZstvt2rZtW7PHVFRUqLGxUVlZWd6x5ORkJSUlqby8vMXHcrvd6tatW6vrqa+vV11dnc8NAIBQERLxd7lc6tmzp89YeHi4unXrJpfL1eIxkZGRio2N9RmPj49v8ZitW7dq1apVX/l2QlFRkRwOh/eWmJjY9s0AABBkQY1/QUGBbDZbq7eDBw92yFr27t2rsWPHasGCBbrllltanVtYWCi32+29HTlypEPWCACAP4QH88HnzJmj++67r9U5/fv3l9PpVHV1tc/4uXPnVFNTI6fT2exxTqdTDQ0Nqq2t9Xn2X1VVddEx+/fvV2ZmpqZNm6Z58+Z95bqjoqIUFRX1lfMAAOiMghr/uLg4xcXFfeW8jIwM1dbWqqKiQmlpaZKkTZs2yePxKD09vdlj0tLSFBERobKyMo0fP16SdOjQIVVWViojI8M7b9++fbrppps0ZcoU/eIXv/DDrgAA6NxC4mp/SbrttttUVVWl4uJiNTY2aurUqRoyZIhKSkokSceOHVNmZqZeeOEFDRs2TJL0ox/9SOvXr9fy5csVExOjmTNnSjr/3r50/qX+m266SdnZ2XriiSe8jxUWFtamH0ou4Gp/AIA/dFRPgvrM/1KsWLFCM2bMUGZmpux2u8aPH6+nn37ae39jY6MOHTqkM2fOeMeeeuop79z6+nplZ2fr2Wef9d7/8ssv68SJE3rxxRf14osvesf79Omjjz/+uEP2BQBARwuZZ/6dGc/8AQD+wOf8AQBAQBB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMQ/wBADAM8QcAwDDEHwAAwxB/AAAMEzLxr6mp0aRJkxQTE6PY2Fjl5eXp1KlTrR5z9uxZTZ8+Xd27d9eVV16p8ePHq6qqqtm5n376qa6++mrZbDbV1tYGYAcAAHQOIRP/SZMmad++fdqwYYPWrVunN954Q9OmTWv1mNmzZ2vt2rVavXq1tmzZouPHj2vcuHHNzs3Ly9MNN9wQiKUDANCp2CzLsoK9iK9y4MABDRw4UDt27NCQIUMkSaWlpRo9erSOHj2qhISEi45xu92Ki4tTSUmJ7rrrLknSwYMHlZKSovLycg0fPtw797nnntOqVas0f/58ZWZm6rPPPlNsbGyb11dXVyeHwyG3262YmJjL2ywAwFgd1ZOQeOZfXl6u2NhYb/glKSsrS3a7Xdu2bWv2mIqKCjU2NiorK8s7lpycrKSkJJWXl3vH9u/fr0cffVQvvPCC7Pa2nY76+nrV1dX53AAACBUhEX+Xy6WePXv6jIWHh6tbt25yuVwtHhMZGXnRM/j4+HjvMfX19crNzdUTTzyhpKSkNq+nqKhIDofDe0tMTLy0DQEAEERBjX9BQYFsNlurt4MHDwbs8QsLC5WSkqJ77rnnko9zu93e25EjRwK0QgAA/C88mA8+Z84c3Xfffa3O6d+/v5xOp6qrq33Gz507p5qaGjmdzmaPczqdamhoUG1trc+z/6qqKu8xmzZt0p49e/Tyyy9Lki5c/tCjRw898sgjWrhwYbPfOyoqSlFRUW3ZIgAAnU5Q4x8XF6e4uLivnJeRkaHa2lpVVFQoLS1N0vlwezwepaenN3tMWlqaIiIiVFZWpvHjx0uSDh06pMrKSmVkZEiSXnnlFX3xxRfeY3bs2KEf/OAHevPNN/XNb37zcrcHAECnFNT4t1VKSopuvfVW3X///SouLlZjY6NmzJihiRMneq/0P3bsmDIzM/XCCy9o2LBhcjgcysvLU35+vrp166aYmBjNnDlTGRkZ3iv9/3fgT5486X28S7naHwCAUBIS8ZekFStWaMaMGcrMzJTdbtf48eP19NNPe+9vbGzUoUOHdObMGe/YU0895Z1bX1+v7OxsPfvss8FYPgAAnUZIfM6/s+Nz/gAAf+Bz/gAAICCIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYhvgDAGAY4g8AgGGIPwAAhiH+AAAYJmTiX1NTo0mTJikmJkaxsbHKy8vTqVOnWj3m7Nmzmj59urp3764rr7xS48ePV1VV1UXzli9frhtuuEHR0dHq2bOnpk+fHqhtAAAQdCET/0mTJmnfvn3asGGD1q1bpzfeeEPTpk1r9ZjZs2dr7dq1Wr16tbZs2aLjx49r3LhxPnOefPJJPfLIIyooKNC+ffu0ceNGZWdnB3IrAAAElc2yLCvYi/gqBw4c0MCBA7Vjxw4NGTJEklRaWqrRo0fr6NGjSkhIuOgYt9utuLg4lZSU6K677pIkHTx4UCkpKSovL9fw4cP12WefqXfv3lq7dq0yMzPbvb66ujo5HA653W7FxMS0+/sAAMzWUT0JD9h39qPy8nLFxsZ6wy9JWVlZstvt2rZtm+68886LjqmoqFBjY6OysrK8Y8nJyUpKSvLGf8OGDfJ4PDp27JhSUlL0+eefa8SIEVq0aJESExNbXE99fb3q6+u9X7vdbknn/6UBANBeFzoS6OflIRF/l8ulnj17+oyFh4erW7ducrlcLR4TGRmp2NhYn/H4+HjvMf/4xz/k8Xj0y1/+UkuWLJHD4dC8efN08803a/fu3YqMjGz2excVFWnhwoUXjbf2AwMAAG316aefyuFwBOz7BzX+BQUFevzxx1udc+DAgYA9vsfjUWNjo55++mndcsstkqSXXnpJTqdTmzdvbvG9/8LCQuXn53u/rq2tVZ8+fVRZWRnQf1mhoK6uTomJiTpy5AhvgYjz8c84F1/iXPjifHzJ7XYrKSlJ3bp1C+jjBDX+c+bM0X333dfqnP79+8vpdKq6utpn/Ny5c6qpqZHT6Wz2OKfTqYaGBtXW1vo8+6+qqvIe06tXL0nSwIEDvffHxcWpR48eqqysbHFNUVFRioqKumjc4XAY/x/uBTExMZyLf8L5+BLn4kucC1+cjy/Z7YG9Hj+o8Y+Li1NcXNxXzsvIyFBtba0qKiqUlpYmSdq0aZM8Ho/S09ObPSYtLU0REREqKyvT+PHjJUmHDh1SZWWlMjIyJEnf+c53vONXX321pPMfKTx58qT69Olz2fsDAKAzComP+qWkpOjWW2/V/fffr+3bt+utt97SjBkzNHHiRO+V/seOHVNycrK2b98u6fyz8Ly8POXn52vz5s2qqKjQ1KlTlZGRoeHDh0uSrrnmGo0dO1azZs3S1q1btXfvXk2ZMkXJycm68cYbg7ZfAAACKSTiL0krVqxQcnKyMjMzNXr0aI0cOVLLli3z3t/Y2KhDhw7pzJkz3rGnnnpKt99+u8aPH6/vfe97cjqdevXVV32+7wsvvKD09HSNGTNGo0aNUkREhEpLSxUREdHmtUVFRWnBggXNvhVgGs6FL87HlzgXX+Jc+OJ8fKmjzkVIfM4fAAD4T8g88wcAAP5B/AEAMAzxBwDAMMQfAADDEP824M8J+wrk+ZDO/1rLq6++WjabTbW1tQHYgf8E4ly8++67ys3NVWJioq644gqlpKRoyZIlgd5KuzzzzDPq27evoqOjlZ6e7v2obUtWr16t5ORkRUdHa9CgQVq/fr3P/ZZlaf78+erVq5euuOIKZWVl6f333w/kFvzGn+eisbFRDz30kAYNGqSuXbsqISFBkydP1vHjxwO9Db/w938X/+yHP/yhbDabFi9e7OdVB04gzseBAwd0xx13yOFwqGvXrho6dGirv5zuIha+0q233moNHjzYevvtt60333zT+j//5/9Yubm5rR7zwx/+0EpMTLTKysqsd955xxo+fLg1YsQInzmLFi2yEhISrBUrVlgffPCB9e6771p//OMfA7kVvwjU+bhg7Nix1m233WZJsj777LMA7MB/AnEufv3rX1sPPPCA9frrr1sffvih9bvf/c664oorrP/6r/8K9HYuycqVK63IyEjr+eeft/bt22fdf//9VmxsrFVVVdXs/LfeessKCwuzfvWrX1n79++35s2bZ0VERFh79uzxznnssccsh8NhrVmzxnr33XetO+64w+rXr5/1xRdfdNS22sXf56K2ttbKysqyVq1aZR08eNAqLy+3hg0bZqWlpXXkttolEP9dXPDqq69agwcPthISEqynnnoqwDvxj0Ccjw8++MDq1q2bNXfuXGvnzp3WBx98YP3xj39s8Xs2h/h/hf3791uSrB07dnjH/vKXv1g2m806duxYs8fU1tZaERER1urVq71jBw4csCRZ5eXllmVZVk1NjXXFFVdYGzduDOwG/CxQ5+OCZ5991ho1apRVVlbW6eMf6HPxz/793//duvHGG/23eD8YNmyYNX36dO/XTU1NVkJCglVUVNTs/LvvvtsaM2aMz1h6err1//1//59lWZbl8Xgsp9NpPfHEE977a2trraioKOull14KwA78x9/nojnbt2+3JFmHDx/2z6IDJFDn4ujRo1bv3r2tvXv3Wn369AmZ+AfifEyYMMG65557LmtdvOz/Fb7qzwk356v+nLCki/6c8NVXX627775bR44cCeyGLlOgzock7d+/X48++qheeOGFgP9ea38I5Ln439xud8D/0MelaGhoUEVFhc8+7Ha7srKyWtxHeXm5z3xJys7O9s7/6KOP5HK5fOY4HA6lp6e3em6CLRDnojlut1s2m+2iv1TamQTqXHg8Ht17772aO3eurrvuusAsPgACcT48Ho/+/Oc/65prrlF2drZ69uyp9PR0rVmz5pLW1vn/P2yQdcSfE168eLFefvll1dTU6Oabb1ZDQ0NA9uIPgTof9fX1ys3N1RNPPKGkpKSArN3fAnUu/retW7dq1apVmjZtml/W7Q8nT55UU1OT4uPjfcZb24fL5Wp1/oX/vZTv2RkE4lz8b2fPntVDDz2k3NzcTv2HbwJ1Lh5//HGFh4frgQce8P+iAygQ56O6ulqnTp3SY489pltvvVV//etfdeedd2rcuHHasmVLm9dmbPwLCgpks9lavR08eDBgj//Pf044Oztbw4cP10svvaT3339fmzdvDtjjtiTY56OwsFApKSm65557AvYYbRXsc/HP9u7dq7Fjx2rBggXePzsNszQ2Nuruu++WZVl67rnngr2cDldRUaElS5Zo+fLlstlswV5O0Hk8HknS2LFjNXv2bKWmpqqgoEC33367iouL2/x9gvpX/YIpVP+ccKAE+3xs2rRJe/bs0csvvyzp/FXfktSjRw898sgjWrhwYTt3dumCfS4u2L9/vzIzMzVt2jTNmzevXXsJlB49eigsLOyiT2w0t48LnE5nq/Mv/G9VVZX3/z4ufJ2amurH1ftXIM7FBRfCf/jwYW3atKlTP+uXAnMu3nzzTVVXV/u8ItjU1KQ5c+Zo8eLF+vjjj/27CT8KxPno0aOHwsPDfdohnf8DeH/729/avrjLumLAABcu6nrnnXe8Y6+99lqbLup6+eWXvWMHDx70uajr0KFDliSfC/4+/fRTy263W6+99lqAdnP5AnU+PvjgA2vPnj3e2/PPP29JsrZu3XpJV7B2pECdC8uyrL1791o9e/a05s6dG7gNXKZhw4ZZM2bM8H7d1NRk9e7du9ULmW6//XafsYyMjIsu+PvP//xP7/1utztkLvjz57mwLMtqaGiwcnJyrOuuu86qrq4OzMIDwN/n4uTJkz7/v2HPnj1WQkKC9dBDD1kHDx4M3Eb8JBD/bWRkZFx0wV9OTs5XftLonxH/Nrj11lutb33rW9a2bdusv/3tb9aAAQN8TvLRo0eta6+91tq2bZt37Ic//KGVlJRkbdq0yXrnnXesjIwMKyMjw+f7jh071rruuuust956y9qzZ491++23WwMHDrQaGho6bG/tEajz8c82b97c6a/2t6zAnIs9e/ZYcXFx1j333GN98skn3ltnC8DKlSutqKgoa/ny5db+/futadOmWbGxsZbL5bIsy7Luvfdeq6CgwDv/rbfessLDw63//M//v737CYmqi8M4/gyDN5kGG5MYsLCBagQTyk0tIkzauNLGhCGCKVtGuGm2MdBCN+9CcxEEMUYbcaEFGu1U3FgSRKL9gyZmI0pFoRhjjL8WLw1N9oLzOqPZ/X7gLubew+Gcw4Fn7uXce/6xly9fWiKR+O2rfoFAwB4+fGgvXryw1tbWHfOqXzHHYnV11VpaWuzAgQP2/PnzvHmQyWS2pY8bVYp58audtNq/FOMxNDRkZWVldufOHXv79q319fWZ1+u1ycnJDbeL8N+Ajx8/2oULF8zv91tFRYV1dHTY0tJS7noqlTJJNjY2ljv39etXu3r1qlVWVprP57NIJGLz8/N59X758sWuXLligUDA9u7da5FIxNLp9FZ1638r1Xj8bKeEfynGIpFImKR1x8GDB7ewZxvT19dnNTU15jiOnThxwqampnLXGhsb7dKlS3nlBwcHLRwOm+M4dvToURsdHc27vra2Zjdu3LBgMGi7du2ys2fP2uvXr7eiK5tWzLH4MW9+d/w8l/5UxZ4Xv9pJ4W9WmvG4e/euHT582MrLy+3YsWP24MGDgtrElr4AALiMa1f7AwDgVoQ/AAAuQ/gDAOAyhD8AAC5D+AMA4DKEPwAALkP4AwDgMoQ/AAAuQ/gD2LTx8XF5PB59/vx5u5sCYAP4wh+Agp05c0bHjx9XT0+PJGl1dVWfPn1SMBhk21VgB3Dtlr4AisdxnP/cohTAn4fH/gAKcvnyZU1MTKi3t1cej0cej0f9/f15j/37+/sVCAQ0MjKi2tpa+Xw+tbe3a2VlRffu3VMoFFJlZaU6OzuVzWZzdWcyGcXjce3fv1+7d+/WyZMnNT4+vj0dBf5i3PkDKEhvb6/evHmj+vp63bx5U5I0Ozu7rtzKyopu3bqlgYEBLS0tqa2tTZFIRIFAQI8ePdK7d+90/vx5nTp1StFoVJJ07do1zc3NaWBgQNXV1RoeHlZzc7NmZmZ05MiRLe0n8Dcj/AEUZM+ePXIcRz6fL/eo/9WrV+vKffv2Tbdv39ahQ4ckSe3t7bp//74WFhbk9/tVV1enpqYmjY2NKRqNKp1OK5lMKp1Oq7q6WpIUj8f1+PFjJZNJdXV1bV0ngb8c4Q+gJHw+Xy74JSkYDCoUCsnv9+edW1xclCTNzMwom80qHA7n1ZPJZFRVVbU1jQZcgvAHUBJlZWV5vz0ez2/Pra2tSZKWl5fl9Xr17Nkzeb3evHI//2EAsHmEP4CCOY6Tt1CvGBoaGpTNZrW4uKjTp08XtW4A+VjtD6BgoVBIT5480fv37/Xhw4fc3ftmhMNhXbx4UbFYTENDQ0qlUnr69Km6u7s1OjpahFYD+IHwB1CweDwur9eruro67du3T+l0uij1JpNJxWIxXb9+XbW1tTp37pymp6dVU1NTlPoB/Isv/AEA4DLc+QMA4DKEPwAALkP4AwDgMoQ/AAAuQ/gDAOAyhD8AAC5D+AMA4DKEPwAALkP4AwDgMoQ/AAAuQ/gDAOAy3wFH4YZ8La25MgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "RE(simple_scan_saving(det2,motor,noisy_det),bec)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "8e3216f2-1fd2-4d0f-a950-2e259830a99f", + "metadata": {}, + "outputs": [], + "source": [ + " y_position = [1]" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "3c5ba9c7-790c-4aeb-bc69-8d4da73c8420", + "metadata": {}, + "outputs": [], + "source": [ + "y_position.extend((2,2))" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "31204b68-490f-4497-aeeb-02a83f9cd1f6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[1, 2, 2]" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_position" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "a3938089-0180-4ff9-a889-f7ba2175f92b", + "metadata": {}, + "outputs": [], + "source": [ + "from numpy import linspace\n", + "x_start = 0\n", + "x_end = 2\n", + "num_step = 5\n", + "y_start = -5\n", + "y_end = 5\n", + "speed = 1\n", + "steps = linspace(x_start, x_end, num_step, endpoint=True)\n", + "y_position = [y_start]\n", + "for cnt, i in enumerate(steps[1:-1]):\n", + " if cnt % 2 == 0:\n", + " y_position.extend((y_end, y_end))\n", + " else:\n", + " y_position.extend((y_start, y_start))\n", + "y_position.append(y_start)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "2358d3b7-ce55-4f20-ac8e-394124b3d234", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[-5, 5, 5, -5, -5, 5, 5, -5]" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_position" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "18d00883-5e07-4429-b690-19921272b70b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Run aborted\n", - "Traceback (most recent call last):\n", - " File \"/venv/lib/python3.11/site-packages/bluesky/run_engine.py\", line 1522, in _run\n", - " msg = self._plan_stack[-1].throw(stashed_exception or resp)\n", - " ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n", - " File \"/tmp/ipykernel_1071954/2290841470.py\", line 10, in simple_scan_saving\n", - " yield Msg(\"read\", det1)\n", - " File \"/venv/lib/python3.11/site-packages/bluesky/run_engine.py\", line 1607, in _run\n", - " new_response = await coro(msg)\n", - " ^^^^^^^^^^^^^^^\n", - " File \"/venv/lib/python3.11/site-packages/bluesky/run_engine.py\", line 1902, in _read\n", - " await current_run.read(msg, ret)\n", - " File \"/venv/lib/python3.11/site-packages/bluesky/bundlers.py\", line 314, in read\n", - " raise ValueError(\n", - "ValueError: Data keys (field names) from SynGauss(prefix='', name='noisy_det', read_attrs=['val'], configuration_attrs=['Imax', 'center', 'sigma', 'noise', 'noise_multiplier']) collide with those from SynGauss(prefix='', name='noisy_det', read_attrs=['val'], configuration_attrs=['Imax', 'center', 'sigma', 'noise', 'noise_multiplier']). The colliding keys are {'noisy_det'}\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "+-----------+------------+------------+------------+------------+\n", - "generator simple_scan_saving ['bba38f0c'] (scan num: 5)\n", - "LivePlot did not get any data that corresponds to the x axis. time\n", - "LivePlot did not get any data that corresponds to the y axis. det2\n", - "LivePlot did not get any data that corresponds to the x axis. time\n", - "LivePlot did not get any data that corresponds to the y axis. noisy_det\n", - "LivePlot did not get any data that corresponds to the x axis. time\n", - "LivePlot did not get any data that corresponds to the y axis. motor\n", - "\n", - "\n", - "\n" - ] - }, - { - "ename": "ValueError", - "evalue": "Data keys (field names) from SynGauss(prefix='', name='noisy_det', read_attrs=['val'], configuration_attrs=['Imax', 'center', 'sigma', 'noise', 'noise_multiplier']) collide with those from SynGauss(prefix='', name='noisy_det', read_attrs=['val'], configuration_attrs=['Imax', 'center', 'sigma', 'noise', 'noise_multiplier']). The colliding keys are {'noisy_det'}", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[11], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mRE\u001b[49m\u001b[43m(\u001b[49m\u001b[43msimple_scan_saving\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdet2\u001b[49m\u001b[43m,\u001b[49m\u001b[43mmotor\u001b[49m\u001b[43m,\u001b[49m\u001b[43mnoisy_det\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43mbec\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m/venv/lib/python3.11/site-packages/bluesky/run_engine.py:918\u001b[0m, in \u001b[0;36mRunEngine.__call__\u001b[0;34m(self, *args, **metadata_kw)\u001b[0m\n\u001b[1;32m 914\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_blocking_event\u001b[38;5;241m.\u001b[39mset()\n\u001b[1;32m 916\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_task_fut\u001b[38;5;241m.\u001b[39madd_done_callback(set_blocking_event)\n\u001b[0;32m--> 918\u001b[0m plan_return \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_resume_task\u001b[49m\u001b[43m(\u001b[49m\u001b[43minit_func\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m_build_task\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 920\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_interrupted:\n\u001b[1;32m 921\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m RunEngineInterrupted(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpause_msg) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n", - "File \u001b[0;32m/venv/lib/python3.11/site-packages/bluesky/run_engine.py:1057\u001b[0m, in \u001b[0;36mRunEngine._resume_task\u001b[0;34m(self, init_func)\u001b[0m\n\u001b[1;32m 1053\u001b[0m \u001b[38;5;66;03m# if the main task exception is not None, re-raise\u001b[39;00m\n\u001b[1;32m 1054\u001b[0m \u001b[38;5;66;03m# it (unless it is a canceled error)\u001b[39;00m\n\u001b[1;32m 1055\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (exc \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 1056\u001b[0m \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(exc, _RunEnginePanic)):\n\u001b[0;32m-> 1057\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m exc\n\u001b[1;32m 1058\u001b[0m \u001b[38;5;66;03m# Only try to get a result if there wasn't an error,\u001b[39;00m\n\u001b[1;32m 1059\u001b[0m \u001b[38;5;66;03m# (other than a cancelled error)\u001b[39;00m\n\u001b[1;32m 1060\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m exc \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", - "File \u001b[0;32m/venv/lib/python3.11/site-packages/bluesky/run_engine.py:1687\u001b[0m, in \u001b[0;36mRunEngine._run\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1685\u001b[0m exit_reason \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mstr\u001b[39m(err)\n\u001b[1;32m 1686\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mlog\u001b[38;5;241m.\u001b[39mexception(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mRun aborted\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m-> 1687\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m err\n\u001b[1;32m 1688\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m 1689\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m exit_reason:\n", - "File \u001b[0;32m/venv/lib/python3.11/site-packages/bluesky/run_engine.py:1522\u001b[0m, in \u001b[0;36mRunEngine._run\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1519\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (stashed_exception \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(resp, \u001b[38;5;167;01mException\u001b[39;00m)):\n\u001b[1;32m 1520\u001b[0m \u001b[38;5;66;03m# throw the exception at the current plan\u001b[39;00m\n\u001b[1;32m 1521\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m-> 1522\u001b[0m msg \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_plan_stack[\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m]\u001b[38;5;241m.\u001b[39mthrow(stashed_exception \u001b[38;5;129;01mor\u001b[39;00m resp)\n\u001b[1;32m 1523\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m 1524\u001b[0m \u001b[38;5;66;03m# The current plan did not handle it,\u001b[39;00m\n\u001b[1;32m 1525\u001b[0m \u001b[38;5;66;03m# maybe the next plan (if any) would like\u001b[39;00m\n\u001b[1;32m 1526\u001b[0m \u001b[38;5;66;03m# to try\u001b[39;00m\n\u001b[1;32m 1527\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_plan_stack\u001b[38;5;241m.\u001b[39mpop()\n", - "Cell \u001b[0;32mIn[10], line 10\u001b[0m, in \u001b[0;36msimple_scan_saving\u001b[0;34m(det, motor, det1)\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[38;5;28;01myield\u001b[39;00m Msg(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mread\u001b[39m\u001b[38;5;124m\"\u001b[39m, det)\n\u001b[1;32m 9\u001b[0m \u001b[38;5;28;01myield\u001b[39;00m Msg(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mread\u001b[39m\u001b[38;5;124m\"\u001b[39m, det1)\n\u001b[0;32m---> 10\u001b[0m \u001b[38;5;28;01myield\u001b[39;00m Msg(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mread\u001b[39m\u001b[38;5;124m\"\u001b[39m, det1)\n\u001b[1;32m 11\u001b[0m \u001b[38;5;28;01myield\u001b[39;00m Msg(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msave\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 12\u001b[0m \u001b[38;5;28;01myield\u001b[39;00m Msg(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mclose_run\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", - "File \u001b[0;32m/venv/lib/python3.11/site-packages/bluesky/run_engine.py:1607\u001b[0m, in \u001b[0;36mRunEngine._run\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 1602\u001b[0m \u001b[38;5;66;03m# try to finally run the command the user asked for\u001b[39;00m\n\u001b[1;32m 1603\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 1604\u001b[0m \u001b[38;5;66;03m# this is one of two places that 'async'\u001b[39;00m\n\u001b[1;32m 1605\u001b[0m \u001b[38;5;66;03m# exceptions (coming in via throw) can be\u001b[39;00m\n\u001b[1;32m 1606\u001b[0m \u001b[38;5;66;03m# raised\u001b[39;00m\n\u001b[0;32m-> 1607\u001b[0m new_response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mawait\u001b[39;00m coro(msg)\n\u001b[1;32m 1609\u001b[0m \u001b[38;5;66;03m# special case `CancelledError` and let the outer\u001b[39;00m\n\u001b[1;32m 1610\u001b[0m \u001b[38;5;66;03m# exception block deal with it.\u001b[39;00m\n\u001b[1;32m 1611\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m asyncio\u001b[38;5;241m.\u001b[39mCancelledError:\n", - "File \u001b[0;32m/venv/lib/python3.11/site-packages/bluesky/run_engine.py:1902\u001b[0m, in \u001b[0;36mRunEngine._read\u001b[0;34m(self, msg)\u001b[0m\n\u001b[1;32m 1900\u001b[0m \u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m\u001b[38;5;241m.\u001b[39m\n\u001b[1;32m 1901\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m-> 1902\u001b[0m \u001b[38;5;28;01mawait\u001b[39;00m current_run\u001b[38;5;241m.\u001b[39mread(msg, ret)\n\u001b[1;32m 1904\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m ret\n", - "File \u001b[0;32m/venv/lib/python3.11/site-packages/bluesky/bundlers.py:314\u001b[0m, in \u001b[0;36mRunBundler.read\u001b[0;34m(self, msg, reading)\u001b[0m\n\u001b[1;32m 312\u001b[0m known_keys \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_describe_cache[read_obj]\u001b[38;5;241m.\u001b[39mkeys()\n\u001b[1;32m 313\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mset\u001b[39m(known_keys) \u001b[38;5;241m&\u001b[39m cur_keys:\n\u001b[0;32m--> 314\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 315\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mData keys (field names) from \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mobj\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[38;5;124m \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 316\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mcollide with those from \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mread_obj\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[38;5;124m. \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 317\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe colliding keys are \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mset\u001b[39m(known_keys)\u001b[38;5;250m \u001b[39m\u001b[38;5;241m&\u001b[39m\u001b[38;5;250m \u001b[39mcur_keys\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 318\u001b[0m )\n\u001b[1;32m 320\u001b[0m \u001b[38;5;66;03m# add this object to the cache of things we have read\u001b[39;00m\n\u001b[1;32m 321\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_objs_read\u001b[38;5;241m.\u001b[39mappend(obj)\n", - "\u001b[0;31mValueError\u001b[0m: Data keys (field names) from SynGauss(prefix='', name='noisy_det', read_attrs=['val'], configuration_attrs=['Imax', 'center', 'sigma', 'noise', 'noise_multiplier']) collide with those from SynGauss(prefix='', name='noisy_det', read_attrs=['val'], configuration_attrs=['Imax', 'center', 'sigma', 'noise', 'noise_multiplier']). The colliding keys are {'noisy_det'}" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "RE(simple_scan_saving(det2,motor,noisy_det),bec)" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "id": "8e3216f2-1fd2-4d0f-a950-2e259830a99f", - "metadata": {}, - "outputs": [], - "source": [ - " y_position = [1]" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "3c5ba9c7-790c-4aeb-bc69-8d4da73c8420", - "metadata": {}, - "outputs": [], - "source": [ - "y_position.extend((2,2))" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "31204b68-490f-4497-aeeb-02a83f9cd1f6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[1, 2, 2]" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "y_position" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "id": "a3938089-0180-4ff9-a889-f7ba2175f92b", - "metadata": {}, - "outputs": [], - "source": [ - "from numpy import linspace\n", - "x_start = 0\n", - "x_end = 2\n", - "num_step = 5\n", - "y_start = -5\n", - "y_end = 5\n", - "speed = 1\n", - "steps = linspace(x_start, x_end, num_step, endpoint=True)\n", - "y_position = [y_start]\n", - "for cnt, i in enumerate(steps[1:-1]):\n", - " if cnt % 2 == 0:\n", - " y_position.extend((y_end, y_end))\n", - " else:\n", - " y_position.extend((y_start, y_start))\n", - "y_position.append(y_start)" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "id": "2358d3b7-ce55-4f20-ac8e-394124b3d234", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[-5, 5, 5, -5, -5, 5, 5, -5]" - ] - }, - "execution_count": 33, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "y_position" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "18d00883-5e07-4429-b690-19921272b70b", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/tests/jupyter_tests/test_simstage.ipynb b/tests/jupyter_tests/test_simstage.ipynb index 8dae94a..78a664b 100644 --- a/tests/jupyter_tests/test_simstage.ipynb +++ b/tests/jupyter_tests/test_simstage.ipynb @@ -1,428 +1,428 @@ { - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "id": "e1e5d22d-4b5b-4820-89d8-47a769509801", - "metadata": {}, - "outputs": [], - "source": [ - "import asyncio\n", - "\n", - "from bluesky import RunEngine\n", - "from bluesky.callbacks.best_effort import BestEffortCallback\n", - "\n", - "#from ophyd.mock import det1\n", - "from ophyd_async.core import (\n", - " DeviceCollector,\n", - ")\n", - "\n", - "#from dodal.beamlines.beamline_utils import set_directory_provider\n", - "from ophyd_async.epics.signal import epics_signal_r\n", - "\n", - "loop = asyncio.get_event_loop()\n", - "bec = BestEffortCallback()\n", - "RE = RunEngine({})\n", - "from unittest.mock import Mock\n", - "\n", - "import numpy as np" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3148be78-0ee9-45c1-b858-6c72c70a0d18", - "metadata": {}, - "outputs": [], - "source": [ - "motor_rbv_mocks = Mock()\n", - "motor_rbv_mocks.get.side_effect = np.arange(0,30,0.1)" - ] - }, - { - "cell_type": "markdown", - "id": "96990788-8040-457a-81ca-1d522164107e", - "metadata": {}, - "source": [ - "for i in range(0,10):\n", - " print(motor_rbv_mocks.get())" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "23298f32-7a6d-4b5a-b8af-d675550172a2", - "metadata": {}, - "outputs": [], - "source": [ - "from p99Bluesky.devices.stages import ThreeAxisStage" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "87bf4f05-47aa-4f3c-ae05-e9f8cb86ae07", - "metadata": {}, - "outputs": [], - "source": [ - "with DeviceCollector(mock=True):\n", - " sample_angle_stage = ThreeAxisStage('BL99P-MO-STAGE-01:',name = \"sample_angle_stage\")" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "id": "ce9d3acc-a387-4038-b32c-6ce824070fd0", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Starting iocInit\n", - "iocRun: All initialization complete\n", - "Python 3.11.9 (main, May 14 2024, 08:04:54) [GCC 12.2.0] on linux\n", - "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n", - "(InteractiveConsole)\n", - "\n" - ] - } - ], - "source": [ - "import subprocess\n", - "\n", - "p = subprocess.Popen([\"python\", \"../junk.py\"], stdout=subprocess.PIPE)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "a2607554-3136-4685-ab42-ae588a3f96c5", - "metadata": {}, - "outputs": [], - "source": [ - "from epics import caget" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "f36722c2-0744-4538-a66f-c106f81a1cfa", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "cannot connect to p99-motor:AI\n" - ] - } - ], - "source": [ - "caget(\"p99-motor:AI\")" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "id": "3ffca3dd-dea0-48b1-b265-94a02e3944c3", - "metadata": {}, - "outputs": [ - { - "ename": "ValueError", - "evalue": "read of closed file", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[50], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcommunicate\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mexit\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m/usr/local/lib/python3.11/subprocess.py:1196\u001b[0m, in \u001b[0;36mPopen.communicate\u001b[0;34m(self, input, timeout)\u001b[0m\n\u001b[1;32m 1194\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_stdin_write(\u001b[38;5;28minput\u001b[39m)\n\u001b[1;32m 1195\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstdout:\n\u001b[0;32m-> 1196\u001b[0m stdout \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstdout\u001b[38;5;241m.\u001b[39mread()\n\u001b[1;32m 1197\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstdout\u001b[38;5;241m.\u001b[39mclose()\n\u001b[1;32m 1198\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstderr:\n", - "\u001b[0;31mValueError\u001b[0m: read of closed file" - ] + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "e1e5d22d-4b5b-4820-89d8-47a769509801", + "metadata": {}, + "outputs": [], + "source": [ + "import asyncio\n", + "\n", + "from bluesky import RunEngine\n", + "from bluesky.callbacks.best_effort import BestEffortCallback\n", + "\n", + "#from ophyd.mock import det1\n", + "from ophyd_async.core import (\n", + " DeviceCollector,\n", + ")\n", + "\n", + "#from dodal.beamlines.beamline_utils import set_directory_provider\n", + "from ophyd_async.epics.core import epics_signal_r\n", + "\n", + "loop = asyncio.get_event_loop()\n", + "bec = BestEffortCallback()\n", + "RE = RunEngine({})\n", + "from unittest.mock import Mock\n", + "\n", + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3148be78-0ee9-45c1-b858-6c72c70a0d18", + "metadata": {}, + "outputs": [], + "source": [ + "motor_rbv_mocks = Mock()\n", + "motor_rbv_mocks.get.side_effect = np.arange(0,30,0.1)" + ] + }, + { + "cell_type": "markdown", + "id": "96990788-8040-457a-81ca-1d522164107e", + "metadata": {}, + "source": [ + "for i in range(0,10):\n", + " print(motor_rbv_mocks.get())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "23298f32-7a6d-4b5a-b8af-d675550172a2", + "metadata": {}, + "outputs": [], + "source": [ + "from p99Bluesky.devices.stages import ThreeAxisStage" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "87bf4f05-47aa-4f3c-ae05-e9f8cb86ae07", + "metadata": {}, + "outputs": [], + "source": [ + "with DeviceCollector(mock=True):\n", + " sample_angle_stage = ThreeAxisStage('BL99P-MO-STAGE-01:',name = \"sample_angle_stage\")" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "ce9d3acc-a387-4038-b32c-6ce824070fd0", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Starting iocInit\n", + "iocRun: All initialization complete\n", + "Python 3.11.9 (main, May 14 2024, 08:04:54) [GCC 12.2.0] on linux\n", + "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n", + "(InteractiveConsole)\n", + "\n" + ] + } + ], + "source": [ + "import subprocess\n", + "\n", + "p = subprocess.Popen([\"python\", \"../junk.py\"], stdout=subprocess.PIPE)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a2607554-3136-4685-ab42-ae588a3f96c5", + "metadata": {}, + "outputs": [], + "source": [ + "from epics import caget" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "f36722c2-0744-4538-a66f-c106f81a1cfa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cannot connect to p99-motor:AI\n" + ] + } + ], + "source": [ + "caget(\"p99-motor:AI\")" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "3ffca3dd-dea0-48b1-b265-94a02e3944c3", + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "read of closed file", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[50], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcommunicate\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mexit\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", + "File \u001b[0;32m/usr/local/lib/python3.11/subprocess.py:1196\u001b[0m, in \u001b[0;36mPopen.communicate\u001b[0;34m(self, input, timeout)\u001b[0m\n\u001b[1;32m 1194\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_stdin_write(\u001b[38;5;28minput\u001b[39m)\n\u001b[1;32m 1195\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstdout:\n\u001b[0;32m-> 1196\u001b[0m stdout \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstdout\u001b[38;5;241m.\u001b[39mread()\n\u001b[1;32m 1197\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstdout\u001b[38;5;241m.\u001b[39mclose()\n\u001b[1;32m 1198\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstderr:\n", + "\u001b[0;31mValueError\u001b[0m: read of closed file" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1320\n", + " Current Time: Thu Jun 06 2024 14:57:44.758942689\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1320\n", + " Current Time: Thu Jun 06 2024 14:57:44.759415284\n", + "..................................................................\n" + ] + } + ], + "source": [ + "p.communicate(\"exit\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "06d1db87-ef4c-4c84-aa78-ac513cda415e", + "metadata": {}, + "outputs": [], + "source": [ + "p.communicate()" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "00af3691-45b8-43a4-8ad1-dc3bdcb42a86", + "metadata": {}, + "outputs": [], + "source": [ + "sig = epics_signal_r(float, \"p99-motor:AI\")" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "87e36631-3562-4388-92cf-671763a46fb0", + "metadata": {}, + "outputs": [], + "source": [ + "result = asyncio.create_task(sig.connect())" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "466db0fd-ecca-498a-83d9-9355ad1baa27", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + " result=None>" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "1c03876e-a4f1-419e-b4cf-8dbc2ac0a086", + "metadata": {}, + "outputs": [], + "source": [ + "result = asyncio.create_task(sig.get_value())" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "36b877ef-639a-4f6d-a93c-56752dff80b6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + " wait_for=>" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1320\n", + " Current Time: Thu Jun 06 2024 15:06:20.554814900\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1320\n", + " Current Time: Thu Jun 06 2024 15:06:20.555540568\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Virtual circuit disconnect\"\n", + " Context: \"host.containers.internal:5064\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1237\n", + " Current Time: Thu Jun 06 2024 15:07:53.177848331\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1320\n", + " Current Time: Thu Jun 06 2024 15:08:23.352324049\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1320\n", + " Current Time: Thu Jun 06 2024 15:08:23.352711500\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Virtual circuit disconnect\"\n", + " Context: \"host.containers.internal:5064\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1237\n", + " Current Time: Thu Jun 06 2024 15:10:42.226600528\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1320\n", + " Current Time: Thu Jun 06 2024 15:19:18.318243397\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1320\n", + " Current Time: Thu Jun 06 2024 15:19:18.318647210\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Virtual circuit disconnect\"\n", + " Context: \"host.containers.internal:5064\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1237\n", + " Current Time: Thu Jun 06 2024 15:25:01.030747101\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1320\n", + " Current Time: Thu Jun 06 2024 15:25:59.486275531\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1320\n", + " Current Time: Thu Jun 06 2024 15:25:59.486658851\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Virtual circuit disconnect\"\n", + " Context: \"host.containers.internal:5064\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1237\n", + " Current Time: Thu Jun 06 2024 15:26:04.844458905\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1320\n", + " Current Time: Thu Jun 06 2024 15:26:10.734626820\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1320\n", + " Current Time: Thu Jun 06 2024 15:26:10.735149692\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Virtual circuit disconnect\"\n", + " Context: \"host.containers.internal:5064\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1237\n", + " Current Time: Thu Jun 06 2024 15:26:12.041809116\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1320\n", + " Current Time: Thu Jun 06 2024 15:30:05.099014704\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1320\n", + " Current Time: Thu Jun 06 2024 15:30:05.099428411\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: host.containers.internal:37957\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1320\n", + " Current Time: Thu Jun 06 2024 15:30:05.099433488\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"errlog: lost 5 messages\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:37957\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1320\n", + " Current Time: Thu Jun 06 2024 15:30:05.100127929\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:37957\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1320\n", + " Current Time: Thu Jun 06 2024 15:30:05.100455936\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: host.containers.internal:35651\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1320\n", + " Current Time: Thu Jun 06 2024 15:30:05.100461267\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"errlog: lost 5 messages\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:35651\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1320\n", + " Current Time: Thu Jun 06 2024 15:30:05.100948666\n", + "..................................................................\n", + "CA.Client.Exception...............................................\n", + " Warning: \"Identical process variable names on multiple servers\"\n", + " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:35651\"\n", + " Source File: modules/ca/src/client/cac.cpp line 1320\n", + " Current Time: Thu Jun 06 2024 15:30:05.101454749\n", + "..................................................................\n" + ] + } + ], + "source": [ + "result" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "73616eae-3454-4cb9-8903-758c8c446adc", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1320\n", - " Current Time: Thu Jun 06 2024 14:57:44.758942689\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1320\n", - " Current Time: Thu Jun 06 2024 14:57:44.759415284\n", - "..................................................................\n" - ] - } - ], - "source": [ - "p.communicate(\"exit\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "06d1db87-ef4c-4c84-aa78-ac513cda415e", - "metadata": {}, - "outputs": [], - "source": [ - "p.communicate()" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "id": "00af3691-45b8-43a4-8ad1-dc3bdcb42a86", - "metadata": {}, - "outputs": [], - "source": [ - "sig = epics_signal_r(float, \"p99-motor:AI\")" - ] - }, - { - "cell_type": "code", - "execution_count": 52, - "id": "87e36631-3562-4388-92cf-671763a46fb0", - "metadata": {}, - "outputs": [], - "source": [ - "result = asyncio.create_task(sig.connect())" - ] - }, - { - "cell_type": "code", - "execution_count": 53, - "id": "466db0fd-ecca-498a-83d9-9355ad1baa27", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - " result=None>" - ] - }, - "execution_count": 53, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "result" - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "id": "1c03876e-a4f1-419e-b4cf-8dbc2ac0a086", - "metadata": {}, - "outputs": [], - "source": [ - "result = asyncio.create_task(sig.get_value())" - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "id": "36b877ef-639a-4f6d-a93c-56752dff80b6", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - " wait_for=>" - ] - }, - "execution_count": 62, - "metadata": {}, - "output_type": "execute_result" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1320\n", - " Current Time: Thu Jun 06 2024 15:06:20.554814900\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1320\n", - " Current Time: Thu Jun 06 2024 15:06:20.555540568\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Virtual circuit disconnect\"\n", - " Context: \"host.containers.internal:5064\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1237\n", - " Current Time: Thu Jun 06 2024 15:07:53.177848331\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1320\n", - " Current Time: Thu Jun 06 2024 15:08:23.352324049\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1320\n", - " Current Time: Thu Jun 06 2024 15:08:23.352711500\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Virtual circuit disconnect\"\n", - " Context: \"host.containers.internal:5064\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1237\n", - " Current Time: Thu Jun 06 2024 15:10:42.226600528\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1320\n", - " Current Time: Thu Jun 06 2024 15:19:18.318243397\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1320\n", - " Current Time: Thu Jun 06 2024 15:19:18.318647210\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Virtual circuit disconnect\"\n", - " Context: \"host.containers.internal:5064\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1237\n", - " Current Time: Thu Jun 06 2024 15:25:01.030747101\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1320\n", - " Current Time: Thu Jun 06 2024 15:25:59.486275531\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1320\n", - " Current Time: Thu Jun 06 2024 15:25:59.486658851\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Virtual circuit disconnect\"\n", - " Context: \"host.containers.internal:5064\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1237\n", - " Current Time: Thu Jun 06 2024 15:26:04.844458905\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1320\n", - " Current Time: Thu Jun 06 2024 15:26:10.734626820\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1320\n", - " Current Time: Thu Jun 06 2024 15:26:10.735149692\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Virtual circuit disconnect\"\n", - " Context: \"host.containers.internal:5064\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1237\n", - " Current Time: Thu Jun 06 2024 15:26:12.041809116\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1320\n", - " Current Time: Thu Jun 06 2024 15:30:05.099014704\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:5064\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1320\n", - " Current Time: Thu Jun 06 2024 15:30:05.099428411\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: host.containers.internal:37957\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1320\n", - " Current Time: Thu Jun 06 2024 15:30:05.099433488\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"errlog: lost 5 messages\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:37957\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1320\n", - " Current Time: Thu Jun 06 2024 15:30:05.100127929\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:37957\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1320\n", - " Current Time: Thu Jun 06 2024 15:30:05.100455936\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: host.containers.internal:35651\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1320\n", - " Current Time: Thu Jun 06 2024 15:30:05.100461267\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"errlog: lost 5 messages\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:35651\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1320\n", - " Current Time: Thu Jun 06 2024 15:30:05.100948666\n", - "..................................................................\n", - "CA.Client.Exception...............................................\n", - " Warning: \"Identical process variable names on multiple servers\"\n", - " Context: \"Channel: \"p99-motor:AI\", Connecting to: 172.23.241.223:5064, Ignored: 192.168.122.1:35651\"\n", - " Source File: modules/ca/src/client/cac.cpp line 1320\n", - " Current Time: Thu Jun 06 2024 15:30:05.101454749\n", - "..................................................................\n" - ] - } - ], - "source": [ - "result" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "73616eae-3454-4cb9-8903-758c8c446adc", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.9" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/tests/plan_stubs/test_motor_plan.py b/tests/plan_stubs/test_motor_plan.py index 31808cc..9029070 100644 --- a/tests/plan_stubs/test_motor_plan.py +++ b/tests/plan_stubs/test_motor_plan.py @@ -1,7 +1,8 @@ import pytest from bluesky.run_engine import RunEngine -from ophyd_async.core import DeviceCollector, set_mock_value +from ophyd_async.core import DeviceCollector from ophyd_async.epics.motor import Motor +from ophyd_async.testing import set_mock_value from p99_bluesky.plan_stubs.motor_plan import check_within_limit diff --git a/tests/soft_motor.py b/tests/soft_motor.py index e3deaaf..0c5c561 100644 --- a/tests/soft_motor.py +++ b/tests/soft_motor.py @@ -5,12 +5,11 @@ from ophyd_async.core import ( CALCULATE_TIMEOUT, AsyncStatus, - ConfigSignal, Device, - HintedSignal, + SignalDatatypeT, SignalR, StandardReadable, - T, + StandardReadableFormat, WatchableAsyncStatus, observe_value, wait_for_value, @@ -20,7 +19,7 @@ CalculatableTimeout, WatcherUpdate, ) -from ophyd_async.epics.signal import epics_signal_r, epics_signal_rw, epics_signal_x +from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_x from pydantic import BaseModel, Field @@ -98,11 +97,11 @@ class SoftMotor(StandardReadable, Movable, Stoppable): def __init__(self, prefix: str, name="") -> None: # Define some signals - with self.add_children_as_readables(ConfigSignal): + with self.add_children_as_readables(StandardReadableFormat.CONFIG_SIGNAL): self.motor_egu = epics_signal_r(str, prefix + ".EGU") self.velocity = epics_signal_rw(float, prefix + "VELO") - with self.add_children_as_readables(HintedSignal): + with self.add_children_as_readables(StandardReadableFormat.HINTED_SIGNAL): self.user_readback = epics_signal_r(float, prefix + "RBV") self.user_setpoint = epics_signal_rw(float, prefix + "VAL") @@ -129,16 +128,16 @@ def __init__(self, prefix: str, name="") -> None: super().__init__(name=name) - def set_name(self, name: str): - super().set_name(name) + def set_name(self, name: str, *, child_name_separator: str | None = None) -> None: + super().set_name(name, child_name_separator=child_name_separator) # Readback should be named the same as its parent in read() self.user_readback.set_name(name) @AsyncStatus.wrap async def wait_for_value_with_status( self, - signal: SignalR[T], - match: T | Callable[[T], bool], + signal: SignalR[SignalDatatypeT], + match: SignalDatatypeT | Callable[[SignalDatatypeT], bool], timeout: float | None, ): """wrap wait for value so it return an asyncStatus""" diff --git a/tests/test_AD_plans.py b/tests/test_AD_plans.py index 68c3207..00dcef5 100644 --- a/tests/test_AD_plans.py +++ b/tests/test_AD_plans.py @@ -4,10 +4,9 @@ from bluesky.run_engine import RunEngine from ophyd_async.core import ( StaticPathProvider, - assert_emitted, - set_mock_value, ) from ophyd_async.epics.adcore._core_io import DetectorState +from ophyd_async.testing import assert_emitted, set_mock_value from p99_bluesky.devices.andorAd import Andor2Ad, Andor3Ad from p99_bluesky.devices.stages import ThreeAxisStage @@ -24,7 +23,7 @@ def capture_emitted(name, doc): RE.subscribe(capture_emitted) - set_mock_value(andor2.drv.detector_state, DetectorState.Idle) + set_mock_value(andor2.drv.detector_state, DetectorState.IDLE) RE(tiggerImg(andor2, 4)) @@ -51,7 +50,7 @@ def capture_emitted(name, doc): RE.subscribe(capture_emitted) - set_mock_value(andor2.drv.detector_state, DetectorState.Idle) + set_mock_value(andor2.drv.detector_state, DetectorState.IDLE) RE(takeImg(andor2, 1, 4)) assert ( @@ -80,7 +79,7 @@ def capture_emitted(name, doc): docs[name].append(doc) RE.subscribe(capture_emitted) - set_mock_value(andor2.drv.detector_state, DetectorState.Idle) + set_mock_value(andor2.drv.detector_state, DetectorState.IDLE) RE(scan([andor2], sim_motor.y, -3, 3, 10)) assert ( str(static_path_provider._directory_path) @@ -107,7 +106,7 @@ def capture_emitted(name, doc): docs[name].append(doc) RE.subscribe(capture_emitted) - set_mock_value(andor3.drv.detector_state, DetectorState.Idle) + set_mock_value(andor3.drv.detector_state, DetectorState.IDLE) RE(scan([andor3], sim_motor.x, -3, 3, 10)) assert ( str(static_path_provider._directory_path) diff --git a/tests/test_fast_scan.py b/tests/test_fast_scan.py index e1bf369..a34fc2c 100644 --- a/tests/test_fast_scan.py +++ b/tests/test_fast_scan.py @@ -5,7 +5,7 @@ from bluesky.run_engine import RunEngine from numpy import linspace from ophyd.sim import SynPeriodicSignal -from ophyd_async.core import ( +from ophyd_async.testing import ( assert_emitted, get_mock_put, ) @@ -20,7 +20,8 @@ @pytest.fixture def det(): - return SynPeriodicSignal(name="rand", labels={"detectors"}) + det = SynPeriodicSignal(name="rand", labels={"detectors"}) + return det async def test_fast_scan_1d_fail_limit_check( @@ -45,6 +46,7 @@ def capture_emitted(name, doc): async def test_fast_scan_1d_success(sim_motor: ThreeAxisStage, RE: RunEngine, det): docs = defaultdict(list) + det.start_simulation() def capture_emitted(name, doc): docs[name].append(doc) @@ -56,9 +58,9 @@ def capture_emitted(name, doc): assert 3 == get_mock_put(sim_motor.x.velocity).call_count # check speed is set and reset assert [ - mock.call(10.0, wait=True, timeout=mock.ANY), # prepare set it to max speed - mock.call(8.0, wait=True, timeout=mock.ANY), - mock.call(2.78, wait=True, timeout=mock.ANY), + mock.call(10.0, wait=True), # prepare set it to max speed + mock.call(8.0, wait=True), + mock.call(2.78, wait=True), ] == get_mock_put(sim_motor.x.velocity).call_args_list """Only 1 event as sim motor motor_done_move is set to true, @@ -74,20 +76,21 @@ async def test_fast_scan_1d_success_without_speed( def capture_emitted(name, doc): docs[name].append(doc) - RE(fast_scan_1d([det], sim_motor.x, 1, 5), capture_emitted) + RE(fast_scan_1d([sim_motor.y], sim_motor.x, 1, 5), capture_emitted) assert 2.78 == await sim_motor.x.velocity.get_value() assert 2 == get_mock_put(sim_motor.x.user_setpoint).call_count assert 3 == get_mock_put(sim_motor.x.velocity).call_count # check speed is set and reset assert [ - mock.call(pytest.approx(10.0), wait=True, timeout=mock.ANY), - mock.call(pytest.approx(2.78), wait=True, timeout=mock.ANY), - mock.call(pytest.approx(2.78), wait=True, timeout=mock.ANY), + mock.call(pytest.approx(10.0), wait=True), + mock.call(pytest.approx(2.78), wait=True), + mock.call(pytest.approx(2.78), wait=True), ] == get_mock_put(sim_motor.x.velocity).call_args_list """Only 1 event as sim motor motor_done_move is set to true, - so only 1 loop is ran""" + so only 1 loop is ran""" # + print(docs) assert_emitted(docs, start=1, descriptor=1, event=1, stop=1) @@ -126,7 +129,7 @@ def capture_emitted(name, doc): # check step set points steps = linspace(x_start, x_end, num_step, endpoint=True) for cnt, motor_x in enumerate(get_mock_put(sim_motor.x.user_setpoint).call_args_list): - assert motor_x == mock.call(steps[cnt], wait=True, timeout=mock.ANY) + assert motor_x == mock.call(steps[cnt], wait=True) assert 2.88 == await sim_motor.y.velocity.get_value() assert num_step * 3 == get_mock_put(sim_motor.y.velocity).call_count @@ -134,9 +137,9 @@ def capture_emitted(name, doc): # check scan axis set and end point for cnt, motor_y in enumerate(get_mock_put(sim_motor.y.user_setpoint).call_args_list): if cnt % 2 == 0: - assert motor_y == mock.call(y_start, wait=True, timeout=mock.ANY) + assert motor_y == mock.call(y_start, wait=True) else: - assert motor_y == mock.call(y_end, wait=True, timeout=mock.ANY) + assert motor_y == mock.call(y_end, wait=True) """Only 1 event per step as sim motor motor_done_move is set to true, so only 1 loop is ran""" assert_emitted(docs, start=1, descriptor=1, event=num_step, stop=1) @@ -176,7 +179,7 @@ def capture_emitted(name, doc): assert 0 == get_mock_put(sim_motor.x.velocity).call_count steps = linspace(x_start, x_end, num_step, endpoint=True) for cnt, motor_x in enumerate(get_mock_put(sim_motor.x.user_setpoint).call_args_list): - assert motor_x == mock.call(steps[cnt], wait=True, timeout=mock.ANY) + assert motor_x == mock.call(steps[cnt], wait=True) assert 2.88 == await sim_motor.y.velocity.get_value() assert num_step * 3 == get_mock_put(sim_motor.y.velocity).call_count @@ -194,7 +197,7 @@ def capture_emitted(name, doc): y_position.append(y_end) """check them""" for cnt, motor_y in enumerate(get_mock_put(sim_motor.y.user_setpoint).call_args_list): - assert motor_y == mock.call(y_position[cnt], wait=True, timeout=mock.ANY) + assert motor_y == mock.call(y_position[cnt], wait=True) """Only 1 event per step as sim motor motor_done_move is set to true, so only 1 loop is ran""" diff --git a/tests/test_p99_stage.py b/tests/test_p99_stage.py index 8d2fa91..7d88a47 100644 --- a/tests/test_p99_stage.py +++ b/tests/test_p99_stage.py @@ -1,5 +1,6 @@ import pytest -from ophyd_async.core import DeviceCollector, set_mock_value +from ophyd_async.core import DeviceCollector +from ophyd_async.testing import set_mock_value from p99_bluesky.devices.p99.sample_stage import ( FilterMotor, @@ -37,5 +38,5 @@ async def test_sampleAngleStage(mock_sampleAngleStage: SampleAngleStage) -> None async def test_filter_wheel(mock_filter_wheel: FilterMotor) -> None: assert mock_filter_wheel.name == "mock_filter_wheel" - set_mock_value(mock_filter_wheel.user_setpoint, p99StageSelections.Cd25um) - assert await mock_filter_wheel.user_setpoint.get_value() == p99StageSelections.Cd25um + set_mock_value(mock_filter_wheel.user_setpoint, p99StageSelections.CD25UM) + assert await mock_filter_wheel.user_setpoint.get_value() == p99StageSelections.CD25UM diff --git a/tests/test_p99_stages_softioc.py b/tests/test_p99_stages_sofifioc.py similarity index 94% rename from tests/test_p99_stages_softioc.py rename to tests/test_p99_stages_sofifioc.py index ecd24a7..78c7945 100644 --- a/tests/test_p99_stages_softioc.py +++ b/tests/test_p99_stages_sofifioc.py @@ -3,7 +3,8 @@ from bluesky.plans import scan from bluesky.run_engine import RunEngine -from ophyd_async.core import DeviceCollector, assert_emitted +from ophyd_async.core import DeviceCollector +from ophyd_async.testing import assert_emitted from p99_bluesky.devices.p99.sample_stage import ( FilterMotor, @@ -39,7 +40,7 @@ def capture_emitted(name, doc): mock_sampleAngleStage.theta.set(2), mock_sampleAngleStage.pitch.set(3.1), mock_sampleAngleStage.roll.set(4), - mock_filter_wheel.user_setpoint.set(p99StageSelections.Cd25um), + mock_filter_wheel.user_setpoint.set(p99StageSelections.CD25UM), ) await asyncio.sleep(A_BIT) result = asyncio.gather( @@ -49,7 +50,7 @@ def capture_emitted(name, doc): mock_filter_wheel.user_setpoint.get_value(), ) await asyncio.wait_for(result, timeout=2) - assert result.result() == [2.0, 3.1, 4.0, p99StageSelections.Cd25um] + assert result.result() == [2.0, 3.1, 4.0, p99StageSelections.CD25UM] RE( scan( diff --git a/tests/test_single_statAd.py b/tests/test_single_statAd.py deleted file mode 100644 index 2663832..0000000 --- a/tests/test_single_statAd.py +++ /dev/null @@ -1,62 +0,0 @@ -from collections import defaultdict -from unittest.mock import Mock - -import pytest -from bluesky.plans import count -from bluesky.run_engine import RunEngine -from ophyd_async.core import ( - DeviceCollector, - assert_emitted, - callback_on_mock_put, - set_mock_value, -) -from ophyd_async.epics.adcore import NDPluginStatsIO, SingleTriggerDetector - -from p99_bluesky.devices.andorAd import Andor2Ad -from p99_bluesky.devices.epics.drivers.andor2_driver import ImageMode - - -@pytest.fixture -async def single_trigger_stat_det(andor2: Andor2Ad): - async with DeviceCollector(mock=True): - stats = NDPluginStatsIO("PREFIX:STATS") - det = SingleTriggerDetector( - drv=andor2.drv, stats=stats, read_uncached=[andor2.drv.stat_mean] - ) - - assert det.name == "det" - assert stats.name == "det-stats" - yield det - - -async def test_single_stat_ad( - single_trigger_stat_det: SingleTriggerDetector, RE: RunEngine, andor2: Andor2Ad -): - docs = defaultdict(list) - - def capture_emitted(name, doc): - docs[name].append(doc) - - num_cnt = 10 - - mean_mocks = Mock() - mean_mocks.get.side_effect = range(0, 100, 2) - callback_on_mock_put( - single_trigger_stat_det.drv.acquire, - lambda *_, **__: set_mock_value(andor2.drv.stat_mean, mean_mocks.get()), - ) - RE(count([single_trigger_stat_det], num_cnt), capture_emitted) - - drv = single_trigger_stat_det.drv - assert 1 == await drv.acquire.get_value() - assert ImageMode.single == await drv.image_mode.get_value() - assert True is await drv.wait_for_plugins.get_value() - - assert_emitted(docs, start=1, descriptor=1, event=num_cnt, stop=1) - assert ( - docs["descriptor"][0]["configuration"]["det"]["data"]["det-drv-acquire_time"] == 0 - ) - assert docs["event"][0]["data"]["det-drv-array_counter"] == 0 - - for i, mean in enumerate(range(0, num_cnt, 2)): - assert docs["event"][i]["data"]["det-drv-stat_mean"] == mean diff --git a/tests/test_stxm.py b/tests/test_stxm.py index 58be8bb..a8b77df 100644 --- a/tests/test_stxm.py +++ b/tests/test_stxm.py @@ -5,9 +5,8 @@ from bluesky.run_engine import RunEngine from ophyd_async.core import ( DeviceCollector, - assert_emitted, - set_mock_value, ) +from ophyd_async.testing import assert_emitted, set_mock_value from p99_bluesky.devices.andorAd import Andor2Ad, Andor3Ad from p99_bluesky.devices.stages import ThreeAxisStage