`ophyd_async.sim`#

Some simulated devices to be used in tutorials and testing.

Package Contents#

Classes#

`SimMotor`	For usage when simulating a motor.
`FlySimMotorInfo`	Minimal set of information required to fly a `SimMotor`.
`SimStage`	A simulated sample stage with X and Y movables.
`PatternGenerator`	Generates pattern images in files.
`SimPointDetector`	Simalutes a point detector with multiple channels.
`SimBlobDetector`	Simulates a detector and writes Blobs to file.
`VerticalMirror`	Common base class for all Ophyd Async Devices.
`HorizontalMirror`	Common base class for all Ophyd Async Devices.
`HorizontalMirrorDerived`	dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object’s (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2)
`TwoJackTransform`	Baseclass for bidirectional transforms for Derived Signals.
`TwoJackDerived`	dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object’s (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2)
`TwoJackRaw`	dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object’s (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2)

API#

class ophyd_async.sim.SimMotor(name='', instant=True)[source]#

Bases: ophyd_async.core.StandardReadable, bluesky.protocols.Stoppable, bluesky.protocols.Subscribable[float]

For usage when simulating a motor.

set_name(name: str, *, child_name_separator: str | None = None) → None[source]#

Set self.name=name and each self.child.name=name+"-child".

Parameters:

name – New name to set.
child_name_separator – Use this as a separator instead of “-”. Use “_” instead to make the same names as the equivalent ophyd sync device.

async prepare(value: FlySimMotorInfo)[source]#: Calculate run-up and move there, setting fly velocity when there.

async locate() → Location[float][source]#: Return the current setpoint and readback of the motor.

subscribe(function: Callback[dict[str, Reading[float]]]) → None[source]#

Subscribe to updates in value of a device.

When the device has a new value ready, it should call function with something that looks like the output of read().

Needed for :doc:monitored <async>.

clear_sub(function: Callback[dict[str, Reading[float]]]) → None[source]#: Remove a subscription.

async kickoff()[source]#: Begin moving motor from prepared position to final position.

complete() → WatchableAsyncStatus[source]#: Mark as complete once motor reaches completed position.

async set(value: float)[source]#: Asynchronously move the motor to a new position.

async stop(success=True)[source]#: Stop the motor if it is moving.

class ophyd_async.sim.FlySimMotorInfo(/, **data: ~typing.Any)[source]#

Bases: pydantic.BaseModel

Minimal set of information required to fly a SimMotor.

model_config#: ‘ConfigDict(…)’

cv_start: float#

None

Absolute position of the motor once it finishes accelerating to desired velocity, in motor EGUs

cv_end: float#

None

Absolute position of the motor once it begins decelerating from desired velocity, in EGUs

cv_time: float#

‘Field(…)’

Time taken for the motor to get from start_position to end_position, excluding run-up and run-down, in seconds.

property velocity: float#: Calculate the velocity of the constant velocity phase.

start_position(acceleration_time: float) → float[source]#: Calculate the start position with run-up distance added on.

end_position(acceleration_time: float) → float[source]#: Calculate the end position with run-down distance added on.

class ophyd_async.sim.SimStage(pattern_generator: PatternGenerator, name='')[source]#

Bases: ophyd_async.core.StandardReadable

A simulated sample stage with X and Y movables.

class ophyd_async.sim.PatternGenerator(sleep=asyncio.sleep)[source]#

Generates pattern images in files.

set_x(x: float)[source]#

set_y(y: float)[source]#

generate_point(channel: int = 1, high_energy: bool = False) → float[source]#: Make a point between 0 and 1 based on x and y.

open_file(path: Path, width: int, height: int)[source]#

async write_images_to_file(exposure: float, period: float, number_of_frames: int)[source]#

async wait_for_next_index(timeout: float)[source]#

get_last_index() → int[source]#

close_file()[source]#

class ophyd_async.sim.SimPointDetector(generator: PatternGenerator, num_channels: int = 3, name: str = '')[source]#

Bases: ophyd_async.core.StandardReadable

Simalutes a point detector with multiple channels.

async trigger()[source]#

class ophyd_async.sim.SimBlobDetector(path_provider: PathProvider, pattern_generator: PatternGenerator | None = None, config_sigs: Sequence[SignalR] = (), name: str = '')[source]#

Bases: ophyd_async.core.StandardDetector

Simulates a detector and writes Blobs to file.

class ophyd_async.sim.VerticalMirror(name='')[source]#

Bases: ophyd_async.core.Device, bluesky.protocols.Movable[ophyd_async.sim._mirror_vertical.TwoJackDerived]

Common base class for all Ophyd Async Devices.

Parameters:

name – Optional name of the Device
connector – Optional DeviceConnector instance to use at connect()

async set(derived: TwoJackDerived) → None[source]#

class ophyd_async.sim.HorizontalMirror(name='')[source]#

Bases: ophyd_async.core.Device, bluesky.protocols.Movable

Common base class for all Ophyd Async Devices.

Parameters:

name – Optional name of the Device
connector – Optional DeviceConnector instance to use at connect()

async set(value: HorizontalMirrorDerived) → None[source]#

class ophyd_async.sim.HorizontalMirrorDerived[source]#

Bases: typing.TypedDict

dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object’s (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2)

x: float#: None

roll: float#: None

class ophyd_async.sim.TwoJackTransform(/, **data: ~typing.Any)[source]#

Bases: ophyd_async.core.Transform

Baseclass for bidirectional transforms for Derived Signals.

Subclass and add:

type hinted parameters that should be fetched from Signals
a raw_to_derived method that takes the elements of RawT and returns a DerivedT
a derived_to_raw method that takes the elements of DerivedT and returns a RawT

Example:

class MyRaw(TypedDict):
    raw1: float
    raw2: float

class MyDerived(TypedDict):
    derived1: float
    derived2: float

class MyTransform(Transform):
    param1: float

    def raw_to_derived(self, *, raw1: float, raw2: float) -> MyDerived:
        derived1, derived2 = some_maths(self.param1, raw1, raw2)
        return MyDerived(derived1=derived1, derived2=derived2)

    def derived_to_raw(self, *, derived1: float, derived2: float) -> MyRaw:
        raw1, raw2 = some_inverse_maths(self.param1, derived1, derived2)
        return MyRaw(raw1=raw1, raw2=raw2)

distance: float#: None

raw_to_derived(*, jack1: float, jack2: float) → TwoJackDerived[source]#

derived_to_raw(*, height: float, angle: float) → TwoJackRaw[source]#

class ophyd_async.sim.TwoJackDerived[source]#

Bases: typing.TypedDict

dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object’s (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2)

height: float#: None

angle: float#: None

class ophyd_async.sim.TwoJackRaw[source]#

Bases: typing.TypedDict

dict() -> new empty dictionary dict(mapping) -> new dictionary initialized from a mapping object’s (key, value) pairs dict(iterable) -> new dictionary initialized as if via: d = {} for k, v in iterable: d[k] = v dict(**kwargs) -> new dictionary initialized with the name=value pairs in the keyword argument list. For example: dict(one=1, two=2)

jack1: float#: None

jack2: float#: None

ophyd_async.sim#

Package Contents#

Classes#

API#

This Page

`ophyd_async.sim`#