Trait Calc 

pub trait Calc:
    Send
    + Sync
    + Debug
    + Serialize
    + Deserialize {
    // Required methods
    fn init(
        &mut self,
        ctx: ControllerCtx,
        input_indices: Vec<usize>,
        output_range: Range<usize>,
    ) -> Result<(), String>;
    fn terminate(&mut self) -> Result<(), String>;
    fn eval(&mut self, tape: &mut [f64]) -> Result<(), String>;
    fn get_input_map(&self) -> BTreeMap<CalcInputName, FieldName>;
    fn update_input_map(
        &mut self,
        field: &str,
        source: &str,
    ) -> Result<(), String>;
    fn get_save_outputs(&self) -> bool;
    fn set_save_outputs(&mut self, save_outputs: bool);
    fn get_config(&self) -> BTreeMap<String, f64>;
    fn set_config(&mut self, cfg: &BTreeMap<String, f64>) -> Result<(), String>;
    fn get_input_names(&self) -> Vec<CalcInputName> ;
    fn get_output_names(&self) -> Vec<CalcOutputName> ;

    // Provided method
    fn kind(&self) -> String { ... }
}

A calculation that takes some inputs and produces some outputs at each timestep, and may have some persistent internal state.

Required Methods

fn init( &mut self, ctx: ControllerCtx, input_indices: Vec<usize>, output_range: Range<usize>, ) -> Result<(), String>

Reset internal state and register calc tape indices

fn terminate(&mut self) -> Result<(), String>

Clear state to reset for another run

fn eval(&mut self, tape: &mut [f64]) -> Result<(), String>

Run calcs for a cycle

fn get_input_map(&self) -> BTreeMap<CalcInputName, FieldName>

Map from input field names (like v, without prefix) to the state name that the input should draw from (like peripheral_0.output_1, with prefix)

fn update_input_map(&mut self, field: &str, source: &str) -> Result<(), String>

Change a value in the input map

fn get_save_outputs(&self) -> bool

Get flag for whether to save outputs

fn set_save_outputs(&mut self, save_outputs: bool)

Set flag for whether to save outputs

fn get_config(&self) -> BTreeMap<String, f64>

Get config field values

fn set_config(&mut self, cfg: &BTreeMap<String, f64>) -> Result<(), String>

Apply config field values

fn get_input_names(&self) -> Vec<CalcInputName>

List of input field names in the order that they will be consumed

fn get_output_names(&self) -> Vec<CalcOutputName>

List of output field names in the order that they will be written out

Provided Methods

fn kind(&self) -> String

Get the type name, which is guaranteed to be unique among implementations of the trait because of the use of a global vtable for serialization, and guaranteed not to include non-’static lifetimes due to trait bounds.

Trait Implementations

impl Clone for Box<dyn Calc>

Clone isn’t inherently object-safe, so to be able to clone dyn trait objects, we send it for a loop through the serde typetag system, which provides an automatically-assembled vtable to determine the downcasted type and clone into it.

fn clone(&self) -> Box<dyn Calc>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, 'py> FromPyObject<'a, 'py> for Box<dyn Calc>

Glue for passing dyn Trait objects from Python to Rust via json to handle the fact that they are concrete types on the Python side, but dyn Trait objects on the Rust side.

type Error = PyErr

The type returned in the event of a conversion error.

fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error>

Extracts Self from the bound smart pointer obj.

impl<'typetag> Serialize for dyn Calc + 'typetag

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'typetag> Serialize for dyn Calc + Send + 'typetag

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'typetag> Serialize for dyn Calc + Send + Sync + 'typetag

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'typetag> Serialize for dyn Calc + Sync + 'typetag

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

Implementors

impl Calc for SequenceMachine

impl Calc for Affine

impl Calc for Butter2

impl Calc for Constant

impl Calc for InverseAffine

impl Calc for Pid

impl Calc for Polynomial

impl Calc for RtdPt100

impl Calc for Sin

impl Calc for TcKtype