mirror of
https://github.com/ivan-usov-org/bec.git
synced 2025-04-21 18:20:01 +02:00
323 lines
11 KiB
Python
323 lines
11 KiB
Python
import os
|
|
import time
|
|
|
|
import numpy as np
|
|
import pytest
|
|
import yaml
|
|
|
|
import bec_lib
|
|
from bec_lib import DeviceConfigError, bec_logger
|
|
from bec_lib.alarm_handler import AlarmBase
|
|
|
|
logger = bec_logger.logger
|
|
|
|
|
|
@pytest.mark.timeout(100)
|
|
def test_grid_scan_lib(bec_client_lib):
|
|
bec = bec_client_lib
|
|
scans = bec.scans
|
|
bec.metadata.update({"unit_test": "test_grid_scan_bec_client_lib"})
|
|
dev = bec.device_manager.devices
|
|
scans.umv(dev.samx, 0, dev.samy, 0, relative=False)
|
|
status = scans.grid_scan(dev.samx, -5, 5, 10, dev.samy, -5, 5, 10, exp_time=0.01, relative=True)
|
|
status.wait()
|
|
assert len(status.scan.data) == 100
|
|
assert status.scan.num_points == 100
|
|
|
|
|
|
@pytest.mark.timeout(100)
|
|
def test_mv_scan_lib(bec_client_lib):
|
|
bec = bec_client_lib
|
|
scans = bec.scans
|
|
bec.metadata.update({"unit_test": "test_mv_scan_bec_client_lib"})
|
|
dev = bec.device_manager.devices
|
|
scans.mv(dev.samx, 10, dev.samy, 20, relative=False).wait()
|
|
current_pos_samx = dev.samx.read()["samx"]["value"]
|
|
current_pos_samy = dev.samy.read()["samy"]["value"]
|
|
assert np.isclose(
|
|
current_pos_samx, 10, atol=dev.samx._config["deviceConfig"].get("tolerance", 0.05)
|
|
)
|
|
assert np.isclose(
|
|
current_pos_samy, 20, atol=dev.samy._config["deviceConfig"].get("tolerance", 0.05)
|
|
)
|
|
|
|
|
|
@pytest.mark.timeout(100)
|
|
def test_mv_raises_limit_error(bec_client_lib):
|
|
bec = bec_client_lib
|
|
scans = bec.scans
|
|
bec.metadata.update({"unit_test": "test_mv_raises_limit_error"})
|
|
dev = bec.device_manager.devices
|
|
dev.samx.limits = [-50, 50]
|
|
with pytest.raises(AlarmBase) as exc:
|
|
scans.mv(dev.samx, 1000, relative=False).wait()
|
|
|
|
|
|
@pytest.mark.timeout(100)
|
|
def test_async_callback_data_matches_scan_data_lib(bec_client_lib):
|
|
bec = bec_client_lib
|
|
bec.metadata.update({"unit_test": "test_async_callback_data_matches_scan_data"})
|
|
dev = bec.device_manager.devices
|
|
reference_container = {"data": [], "metadata": {}}
|
|
|
|
def dummy_callback(data, metadata):
|
|
logger.info(f"callback metadata: {metadata}")
|
|
reference_container["metadata"] = metadata
|
|
reference_container["data"].append(data)
|
|
|
|
s = scans.line_scan(dev.samx, 0, 1, steps=10, relative=False, async_callback=dummy_callback)
|
|
s.wait()
|
|
while len(reference_container["data"]) < 10:
|
|
time.sleep(0.1)
|
|
assert len(s.scan.data) == 10
|
|
assert len(reference_container["data"]) == 10
|
|
|
|
for ii, msg in enumerate(s.scan.data.messages.values()):
|
|
assert msg.content == reference_container["data"][ii]
|
|
|
|
|
|
@pytest.mark.timeout(100)
|
|
def test_config_updates(bec_client_lib):
|
|
bec = bec_client_lib
|
|
bec.metadata.update({"unit_test": "test_config_updates"})
|
|
dev = bec.device_manager.devices
|
|
dev.samx.limits = [-80, 80]
|
|
assert dev.samx.limits == [-80, 80]
|
|
dev.samx.limits = [-50, 50]
|
|
assert dev.samx.limits == [-50, 50]
|
|
|
|
dev.samx.velocity.set(10).wait()
|
|
assert dev.samx.velocity.read()["samx_velocity"]["value"] == 10
|
|
assert dev.samx.velocity.read(cached=False)["samx_velocity"]["value"] == 10
|
|
assert dev.samx.read_configuration()["samx_velocity"]["value"] == 10
|
|
assert dev.samx.read_configuration(cached=False)["samx_velocity"]["value"] == 10
|
|
|
|
dev.samx.velocity.put(5)
|
|
assert dev.samx.velocity.get() == 5
|
|
|
|
dev.samx.velocity.set(10).wait()
|
|
assert dev.samx.velocity.get() == 10
|
|
|
|
dev.samx.setpoint.put(5)
|
|
assert dev.samx.setpoint.get() == 5
|
|
|
|
dev.samx.setpoint.set(10).wait()
|
|
assert dev.samx.setpoint.get() == 10
|
|
assert dev.samx.dummy_controller.some_var == 10
|
|
dev.samx.dummy_controller.some_var = 20
|
|
assert dev.samx.dummy_controller.some_var == 20
|
|
dev.samx.dummy_controller.some_var = 10
|
|
val = dev.samx.readback.get()
|
|
assert np.isclose(val, dev.samx.position, atol=0.05)
|
|
|
|
|
|
@pytest.mark.timeout(100)
|
|
def test_dap_fit(bec_client_lib):
|
|
bec = bec_client_lib
|
|
bec.metadata.update({"unit_test": "test_dap_fit"})
|
|
dev = bec.device_manager.devices
|
|
scans = bec.scans
|
|
|
|
dev.bpm4i.sim.sim_select_model("GaussianModel")
|
|
params = dev.bpm4i.sim.sim_params
|
|
params.update(
|
|
{"noise": "uniform", "noise_multiplier": 10, "center": 5, "sigma": 1, "amplitude": 200}
|
|
)
|
|
dev.bpm4i.sim.sim_params = params
|
|
time.sleep(1)
|
|
|
|
res = scans.line_scan(dev.samx, 0, 8, steps=50, relative=False)
|
|
res.wait()
|
|
|
|
fit = bec.dap.GaussianModel.fit(res.scan, "samx", "samx", "bpm4i", "bpm4i")
|
|
|
|
assert np.isclose(fit.center, 5, atol=0.5)
|
|
|
|
|
|
@pytest.mark.timeout(100)
|
|
@pytest.mark.parametrize(
|
|
"config, raises_error, deletes_config, disabled_device",
|
|
[
|
|
(
|
|
{
|
|
"hexapod": {
|
|
"deviceClass": "SynDeviceOPAAS",
|
|
"deviceConfig": {},
|
|
"deviceTags": ["user motors"],
|
|
"readoutPriority": "baseline",
|
|
"enabled": True,
|
|
"readOnly": False,
|
|
},
|
|
"eyefoc": {
|
|
"deviceClass": "SimPositioner",
|
|
"deviceConfig": {
|
|
"delay": 1,
|
|
"limits": [-50, 50],
|
|
"speed": 100,
|
|
"tolerance": 0.01,
|
|
"update_frequency": 400,
|
|
},
|
|
"deviceTags": ["user motors"],
|
|
"enabled": True,
|
|
"readOnly": False,
|
|
},
|
|
},
|
|
True,
|
|
False,
|
|
[],
|
|
),
|
|
(
|
|
{
|
|
"hexapod": {
|
|
"deviceClass": "SynDeviceOPAAS",
|
|
"deviceConfig": {},
|
|
"deviceTags": ["user motors"],
|
|
"readoutPriority": "baseline",
|
|
"enabled": True,
|
|
"readOnly": False,
|
|
},
|
|
"eyefoc": {
|
|
"deviceClass": "SimPositioner",
|
|
"deviceConfig": {
|
|
"delay": 1,
|
|
"limits": [-50, 50],
|
|
"speed": 100,
|
|
"tolerance": 0.01,
|
|
"update_frequency": 400,
|
|
},
|
|
"readoutPriority": "baseline",
|
|
"deviceTags": ["user motors"],
|
|
"enabled": True,
|
|
"readOnly": False,
|
|
},
|
|
},
|
|
False,
|
|
False,
|
|
[],
|
|
),
|
|
(
|
|
{
|
|
"hexapod": {
|
|
"deviceClass": "SynDeviceOPAAS",
|
|
"deviceConfig": {},
|
|
"deviceTags": ["user motors"],
|
|
"readoutPriority": "baseline",
|
|
"enabled": True,
|
|
"readOnly": False,
|
|
},
|
|
"eyefoc": {
|
|
"deviceClass": "utils:bec_utils:DeviceClassConnectionError",
|
|
"deviceConfig": {},
|
|
"readoutPriority": "baseline",
|
|
"deviceTags": ["user motors"],
|
|
"enabled": True,
|
|
"readOnly": False,
|
|
},
|
|
},
|
|
True,
|
|
False,
|
|
["eyefoc"],
|
|
),
|
|
(
|
|
{
|
|
"hexapod": {
|
|
"deviceClass": "SynDeviceOPAAS",
|
|
"deviceConfig": {},
|
|
"deviceTags": ["user motors"],
|
|
"readoutPriority": "baseline",
|
|
"enabled": True,
|
|
"readOnly": False,
|
|
},
|
|
"eyefoc": {
|
|
"deviceClass": "utils:bec_utils:DeviceClassInitError",
|
|
"deviceConfig": {},
|
|
"readoutPriority": "baseline",
|
|
"deviceTags": ["user motors"],
|
|
"enabled": True,
|
|
"readOnly": False,
|
|
},
|
|
},
|
|
True,
|
|
True,
|
|
[],
|
|
),
|
|
(
|
|
{
|
|
"hexapod": {
|
|
"deviceClass": "SynDeviceOPAAS",
|
|
"deviceConfig": {},
|
|
"deviceTags": ["user motors"],
|
|
"readoutPriority": "baseline",
|
|
"enabled": True,
|
|
"readOnly": False,
|
|
},
|
|
"eyefoc": {
|
|
"deviceClass": "WrongDeviceClass",
|
|
"deviceConfig": {},
|
|
"readoutPriority": "baseline",
|
|
"deviceTags": ["user motors"],
|
|
"enabled": True,
|
|
"readOnly": False,
|
|
},
|
|
},
|
|
True,
|
|
True,
|
|
[],
|
|
),
|
|
],
|
|
ids=[
|
|
"invalid_config_missing_readoutPriority",
|
|
"valid_config_no_error",
|
|
"invalid_device_class_connection_error",
|
|
"invalid_device_class_init",
|
|
"invalid_device_class",
|
|
],
|
|
)
|
|
def test_config_reload(bec_client_lib, config, raises_error, deletes_config, disabled_device):
|
|
bec = bec_client_lib
|
|
bec.metadata.update({"unit_test": "test_config_reload"})
|
|
try:
|
|
# write new config to disk
|
|
with open("./e2e_runtime_config_test.yaml", "w") as f:
|
|
f.write(yaml.dump(config))
|
|
num_devices = len(bec.device_manager.devices)
|
|
if raises_error:
|
|
with pytest.raises(DeviceConfigError):
|
|
bec.config.update_session_with_file("./e2e_runtime_config_test.yaml")
|
|
if deletes_config:
|
|
assert len(bec.device_manager.devices) == 0
|
|
elif disabled_device:
|
|
assert len(bec.device_manager.devices) == 2
|
|
else:
|
|
assert len(bec.device_manager.devices) == num_devices
|
|
else:
|
|
bec.config.update_session_with_file("./e2e_runtime_config_test.yaml")
|
|
assert len(bec.device_manager.devices) == 2
|
|
for dev in disabled_device:
|
|
assert bec.device_manager.devices[dev].enabled is False
|
|
finally:
|
|
test_device_config = os.path.join(
|
|
os.path.dirname(os.path.abspath(bec_lib.tests.__file__)), "test_config.yaml"
|
|
)
|
|
bec.config.update_session_with_file(test_device_config)
|
|
# bec.config.load_demo_config()
|
|
|
|
|
|
def test_computed_signal(bec_client_lib):
|
|
bec = bec_client_lib
|
|
bec.metadata.update({"unit_test": "test_computed_signal"})
|
|
dev = bec.device_manager.devices
|
|
scans = bec.scans
|
|
|
|
res = scans.line_scan(dev.samx, -0.1, 0.1, steps=10, relative=False, exp_time=0)
|
|
res.wait()
|
|
assert "pseudo_signal1" in res.scan.baseline
|
|
|
|
def compute_signal1(*args, **kwargs):
|
|
return 5
|
|
|
|
dev.pseudo_signal1.set_compute_method(compute_signal1)
|
|
dev.pseudo_signal1.set_input_signals()
|
|
|
|
assert dev.pseudo_signal1.read(cached=False)["pseudo_signal1"]["value"] == 5
|