Bluesky数据采集框架-5-CSDN博客

本文链接：https://blog.csdn.net/yuyuyuliang00/article/details/136302463

计划(Plans)

一个计划plan时bluesky的一个实验过程的概念。一个计划可能是一个任何可迭代对象(列表，元组，自定义可迭代类，...)，但它最常见作为一个Python生成器被实现。更多技术细节的讨论，我们参考消息协议。

提供了各种预定义的计划。像熟食菜单上的三明治，你可以使用我们的预组装计划或者从在以下Stub计划下分类的相同成分组装你自己的计划。

注意：在以下示例中，我们将认为你有一个名为RE的RunEngine实例。如果你是一个运行了bluesky设施的用户，这可能已经为你配置好了。见教程本章来区分你是否已经有了一个RunEngine或者根据需要快速产生一个。

预组装计划

以下概要表格，我们通过类别分解这些计划并且用图展示示例。

概要

注意：在左列中的名称链接到了详细的API文档。

count	从探测器获取一个或多个读数
scan	扫描一个多电机轨迹
rel_scan	相对于当前位置扫描一个多电机轨迹
list_scan	同时以相同步骤扫描一个或多个变量(内积)
rel_list_scan	相对当前位置用相同步骤扫描一个变量
list_grid_scan	扫描一个网格；每个电机在一个独立轨迹上。
rel_list_grid_scan	扫描一个网格；每个电机在一个独立轨迹上。
log_scan	用对数间隔步骤扫描一个变量。
rel_log_scan	相对于当前位置用对数间隔步骤扫描一个变量。
grid_scan	扫描一个网格；每个电机是一个独立轨迹。
rel_grid_scan	相对于当前位置扫描一个网格
scan_nd	扫描任意N维轨迹
spiral	螺旋扫描，以(x_start, y_start)为中心
spiral_fermat	绝对费马螺旋扫描，以(x_start, y_start)为中心
spiral_squre	绝对分行螺旋扫描，以(x_start, y_start)为中心
rel_spiral	相对螺旋扫描
rel_spiral_fermat	相对费马螺旋扫描
rel_spiral_squre	相对分行螺旋扫描
adaptive_scan	用自适应调整步长扫描一个变量
rel_adaptive_scan	用自适应调整步长相对扫描一个变量
tune_centroid	计划：调整电机到()电机信号质心
tweak	用交互提示移动电机读取探测器
ramp_plan	在ramping一个或多个定位器时采集数据
fly	用一个或多个'flyers'执行一个飞行扫描

时序("count")

示例：

from bluesky import RunEngine
from bluesky.callbacks.best_effort import BestEffortCallback
from ophyd.sim import det
from bluesky.plans import count

bec = BestEffortCallback()

RE = RunEngine({})
RE.subscribe(bec)

# 探测器'det'的单次读取
RE(count([det]))

# 5次连续读取
RE(count([det], num=5))

# 5次顺序读取,读取之间由1秒延时
RE(count([det], num=5, delay=1))

# 一个读取之间可变延时
RE(count([det], num=5, delay=[1, 2, 3, 4]))

# 一直采集,知道被中断(例如,用Ctrl+c)
RE(count([det], num=None))

# 我们将为一个更有趣绘图使用'noisy_det'示例探测器.
from ophyd.sim import noisy_det

RE(count([noisy_det], num=5))

注意：为什么count()没有一个expoure_time参数？

现代CCD探测器一般用多个参数(采集时间，采集周期，曝光数目)参数化曝光时间，如scalers做的相同(预置时间，自动计数时间)。没有可以被用于所有探测器的"曝光时间"。

另外，当如在count([det1, det2])中使用多个探测器时，用户在一般情况中需要为每个探测器提供一个单独的曝光时间，这将变得冗长。

一个选择是作为单独一步设置时间相关的参数。

对于交互用法：

# 只是一个示例.你的探测器会有不同名称或者很多曝光相关的参数,这是要点.
det.exposure_time.set(3)
det.acquire_period.set(3.5)

