ophyd-async 0.9.0a2__py3-none-any.whl → 0.10.0a2__py3-none-any.whl

ophyd_async/epics/sim/__init__.py

@@ -1,54 +0,0 @@
-"""Demo EPICS Devices for the tutorial"""
-
-import atexit
-import random
-import string
-import subprocess
-import sys
-from pathlib import Path
-
-from ._mover import Mover, SampleStage
-from ._sensor import EnergyMode, Sensor, SensorGroup
-
-__all__ = [
-    "Mover",
-    "SampleStage",
-    "EnergyMode",
-    "Sensor",
-    "SensorGroup",
-]
-
-
-def start_ioc_subprocess() -> str:
-    """Start an IOC subprocess with EPICS database for sample stage and sensor
-    with the same pv prefix
-    """
-
-    pv_prefix = "".join(random.choice(string.ascii_uppercase) for _ in range(12)) + ":"
-    here = Path(__file__).absolute().parent
-    args = [sys.executable, "-m", "epicscorelibs.ioc"]
-
-    # Create standalone sensor
-    args += ["-m", f"P={pv_prefix}"]
-    args += ["-d", str(here / "sensor.db")]
-
-    # Create sensor group
-    for suffix in ["1", "2", "3"]:
-        args += ["-m", f"P={pv_prefix}{suffix}:"]
-        args += ["-d", str(here / "sensor.db")]
-
-    # Create X and Y motors
-    for suffix in ["X", "Y"]:
-        args += ["-m", f"P={pv_prefix}{suffix}:"]
-        args += ["-d", str(here / "mover.db")]
-
-    # Start IOC
-    process = subprocess.Popen(
-        args,
-        stdin=subprocess.PIPE,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.STDOUT,
-        universal_newlines=True,
-    )
-    atexit.register(process.communicate, "exit")
-    return pv_prefix

ophyd_async/epics/sim/_ioc.py

@@ -1,29 +0,0 @@
-import atexit
-from pathlib import Path
-
-from ophyd_async.epics.testing import TestingIOC
-
-HERE = Path(__file__).absolute().parent
-
-
-def start_ioc_subprocess(prefix: str, num_counters: int):
-    """Start an IOC subprocess with EPICS database for sample stage and sensor
-    with the same pv prefix
-    """
-    ioc = TestingIOC()
-    # Create X and Y motors
-    for suffix in ["X", "Y"]:
-        ioc.add_database(HERE / "mover.db", P=f"{prefix}STAGE:{suffix}:")
-    # Create a multichannel counter with num_counters
-    ioc.add_database(HERE / "multichannelcounter.db", P=f"{prefix}MCC:")
-    for i in range(1, num_counters + 1):
-        ioc.add_database(
-            HERE / "counter.db",
-            P=f"{prefix}MCC:",
-            CHANNEL=str(i),
-            X=f"{prefix}STAGE:X:",
-            Y=f"{prefix}STAGE:Y:",
-        )
-    # Start IOC and register it to be stopped at exit
-    ioc.start()
-    atexit.register(ioc.stop)

ophyd_async/epics/sim/_mover.py

