Struct PyState 

pub struct PyState(/* private fields */);

A State object.

Implementations

impl PyState

A single ‘assembly’, or ‘state’, containing a canvas with tiles at locations. Generally does not store concentration or temperature information, but does store time simulated.

pub fn empty( shape: (usize, usize), kind: &str, tracking: &str, n_tile_types: Option<usize>, ) -> PyResult<Self>

pub fn from_array( array: PyReadonlyArray2<'_, Tile>, kind: &str, tracking: &str, n_tile_types: Option<usize>, ) -> PyResult<Self>

pub fn rate_array<'py>(&self, py: Python<'py>) -> Bound<'py, PyArray2<f64>>

Return a cloned copy of an array with the total possible next event rate for each point in the canvas. This is the deepest level of the quadtree for tree-based states.

Returns

NDArray[np.uint]

pub fn total_rate(&self) -> f64

float: the total rate of possible next events for the state.

pub fn canvas_view<'py>( this: Bound<'py, Self>, _py: Python<'py>, ) -> PyResult<Bound<'py, PyArray2<Tile>>>

NDArray[np.uint]: a direct, mutable view of the state’s canvas. This is potentially unsafe.

pub fn canvas_copy<'py>( this: &Bound<'py, Self>, py: Python<'py>, ) -> PyResult<Bound<'py, PyArray2<Tile>>>

Return a copy of the state’s canvas. This is safe, but can’t be modified and is slower than canvas_view.

Returns

NDArray[np.uint] A cloned copy of the state’s canvas, in raw form.

pub fn rate_at_point(&self, point: (usize, usize)) -> PyResult<f64>

Return the total possible next event rate at a specific canvas point.

Parameters

point: tuple[int, int] The canvas point.

Returns

f64

Raises

ValueError if point is out of bounds for the canvas.

pub fn tracking_copy(this: &Bound<'_, Self>) -> PyResult<RustAny>

Return a copy of the tracker’s tracking data.

Returns

Any

pub fn n_tiles(&self) -> NumTiles

int: the number of tiles in the state.

pub fn ntiles(&self) -> NumTiles

int: the number of tiles in the state (deprecated, use n_tiles instead).

pub fn total_events(&self) -> NumEvents

int: the total number of events that have occurred in the state.

pub fn time(&self) -> f64

float: the total time the state has simulated, in seconds.

pub fn tile_counts<'py>(&self, py: Python<'py>) -> Bound<'py, PyArray1<u32>>

pub fn __repr__(&self) -> String

pub fn print_debug(&self)

pub fn write_json(&self, filename: &str) -> Result<(), RgrowError>

Write the state to a JSON file. This is inefficient, and is likely useful primarily for debugging.

pub fn read_json(filename: &str) -> Result<Self, RgrowError>

pub fn copy(&self) -> Self

Create a copy of the state.

This creates a complete clone of the state, including all canvas data, tracking information, and simulation state (time, events, etc.).

Returns

State A new State object that is a copy of this state.

Examples

original_state = State((10, 10)) copied_state = original_state.copy()

The copied state is independent of the original

assert copied_state.time == original_state.time assert copied_state.total_events == original_state.total_events

pub fn replay(&self, up_to_event: Option<u64>) -> PyResult<Self>

Replay the events from a MovieTracker up to a given event ID.

This reconstructs the state by replaying all events from the MovieTracker. The state must have been created with Movie tracking enabled.

Parameters

up_to_event : int, optional The event ID up to which to replay (inclusive). If not provided, all events are replayed.

Returns

State A new State with the events replayed. The returned state has no tracker and no rates calculated.

Raises

ValueError If the state does not have a MovieTracker.

Examples

Create a state with movie tracking and evolve it

state = ts.create_state(tracking=“Movie”) sys.evolve(state, for_events=100)

Replay to get state at event 50

replayed = state.replay(up_to_event=50)

pub fn replay_inplace( &mut self, coords: Vec<(usize, usize)>, new_tiles: Vec<Tile>, event_ids: Vec<u64>, up_to_event_id: u64, n_tiles: Option<Vec<u32>>, total_time: Option<Vec<f64>>, energy: Option<Vec<f64>>, ) -> PyResult<()>

Replay events in-place on this state from external event data.

This modifies the state’s canvas by applying the events from the provided coordinate and tile arrays. Unlike replay(), this method takes external event data rather than using a MovieTracker.

Parameters

coords : list[tuple[int, int]] List of (row, col) coordinates for each event. new_tiles : list[int] List of tile values for each event. event_ids : list[int] List of event IDs for each event. up_to_event_id : int The event ID up to which to replay (inclusive).

Raises

ValueError If there is an error during replay.

Examples

state = State((10, 10)) coords = [(1, 1), (2, 2)] new_tiles = [1, 2] event_ids = [0, 1] state.replay_inplace(coords, new_tiles, event_ids, 1)

Trait Implementations

impl From<FFSStateRef> for PyState

fn from(state: FFSStateRef) -> Self

Converts to this type from the input type.

impl<'py> IntoPyObject<'py> for PyState

type Target = PyState

The Python output type

type Output = Bound<'py, <PyState as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PyClass for PyState

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for PyState

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = /// A State object.

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<PyState>

This handles following two situations:

type Inventory = Pyo3MethodsInventoryForPyState

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyClassNewTextSignature for PyState

const TEXT_SIGNATURE: &'static str = "(shape, kind=\"Square\", tracking=\"None\", n_tile_types=None)"

impl PyTypeInfo for PyState

const NAME: &'static str = "State"

Class name.

const MODULE: Option<&'static str>

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl DerefToPyAny for PyState

impl ExtractPyClassWithClone for PyState