pub struct BlockInstance {
pub name: String,
pub kind: BlockKind,
pub inputs: Vec<Signal>,
pub ic: Option<Vec<f64>>,
}Expand description
One named block instance and where its inputs (if any) come from.
Const/Pwc/Pwl/Waveform/Phys2Sig blocks must have zero inputs; Sum/Product need one
input per sign/factor; Gain/
StateSpace/TransferFunction/Vco/Saturation/Table/MathFn1/Sig2Phys
each need exactly one; Pid needs exactly one (the error signal)
when its clamp is PidClamp::Fixed, or exactly three (error, clamp_lo, clamp_hi, in that
order) when PidClamp::Dynamic; MathFn2 needs two; MathFn3 needs three;
CoordinateTransform needs kind.input_count() (3 for Clarke/ClarkeInv, 4 for the
others — see continuous_blocks::CoordinateTransform::input_count); Pmsm needs exactly
three (vd, vq, t_load, in that order). Evaluated once per step in the causal order
topological_order (in dae-runtime) derives from the slice’s own Signal::Block dependency graph — not
the order the slice happens to be given in; a Signal::Block input may name any block in
the same slice regardless of declared position (source blocks, naturally, need none, and a
genuine cycle among these edges is rejected as DaeError::AlgebraicLoop before any step
runs — see topological_order’s own doc comment for how).
Generic field-parsing errors, shared by every kind= block and not repeated per
variant below: a field required by that kind but absent from the line is line N: device '<name>' missing field '<key>'; present but not parseable as the expected type (almost
always f64) is line N: device '<name>' field '<key>' is not a number; present but read
by nothing for that kind (a misspelling, or a field that belongs to another kind) is
line N: device '<name>' unknown field '<key>' (kind=<kind> accepts only: ...), listing the
keys that kind consulted on that line — the same shape a device card’s unknown field
reports. Nothing on a block line is silently ignored: the only keys a kind accepts are the
ones documented in its own ## Parameters (plus ic=/y0= below), and the escape hatches
(cscript/pyblock/pyfunc/octfunc/octblock) take no free-form parameters from the
netlist line either.
Initial conditions. Every block that carries state across steps accepts an optional
ic= (each such variant’s own ## Parameters says what it means there); an ic= on any
other kind is rejected rather than dropped — line N: device '<name>' field 'ic': this kind has no state to initialize -- 'ic' is accepted on ... — as is a non-finite entry
(initial condition must be finite). cscript/pyblock/octblock initialize their own
state and take no ic=.
Fields§
§name: StringThis block’s own unique name.
kind: BlockKindWhat this block computes.
inputs: Vec<Signal>Where each input comes from, in the order kind expects.
ic: Option<Vec<f64>>The state this block starts the run in, or None to start from rest (every state zero,
every logic output low) exactly as before this field existed. Already resolved into the
block’s own state layout and already validated by the netlist parser, so dae-runtime
only has to copy it in:
StateSpace/DiscreteStateSpace— the state vector $x(0)$, one entry per state.TransferFunction/DiscreteTransferFunction— the state vector of the controllable canonical realization (ic=), or the settled state a netlist’sy0=resolves to (seecontinuous_blocks::TransferFunction::settled_state).Pid— the canonical state holding the controller output at the netlist’sic=with zero error;DiscretePid— one entry, the integrator’s accumulated value (ic / ki).Vco/PhaseShiftPwm— one entry, the phase in cycles, $0 \le \phi_0 < 1$.Pmsm— four entries, $(i_d, i_q, \omega_m, \theta_e)$.Hysteresis/SrLatch/FlipFlop— one entry,0.0or1.0, the initial output.Counter— one entry, the (integer-valued) initial count.
None on every other kind: a stateless block has nothing to initialize, and
cscript/pyblock/octblock own their initialization themselves.
Trait Implementations§
Source§impl Clone for BlockInstance
impl Clone for BlockInstance
Source§fn clone(&self) -> BlockInstance
fn clone(&self) -> BlockInstance
1.0.0 (const: unstable) · Source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source. Read more