从一个计划：

# 只是一个示例.你的探测器会有不同名称或者很多曝光相关的参数,这是要点.
 yield from bluesky.plan_stubs.mv(
     det.exposure_time, 3,
     det.acquire_period, 3.5)

另一种是编写一个包含了count()并且设置了曝光时间的自定义计划。这个计划可以编码bluesky一般不知道的详情。

def count_with_time(detectors, num, delay, exposure_time, *, md=None):
    # 假设所有探测器有一个称为'exposure_time'的完全指定其曝光的曝光时间成分
    for detector in detectors:
        yield from bluesky.plan_stubs.mv(detector.exposure_time, exposure_time)
    yield from bluesky.plans.count(detectors, num, delay, md=md)

# bluesky.plans.count
# 从一个或者多个探测读取
bluesky.plans.count(detectors, num=1, delay=None, *, per_shot=None, md=None)
'''
参数：
1、detectors：list '可读的'对象的列表
2、num：integer, 可选，要获取的读数数目；默认为1。如果为None，在取消前一直捕获
3、delay：可迭代或者标量，可选，连续读取之间延时(以秒为单位)，默认为0。
4、per_shot：可调用，可选，内层循环(每步消息)的自定义操作的hook。期望签名：
    def f(detectors: Iterable[OphydObj]) -> Generator[Msg]:
        ...
md：dict, 可选，元数据

注意：如果delay是一个可迭代的，它必须至少有num-1项，否则在迭代中这个计划将产生一个ValueError。
'''

在一维上扫描

"维度"可能是一个物理电机位置，一个温度或者一个伪轴。对于计划，它都相同。示例：

from ophyd.sim import det, motor
from bluesky.plans import scan, rel_scan, list_scan

# 从1到5扫描一个电机，获取'det'的5个等间隔读数
RE(scan([det], motor, 1, 5, 5))

# 相对其当前位置，从1到5扫描一个电机
RE(rel_scan([det], motor, 1, 5, 5))

# scan a motor through a list of user-specified positions
# 扫描一个电机通过一个用户指定位置的列表
RE(list_scan([det], motor, [1, 1, 2, 3, 5, 8]))

注意：扫描为什么没有一个delay参数？你可能已经注意count()有一个delay参数，但扫描没有它。这是故意的。在一个扫描中等待一个延时的常见原因是等待电机稳定或者温控器达到平衡。在各自设备上配置这个延时更好，因此扫描将总是为正在被扫描的特定设备添加一个合适的延时。

motor.settle_time = 1
temperature_controller.settle_time = 10

在很多情况中，这比在扫描每次调用中输入一个延时参数更加方便和更加健壮。你只需要设置它一次，并且它此后适用。

这是bluesky为什么把delay留在了扫描之外，指导用户选择相较于首先对它们发生将更适用的方法。对于delay参数真是用于此工作的正确工具的情况，通过编写一个自定义计划你自己添加delay参数当前总是可能的。这是一个方法，使用了per_step hook，

import bluesky.plans
import bluesky.plan_stubs

def scan_with_delay(*args, delay=0, **kwargs):
    """接受所有常见的'scan'参数，加上一个可选的延时"""

    def one_nd_step_with_delay(detectors, step, pos_cache):
        """这是一个添加了睡眠的bluesky.plan_stubs.one_nd_step的副本"""
        motors = step.keys()
        yield from bluesky.plan_stubs.move_per_step(step, pos_cache)
        yield from bluesky.plan_stubs.sleep(delay)
        yield from bluesky.plan_stubs.trigger_and_read(list(detectors) + list(motors))

    kwargs.setdefault('per_step', one_nd_step_with_delay)
    yield from bluesky.plans.scan(*args, **kwargs)

bluesky.plans.scan

# 扫描一个多电机轨迹
bluesky.plans.scan(detectors, *args, num=None, per_step=None, md=None)

