Sdc1d

Cargo.toml

@@ -10,7 +10,7 @@ serde = {version = "^1.0.185", features=["derive", "rc"]}
 pyo3 = {version = "^0.21", features = ["extension-module", "multiple-pymethods"]}
 rayon = { version = "1" }
 numpy = "^0.21"
-enum_dispatch = "0.3"
+approx = "^0.5"
 pyo3-polars = "^0.15"
 polars = {version = "^0.41", features = ["lazy", "parquet", "product"]}
 
@@ -21,7 +21,5 @@ edition = "2021"
 repository = "https://github.com/cgevans/rgrow"
 license = "BSD-3-Clause"
 categories = ["science", "simulation"]
-
-[profile.release]
 # debug = true
 # lto = true

py-rgrow/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "rgrow"
-dependencies = ["numpy ~= 1.26", "attrs ~= 23.2", "matplotlib ~= 3.8.2", "typing_extensions"]
+dependencies = ["numpy ~= 1.26", "attrs ~= 23.2", "matplotlib ~= 3.8.2", "typing_extensions", "tqdm"]
 requires-python = ">=3.9"
 
 [project.optional-dependencies]

py-rgrow/rgrow/__init__.py

@@ -26,6 +26,7 @@
     EvolveBounds,
     FFSStateRef,
 )
+from .sdc import SDC
 import attrs
 import attr
 
@@ -40,7 +41,7 @@
 )
 
 System: TypeAlias = ATAM | KTAM | OldKTAM
-SYSTEMS = (ATAM, KTAM, OldKTAM)
+SYSTEMS = (ATAM, KTAM, OldKTAM, SDC)
 
 if TYPE_CHECKING:  # pragma: no cover
     import matplotlib.pyplot as plt
@@ -67,7 +68,9 @@ def _system_name_canvas(self: "System", state: State | FFSStateRef) -> np.ndarra
     return a[state.canvas_view]
 
 
-def _system_color_canvas(self: System, state: State | np.ndarray | FFSStateRef) -> np.ndarray:
+def _system_color_canvas(
+    self: System, state: State | np.ndarray | FFSStateRef
+) -> np.ndarray:
     """Returns the current canvas for state, as an array of tile colors."""
 
     if isinstance(state, (State, FFSStateRef)):
@@ -157,7 +160,11 @@ def _system_plot_canvas(
             tile_colors / 12.92,
             ((tile_colors + 0.055) / 1.055) ** 2.4,
         )
-        lum = 0.2126 * lumcolors[:, 0] + 0.7152 * lumcolors[:, 1] + 0.0722 * lumcolors[:, 2]
+        lum = (
+            0.2126 * lumcolors[:, 0]
+            + 0.7152 * lumcolors[:, 1]
+            + 0.0722 * lumcolors[:, 2]
+        )
         for i in range(i_min, i_max + 1):
             for j in range(j_min, j_max + 1):
                 if cv[i, j] == 0:
@@ -411,7 +418,9 @@ def ensure_state(self, n: int = 0) -> int:
     def check_state(self, n: int = 0) -> int:
         """Check that the simulation has at least n states."""
         if len(self.states) < n:
-            raise ValueError(f"Simulation has {len(self.states)} states, but {n} were required.")
+            raise ValueError(
+                f"Simulation has {len(self.states)} states, but {n} were required."
+            )
 
         return n
 
@@ -609,7 +618,9 @@ def evolve_some(
             require_strong_bound=require_strong_bound,
         )
 
-    def plot_state(self, state_index: int = 0, ax: "plt.Axes | None" = None) -> "plt.QuadMesh":
+    def plot_state(
+        self, state_index: int = 0, ax: "plt.Axes | None" = None
+    ) -> "plt.QuadMesh":
         """Plot a state as a pcolormesh.  Returns the pcolormesh object."""
         import matplotlib.pyplot as plt
 

py-rgrow/rgrow/rgrow.pyi

@@ -5,6 +5,7 @@ from numpy import ndarray
 import numpy as np
 import polars as pl
 from numpy.typing import NDArray
+from matplotlib.axes import Axes
 
 class ATAM:
     @property
