tiling.py

import typeguard
import typing
from bliss.scanning.group import Sequence
from bliss.controllers.lima.lima_base import Lima
from .tomoconfig import TomoConfig
from .presets import MoveAxisPreset
from tomo.helpers.nexuswriter_utils import hdf5_axis_name


@typeguard.typechecked
def tiling(
    xstart: float,
    xstop: float,
    ystart: float,
    ystop: float,
    zstart: float,
    zstop: float,
    detector: Lima,
    expo_time: float,
    tomoconfig: TomoConfig,
    n_dark: int = 3,
    n_flat: int = 3,
    sleep_time: typing.Optional[float] = None,
):
    """
    Scan a tomo sample stage using full field acquisition as tiled images.

    The sequence contains:

    - Few dark
    - Few flat
    - A 2D scan at rotation -90 (at this angle scanning sy is like scanning sx at rot 0)
    - Few flat
    - A 2D scan at rotation 0

    Arguments:
        xstart: X position to start in absolute coordinate of the sample stage (y-axis at -rot90)
        xstop: X position to stop in absolute coordinate of the sample stage (y-axis at -rot90)
        ystart: Y position to start in absolute coordinate of the sample stage
        ystop: Y position to stop in absolute coordinate of the sample stage
        zstart: Z position to start in absolute coordinate of the sample stage
        zstop: Z position to stop in absolute coordinate of the sample stage
        detector: Lima detector to use
        expo_time: Integration time for the Lima detector
        sleep_time: Time to wait between motor move before taking a new acquisition
        tomoconfig: Description of the tomo sample stage
    """
    tomo_detector = tomoconfig.detectors.get_tomo_detector(detector)

    technique = {
        "y_axis_name": hdf5_axis_name(tomoconfig.y_axis, False),
        "z_axis_name": hdf5_axis_name(tomoconfig.z_axis, True),
        "sample_y_axis_name": hdf5_axis_name(tomoconfig.sample_y_axis, True),
        "rotation_axis_name": hdf5_axis_name(tomoconfig.rotation_axis, True),
        "exposure_time": expo_time,
        "exposure_time@units": "s",
        "detector_name": detector.name,
        "detector_size": tomo_detector.actual_size,
        "sample_pixel_size": tomo_detector.sample_pixel_size,
        "sample_pixel_size@units": "um",
        "subscans": {
            "scan1": {"type": "tomo:dark"},
            "scan2": {"type": "tomo:flat"},
            "scan3": {
                "type": "tomo:tiling:side",
                "vertical_range": [zstart, zstop],
                "vertical_range@units": "mm",
                "horizontal_range": [xstart, xstop],
                "horizontal_range@units": "mm",
            },
            "scan4": {"type": "tomo:flat"},
            "scan5": {
                "type": "tomo:tiling:front",
                "vertical_range": [zstart, zstop],
                "vertical_range@units": "mm",
                "horizontal_range": [ystart, ystop],
                "horizontal_range@units": "mm",
            },
        },
    }

    scan_info = {"tomotype": "tilingseq", "technique": technique}
    sequence = Sequence(title="tiling sequence", scan_info=scan_info)

    srot = tomoconfig.rotation_axis
    # FIXME: It would be better to normalize rot at dial 0 and -90
    rotationAt0 = MoveAxisPreset(srot, 0)
    rotationAt90 = MoveAxisPreset(srot, -90)

    with sequence.sequence_context() as scan_seq:

        dark_runner = tomoconfig.get_runner("dark")
        scan = dark_runner(expo_time, n_dark, detector, run=False)
        scan_seq.add(scan)
        scan.run()

        flat_runner = tomoconfig.get_runner("flat")
        scan = flat_runner(expo_time, n_flat, detector, run=False)
        scan_seq.add(scan)
        scan.run()

        tiling_runner = tomoconfig.get_runner("tiling")
        scan = tiling_runner(
            expo_time=expo_time,
            tomo_detector=tomo_detector,
            zstart=zstart,
            zstop=zstop,
            ystart=xstart,
            ystop=xstop,
            sleep_time=sleep_time,
            run=False,
        )
        scan.add_preset(rotationAt90)
        scan_seq.add(scan)
        scan.run()

        flat_runner = tomoconfig.get_runner("flat")
        scan = flat_runner(expo_time, n_flat, detector, run=False)
        scan_seq.add(scan)
        scan.run()

        tiling_runner = tomoconfig.get_runner("tiling")
        scan = tiling_runner(
            expo_time=expo_time,
            tomo_detector=tomo_detector,
            zstart=zstart,
            zstop=zstop,
            ystart=ystart,
            ystop=ystop,
            sleep_time=sleep_time,
            run=False,
        )
        scan.add_preset(rotationAt0)
        scan_seq.add(scan)
        scan.run()

    return scan