"""
参数:
1、detectors：list "可读"对象的列表


2、*args：用于一个维度，电机，起始，终止。一般：
    motor1, start1, stop1,
    motor2, start2, stop2,
    ...,
    motorN, startN, stopN
    电机可以是任何'可设置'对象(电机，温控器)

3、num：integer，点数

4、per_step：可调用，可选，内部循环的自定义操作(每步消息)的hook。
    详见bluesky.plan_stubs.one_nd_step()(默认)的文档
5、md：dict, 可选，元数据
"""

bluesky.plans.rel_scan

# 相对于当前位置扫描一个多电机轨迹
bluesky.plans.rel_scan(detectors, *args, num=None, per_step=None, md=None)
"""
参数：
1、detectors：list，可读对象的列表
2、*args：对于一个维度，电机，起始，停止。一般：
    motor1, start1, stop1,
    motor2, start2, start2,
    ...,
    motorN, startN, stopN,
    电机可以是任何可设置的对象(电机，温控器等)
3、num：integer，点数
4、per_step：可调用，可选，内层循环(每步消息)的自定义操作的
     详见bluesky.plan_stubs.one_nd_step()(默认)的文档
5、md：dict,可选，元数据
"""

bluesky.plans.list_scan

# 同时用相同步数扫描一个或多个变量
bluesky.plans.list_scan(detectors, *args, per_step=None, md=None)
"""
参数：
1、detectors：list，可读对象的列表
2、*args：对于一维，电机，[点1，点2，...]。一般：
    motor1, [point1, point2, ...],
    motor2, [point1, point2, ...],
    ...,
    motorN, [point1, point2, ...]
    电机可以是任何'可设置'对象(电机，温控器等)
3、per_step：可调用，可选。内层循环(每步消息)的自定义操作的hook。预计签名：
    f(detectors, motor, step) -> plan (a generator)
4、md：dict, 可选，元数据
"""

bluesky.plans.rel_list_scan

# 相对于当前位置用相同步骤扫描一个变量
bluesky.plans.rel_list_scan(detectors, *args, per_step=None, md=None)
"""
参数:
1、detectors：list，可读对象的列表
2、*args：对于一个维，电机，[点1，点2，...]。一般：
    motor1, [point1, point2, ...],
    motor2, [point1, point2, ...],
    ...,
    motorN, [point1, point2, ...]
    电机可以是任何可设置的对象(电机，温控器等)。点1，点2等相对于当前位置
    motor：任何可设置的对象(电机，温控器等)。
3、steps：list，相对于当前位置的列表
4、per_step：可调用，可选的，内层循环(每步消息)的自定义hook。预计签名：
    f(detectors, motor, step)
5、md：dict, 可选的，元数据
"""

bluesky.plans.log_scan

# 用对数间隔步骤扫描一个变量
bluesky.plans.log_scan(detectors, motor, start, stop, num, *, per_step=None, md=None)
"""
参数：
1、detectors：list，可读对象的列表
2、motor：对象，可设置对象(电机，温控器等)
3、start：float，电机的起始位置
4、stop：float，电机的终止位置
5、num：int，步数
6、per_step：可调用，可选的，内层循环的自定义操作的hook。预计签名：
   f(detectors, motor, step)
7、mddict, 可选的，元数据
"""

bluesky.plans.rel_log_scan

# 用对数间隔步骤扫描一个变量
bluesky.plans.rel_log_scan(detectors, motor, start, stop, num, *, per_step=None, md=None)
"""
参数：
1、detectors：list，可读对象的列表
2、motor：对象，可设置对象(电机，温控器等)
3、start：float，电机的起始位置
4、stop：float，电机的终止位置
5、num：int，步数
6、per_step：可调用，可选的，内层循环的自定义操作的hook。预计签名：
   f(detectors, motor, step)
7、mddict, 可选的，元数据
"""

多维扫描

见本教程中一起扫描多个电机，介绍协同的常见情况(即：沿对角线移动X和Y)或者在一个网格中移动多个电机。这里重介绍这个重要的示例。

