def test_live_grid(RE, hw):
hw.motor1.delay = 0
hw.motor2.delay = 0
RE(grid_scan([hw.det4], hw.motor1, -3, 3, 6, hw.motor2, -5, 5, 10, False),
LiveGrid((6, 10), 'det4'))
# Test the deprecated name.
with pytest.warns(UserWarning):
RE(
grid_scan([hw.det4], hw.motor1, -3, 3, 6, hw.motor2, -5, 5, 10,
False), LiveRaster((6, 10), 'det4'))
def test_live_grid(RE, hw):
hw.motor1.delay = 0
hw.motor2.delay = 0
RE(grid_scan([hw.det4],
hw.motor1, -3, 3, 6,
hw.motor2, -5, 5, 10, False),
LiveGrid((6, 10), 'det4'))
# Test the deprecated name.
with pytest.warns(UserWarning):
RE(grid_scan([hw.det4], hw.motor1, -3, 3, 6, hw.motor2,
-5, 5, 10, False),
LiveRaster((6, 10), 'det4'))
def test_live_scatter(RE, hw):
RE(grid_scan([hw.det5],
hw.jittery_motor1, -3, 3, 6,
hw.jittery_motor2, -5, 5, 10, False),
LiveScatter('jittery_motor1', 'jittery_motor2', 'det5',
xlim=(-3, 3), ylim=(-5, 5)))
# Test the deprecated name.
with pytest.warns(UserWarning):
RE(grid_scan([hw.det5],
hw.jittery_motor1, -3, 3, 6,
hw.jittery_motor2, -5, 5, 10, False),
LiveMesh('jittery_motor1', 'jittery_motor2', 'det5',
xlim=(-3, 3), ylim=(-5, 5)))
def test_live_scatter(RE, hw):
RE(grid_scan([hw.det5],
hw.jittery_motor1, -3, 3, 6,
hw.jittery_motor2, -5, 5, 10, False),
LiveScatter('jittery_motor1', 'jittery_motor2', 'det5',
xlim=(-3, 3), ylim=(-5, 5)))
# Test the deprecated name.
with pytest.warns(UserWarning):
RE(grid_scan([hw.det5],
hw.jittery_motor1, -3, 3, 6,
hw.jittery_motor2, -5, 5, 10, False),
LiveMesh('jittery_motor1', 'jittery_motor2', 'det5',
xlim=(-3, 3), ylim=(-5, 5)))
def make_areascan(dets,
slow,
startslow,
stopslow,
nslow,
fast,
startfast,
stopfast,
nfast,
snake=False):
BMMuser.final_log_entry = False
uid = yield from grid_scan(
dets,
slow,
startslow,
stopslow,
nslow,
fast,
startfast,
stopfast,
nfast,
snake,
md={
'plan_name':
f'grid_scan measurement {slow.name} {fast.name} {detector}'
})
BMMuser.final_log_entry = True
return uid
def test_pencil_tomo_pipeline(RE, hw, db):
L = []
rr = RunRouter([
lambda x: tomo_callback_factory(x,
publisher=lambda *x: L.append(x),
handler_reg=db.reg.handler_reg)
])
RE.subscribe(rr)
RE(
bp.grid_scan(
[hw.det1],
hw.motor1,
0,
180,
30,
hw.motor2,
-5,
5,
5,
False,
md={
"tomo": {
"type": "pencil",
"translation": "motor2",
"rotation": "motor1",
"center": 0.0,
}
},
))
# det1
# sinogram and recon
assert len(L) == (30 * 5 + 2 + 1 + 2) * 2
def test_outer_product_ascan_snaked(RE, hw):
scan = bp.grid_scan([hw.det], hw.motor1, 1, 3, 3, hw.motor2, 10, 20, 2,
True)
# Note: motor1 is the first motor specified, and so it is the "slow"
# axis, matching the numpy convention.
expected_data = [{
'motor2': 10.0,
'det': 1.0,
'motor1': 1.0
}, {
'motor2': 20.0,
'det': 1.0,
'motor1': 1.0
}, {
'motor2': 20.0,
'det': 1.0,
'motor1': 2.0
}, {
'motor2': 10.0,
'det': 1.0,
'motor1': 2.0
}, {
'motor2': 10.0,
'det': 1.0,
'motor1': 3.0
}, {
'motor2': 20.0,
'det': 1.0,
'motor1': 3.0
}]
for d in expected_data:
d.update({'motor1_setpoint': d['motor1']})
d.update({'motor2_setpoint': d['motor2']})
multi_traj_checker(RE, scan, expected_data)
def test_mesh_pseudo(hw, RE):
p3x3 = hw.pseudo3x3
sig = hw.sig
d = DocCollector()
RE.subscribe(d.insert)
rs = RE(bp.grid_scan([sig], p3x3.pseudo1, 0, 3, 5, p3x3.pseudo2, 7, 10, 7))
if RE.call_returns_result:
uid = rs.run_start_uids[0]
else:
uid = rs[0]
df = pd.DataFrame(
[_['data'] for _ in d.event[d.descriptor[uid][0]['uid']]])
for k in p3x3.describe():
assert k in df
for k in sig.describe():
assert k in df
assert all(df[sig.name] == 0)
assert all(df[p3x3.pseudo3.name] == 0)
def test_live_fit_multidim(RE, hw):
try:
import lmfit
except ImportError:
raise pytest.skip('requires lmfit')
hw.motor1.delay = 0
hw.motor2.delay = 0
hw.det4.exposure_time = 0
def gaussian(x, y, A, sigma, x0, y0):
return A * np.exp(-((x - x0) ** 2 + (y - y0) ** 2) / (2 * sigma ** 2))
model = lmfit.Model(gaussian, ['x', 'y'])
init_guess = {'A': 2,
'sigma': lmfit.Parameter('sigma', 3, min=0),
'x0': -0.2,
'y0': 0.3}
cb = LiveFit(model, 'det4', {'x': 'motor1', 'y': 'motor2'}, init_guess,
update_every=50)
RE(grid_scan([hw.det4],
hw.motor1, -1, 1, 10,
hw.motor2, -1, 1, 10, False),
cb)
expected = {'A': 1, 'sigma': 1, 'x0': 0, 'y0': 0}
for k, v in expected.items():
assert np.allclose(cb.result.values[k], v, atol=1e-6)
def _test_srw_det_grid_scan(RE, db, tmpdir, sim_type, sim_id, server_name):
import datetime
from ophyd.utils import make_dir_tree
RE.subscribe(db.insert)
root_dir = '/tmp/data'
_ = make_dir_tree(datetime.datetime.now().year, base_path=root_dir)
srw_det = SirepoSRWDetector(name="srw_det",
sim_type=sim_type,
sim_id=sim_id,
sirepo_server=server_name,
root_dir=root_dir)
srw_det.select_optic('Aperture')
param1 = srw_det.create_parameter('horizontalSize')
param2 = srw_det.create_parameter('verticalSize')
srw_det.read_attrs = ['image', 'mean', 'photon_energy']
srw_det.configuration_attrs = [
'horizontal_extent', 'vertical_extent', 'shape'
]
RE(bp.grid_scan([srw_det], param1, 0, 1, 3, param2, 0, 1, 3, True))
db_means = []
actual_means = [
0, 0, 0, 1334615738479247.2, 1208898410914477.0, 0, 0,
1208898410914477.0, 1334615738479247.2
]
hdr = db[-1]
t = hdr.table()
for i in range(len(t)):
db_means.append(t.iloc[i]['srw_det_mean'])
assert actual_means == db_means, "grid_scan means do not match actual means"
def test_plan_header(RE, hw):
args = []
##
args.append((bp.grid_scan([hw.det],
hw.motor, 1, 2, 3,
hw.motor1, 4, 5, 6,
hw.motor2, 7, 8, 9,
snake_axes=True),
{'motors': ('motor', 'motor1', 'motor2'),
'extents': ([1, 2], [4, 5], [7, 8]),
'shape': (3, 6, 9),
'snaking': (False, True, True),
'plan_pattern_module': 'bluesky.plan_patterns',
'plan_pattern': 'outer_product',
'plan_name': 'grid_scan'}))
##
args.append((bp.inner_product_scan([hw.det], 9,
hw.motor, 1, 2,
hw.motor1, 4, 5,
hw.motor2, 7, 8),
{'motors': ('motor', 'motor1', 'motor2')}))
for plan, target in args:
c = DocCollector()
RE(plan, c.insert)
for s in c.start:
_validate_start(s, target)
def test_plan_header(RE, hw):
args = []
##
args.append((bp.grid_scan([hw.det],
hw.motor, 1, 2, 3,
hw.motor1, 4, 5, 6, True,
hw.motor2, 7, 8, 9, True),
{'motors': ('motor', 'motor1', 'motor2'),
'extents': ([1, 2], [4, 5], [7, 8]),
'shape': (3, 6, 9),
'snaking': (False, True, True),
'plan_pattern_module': 'bluesky.plan_patterns',
'plan_pattern': 'outer_product',
'plan_name': 'grid_scan'}))
##
args.append((bp.inner_product_scan([hw.det], 9,
hw.motor, 1, 2,
hw.motor1, 4, 5,
hw.motor2, 7, 8),
{'motors': ('motor', 'motor1', 'motor2')}))
for plan, target in args:
c = DocCollector()
RE(plan, c.insert)
for s in c.start:
_validate_start(s, target)
def test_live_fit_multidim(RE, hw):
try:
import lmfit
except ImportError:
raise pytest.skip('requires lmfit')
hw.motor1.delay = 0
hw.motor2.delay = 0
hw.det4.exposure_time = 0
def gaussian(x, y, A, sigma, x0, y0):
return A * np.exp(-((x - x0)**2 + (y - y0)**2) / (2 * sigma**2))
model = lmfit.Model(gaussian, ['x', 'y'])
init_guess = {
'A': 2,
'sigma': lmfit.Parameter('sigma', 3, min=0),
'x0': -0.2,
'y0': 0.3
}
cb = LiveFit(model,
'det4', {
'x': 'motor1',
'y': 'motor2'
},
init_guess,
update_every=50)
RE(grid_scan([hw.det4], hw.motor1, -1, 1, 10, hw.motor2, -1, 1, 10, False),
cb)
expected = {'A': 1, 'sigma': 1, 'x0': 0, 'y0': 0}
for k, v in expected.items():
assert np.allclose(cb.result.values[k], v, atol=1e-6)
def test_pencil_tomo_pipeline(RE, hw, db):
L = []
rr = RunRouter(
[lambda x: tomo_callback_factory(x, publisher=lambda *x: L.append(x),
handler_reg=db.reg.handler_reg)]
)
RE.subscribe(rr)
RE(
bp.grid_scan(
[hw.det1],
hw.motor1,
0,
180,
30,
hw.motor2,
-5,
5,
5,
False,
md={
"tomo": {
"type": "pencil",
"translation": "motor2",
"rotation": "motor1",
"center": 0.0,
}
},
)
)
# det1
# sinogram and recon
assert len(L) == (30 * 5 + 2 + 1 +2) * 2
def run_exp(delay): # pragma: no cover
time.sleep(delay)
print("running exp")
p = Publisher(proxy[0], prefix=b"an")
RE.subscribe(p)
RE(
bp.grid_scan(
[hw.noisy_det],
hw.motor3,
0,
2,
2,
hw.motor1,
0,
2,
2,
True,
hw.motor2,
0,
2,
2,
True,
md={
"tomo": {
"type": "pencil",
"rotation": "motor1",
"translation": "motor2",
"stack": "motor3",
"center": 1,
}
},
))
def run_exp(delay): # pragma: no cover
time.sleep(delay)
print("running exp")
p = Publisher(proxy[0], prefix=b"an")
RE.subscribe(p)
RE(
bp.grid_scan(
[hw.noisy_det],
hw.motor3,
0,
2,
2,
hw.motor1,
0,
2,
2,
True,
hw.motor2,
0,
2,
2,
True,
md={
"tomo": {
"type": "pencil",
"rotation": "motor1",
"translation": "motor2",
"stack": "motor3",
"center": 1,
}
},
)
)
def generate_example_catalog(data_path):
data_path = Path(data_path)
def factory(name, doc):
serializer = Serializer(data_path / 'abc')
serializer('start', doc)
return [serializer], []
RE = RunEngine()
sd = SupplementalData()
RE.preprocessors.append(sd)
sd.baseline.extend([motor1, motor2])
rr = RunRouter([factory])
RE.subscribe(rr)
RE(count([det]))
RE(count([noisy_det], 5))
RE(scan([det], motor, -1, 1, 7))
RE(grid_scan([det4], motor1, -1, 1, 4, motor2, -1, 1, 7, False))
RE(scan([det], motor, -1, 1, motor2, -1, 1, 5))
RE(count([noisy_det, det], 5))
RE(count([random_img], 5))
RE(count([img], 5))
def factory(name, doc):
serializer = Serializer(data_path / 'xyz')
serializer('start', doc)
return [serializer], []
RE = RunEngine()
rr = RunRouter([factory])
RE.subscribe(rr)
RE(count([det], 3))
catalog_filepath = data_path / 'catalog.yml'
with open(catalog_filepath, 'w') as file:
file.write(f'''
sources:
abc:
description: Some imaginary beamline
driver: bluesky-jsonl-catalog
container: catalog
args:
paths: {Path(data_path) / 'abc' / '*.jsonl'}
handler_registry:
NPY_SEQ: ophyd.sim.NumpySeqHandler
metadata:
beamline: "00-ID"
xyz:
description: Some imaginary beamline
driver: bluesky-jsonl-catalog
container: catalog
args:
paths: {Path(data_path) / 'xyz' / '*.jsonl'}
handler_registry:
NPY_SEQ: ophyd.sim.NumpySeqHandler
metadata:
beamline: "99-ID"
''')
return str(catalog_filepath)
def test_live_scatter(RE, hw):
RE(
grid_scan(
[hw.det5],
hw.jittery_motor1,
-3,
3,
6,
hw.jittery_motor2,
-5,
5,
10,
False,
),
LiveScatter(
"jittery_motor1",
"jittery_motor2",
"det5",
xlim=(-3, 3),
ylim=(-5, 5),
),
)
# Test the deprecated name.
with pytest.warns(UserWarning):
RE(
grid_scan(
[hw.det5],
hw.jittery_motor1,
-3,
3,
6,
hw.jittery_motor2,
-5,
5,
10,
False,
),
LiveMesh(
"jittery_motor1",
"jittery_motor2",
"det5",
xlim=(-3, 3),
ylim=(-5, 5),
),
)
def _plan(self, p1, p2):
x1, y1 = p1
x2, y2 = p2
return grid_scan(self.dets,
self.motor1, x1, x2, self.num1,
self.motor2, y1, y2, self.num2,
self.snake, md=self.md)
def test_live_scatter(RE, hw):
RE(
grid_scan(
[hw.det5],
hw.jittery_motor1,
-3,
3,
6,
hw.jittery_motor2,
-5,
5,
10,
False,
),
LiveScatter(
"jittery_motor1",
"jittery_motor2",
"det5",
xlim=(-3, 3),
ylim=(-5, 5),
),
)
# Test the deprecated name.
with pytest.warns(UserWarning):
RE(
grid_scan(
[hw.det5],
hw.jittery_motor1,
-3,
3,
6,
hw.jittery_motor2,
-5,
5,
10,
False,
),
LiveMesh(
"jittery_motor1",
"jittery_motor2",
"det5",
xlim=(-3, 3),
ylim=(-5, 5),
),
)
def test_plotting_hints(RE, hw, db):
''' This tests the run and checks that the correct hints are created.
Hints are mainly created to help the BestEffortCallback in plotting the
data.
Use a callback to do the checking.
'''
dc = DocCollector()
RE.subscribe(dc.insert)
# check that the inner product hints are passed correctly
hint = {
'dimensions': [([hw.motor1.name, hw.motor2.name,
hw.motor3.name], 'primary')]
}
RE(
inner_product_scan([hw.det], 20, hw.motor1, -1, 1, hw.motor2, -1, 1,
hw.motor3, -2, 0))
assert dc.start[-1]['hints'] == hint
# check that the outer product (grid_scan) hints are passed correctly
hint = {
'dimensions': [(['motor1'], 'primary'), (['motor2'], 'primary'),
(['motor3'], 'primary')]
}
# grid_scan passes "rectilinear" gridding as well
# make sure this is also passed
output_hint = hint.copy()
output_hint['gridding'] = 'rectilinear'
RE(
grid_scan([hw.det], hw.motor1, -1, 1, 2, hw.motor2, -1, 1, 2, True,
hw.motor3, -2, 0, 2, True))
assert dc.start[-1]['hints'] == output_hint
# check that if gridding is supplied, it's not overwritten by grid_scan
# check that the outer product (grid_scan) hints are passed correctly
hint = {
'dimensions': [(['motor1'], 'primary'), (['motor2'], 'primary'),
(['motor3'], 'primary')],
'gridding':
'rectilinear'
}
RE(
grid_scan([hw.det], hw.motor1, -1, 1, 2, hw.motor2, -1, 1, 2, True,
hw.motor3, -2, 0, 2, True))
assert dc.start[-1]['hints'] == hint
def test_grid_scan():
trigger_and_read = helper.shutter_wrapper(bps.trigger_and_read,
movers.shctl1, 0, 100, 0)
one_nd_step = helper.take_reading_wrapper(bps.one_nd_step,
trigger_and_read)
plan = bp.grid_scan([movers.cs700],
movers.cs700,
-1,
1,
3,
per_step=one_nd_step)
sim.summarize_plan(plan)
def test_plotting_hints(RE, hw, db):
''' This tests the run and checks that the correct hints are created.
Hints are mainly created to help the BestEffortCallback in plotting the
data.
Use a callback to do the checking.
'''
dc = DocCollector()
RE.subscribe(dc.insert)
# check that the inner product hints are passed correctly
hint = {'dimensions': [([hw.motor1.name, hw.motor2.name, hw.motor3.name],
'primary')]}
RE(inner_product_scan([hw.det], 20, hw.motor1, -1, 1, hw.motor2, -1, 1,
hw.motor3, -2, 0))
assert dc.start[-1]['hints'] == hint
# check that the outer product (grid_scan) hints are passed correctly
hint = {'dimensions': [(['motor1'], 'primary'),
(['motor2'], 'primary'),
(['motor3'], 'primary')]}
# grid_scan passes "rectilinear" gridding as well
# make sure this is also passed
output_hint = hint.copy()
output_hint['gridding'] = 'rectilinear'
RE(grid_scan([hw.det], hw.motor1, -1, 1, 2, hw.motor2, -1, 1, 2,
True, hw.motor3, -2, 0, 2, True))
assert dc.start[-1]['hints'] == output_hint
# check that if gridding is supplied, it's not overwritten by grid_scan
# check that the outer product (grid_scan) hints are passed correctly
hint = {'dimensions': [(['motor1'], 'primary'),
(['motor2'], 'primary'),
(['motor3'], 'primary')],
'gridding': 'rectilinear'}
RE(grid_scan([hw.det], hw.motor1, -1, 1, 2, hw.motor2, -1, 1, 2,
True, hw.motor3, -2, 0, 2, True))
assert dc.start[-1]['hints'] == hint
def test_old_module_name(hw):
det = hw.det
motor = hw.motor
motor1 = hw.motor1
motor2 = hw.motor2
from bluesky.plan_tools import (print_summary, print_summary_wrapper,
plot_raster_path)
with pytest.warns(UserWarning):
print_summary(scan([det], motor, -1, 1, 10))
with pytest.warns(UserWarning):
list(print_summary_wrapper(scan([det], motor, -1, 1, 10)))
with pytest.warns(UserWarning):
plan = grid_scan([det], motor1, -5, 5, 10, motor2, -7, 7, 15, True)
plot_raster_path(plan, 'motor1', 'motor2', probe_size=.3)
def get_catalog():
RE = RunEngine()
directory = tempfile.TemporaryDirectory().name
for i in range(1, 5):
with Serializer(directory) as serializer:
RE(scan([det], motor, -1, 1, 5 * i), serializer)
with Serializer(directory) as serializer:
RE(count([random_img], 3), serializer)
with Serializer(directory) as serializer:
RE(grid_scan([det4], motor1, -1, 2, 5, motor2, -1, 2, 7), serializer)
catalog = BlueskyMsgpackCatalog(f"{directory}/*.msgpack")
return catalog
def test_ops_dimension_hints(RE, hw):
det = hw.det
motor = hw.motor
motor1 = hw.motor1
c = DocCollector()
RE.subscribe(c.insert)
RE(bp.grid_scan([det], motor, -1, 1, 7, motor1, 0, 2, 3))
st = c.start[0]
assert 'dimensions' in st['hints']
assert st['hints']['dimensions'] == [(m.hints['fields'], 'primary')
for m in (motor, motor1)]
def make_areascan(dets,
slow,
startslow,
stopslow,
nslow,
fast,
startfast,
stopfast,
nfast,
snake=False):
BMMuser.final_log_entry = False
uid = yield from grid_scan(dets, slow, startslow, stopslow, nslow,
fast, startfast, stopfast, nfast, snake)
BMMuser.final_log_entry = True
return uid
def _plan(self, p1, p2):
x1, y1 = p1
x2, y2 = p2
return grid_scan(self.dets,
self.motor1,
x1,
x2,
self.num1,
self.motor2,
y1,
y2,
self.num2,
self.snake,
md=self.md)
def simple_run(RE, db, sim_id, optic):
sim_id = sim_id
sirepo_det = sd.SirepoDetector(sim_id=sim_id)
sirepo_det.select_optic(optic)
param1 = sirepo_det.create_parameter("horizontalSize")
param2 = sirepo_det.create_parameter("verticalSize")
sirepo_det.read_attrs = ["image", "mean", "photon_energy"]
sirepo_det.configuration_attrs = ["horizontal_extent", "vertical_extent", "shape"]
RE(bp.grid_scan([sirepo_det], param1, 0, 1, 10, param2, 0, 1, 10, True))
plt.show()
hdr = db[-1]
data = np.array(list(hdr.data("sirepo_det_image")))
plt.imshow(data[data.shape[0] - 3])
plt.show()
def test_ops_dimension_hints(RE, hw):
det = hw.det
motor = hw.motor
motor1 = hw.motor1
c = DocCollector()
RE.subscribe(c.insert)
rs, = RE(bp.grid_scan([det],
motor, -1, 1, 7,
motor1, 0, 2, 3, False))
st = c.start[0]
assert 'dimensions' in st['hints']
assert st['hints']['dimensions'] == [
(m.hints['fields'], 'primary') for m in (motor, motor1)]
def xpdacq_grid_scan_with_dark(
detectors: list,
*args,
snake_axes: typing.Union[bool, typing.Iterable[bool], None] = None,
per_step: typing.Callable = xpdacq_per_step,
md: typing.Union[dict, None] = None) -> typing.Generator:
"""
Scan over a mesh; each motor is on an independent trajectory. If there is a change in the position of the
slow motor, take a dark image.
Parameters
----------
detectors: list
list of 'readable' objects
``*args``
patterned like (``motor1, start1, stop1, num1,``
``motor2, start2, stop2, num2,``
``motor3, start3, stop3, num3,`` ...
``motorN, startN, stopN, numN``)
The first motor is the "slowest", the outer loop. For all motors
except the first motor, there is a "snake" argument: a boolean
indicating whether to following snake-like, winding trajectory or a
simple left-to-right trajectory.
snake_axes: boolean or iterable, optional
which axes should be snaked, either ``False`` (do not snake any axes),
``True`` (snake all axes) or a list of axes to snake. "Snaking" an axis
is defined as following snake-like, winding trajectory instead of a
simple left-to-right trajectory. The elements of the list are motors
that are listed in `args`. The list must not contain the slowest
(first) motor, since it can't be snaked.
per_step: callable, optional
hook for customizing action of inner loop (messages per step).
See docstring of `xpdacq_per_step` (the default)
for details.
md: dict, optional
metadata
"""
if args:
slow_motor = args[0]
per_step = slow_dark_wrapper(per_step, slow_motor)
yield from bp.grid_scan(detectors,
*args,
snake_axes=snake_axes,
per_step=per_step,
md=md)
def test_outer_product_ascan_snaked(RE, hw):
scan = bp.grid_scan([hw.det],
hw.motor1, 1, 3, 3,
hw.motor2, 10, 20, 2, True)
# Note: motor1 is the first motor specified, and so it is the "slow"
# axis, matching the numpy convention.
expected_data = [
{'motor2': 10.0, 'det': 1.0, 'motor1': 1.0},
{'motor2': 20.0, 'det': 1.0, 'motor1': 1.0},
{'motor2': 20.0, 'det': 1.0, 'motor1': 2.0},
{'motor2': 10.0, 'det': 1.0, 'motor1': 2.0},
{'motor2': 10.0, 'det': 1.0, 'motor1': 3.0},
{'motor2': 20.0, 'det': 1.0, 'motor1': 3.0}]
for d in expected_data:
d.update({'motor1_setpoint': d['motor1']})
d.update({'motor2_setpoint': d['motor2']})
multi_traj_checker(RE, scan, expected_data)
def test_mesh_pseudo(hw, RE):
p3x3 = hw.pseudo3x3
sig = hw.sig
d = DocCollector()
RE.subscribe(d.insert)
rs, = RE(bp.grid_scan([sig], p3x3.pseudo1, 0, 3, 5, p3x3.pseudo2, 7, 10,
7))
df = pd.DataFrame([_['data'] for _ in d.event[d.descriptor[rs][0]['uid']]])
for k in p3x3.describe():
assert k in df
for k in sig.describe():
assert k in df
assert all(df[sig.name] == 0)
assert all(df[p3x3.pseudo3.name] == 0)
def test_mesh_pseudo(hw, RE):
p3x3 = hw.pseudo3x3
sig = hw.sig
d = DocCollector()
RE.subscribe(d.insert)
rs, = RE(bp.grid_scan([sig],
p3x3.pseudo1, 0, 3, 5,
p3x3.pseudo2, 7, 10, 7, False))
df = pd.DataFrame([_['data']
for _ in d.event[d.descriptor[rs][0]['uid']]])
for k in p3x3.describe():
assert k in df
for k in sig.describe():
assert k in df
assert all(df[sig.name] == 0)
assert all(df[p3x3.pseudo3.name] == 0)
def test_colliding_streams(RE, hw):
collector = {'primary': [], 'baseline': []}
descs = {}
def local_cb(name, doc):
if name == 'descriptor':
descs[doc['uid']] = doc['name']
elif name == 'event':
collector[descs[doc['descriptor']]].append(doc)
RE(
baseline_wrapper(
grid_scan([hw.motor], hw.motor, -1, 1, 5, hw.motor1, -5, 5, 7,
True), [hw.motor, hw.motor1]), local_cb)
assert len(collector['primary']) == 35
assert len(collector['baseline']) == 2
assert list(range(1, 36)) == [e['seq_num'] for e in collector['primary']]
assert list(range(1, 3)) == [e['seq_num'] for e in collector['baseline']]
def test_live_fit_multidim(RE, hw):
try:
import lmfit
except ImportError:
raise pytest.skip("requires lmfit")
hw.motor1.delay = 0
hw.motor2.delay = 0
hw.det4.exposure_time = 0
def gaussian(x, y, A, sigma, x0, y0):
return A * np.exp(-((x - x0)**2 + (y - y0)**2) / (2 * sigma**2))
model = lmfit.Model(gaussian, ["x", "y"])
init_guess = {
"A": 2,
"sigma": lmfit.Parameter("sigma", 3, min=0),
"x0": -0.2,
"y0": 0.3,
}
cb = LiveFit(
model,
"det4",
{
"x": "motor1",
"y": "motor2"
},
init_guess,
update_every=50,
)
RE(
grid_scan([hw.det4], hw.motor1, -1, 1, 10, hw.motor2, -1, 1, 10,
False),
cb,
)
expected = {"A": 1, "sigma": 1, "x0": 0, "y0": 0}
for k, v in expected.items():
assert np.allclose(cb.result.values[k], v, atol=1e-6)
def test_colliding_streams(RE, hw):
collector = {'primary': [], 'baseline': []}
descs = {}
def local_cb(name, doc):
if name == 'descriptor':
descs[doc['uid']] = doc['name']
elif name == 'event':
collector[descs[doc['descriptor']]].append(doc)
RE(baseline_wrapper(grid_scan([hw.motor],
hw.motor, -1, 1, 5,
hw.motor1, -5, 5, 7, True),
[hw.motor, hw.motor1]),
local_cb)
assert len(collector['primary']) == 35
assert len(collector['baseline']) == 2
assert list(range(1, 36)) == [e['seq_num'] for e in collector['primary']]
assert list(range(1, 3)) == [e['seq_num'] for e in collector['baseline']]
def test_live_fit_multidim(RE, hw):
try:
import lmfit
except ImportError:
raise pytest.skip("requires lmfit")
hw.motor1.delay = 0
hw.motor2.delay = 0
hw.det4.exposure_time = 0
def gaussian(x, y, A, sigma, x0, y0):
return A * np.exp(-((x - x0) ** 2 + (y - y0) ** 2) / (2 * sigma ** 2))
model = lmfit.Model(gaussian, ["x", "y"])
init_guess = {
"A": 2,
"sigma": lmfit.Parameter("sigma", 3, min=0),
"x0": -0.2,
"y0": 0.3,
}
cb = LiveFit(
model,
"det4",
{"x": "motor1", "y": "motor2"},
init_guess,
update_every=50,
)
RE(
grid_scan(
[hw.det4], hw.motor1, -1, 1, 10, hw.motor2, -1, 1, 10, False
),
cb,
)
expected = {"A": 1, "sigma": 1, "x0": 0, "y0": 0}
for k, v in expected.items():
assert np.allclose(cb.result.values[k], v, atol=1e-6)
res = SimpleToEventStream(pipeline, ('result', ))
merge = AlignEventStreams(res, raw_source)
merge.starsink(bec)
RE.subscribe(lambda *x: raw_source.emit(x))
RE(
pchain(
bp.scan([hw.noisy_det], hw.motor, 0, 10, 10),
bp.grid_scan([hw.ab_det],
hw.motor,
0,
10,
10,
hw.motor2,
0,
10,
10,
True,
per_step=one_nd_step),
bp.spiral([hw.ab_det],
hw.motor,
hw.motor2,
0,
0,
10,
10,
1,
10,
per_step=one_nd_step),
def _gen(self):
return grid_scan(self.detectors, *self.args, md=self.md)
from bluesky.plans import grid_scan
from ophyd.sim import motor1, motor2, det4
dets = [det4]
RE(
grid_scan(
dets,
motor1,
-1.5,
1.5,
3, # scan motor1 from -1.5 to 1.5 in 3 steps
motor2,
-0.1,
0.1,
5,
False)) # scan motor2 from -0.1 to 0.1 in 5 steps
mmm.kind = "hinted"
xrun(0,
bp.grid_scan(
[xpd_pe1c],
mmm,
0,
2,
2,
m,
0,
180,
4,
True,
mm,
200,
401,
4,
True,
md={
"tomo": {
"type": "pencil",
"rotation": "motor1",
"translation": "motor2",
"stack": "motor3",
"center": rot_center - 200,
}
},
)
)
from bluesky import RunEngine
from bluesky.plans import grid_scan
from ophyd.sim import det4, motor1, motor2
from bluesky.callbacks.mpl_plotting import LiveGrid
motor1.delay = 0
motor2.delay = 0
RE = RunEngine({})
RE(grid_scan([det4], motor1, -3, 3, 6, motor2, -5, 5, 10, False),
LiveGrid((6, 10), 'det4'))
def test_plotting_hints(RE, hw, db):
""" This tests the run and checks that the correct hints are created.
Hints are mainly created to help the BestEffortCallback in plotting the
data.
Use a callback to do the checking.
"""
dc = DocCollector()
RE.subscribe(dc.insert)
# check that the inner product hints are passed correctly
hint = {
"dimensions": [([hw.motor1.name, hw.motor2.name,
hw.motor3.name], "primary")]
}
RE(
inner_product_scan([hw.det], 20, hw.motor1, -1, 1, hw.motor2, -1, 1,
hw.motor3, -2, 0))
assert dc.start[-1]["hints"] == hint
# check that the outer product (grid_scan) hints are passed correctly
hint = {
"dimensions": [
(["motor1"], "primary"),
(["motor2"], "primary"),
(["motor3"], "primary"),
]
}
# grid_scan passes "rectilinear" gridding as well
# make sure this is also passed
output_hint = hint.copy()
output_hint["gridding"] = "rectilinear"
RE(
grid_scan(
[hw.det],
hw.motor1,
-1,
1,
2,
hw.motor2,
-1,
1,
2,
True,
hw.motor3,
-2,
0,
2,
True,
))
assert dc.start[-1]["hints"] == output_hint
# check that if gridding is supplied, it's not overwritten by grid_scan
# check that the outer product (grid_scan) hints are passed correctly
hint = {
"dimensions": [
(["motor1"], "primary"),
(["motor2"], "primary"),
(["motor3"], "primary"),
],
"gridding":
"rectilinear",
}
RE(
grid_scan(
[hw.det],
hw.motor1,
-1,
1,
2,
hw.motor2,
-1,
1,
2,
True,
hw.motor3,
-2,
0,
2,
True,
))
assert dc.start[-1]["hints"] == hint
def generate_example_catalog(data_path):
data_path = Path(data_path)
def factory(name, doc):
serializer = Serializer(data_path / 'abc')
serializer('start', doc)
return [serializer], []
RE = RunEngine()
sd = SupplementalData()
RE.preprocessors.append(sd)
sd.baseline.extend([motor1, motor2])
rr = RunRouter([factory])
RE.subscribe(rr)
RE(count([det]))
RE(count([noisy_det], 5))
RE(scan([det], motor, -1, 1, 7))
RE(grid_scan([det4], motor1, -1, 1, 4, motor2, -1, 1, 7, False))
RE(scan([det], motor, -1, 1, motor2, -1, 1, 5))
RE(count([noisy_det, det], 5))
# RE(count([img], 5))
def factory(name, doc):
serializer = Serializer(data_path / 'xyz')
serializer('start', doc)
return [serializer], []
RE = RunEngine()
rr = RunRouter([factory])
RE.subscribe(rr)
RE(count([det], 3))
catalog_filepath = data_path / 'catalog.yml'
with open(catalog_filepath, 'w') as file:
file.write(f'''
plugins:
source:
- module: intake_bluesky
sources:
abc:
description: Some imaginary beamline
driver: intake_bluesky.jsonl.BlueskyJSONLCatalog
container: catalog
args:
paths: {Path(data_path) / 'abc' / '*.jsonl'}
handler_registry:
NPY_SEQ: ophyd.sim.NumpySeqHandler
metadata:
beamline: "00-ID"
xyz:
description: Some imaginary beamline
driver: intake_bluesky.jsonl.BlueskyJSONLCatalog
container: catalog
args:
paths: {Path(data_path) / 'xyz' / '*.jsonl'}
handler_registry:
NPY_SEQ: ophyd.sim.NumpySeqHandler
metadata:
beamline: "99-ID"
''')
return str(catalog_filepath)
def test_simple_grid_scan():
RE = RunEngine()
hardware = yaqc_bluesky.Device(39424)
sensor = yaqc_bluesky.Device(39425)
RE(grid_scan([sensor], hardware, -10, 10, 15))
def test_plotting_hints(RE, hw, db):
""" This tests the run and checks that the correct hints are created.
Hints are mainly created to help the BestEffortCallback in plotting the
data.
Use a callback to do the checking.
"""
dc = DocCollector()
RE.subscribe(dc.insert)
# check that the inner product hints are passed correctly
hint = {
"dimensions": [
([hw.motor1.name, hw.motor2.name, hw.motor3.name], "primary")
]
}
RE(
inner_product_scan(
[hw.det], 20, hw.motor1, -1, 1, hw.motor2, -1, 1, hw.motor3, -2, 0
)
)
assert dc.start[-1]["hints"] == hint
# check that the outer product (grid_scan) hints are passed correctly
hint = {
"dimensions": [
(["motor1"], "primary"),
(["motor2"], "primary"),
(["motor3"], "primary"),
]
}
# grid_scan passes "rectilinear" gridding as well
# make sure this is also passed
output_hint = hint.copy()
output_hint["gridding"] = "rectilinear"
RE(
grid_scan(
[hw.det],
hw.motor1,
-1,
1,
2,
hw.motor2,
-1,
1,
2,
True,
hw.motor3,
-2,
0,
2,
True,
)
)
assert dc.start[-1]["hints"] == output_hint
# check that if gridding is supplied, it's not overwritten by grid_scan
# check that the outer product (grid_scan) hints are passed correctly
hint = {
"dimensions": [
(["motor1"], "primary"),
(["motor2"], "primary"),
(["motor3"], "primary"),
],
"gridding": "rectilinear",
}
RE(
grid_scan(
[hw.det],
hw.motor1,
-1,
1,
2,
hw.motor2,
-1,
1,
2,
True,
hw.motor3,
-2,
0,
2,
True,
)
)
assert dc.start[-1]["hints"] == hint
def e_grid_scan(*args, **kwargs):
return (yield from bp.grid_scan(*args, per_step=one_nd_step_pseudo_shutter, **kwargs))
RE.subscribe(lambda *x: raw_source.emit(x))
RE.subscribe(lambda *x: p(*x))
RE.subscribe(lambda *x: time.sleep(.1))
RE.subscribe(lambda *x: time.sleep(1), "stop")
RE(
pchain(
bp.scan([hw.noisy_det], hw.motor, 0, 10, 10),
bp.grid_scan(
[hw.ab_det],
hw.motor,
0,
5,
5,
hw.motor2,
0,
5,
5,
True,
per_step=one_nd_step,
),
bp.grid_scan(
[hw.ab_det],
hw.motor,
0,
10,
10,
hw.motor2,
0,
10,
def test_live_grid(RE, hw):
bec = BestEffortCallback()
RE.subscribe(bec)
RE(grid_scan([hw.det4], hw.motor1, 0, 1, 1, hw.motor2, 0, 1, 2, True))