Recorded Experiments

Recorded Experiments#

Recorded Run#

class RecordedExperimentalRun#

A recorded experimental run.

All data is loaded from a HDF5 group and served with the same getter methods and attributes as navground.sim.ExperimentalRun but limited to read-only. All setters are explicitly blocked.

It holds a navground.sim.World. At initialization, the world is set to the state at the begin of the recorded run. By repeatedly calling do_step(), the world can be advanced, setting the state according to the data stored in the HDF5 group.

__init__(group: h5py.Group, scenario: Scenario | None = None, record_config: RecordConfig | None = None)#

Constructs a new instance.

Parameters:: group – The HDF5 group recorded by a navground.sim.ExperimentalRun

do_step() → bool#

Try to advance the world by one recorded simulation step, see go_to_step().

Returns:: True if the operation was possible and False otherwise.

get_collision_events(min_interval: int = 0) → ndarray[Any, dtype[int64]]#

Gets the recorded collisions events, i.e. collisions separated by more than min_interval steps

Parameters:: min_interval – The minimal interval between collision among the same pair to be considered a new event
Returns:: A dataset of shape {#events, 4} of events <begin, end, e1, e2>

get_record(key: str = '') → h5py.Dataset | None#

Gets recorded data.

Parameters:: group (str) – the name of the record
Returns:: recorded dataset or None if no data has been recorded for the given key

get_record_names(group: str = '') → set[str]#

Gets the names of records.

Parameters:: group (str) – An optional group. If specified, the looks for record associated to keys <group>/....
Returns:: The record names (relative to the group if specified).

get_records(group: str = '') → dict[str, h5py.Dataset]#

Gets recorded data map.

Parameters:: group – if specified, limits to records in a given group.
Returns:: recorded datasets indexed by their key (relative to the group if specified).

get_steps_to_collision(min_interval: int = 0) → ndarray[Any, dtype[int64]]#

Gets the steps to the next recorded collision for each agent at each simulation step.

Parameters:: min_interval – The minimal interval between collision among the same pair to be considered a new event
Returns:: An array of shape {#steps, #agents}

get_task_events(agent: Agent) → h5py.Dataset | ndarray[Any, dtype[floating[Any]]]#

The recorded events logged by the task of an agent as a HDF5 dataset of shape (number events, size of event log) and dtype float:

[[data_0, ...],
 ...]

The dataset is empty if the agent’s task has not been recorded in the run.

Parameters:: agent – The agent
Returns:: The events logged by the agent task

go_to_step(step: int) → bool#

Try to advance the world to a given recorded simulation step.

Depending if the data has been recorded, it will update:

Returns:: True if the operation was possible and False otherwise.

index_of_agent(agent: Agent) → int#

Associate an index to a given agent.

Data related to agents is stored in this order. For example, poses at a given time step are stored as [[x_0, y_0, z_0], [x_1, y_1, z_1], ...]

where the pose of agent a is at the index returned by this function.

Parameters:: agent – The agent
Returns:: The index of data related to this agent or -1 if not found.

reset() → None#: Reset the run to the state at the begin of the recorded run.

property bounding_box: BoundingBox#: Gets the rectangle that contains the world during the whole run.

property bounds: tuple[ndarray[tuple[Literal[2]], dtype[float64]], ndarray[tuple[Literal[2]], dtype[float64]]] | None#: Computes the rectangle in which agents are contained during the run: (lower-left corner, top-right corner) or None if no poses has been recorded

collisions: 'h5py.Dataset' | None#: The recorded collisions

commands: 'h5py.Dataset' | None#: The recorded commands

deadlocks: 'h5py.Dataset' | None#: The recorded deadlocks

duration: datetime.timedelta#: The duration of the run

efficacy: 'h5py.Dataset' | None#: The recorded efficacy

property has_finished: bool#: Determines if play back has finished: True if there are no more steps to play back, False otherwise

maximal_steps: int#: The maximal steps that could have been performed

number_of_agents: int#: The number of agents recorded

poses: 'h5py.Dataset' | None#: The recorded poses

property record_names: set[str]#: All recorded dataset names

recorded_steps: int#: The actual number of steps that have been performed

property records: dict[str, h5py.Dataset]#: All recorded datasets

property root: h5py.Group#: The run root HDF5 group

safety_violations: 'h5py.Dataset' | None#: The recorded safety violations

seed: int#: The seed used during to initialize the world and during the run

sensing: dict[int, 'h5py.Group']#: The recorded task events

targets: 'h5py.Dataset' | None#: The recorded targets

task_events: dict[int, 'h5py.Dataset']#: The sensing state

time_step: float#: The time step used by the simulation

times: 'h5py.Dataset' | None#: The recorded times

twists: 'h5py.Dataset' | None#: The recorded twists

world: World#: The world that has been simulated