from ophyd.sim import det, motor1, motor2
from bluesky.plans import scan, grid_scan, list_scan, list_grid_scan

dets = [det]

RE(scan(dets,
        motor1, -1.5, 1.5,  # 电机1从-1.5到1.5扫描
        motor2, -0.1, 0.1,  # 电机2从-0.1到0.1扫描
        5))  # 两个电机都用5步

# 电机1和电机2记忆扫描5点轨迹
RE(list_scan(dets, motor1, [1, 1, 3, 5, 8], motor2, [25, 16, 9, 4, 1]))


# 扫描一个3*4的网格
RE(grid_scan(dets,
             motor1, -1.5, 1.5, 3,  # no snake parameter for first motor
             motor2, -0.1, 0.1, 4))

# 用任何空间作为指定位置扫描网格
RE(list_grid_scan(dets,
                  motor1, [1, 3, 5],
                  motor2, [4, 9, 16,25]))

所有这些计划构建在一个更通用的计划scan_nd()上，我们可以把它用于更专用化的情况中。

一些行话：我们称像scan()的联合移动为轨迹的"内积"，以及像grid_scan()的移动为一个轨迹的"外积"。一般情况，在外积中对着另一个电机(或电机)在一个"内积"中一起移动某些电机可以被称为一个cycler。注意：当我们加上或乘以cycler对象时，发生什么。

from cycler import cycler
from ophyd.sim import motor1, motor2, motor3

traj1 = cycler(motor1, [1, 2, 3])
traj2 = cycler(motor2, [10, 20, 30])

我们产生了内积和外积。像这样组合它们时，真是强大出现了。这次，对照电机3，电机1和电机2在一个网格中。

traj3 = cycler(motor3, [100, 200, 300])

list((traj1 + traj2) * traj3)

需要更多有关cycler，参考cycler文档。要构造一个组合了这些轨迹的计划，适用通用的N维扫描计划scan_nd()。

bluesky.plans.grid_scan

# 扫描一个网格，每个电机时在一个独立的轨迹上。
bluesky.plans.grid_scan(detectors, *args, snake_axes=None, per_step=None, md=None)
"""
参数：
1、detector: list, 可读对象的列表
2、*args：模式如
    (motor1, start1, stop1, num1,
     motor2, start2, stop2, num2, 
     motor3, start3, stop3, num3,
     … 
     motorN, startN, stopN, numN)
    第一个电机是最慢的，外层循环。对于除了第一个电机外的所有电机，有一个"snake"参数：
    一个布尔：表明是否按照蛇形蜿蜒曲折的轨迹或者一个简单的左右轨迹。
3、snake_axes: 布尔或可迭代，可选，哪个轴应该是蛇形的，要么False(不蛇形任何轴)，True(蛇形所有轴)或者一个要蛇形轴的列表。"snaking"是一个被定义为蛇形的轴，弯折轨迹，而不是简单的左右轨迹。列表元素是在args中列出的电机。这个列表一定步包含最慢(第一个)电机，由于它不能被蛇形。
4、per_step:可调用，可选的。用于内层循环(每步消息)的自定义操作的hook。详见bluesky.plan_stubs.one_nd_step() (the default) 的文档
4、md：dict，可选的，元数据。
"""

bluesky.plans.rel_grid_scan