@@ -249,8 +250,262 @@ class ATAM:
             The name of the file to write to.
         """
 
-    def color_canvas(self, state: State | FFSStateRef | NDArray[np.uint]) -> NDArray[np.uint8]: ...
-    def name_canvas(self, state: State | FFSStateRef | NDArray[np.uint]) -> NDArray[np.str_]: ...
+    def color_canvas(
+        self, state: State | FFSStateRef | NDArray[np.uint]
+    ) -> NDArray[np.uint8]: ...
+    def name_canvas(
+        self, state: State | FFSStateRef | NDArray[np.uint]
+    ) -> NDArray[np.str_]: ...
+
+class SDC:
+    @property
+    def tile_names(self) -> list[str]: ...
+    @property
+    def tile_colors(self) -> NDArray[np.uint]: ...
+    def calc_dimers(self) -> List[DimerInfo]:
+        """
+        Calculate information about the dimers the system is able to form.
+
+        Returns
+        -------
+        List[DimerInfo]
+        """
+
+    def calc_mismatch_locations(self, state: State | FFSStateRef) -> NDArray[np.uint64]:
+        """
+        Calculate the locations of mismatches in the state.
+
+        This returns a copy of the canvas, with the values set to 0 if there is no mismatch
+        in the location, and > 0, in a model defined way, if there is at least one mismatch.
+        Most models use v = 8*N + 4*E + 2*S + W, where N, E, S, W are the four directions.
+        Thus, a tile with mismatches to the E and W would have v = 4+2 = 6.
+
+        Parameters
+        ----------
+        state : State or FFSStateRef
+           The state to calculate mismatches for.
+
+        Returns
+        -------
+        ndarray
+          An array of the same shape as the state's canvas, with the values set as described above.
+        """
+
+    def calc_mismatches(self, state: State | FFSStateRef) -> int:
+        """
+        Calculate the number of mismatches in a state.
+
+        Parameters
+        ----------
+        state : State or FFSStateRef
+          The state to calculate mismatches for.
+
+        Returns
+        -------
+        int
+         The number of mismatches.
+
+        See also
+        --------
+        calc_mismatch_locations
+          Calculate the location and direction of mismatches, not jus the number.
+        """
+
+    @overload
+    def evolve(
+        self,
+        state: State,
+        for_events: int | None = None,
+        total_events: int | None = None,
+        for_time: float | None = None,
+        total_time: float | None = None,
+        size_min: int | None = None,
+        size_max: int | None = None,
+        for_wall_time: float | None = None,
+        require_strong_bound: bool = True,
+        show_window: bool = False,
+        parallel: bool = True,
+    ) -> EvolveOutcome: ...
+    @overload
+    def evolve(
+        self,
+        state: Sequence[State],
+        for_events: int | None = None,
+        total_events: int | None = None,
+        for_time: float | None = None,
+        total_time: float | None = None,
+        size_min: int | None = None,
+        size_max: int | None = None,
+        for_wall_time: float | None = None,
+        require_strong_bound: bool = True,
+        show_window: bool = False,
+        parallel: bool = True,
+    ) -> List[EvolveOutcome]: ...
+    @overload
+    def evolve(
+        self,
+        state: State | Sequence[State],
+        for_events: int | None = None,
+        total_events: int | None = None,
+        for_time: float | None = None,
+        total_time: float | None = None,
+        size_min: int | None = None,
+        size_max: int | None = None,
+        for_wall_time: float | None = None,
+        require_strong_bound: bool = True,
+        show_window: bool = False,
+        parallel: bool = True,
+    ) -> EvolveOutcome | List[EvolveOutcome]:
+        """
+        Evolve a state (or states), with some bounds on the simulation.
+
+        If evolving multiple states, the bounds are applied per-state.
+
+        Parameters
+        ----------
+        state : State or Sequence[State]
+          The state or states to evolve.
+        for_events : int, optional
+          Stop evolving each state after this many events.
+        total_events : int, optional
+          Stop evelving each state when the state's total number of events (including
+          previous events) reaches this.
+        for_time : float, optional
+          Stop evolving each state after this many seconds of simulated time.
+        total_time : float, optional
+          Stop evolving each state when the state's total time (including previous steps)
+          reaches this.
+        size_min : int, optional
+          Stop evolving each state when the state's number of tiles is less than or equal to this.
+        size_max : int, optional
+          Stop evolving each state when the state's number of tiles is greater than or equal to this.
+        for_wall_time : float, optional
+          Stop evolving each state after this many seconds of wall time.
+        require_strong_bound : bool
+          Require that the stopping conditions are strong, i.e., they are guaranteed to be eventually
+          satisfied under normal conditions.
+        show_window : bool
+          Show a graphical UI window while evolving (requires ui feature, and a single state).
+        parallel : bool
+          Use multiple threads.
+
+        Returns
+        -------
+        EvolveOutcome or List[EvolveOutcome]
+         The outcome (stopping condition) of the evolution.  If evolving a single state, returns a single outcome.
+        """
+
+    def get_param(self, param_name): ...
+    def print_debug(self): ...
+    @staticmethod
+    def read_json(filename: str) -> None:
+        """
+        Read a system from a JSON file.
+
+        Parameters
+        ----------
+        filename : str
+            The name of the file to read from.
+        """
+
+    def run_ffs(self, config: FFSRunConfig = ..., **kwargs: Any) -> FFSRunResult:
+        """
+        Run FFS.
+
+        Parameters
+        ----------
+        config : FFSRunConfig
+         The configuration for the FFS run.
+        **kwargs
+          FFSRunConfig parameters as keyword arguments.
+
+        Returns
+        -------
+        FFSRunResult
+         The result of the FFS run.
+        """
+
+    def set_param(self, param_name: str, value: Any) -> NeededUpdate:
+        """
+        Set a system parameter.
+
+        Parameters
+        ----------
+        param_name : str
+            The name of the parameter to set.
+        value : Any
+            The value to set the parameter to.
+
+        Returns
+        -------
+        NeededUpdate
+            The type of state update needed.  This can be passed to
+           `update_state` to update the state.
+        """
+
+    def tile_color(self, tile_number: int) -> list[int]:
+        """
+        Given a tile number, return the color of the tile.
+
+        Parameters
+        ----------
+        tile_number : int
+         The tile number.
+
+        Returns
+        -------
+        list[int]
+          The color of the tile, as a list of 4 integers (RGBA).
+        """
+
+    def tile_number_from_name(self, tile_name: str) -> int:
+        """
+        Given a tile name, return the tile number.
+
+        Parameters
+        ----------
+        tile_name : str
+          The name of the tile.
+
+        Returns
+        -------
+        int
+         The tile number.
+        """
+
+    def update_all(self, state, needed=...): ...
+    def update_state(self, state: State, needed: NeededUpdate | None = ...) -> None:
+        """
+        Recalculate a state's rates.
+
+        This is usually needed when a parameter of the system has
+        been changed.
+
+        Parameters
+        ----------
+        state : State
+          The state to update.
+        needed : NeededUpdate, optional
+          The type of update needed.  If not provided, all locations
+          will be recalculated.
+        """
+
+    def write_json(self, filename: str) -> None:
+        """
+        Write the system to a JSON file.
+
+        Parameters
+        ----------
+        filename : str
+            The name of the file to write to.
+        """
+
+    def color_canvas(
+        self, state: State | FFSStateRef | NDArray[np.uint]
+    ) -> NDArray[np.uint8]: ...
+    def name_canvas(
+        self, state: State | FFSStateRef | NDArray[np.uint]
+    ) -> NDArray[np.str_]: ...
 
 class EvolveBounds:
     def __init__(self, for_time: float | None = None): ...
@@ -564,16 +819,33 @@ class KTAM:
         filename : str
             The name of the file to write to.
         """