@@ -1,101 +0,0 @@
-import asyncio
-
-import numpy as np
-from bluesky.protocols import Movable, Stoppable
-
-from ophyd_async.core import (
-    CALCULATE_TIMEOUT,
-    DEFAULT_TIMEOUT,
-    AsyncStatus,
-    CalculatableTimeout,
-    Device,
-    StandardReadable,
-    WatchableAsyncStatus,
-    WatcherUpdate,
-    observe_value,
-)
-from ophyd_async.core import StandardReadableFormat as Format
-from ophyd_async.epics.core import epics_signal_r, epics_signal_rw, epics_signal_x
-
-
-class Mover(StandardReadable, Movable, Stoppable):
-    """A demo movable that moves based on velocity"""
-
-    def __init__(self, prefix: str, name="") -> None:
-        # Define some signals
-        with self.add_children_as_readables(Format.HINTED_SIGNAL):
-            self.readback = epics_signal_r(float, prefix + "Readback")
-        with self.add_children_as_readables(Format.CONFIG_SIGNAL):
-            self.velocity = epics_signal_rw(float, prefix + "Velocity")
-            self.units = epics_signal_r(str, prefix + "Readback.EGU")
-        self.setpoint = epics_signal_rw(float, prefix + "Setpoint")
-        self.precision = epics_signal_r(int, prefix + "Readback.PREC")
-        # Signals that collide with standard methods should have a trailing underscore
-        self.stop_ = epics_signal_x(prefix + "Stop.PROC")
-        # Whether set() should complete successfully or not
-        self._set_success = True
-
-        super().__init__(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.readback.set_name(name)
-
-    @WatchableAsyncStatus.wrap
-    async def set(self, value: float, timeout: CalculatableTimeout = CALCULATE_TIMEOUT):
-        new_position = value
-        self._set_success = True
-        old_position, units, precision, velocity = await asyncio.gather(
-            self.setpoint.get_value(),
-            self.units.get_value(),
-            self.precision.get_value(),
-            self.velocity.get_value(),
-        )
-        if timeout is CALCULATE_TIMEOUT:
-            try:
-                timeout = (
-                    abs((new_position - old_position) / velocity) + DEFAULT_TIMEOUT
-                )
-            except ZeroDivisionError as error:
-                msg = "Mover has zero velocity"
-                raise ValueError(msg) from error
-
-        # Make an Event that will be set on completion, and a Status that will
-        # error if not done in time
-        done = asyncio.Event()
-        done_status = AsyncStatus(asyncio.wait_for(done.wait(), timeout))  # type: ignore
-        # Wait for the value to set, but don't wait for put completion callback
-        await self.setpoint.set(new_position, wait=False)
-        async for current_position in observe_value(
-            self.readback, done_status=done_status
-        ):
-            yield WatcherUpdate(
-                current=current_position,
-                initial=old_position,
-                target=new_position,
-                name=self.name,
-                unit=units,
-                precision=precision,
-            )
-            if np.isclose(current_position, new_position):
-                done.set()
-                break
-        if not self._set_success:
-            raise RuntimeError("Motor was stopped")
-
-    async def stop(self, success=True):
-        self._set_success = success
-        status = self.stop_.trigger()
-        await status
-
-
-class SampleStage(Device):
-    """A demo sample stage with X and Y movables"""
-
-    def __init__(self, prefix: str, name="") -> None:
-        # Define some child Devices
-        self.x = Mover(prefix + "X:")
-        self.y = Mover(prefix + "Y:")
-        # Set name of device and child devices
-        super().__init__(name=name)

ophyd_async/epics/sim/_sensor.py

@@ -1,37 +0,0 @@
-from typing import Annotated as A
-
-from ophyd_async.core import (
-    DeviceVector,
-    SignalR,
-    SignalRW,
-    StandardReadable,
-    StrictEnum,
-)
-from ophyd_async.core import StandardReadableFormat as Format
-from ophyd_async.epics.core import EpicsDevice, PvSuffix
-
-
-class EnergyMode(StrictEnum):
-    """Energy mode for `Sensor`"""
-
-    #: Low energy mode
-    LOW = "Low Energy"
-    #: High energy mode
-    HIGH = "High Energy"
-
-
-class Sensor(StandardReadable, EpicsDevice):
-    """A demo sensor that produces a scalar value based on X and Y Movers"""
-
-    value: A[SignalR[float], PvSuffix("Value"), Format.HINTED_SIGNAL]
-    mode: A[SignalRW[EnergyMode], PvSuffix("Mode"), Format.CONFIG_SIGNAL]
-
-
-class SensorGroup(StandardReadable):
-    def __init__(self, prefix: str, name: str = "", sensor_count: int = 3) -> None:
-        with self.add_children_as_readables():
-            self.sensors = DeviceVector(
-                {i: Sensor(f"{prefix}{i}:") for i in range(1, sensor_count + 1)}
-            )
-
-        super().__init__(name)

ophyd_async/epics/sim/sensor.db

@@ -1,19 +0,0 @@
-record(mbbo, "$(P)Mode") {
-    field(DESC, "Energy sensitivity of the image")
-    field(DTYP, "Raw Soft Channel")
-    field(PINI, "YES")
-    field(ZRVL, "10")
-    field(ZRST, "Low Energy")
-    field(ONVL, "100")
-    field(ONST, "High Energy")
-}
-
-record(calc, "$(P)Value") {
-    field(DESC, "Sensor value simulated from X and Y")
-    field(INPA,  "$(P)X:Readback CP")
-    field(INPB,  "$(P)Y:Readback CP")
-    field(INPC,  "$(P)Mode.RVAL CP")
-    field(CALC, "SIN(A)**10+COS(C+B*A)*COS(A)")
-    field(EGU,  "$(EGU=cts/s)")
-    field(PREC, "$(PREC=3)")
-}

ophyd_async/sim/_pattern_detector/__init__.py

@@ -1,13 +0,0 @@
-from ._pattern_detector import PatternDetector
-from ._pattern_detector_controller import PatternDetectorController
-from ._pattern_detector_writer import PatternDetectorWriter
-from ._pattern_generator import DATA_PATH, SUM_PATH, PatternGenerator
-
-__all__ = [
-    "PatternDetector",
-    "PatternDetectorController",
-    "PatternDetectorWriter",
-    "DATA_PATH",
-    "SUM_PATH",
-    "PatternGenerator",
-]

ophyd_async/sim/_pattern_detector/_pattern_detector.py

@@ -1,42 +0,0 @@
-from collections.abc import Sequence
-from pathlib import Path
-
-from ophyd_async.core import (
-    FilenameProvider,
-    PathProvider,
-    SignalR,
-    StandardDetector,
-    StaticFilenameProvider,
-    StaticPathProvider,
-)
-
-from ._pattern_detector_controller import PatternDetectorController
-from ._pattern_detector_writer import PatternDetectorWriter
-from ._pattern_generator import PatternGenerator
-
-
-class PatternDetector(StandardDetector):
-    def __init__(
-        self,
-        path: Path,
-        config_sigs: Sequence[SignalR] = (),
-        name: str = "",
-    ) -> None:
-        fp: FilenameProvider = StaticFilenameProvider(name)
-        self.path_provider: PathProvider = StaticPathProvider(fp, path)
-        self.pattern_generator = PatternGenerator()
-        writer = PatternDetectorWriter(
-            pattern_generator=self.pattern_generator,
-            path_provider=self.path_provider,
-            name_provider=lambda: self.name,
-        )
-        controller = PatternDetectorController(
-            pattern_generator=self.pattern_generator,
-            path_provider=self.path_provider,
-        )
-        super().__init__(
-            controller=controller,
-            writer=writer,
-            config_sigs=config_sigs,
-            name=name,
-        )

ophyd_async/sim/_pattern_detector/_pattern_detector_controller.py

@@ -1,69 +0,0 @@
-import asyncio
-
-from ophyd_async.core import DetectorController, PathProvider, TriggerInfo
-
-from ._pattern_generator import PatternGenerator
-
-
-class PatternDetectorController(DetectorController):
-    def __init__(
-        self,
-        pattern_generator: PatternGenerator,
-        path_provider: PathProvider,
-        exposure: float = 0.1,
-    ) -> None:
-        self.pattern_generator: PatternGenerator = pattern_generator
-        self.pattern_generator.set_exposure(exposure)
-        self.path_provider: PathProvider = path_provider
-        self.task: asyncio.Task | None = None
-        super().__init__()
-
-    async def prepare(self, trigger_info: TriggerInfo):
-        self._trigger_info = trigger_info
-        if self._trigger_info.livetime is None:
-            self._trigger_info.livetime = 0.01
-        self.period: float = self._trigger_info.livetime + self.get_deadtime(
-            trigger_info.livetime
-        )
-
-    async def arm(self):
-        if not hasattr(self, "_trigger_info"):
-            msg = "TriggerInfo information is missing, has 'prepare' been called?"
-            raise RuntimeError(msg)
-        if not self._trigger_info.livetime:
-            msg = "Livetime information is missing in trigger info"
-            raise ValueError(msg)
-        if not self.period:
-            msg = "Period is not set"
-            raise ValueError(msg)
-        self.task = asyncio.create_task(
-            self._coroutine_for_image_writing(
-                self._trigger_info.livetime,
-                self.period,
-                self._trigger_info.total_number_of_triggers,
-            )
-        )
-
-    async def wait_for_idle(self):
-        if self.task:
-            await self.task
-
-    async def disarm(self):
-        if self.task and not self.task.done():
-            self.task.cancel()
-            try:
-                await self.task
-            except asyncio.CancelledError:
-                pass
-        self.task = None
-
-    def get_deadtime(self, exposure: float | None) -> float:
-        return 0.001
-
-    async def _coroutine_for_image_writing(
-        self, exposure: float, period: float, frames_number: int
-    ):
-        for _ in range(frames_number):
-            self.pattern_generator.set_exposure(exposure)
-            await asyncio.sleep(period)
-            await self.pattern_generator.write_image_to_file()

ophyd_async/sim/_pattern_detector/_pattern_detector_writer.py

@@ -1,41 +0,0 @@
-from collections.abc import AsyncGenerator, AsyncIterator
-
-from event_model import DataKey
-
-from ophyd_async.core import DEFAULT_TIMEOUT, DetectorWriter, NameProvider, PathProvider
-
-from ._pattern_generator import PatternGenerator
-
-
-class PatternDetectorWriter(DetectorWriter):
-    pattern_generator: PatternGenerator
-
-    def __init__(
-        self,
-        pattern_generator: PatternGenerator,
-        path_provider: PathProvider,
-        name_provider: NameProvider,
-    ) -> None:
-        self.pattern_generator = pattern_generator
-        self.path_provider = path_provider
-        self.name_provider = name_provider
-
-    async def open(self, multiplier: int = 1) -> dict[str, DataKey]:
-        return await self.pattern_generator.open_file(
-            self.path_provider, self.name_provider(), multiplier
-        )
-
-    async def close(self) -> None:
-        self.pattern_generator.close()
-
-    def collect_stream_docs(self, indices_written: int) -> AsyncIterator:
-        return self.pattern_generator.collect_stream_docs(indices_written)
-
-    async def observe_indices_written(
-        self, timeout=DEFAULT_TIMEOUT
-    ) -> AsyncGenerator[int, None]:
-        async for index in self.pattern_generator.observe_indices_written(timeout):
-            yield index
-
-    async def get_indices_written(self) -> int:
-        return self.pattern_generator.image_counter

ophyd_async/sim/_pattern_detector/_pattern_generator.py

@@ -1,214 +0,0 @@
-from collections.abc import AsyncGenerator, AsyncIterator
-from pathlib import Path
-
-import h5py
-import numpy as np
-from bluesky.protocols import StreamAsset
-from event_model import DataKey
-
-from ophyd_async.core import (
-    DEFAULT_TIMEOUT,
-    HDFDataset,
-    HDFFile,
-    PathProvider,
-    observe_value,
-    soft_signal_r_and_setter,
-)
-
-# raw data path
-DATA_PATH = "/entry/data/data"
-
-# pixel sum path
-SUM_PATH = "/entry/sum"
-
-MAX_UINT8_VALUE = np.iinfo(np.uint8).max
-
-
-def generate_gaussian_blob(height: int, width: int) -> np.ndarray:
-    """Make a Gaussian Blob with float values in range 0..1"""
-    x, y = np.meshgrid(np.linspace(-1, 1, width), np.linspace(-1, 1, height))
-    d = np.sqrt(x * x + y * y)
-    blob = np.exp(-(d**2))
-    return blob
-
-
-def generate_interesting_pattern(x: float, y: float) -> float:
-    """This function is interesting in x and y in range -10..10, returning
-    a float value in range 0..1
-    """
-    z = 0.5 + (np.sin(x) ** 10 + np.cos(10 + y * x) * np.cos(x)) / 2
-    return z
-
-
-class PatternGenerator:
-    def __init__(
-        self,
-        saturation_exposure_time: float = 0.1,
-        detector_width: int = 320,
-        detector_height: int = 240,
-    ) -> None:
-        self.saturation_exposure_time = saturation_exposure_time
-        self.exposure = saturation_exposure_time
-        self.x = 0.0
-        self.y = 0.0
-        self.height = detector_height
-        self.width = detector_width
-        self.image_counter: int = 0
-
-        # it automatically initializes to 0
-        self.counter_signal, self._set_counter_signal = soft_signal_r_and_setter(int)
-        self._full_intensity_blob = (
-            generate_gaussian_blob(width=detector_width, height=detector_height)
-            * MAX_UINT8_VALUE
-        )
-        self._hdf_stream_provider: HDFFile | None = None
-        self._handle_for_h5_file: h5py.File | None = None
-        self.target_path: Path | None = None
-
-    def write_data_to_dataset(self, path: str, data_shape: tuple[int, ...], data):
-        """Write data to named dataset, resizing to fit and flushing after."""
-        if not self._handle_for_h5_file:
-            msg = "No file has been opened!"
-            raise OSError(msg)
-
-        dset = self._handle_for_h5_file[path]
-        if not isinstance(dset, h5py.Dataset):
-            msg = f"Expected {path} to be a dataset, got {type(dset).__name__}"
-            raise TypeError(msg)
-        dset.resize((self.image_counter + 1,) + data_shape)
-        dset[self.image_counter] = data
-        dset.flush()
-
-    async def write_image_to_file(self) -> None:
-        # generate the simulated data
-        intensity: float = generate_interesting_pattern(self.x, self.y)
-        detector_data = (
-            self._full_intensity_blob
-            * intensity
-            * self.exposure
-            / self.saturation_exposure_time
-        ).astype(np.uint8)
-
-        # Write the data and sum
-        self.write_data_to_dataset(DATA_PATH, (self.height, self.width), detector_data)
-        self.write_data_to_dataset(SUM_PATH, (), np.sum(detector_data))
-
-        # counter increment is last
-        # as only at this point the new data is visible from the outside
-        self.image_counter += 1
-        self._set_counter_signal(self.image_counter)
-
-    def set_exposure(self, value: float) -> None:
-        self.exposure = value
-
-    def set_x(self, value: float) -> None:
-        self.x = value
-
-    def set_y(self, value: float) -> None:
-        self.y = value
-
-    async def open_file(
-        self, path_provider: PathProvider, name: str, multiplier: int = 1
-    ) -> dict[str, DataKey]:
-        await self.counter_signal.connect()
-
-        self.target_path = self._get_new_path(path_provider)
-        self._path_provider = path_provider
-
-        self._handle_for_h5_file = h5py.File(self.target_path, "w", libver="latest")
-
-        if not self._handle_for_h5_file:
-            msg = f"Problem opening file {self.target_path}"
-            raise OSError(msg)
-
-        self._handle_for_h5_file.create_dataset(
-            name=DATA_PATH,
-            shape=(0, self.height, self.width),
-            dtype=np.uint8,
-            maxshape=(None, self.height, self.width),
-        )
-        self._handle_for_h5_file.create_dataset(
-            name=SUM_PATH,
-            shape=(0,),
-            dtype=np.float64,
-            maxshape=(None,),
-        )
-
-        # once datasets written, can switch the model to single writer multiple reader
-        self._handle_for_h5_file.swmr_mode = True
-        self.multiplier = multiplier
-
-        outer_shape = (multiplier,) if multiplier > 1 else ()
-
-        # cache state to self
-        # Add the main data
-        self._datasets = [
-            HDFDataset(
-                data_key=name,
-                dataset=DATA_PATH,
-                shape=(self.height, self.width),
-                multiplier=multiplier,
-            ),
-            HDFDataset(
-                f"{name}-sum",
-                dataset=SUM_PATH,
-                shape=(),
-                multiplier=multiplier,
-            ),
-        ]
-
-        describe = {
-            ds.data_key: DataKey(
-                source="sim://pattern-generator-hdf-file",
-                shape=list(outer_shape) + list(ds.shape),
-                dtype="array" if ds.shape else "number",
-                external="STREAM:",
-            )
-            for ds in self._datasets
-        }
-        return describe
-
-    def _get_new_path(self, path_provider: PathProvider) -> Path:
-        info = path_provider(device_name="pattern")
-        new_path: Path = info.directory_path / info.filename
-        return new_path
-
-    async def collect_stream_docs(
-        self, indices_written: int
-    ) -> AsyncIterator[StreamAsset]:
-        """
-        stream resource says "here is a dataset",
-        stream datum says "here are N frames in that stream resource",
-        you get one stream resource and many stream datums per scan
-        """
-        if self._handle_for_h5_file:
-            self._handle_for_h5_file.flush()
-        # when already something was written to the file
-        if indices_written:
-            # if no frames arrived yet, there's no file to speak of
-            # cannot get the full filename the HDF writer will write
-            # until the first frame comes in
-            if not self._hdf_stream_provider:
-                if self.target_path is None:
-                    msg = "open file has not been called"
-                    raise RuntimeError(msg)
-                self._hdf_stream_provider = HDFFile(
-                    self.target_path,
-                    self._datasets,
-                )
-                for doc in self._hdf_stream_provider.stream_resources():
-                    yield "stream_resource", doc
-            if self._hdf_stream_provider:
-                for doc in self._hdf_stream_provider.stream_data(indices_written):
-                    yield "stream_datum", doc
-
-    def close(self) -> None:
-        if self._handle_for_h5_file:
-            self._handle_for_h5_file.close()
-            self._handle_for_h5_file = None
-
-    async def observe_indices_written(
-        self, timeout=DEFAULT_TIMEOUT
-    ) -> AsyncGenerator[int, None]:
-        async for num_captured in observe_value(self.counter_signal, timeout=timeout):
-            yield num_captured // self.multiplier