# 相对于当前位置扫描一个网格，每个电机时在一个独立的轨迹上。
bluesky.plans.rel_grid_scan(detectors, *args, snake_axes=None, per_step=None, md=None)
"""
参数：
1、detector: list, 可读对象的列表
2、*args：模式如
    (motor1, start1, stop1, num1,
     motor2, start2, stop2, num2, 
     motor3, start3, stop3, num3,
     … 
     motorN, startN, stopN, numN)
    第一个电机是最慢的，外层循环。对于除了第一个电机外的所有电机，有一个"snake"参数：
    一个布尔：表明是否按照蛇形蜿蜒曲折的轨迹或者一个简单的左右轨迹。
3、snake_axes: 布尔或可迭代，可选，哪个轴应该是蛇形的，要么False(不蛇形任何轴)，True(蛇形所有轴)或者一个要蛇形轴的列表。"snaking"是一个被定义为蛇形的轴，弯折轨迹，而不是简单的左右轨迹。列表元素是在args中列出的电机。这个列表一定步包含最慢(第一个)电机，由于它不能被蛇形。
4、per_step:可调用，可选的。用于内层循环(每步消息)的自定义操作的hook。详见bluesky.plan_stubs.one_nd_step() (the default) 的文档
4、md：dict，可选的，元数据。
"""

bluesky.plans.list_grid_scan

# 扫描一个网格，每个电机是在一个独立的轨迹上。
bluesky.plans.list_grid_scan(detectors, *args, snake_axes=False, per_step=None, md=None)
"""
参数：
1、detector: list, 可读对象的列表
2、*args：模式如
    (motor1, start1, stop1, num1,
     motor2, start2, stop2, num2, 
     motor3, start3, stop3, num3,
     … 
     motorN, startN, stopN, numN)
    第一个电机是最慢的，外层循环。对于除了第一个电机外的所有电机，有一个"snake"参数：
    一个布尔：表明是否按照蛇形蜿蜒曲折的轨迹或者一个简单的左右轨迹。
3、snake_axes: 布尔或可迭代，可选，哪个轴应该是蛇形的，要么False(不蛇形任何轴)，True(蛇形所有轴)或者一个要蛇形轴的列表。"snaking"是一个被定义为蛇形的轴，弯折轨迹，而不是简单的左右轨迹。列表元素是在args中列出的电机。这个列表一定步包含最慢(第一个)电机，由于它不能被蛇形。
4、per_step:可调用，可选的。用于内层循环(每步消息)的自定义操作的hook。详见bluesky.plan_stubs.one_nd_step() (the default) 的文档
4、md：dict，可选的，元数据。
"""

bluesky.plans.rel_list_grid_scan

# 扫描一个网格，每个电机是在一个独立的轨迹上。每个点相对于当前位置。
bluesky.plans.rel_list_grid_scan(detectors, *args, snake_axes=False, per_step=None, md=None)
"""
参数：
1、detector: list, 可读对象的列表
2、*args：模式如
    (motor1, start1, stop1, num1,
     motor2, start2, stop2, num2, 
     motor3, start3, stop3, num3,
     … 
     motorN, startN, stopN, numN)
    第一个电机是最慢的，外层循环。对于除了第一个电机外的所有电机，有一个"snake"参数：
    一个布尔：表明是否按照蛇形蜿蜒曲折的轨迹或者一个简单的左右轨迹。
3、snake_axes: 布尔或可迭代，可选，哪个轴应该是蛇形的，要么False(不蛇形任何轴)，True(蛇形所有轴)或者一个要蛇形轴的列表。"snaking"是一个被定义为蛇形的轴，弯折轨迹，而不是简单的左右轨迹。列表元素是在args中列出的电机。这个列表一定步包含最慢(第一个)电机，由于它不能被蛇形。
4、per_step:可调用，可选的。用于内层循环(每步消息)的自定义操作的hook。详见bluesky.plan_stubs.one_nd_step() (the default) 的文档
4、md：dict，可选的，元数据。
"""

bluesky.plans.scan_nd

# 在任意N维轨迹上扫描
bluesky.plans.scan_nd(detectors, cycler, *, per_step=None, md=None)
"""
参数：
1、detectors：list
2、cycler：Cycler，映射可移动接口到位置的cycler.Cycler对象
3、per_step：可调用，可选的，用于内层循环(每步消息)的自定义操作的hook。详见bluesky.plan_stubs.one_nd_step() (the default)的文档。
4、md：dict, optional，元数据
"""

