Struct SDC 

pub struct SDC {

    pub strand_names: Vec<String>,
    pub glue_names: Vec<String>,
    pub quencher_id: Option<Tile>,
    pub quencher_concentration: Molar,
    pub reporter_id: Option<Tile>,
    pub fluorophore_concentration: Molar,
    pub scaffold: Array1<Glue>,
    pub strand_concentration: Array1<Molar>,
    pub scaffold_concentration: Molar,
    pub strand_glues: Array2<Glue>,
    pub colors: Vec<[u8; 4]>,
    pub kf: PerMolarSecond,
    pub friends_btm: Vec<Vec<Tile>>,
    pub delta_g_matrix: Array2<KcalPerMol>,
    pub entropy_matrix: Array2<KcalPerMolKelvin>,
    /* private fields */
}

Fields

strand_names: Vec<String>

glue_names: Vec<String>

quencher_id: Option<Tile>

Identifies the strand that serves as a binding site for the quencher

quencher_concentration: Molar

Concentration of the quencher

reporter_id: Option<Tile>

Name of the reporter tile

fluorophore_concentration: Molar

Concentration of the fluorophore,

scaffold: Array1<Glue>

Glues on the scaffold. We only allow a single 1D scaffold here, which is repeated over the i-axis.

strand_concentration: Array1<Molar>

All strands in the system, they are represented by tiles with only glue on the south, west, and east (nothing can stick to the top of a strand)

scaffold_concentration: Molar

The concentration of the scaffold

strand_glues: Array2<Glue>

Glues of a given strand by id

Note that the glues will be sorted in the following manner: [ (0) – [left glue, bottom glue, right glue] … (n) – [left glue, bottom glue, right glue] ]

colors: Vec<[u8; 4]>

Each strand will be given a color so that it can be easily identified when illustrated

kf: PerMolarSecond

The (de)attachment rates will depend on this constant(for the system) value

friends_btm: Vec<Vec<Tile>>

Set of tiles that can stick to scaffold gap with a given glue

delta_g_matrix: Array2<KcalPerMol>

Delta G at 37 degrees C in the formula to generate the glue strengths

entropy_matrix: Array2<KcalPerMolKelvin>

S in the formula to generate the glue strengths

Implementations

impl SDC

pub fn change_temperature_to(&mut self, temperature: impl Into<Kelvin>)

Update the systems temperature. Accepts either Celsius or Kelvin as input.

pub fn n_scaffolds<S: State>(&self, state: &S) -> usize

pub fn total_tile_count<S: State>(&self, state: &S, tile: Tile) -> usize

pub fn fill_energy_array(&mut self)

Fill the energy_bonds array

pub fn monomer_detachment_rate_at_point<S: State>( &self, state: &S, scaffold_point: PointSafe2, ) -> PerSecond

pub fn monomer_change_rate_at_point<S: State>( &self, state: &S, scaffold_point: PointSafe2, ) -> PerSecond

pub fn choose_monomer_change_at_point<S: State>( &self, state: &S, point: PointSafe2, acc: PerSecond, ) -> (bool, PerSecond, Event, f64)

pub fn choose_monomer_attachment_at_point<S: State>( &self, state: &S, point: PointSafe2, acc: PerSecond, ) -> (bool, PerSecond, Event, f64)

pub fn choose_monomer_detachment_at_point<S: State>( &self, state: &S, point: PointSafe2, acc: PerSecond, ) -> (bool, PerSecond, Event, f64)

pub fn system_states(&self) -> Vec<Vec<u32>>

pub fn boltzman_function(&self, attachments: &[u32]) -> f64

pub fn partition_function_full(&self) -> f64

pub fn partition_function(&self) -> BigFloat

Notes:

• This only works for a single scaffold type.

pub fn partial_partition_function( &self, constrain_at_loc: Vec<Vec<Tile>>, ) -> BigFloat

This calculates a partial partition for the system. At each location, it takes a Vec. If the Vec is empty, then no constraints are applied. If the Vec is not empty, then the partition function is only calculated for the tiles in the Vec. 0 corresponds to the site being empty.

pub fn log_partition_function(&self) -> f64

pub fn log_partial_partition_function( &self, constrain_at_loc: Vec<Vec<Tile>>, ) -> f64

pub fn probability_of_constrained_configurations( &self, constrain_at_loc: Vec<Vec<Tile>>, ) -> f64

