Models

class staliro.models.Trace(elements: Mapping[T, S], /)

class staliro.models.Trace(*, times: Iterable[T], states: Iterable[S])

A time-annotated set of system states.

This class can be iterated over to access each time, state pair in time-ascending order. This class can also be indexed by time to access a specific state. The times property iterates over the times in the trace, and the states iterates over the states. Both properties also iterate in time-ascending order.

Parameters:

• times (Mapping[T, S] | Iterable[T]) – The times values for each state or the time-state mapping

• states (Iterable[S] | None) – The states of the system if not using a time-state mapping

Raises:

• ValueError – If the length of times and states is not equal

• ValueError – If not using a time-state mapping and states is omitted

property states: Iterable[S]

An iterator over the states of the trace in time-ascending order.

property times: Iterable[float]

An iterator over the times of the trace in time-ascending order.

class staliro.models.Result(trace: Mapping[SupportsFloat, S], /, extra: E)

class staliro.models.Result(*, states: Iterable[S], times: Iterable[SupportsFloat], extra: E)

Specialized version of staliro.Result that constructs a Trace as the value.

Parameters:

• states (Mapping[SupportsFloat, S] | Iterable[S]) – The states of the system, either as a list or a dictionary where the keys are the associated times

• extra (E) – The user annotation data for the result

• times (Iterable[SupportsFloat] | None) – The times associated with each state if the states are provided as a list

class staliro.models.Model

Representation of the simulation logic for the system under test (SUT).

abstract simulate(sample)

Simulate a system and return a staliro.Result containing a Trace.

Parameters:

sample (Sample) – The sample containing the system inputs

Returns:

A result containing the Trace of system states and additional annotation data

Return type:

Result[Trace[S], E]

staliro.models.model(func: Callable[[Sample], Result[Trace[S], E]]) → ModelWrapper[S, E]

staliro.models.model(func: Callable[[Sample], Trace[R]]) → ModelWrapper[R, None]

staliro.models.model(func: None = None) → ModelDecorator

Create an Model from a function.

The function provided to this model must accept a Sample value and return either a Trace value or a staliro.Result containing a Trace and additional annotation data. If no function is provided a decorator is returned, which can be called with the function instead.

Parameters:

func – The function representing the system

Returns:

A Model or a decorator to create a Model

Blackbox

class staliro.models.Blackbox.Inputs(static, times)

Interpolated inputs to a Blackbox model.

The times attributes will always contain as keys all of the interpolation times for the given tspan in the TestOptions. If no signals are defined in the TestOptions, then the value for each time will be empty.

Attribute static:

The static (time-invariant) inputs to the system

Attribute times:

Mapping from each interpolation time to the values of each signal at that time

Parameters:

• static (dict[str, float]) –

• times (dict[float, dict[str, float]]) –

class staliro.models.Blackbox(func, step_size)

General system model which does not make assumptions about the underlying system.

Parameters:

• func (Callable[[Blackbox.Inputs], _Result[Trace[S], E]]) – User-defined function to evaluate given Blackbox.Inputs into a Trace or staliro.Result

• step_size (float) – Time-step to use for interpolating signal values over the simulation interval

staliro.models.blackbox(func: Callable[[Inputs], Result[Trace[S], E]], *, step_size: float = 0.1) → Blackbox[S, E]

staliro.models.blackbox(func: Callable[[Inputs], Trace[R]], *, step_size: float = 0.1) → Blackbox[R, None]

staliro.models.blackbox(func: None = None, *, step_size: float = 0.1) → BlackboxDecorator

Create an Blackbox model from a function.

The function provided to this model must accept a Blackbox.Inputs value and return either a Trace value or a staliro.Result containing a Trace and additional annotation data. If no function is provided a decorator is returned, which can be called with the function instead. The size of the time step for signal evaluation can be customized using the step_size parameter.

Parameters:

• func – The function representing the system

• step_size – Size of the time step for signal evaluation

Returns:

A Blackbox model or a decorator to create a Blackbox

ODE

class staliro.models.Ode.Inputs(time, state, signals)

Set of inputs to an ODE model function.

Attribute time:

The current time of the integration

Attribute state:

Name-value map containing the state variables for the current time

Attribute signals:

Name-value map containing the signal values for the current time

Parameters:

• time (float) –

• state (dict[str, float]) –

• signals (dict[str, float]) –

class staliro.models.Ode(func, method)

Model for systems that can be modeled by an Ordinary Differential Equation (ODE).

This model is simulated by integration the state derivatives returned by the function. The integration method can be customized to provide different levels of fidelity. The default method is Runge-Kutta 4(5).

Parameters:

• func (Callable[[Ode.Inputs], Mapping[str, float]]) – User-defined function which is given a Ode.Inputs value and returns the derivative of each state variable.

• method (Ode.Method) – The integration method for the ODE solver

staliro.models.ode(func: Callable[[Inputs], Mapping[str, float]], *, method: Literal['RK45', 'RK23', 'DOP853', 'Radau', 'BDF', 'LSODA'] = 'RK45') → Ode

staliro.models.ode(func: None = None, *, method: Literal['RK45', 'RK23', 'DOP853', 'Radau', 'BDF', 'LSODA'] = 'RK45') → OdeDecorator

Create an Ode model from a function.

The function provided to this model must accept a Ode.Inputs value and return a dictionary where each key is the name of a state variable the value is the derivative of that variable for the given time. If no function is provided a decorator is returned, which can be called with the function instead.

Parameters:

• func – The function representing the system ODE

• method – The integration method for the ODE solver. Valid options are: ["RK45", "RK23", "DOP853", "Radau", "BDF", "LSODA"]

Returns:

An Ode model or a decorator to create an Ode model