-    def color_canvas(self, state: State | FFSStateRef | NDArray[np.uint]) -> NDArray[np.uint8]: ...
-    def name_canvas(self, state: State | FFSStateRef | NDArray[np.uint]) -> NDArray[np.str_]: ...
+
+    def color_canvas(
+        self, state: State | FFSStateRef | NDArray[np.uint]
+    ) -> NDArray[np.uint8]: ...
+    def name_canvas(
+        self, state: State | FFSStateRef | NDArray[np.uint]
+    ) -> NDArray[np.str_]: ...
+    def plot_canvas(
+        self,
+        state: State | np.ndarray | FFSStateRef,
+        ax: "Axes" | None = None,
+        annotate_tiles: bool = False,
+        annotate_mismatches: bool = False,
+        crop: bool = False,
+    ) -> "Axes": ...
 
 class OldKTAM:
     @property
     def tile_names(self) -> list[str]: ...
     @property
     def tile_colors(self) -> NDArray[np.uint]: ...
-    def color_canvas(self, state: State | FFSStateRef | NDArray[np.uint]) -> NDArray[np.uint8]: ...
-    def name_canvas(self, state: State | FFSStateRef | NDArray[np.uint]) -> NDArray[np.str_]: ...
+    def color_canvas(
+        self, state: State | FFSStateRef | NDArray[np.uint]
+    ) -> NDArray[np.uint8]: ...
+    def name_canvas(
+        self, state: State | FFSStateRef | NDArray[np.uint]
+    ) -> NDArray[np.str_]: ...
     def calc_dimers(self) -> List[DimerInfo]:
         """
         Calculate information about the dimers the system is able to form.