pub fn probability_of_state(&self, system: &[u32]) -> f64

impl SDC

pub fn mfe_configuration(&self) -> (Vec<Tile>, f64)

Get the mfe configuration, as well as its energy

impl SDC

pub fn from_params(params: SDCParams) -> Self

impl SDC

pub fn py_evolve<'py>( &mut self, state: PyStateOrStates<'py>, for_events: Option<u64>, total_events: Option<u64>, for_time: Option<f64>, total_time: Option<f64>, size_min: Option<u32>, size_max: Option<u32>, for_wall_time: Option<f64>, require_strong_bound: bool, show_window: bool, start_window_paused: bool, parallel: bool, initial_timescale: Option<f64>, initial_max_events_per_sec: Option<u64>, py: Python<'py>, ) -> PyResult<Py<PyAny>>

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 rgrow-gui to be installed, and a single state). start_window_paused : bool If show_window is True, start the GUI window in a paused state. Defaults to True. parallel : bool Use multiple threads. initial_timescale : float, optional If show_window is True, set the initial timescale (sim_time/real_time) in the GUI. None means unlimited. initial_max_events_per_sec : int, optional If show_window is True, set the initial max events per second limit in the GUI. None means unlimited.

Returns

EvolveOutcome or ListEvolveOutcome The outcome (stopping condition) of the evolution. If evolving a single state, returns a single outcome.

pub fn print_debug(&self)

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

Write the system to a JSON file.

Parameters

filename : str The name of the file to write to.

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

Read a system from a JSON file.

Parameters

filename : str The name of the file to read from.

Returns

Self

pub fn py_place_tile( &self, state: &mut PyState, point: (usize, usize), tile: u32, replace: bool, ) -> Result<f64, RgrowError>

Place a tile at a point in the given state.

This updates tile counts and rates but does not increment the event counter or record events in the state tracker.

Parameters

state : PyState The state to modify. point : tuple of int The coordinates at which to place the tile (i, j). tile : int The tile number to place. replace : bool, optional If True (default), any existing tile at the target site is removed first. If False, raises an error if the site is occupied.

Returns

float The energy change from placing the tile.