from cycler import cycler
cy = cycler(motor1, [1,2] ) * cycler(motor2, [4,5,6])
ss=scan_nd([det], cy)

RE(ss)

螺旋轨迹

我们提供了跟踪螺旋轨迹的二维扫描。

一个简单的示例：

from bluesky.simulators import plot_raster_path
from ophyd.sim import motor1, motor2, det
from bluesky.plans import spiral

plan = spiral([det], motor1, motor2, x_start=0.0, y_start=0.0, x_range=1.,
              y_range=1.0, dr=0.1, nth=10)
plot_raster_path(plan, 'motor1', 'motor2', probe_size=.01)

一个费马螺旋

from bluesky.simulators import plot_raster_path
from ophyd.sim import motor1, motor2, det
from bluesky.plans import spiral_fermat

plan = spiral_fermat([det], motor1, motor2, x_start=0.0, y_start=0.0,
                     x_range=2.0, y_range=2.0, dr=0.1, factor=2.0, tilt=0.0)
plot_raster_path(plan, 'motor1', 'motor2', probe_size=.01, lw=0.1)

一个方形螺旋：

from bluesky.simulators import plot_raster_path
from ophyd.sim import motor1, motor2, det
from bluesky.plans import spiral_square

plan = spiral_square([det], motor1, motor2, x_center=0.0, y_center=0.0,
                     x_range=1.0, y_range=1.0, x_num=11, y_num=11)
plot_raster_path(plan, 'motor1', 'motor2', probe_size=.01)

bluesky.plans.spiral

# 以(x_start, y_start)为中心的螺旋扫描
bluesky.plans.spiral(detectors, x_motor, y_motor, x_start, y_start, x_range, y_range, dr, nth, *, dr_y=None, tilt=0.0, per_step=None, md=None)
"""
参数：
1、detectors:list, 可读对象的列表
2、x_motor：object，任何可设置的对象(电机，温控器等)
3、y_motor：object，任何可设置的对象(电机，温控器等)
4、x_start：float，x的中心
5、y_start：float，y的中心
6、x_range：float，螺旋的x宽度
7、y_range：float，螺旋的y宽度
8、dr：float，沿着椭圆短轴的delta半径
9、dr_y:float, 沿椭圆长轴的delta半径。如果None，默认为dr。
10、nth：float，theta步的数目
11、tilt：float, 可选，以弧度为单位的倾角，默认0.0
12、per_step：可调用，可选的，用于内层循环(每步消息)的自定义的hook。详见bluesky.plan_stubs.one_nd_step() (the default)的文档
13、md：dict, 可选的，元数据
"""

bluesky.plans.spiral_fermat

# 以(x_start, y_start)为中心的绝对费马螺旋扫描
bluesky.plans.spiral_fermat(detectors, x_motor, y_motor, x_start, y_start, x_range, y_range, dr, factor, *, dr_y=None, tilt=0.0, per_step=None, md=None)
"""
参数：
1、detectors:list, 可读对象的列表
2、x_motor：object，任何可设置的对象(电机，温控器等)
3、y_motor：object，任何可设置的对象(电机，温控器等)
4、x_start：float，x的中心
5、y_start：float，y的中心
6、x_range：float，螺旋的x宽度
7、y_range：float，螺旋的y宽度
8、dr：float，沿着椭圆短轴的delta半径
9、factor:float, 由此分隔的半径
10、dr_y:float, 沿椭圆长轴的delta半径。如果None，默认为dr。
11、tilt：float, 可选，以弧度为单位的倾角，默认0.0
12、per_step：可调用，可选的，用于内层循环(每步消息)的自定义的hook。详见bluesky.plan_stubs.one_nd_step() (the default)的文档
13、md：dict, 可选的，元数据
"""

bluesky.plans.spiral_square