pub fn py_find_first_critical_state( &mut self, end_state: &PyState, config: CriticalStateConfig, py: Python<'_>, ) -> PyResult<Option<CriticalStateResult>>

pub fn py_find_last_critical_state( &mut self, end_state: &PyState, config: CriticalStateConfig, py: Python<'_>, ) -> PyResult<Option<CriticalStateResult>>

Trait Implementations

impl Clone for SDC

fn clone(&self) -> SDC

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SDC

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SDC

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<SDC> for SystemEnum

fn from(v: SDC) -> SystemEnum

Converts to this type from the input type.

impl<'py> IntoPyObject<'py> for SDC

type Target = SDC

The Python output type

type Output = Bound<'py, <SDC 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 SDC

type Frozen = False

Whether the pyclass is frozen.

impl PyClassBaseType for SDC

type LayoutAsBase = PyClassObject<SDC>

type BaseNativeType = <SDC as PyClassImpl>::BaseNativeType

type Initializer = PyClassInitializer<SDC>

type PyClassMutability = <SDC as PyClassImpl>::PyClassMutability

impl PyClassImpl for SDC

const IS_BASETYPE: bool = true

#[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 = c"\x00"

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<SDC>

This handles following two situations:

type Inventory = Pyo3MethodsInventoryForSDC

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 SDC

const TEXT_SIGNATURE: &'static str = "(params)"

impl PyTypeInfo for SDC

const NAME: &'static str = "SDC"

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 Serialize for SDC

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl System for SDC

fn update_after_event<St: State>(&self, state: &mut St, event: &Event)

fn perform_event<St: State>(&self, state: &mut St, event: &Event) -> f64

Perform a particular event/change to a state. Do not update the state’s time/etc, or rates, which should be done in update_after_event and take_single_step.

fn event_rate_at_point<St: State>( &self, state: &St, p: PointSafeHere, ) -> PerSecond

Returns the total event rate at a given point. These should correspond with the events chosen by choose_event_at_point.

fn choose_event_at_point<St: State>( &self, state: &St, point: PointSafe2, acc: PerSecond, ) -> (Event, f64)

Given a point, and an accumulated random rate choice acc (which should be less than the total rate at the point), return the event that should take place, and the rate of that particular event.

fn seed_locs(&self) -> Vec<(PointSafe2, Tile)>

Returns a vector of (point, tile number) tuples for the seed tiles, useful for populating an initial state.

fn calc_mismatch_locations<St: State>(&self, state: &St) -> Array2<usize>

Returns an array of mismatch locations. At each point, mismatches are designated by 8N+4E+2S+1W.

fn set_param( &mut self, name: &str, value: Box<dyn Any>, ) -> Result<NeededUpdate, GrowError>

fn get_param(&self, name: &str) -> Result<Box<dyn Any>, GrowError>

fn list_parameters(&self) -> Vec<ParameterInfo>

fn system_info(&self) -> String

fn new_state<St: StateWithCreate + State>( &self, params: St::Params, ) -> Result<St, GrowError>

fn calc_n_tiles<St: State>(&self, state: &St) -> NumTiles

fn take_single_step<St: State>( &self, state: &mut St, max_time_step: Second, ) -> StepOutcome

fn evolve<St: State>( &self, state: &mut St, bounds: EvolveBounds, ) -> Result<EvolveOutcome, GrowError>

fn evolve_states<St: State>( &mut self, states: &mut [St], bounds: EvolveBounds, ) -> Vec<Result<EvolveOutcome, GrowError>>

fn set_point<St: State>( &self, state: &mut St, point: Point, tile: Tile, ) -> Result<&Self, GrowError>

fn set_safe_point<St: State>( &self, state: &mut St, point: PointSafe2, tile: Tile, ) -> &Self

fn set_points<St: State>( &self, state: &mut St, changelist: &[(Point, Tile)], ) -> &Self

fn set_safe_points<St: State>( &self, state: &mut St, changelist: &[(PointSafe2, Tile)], ) -> &Self

fn place_tile<St: State>( &self, state: &mut St, point: PointSafe2, tile: Tile, replace: bool, ) -> Result<f64, GrowError>

Place a tile at a particular location, handling double tiles appropriately for kTAM. For kTAM, placing a “real” tile (left/top part of double tile) will also place the corresponding “fake” tile (right/bottom part). Attempting to place a “fake” tile directly will place the corresponding “real” tile instead.

fn configure_empty_state<St: State>( &self, state: &mut St, ) -> Result<(), GrowError>

fn calc_mismatches<St: State>(&self, state: &St) -> usize

fn update_points<St: State>(&self, state: &mut St, points: &[PointSafeHere])

fn update_state<St: State>(&self, state: &mut St, needed: &NeededUpdate)

fn extract_model_name(info: &str) -> String

fn evolve_in_window<St: State>( &mut self, state: &mut St, block: Option<usize>, start_paused: bool, bounds: EvolveBounds, initial_timescale: Option<f64>, initial_max_events_per_sec: Option<u64>, ) -> Result<EvolveOutcome, RgrowError>

fn calc_dimers(&self) -> Result<Vec<DimerInfo>, GrowError>

Returns information on dimers that the system can form.

fn clone_state<St: StateWithCreate>(&self, initial_state: &St) -> St

fn clone_state_into_state<St: StateWithCreate>( &self, initial_state: &St, target: &mut St, )

fn clone_state_into_empty_state<St: StateWithCreate>( &self, initial_state: &St, target: &mut St, )

impl TileBondInfo for SDC

fn tile_colors(&self) -> &Vec<[u8; 4]>

fn tile_names(&self) -> &[String]

fn bond_names(&self) -> &[String]

fn tile_color(&self, tile_number: Tile) -> [u8; 4]

fn tile_name(&self, tile_number: Tile) -> &str

fn bond_name(&self, bond_number: usize) -> &str

fn tile_style(&self, tile_number: Tile) -> TileStyle

By default, we will make a tile be just a solid clor, but a system may override this to customize how a tile looks.

fn tile_pixels(&self, tile_number: Tile, size: usize) -> SpriteSquare

Turn the tile into a sprite

fn tile_blocker_mask(&self, _tile_number: Tile) -> u8

Return a bitmask of sides that have blockers attached. Bit layout: 0b_WESN (bit 0 = North, bit 1 = East, bit 2 = South, bit 3 = West). Default: no blockers.

impl TryInto<SDC> for SystemEnum

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<SDC, <Self as TryInto<SDC>>::Error>

Performs the conversion.

impl DerefToPyAny for SDC

impl ExtractPyClassWithClone for SDC