# 以(x_start, y_start)为中心的绝对方形扫描
bluesky.plans.spiral_square(detectors, x_motor, y_motor, x_center, y_center, x_range, y_range, x_num, y_num, *, per_step=None, md=None)
"""
参数：
1、detectors:list, 可读对象的列表
2、x_motor：object，任何可设置的对象(电机，温控器等)
3、y_motor：object，任何可设置的对象(电机，温控器等)
4、x_start：float，x的中心
5、y_start：float，y的中心
6、x_range：float，螺旋的x宽度
7、y_range：float，螺旋的y宽度
8、x_num:float, x轴的点数
9、y_num:float, y轴的点数
10、per_step：可调用，可选的，用于内层循环(每步消息)的自定义的hook。详见bluesky.plan_stubs.one_nd_step() (the default)的文档
11、md：dict, 可选的，元数据
"""

# 相对螺旋扫描
bluesky.plans.rel_spiral(detectors, x_motor, y_motor, x_range, y_range, dr, nth, *, dr_y=None, tilt=0.0, per_step=None, md=None)
# 相对费马螺旋扫描
bluesky.plans.rel_spiral_fermat(detectors, x_motor, y_motor, x_range, y_range, dr, factor, *, dr_y=None, tilt=0.0, per_step=None, md=None)
# 相对对方形扫描
bluesky.plans.rel_spiral_square(detectors, x_motor, y_motor, x_range, y_range, x_num, y_num, *, per_step=None, md=None)

自适应扫描

这些是一维扫描，具有自适应步长被调节为在平整区域上快速移动，这些扫描通过计算本地斜率来查找连续点之间大的y变化率来集中读数在变化大的区域中。

这是一个具有自适应计划逻辑的强大基本示例：

from bluesky.plans import adaptive_scan
from ophyd.sim import motor, det

RE(adaptive_scan([det], 'det', motor,
                 start=-15,
                 stop=10,
                 min_step=0.01,
                 max_step=5,
                 target_delta=.05,
                 backstep=True))

从左到右，这个扫描增长其跨度通过平整区域。首先，它步进通过这个峰。大跳跃使得它原路返回并且接着更密集采样通过峰。由于峰变平了，它再次增长其跨度。

bluesky.plans.adaptive_scan

# 用自适应调整的步长扫描一个变量。
bluesky.plans.adaptive_scan(detectors, target_field, motor, start, stop, min_step, max_step, target_delta, backstep, threshold=0.8, *, md=None)
"""
参数:
1、detectors：list，可读对象列表
2、target_field：string，数据字段，其输出是自适应调节的焦点
3、motor：object，任何可设置的对象(电机，温控器等)
4、start：float，电机开始的地方
5、stop：float，电机终止的位置
6、min_step：float，快速变化区域的最小步长
7、max_step：float，慢速变化区域的最大步长
8、target_delta：float，步与步之间探测器信号的所需的分数变化
9、backstep：bool，是否允许后退步骤，这是与某些电机有关
10、threshold：float, 可选，倒退并且重新扫描一个区域的阈值，默认0.8
11、md：dcit，可选，元数据
"""

bluesky.plans.rel_adaptive_scan

# 用自适应调整的步长相对扫描一个变量
bluesky.plans.rel_adaptive_scan(detectors, target_field, motor, start, stop, min_step, max_step, target_delta, backstep, threshold=0.8, *, md=None)

MISC

bluesky.plans.tweak

# 用交互提示移动电机并且读取探测器。
bluesky.plans.tweak(detector, target_field, motor, step, *, md=None)
"""
参数：
1、detetector：Device
2、target_field：string，数据字段，其输出是自适应调节的焦点。
3、motor：Device
4、step：float，步长的初始建议。
5、md：dict, 可选
"""

bluesky.plans.fly

# 用一个或多个'flyers'执行一个飞行扫描。
bluesky.plans.fly(flyers, *, md=None)
"""
参数：
1、flyers：collection，支持flyer接口的对象
2、md：dict, 可选，元数据

生成：msg:Msg
    ‘kickoff’, ‘wait’, ‘complete, ‘wait’, ‘collect’ 消息
"""