rspice 0.1.0

Pure-Rust circuit simulation backend
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

use crate::BasicComponent;
use crate::Circuit;
use crate::ComponentRef;
use crate::ConnectionRef;
use crate::EquationRef;
use crate::NetRef;
use crate::TransientMatrix;
use crate::TransientVector;

/// Ideal capacitor.
pub struct Capacitor {
    nets: Vec<NetRef>,
    connections: Vec<ConnectionRef>,
    equations: Vec<EquationRef>,
    value: f64,
}

impl BasicComponent for Capacitor {
    fn initCircuit(
        &mut self,
        nets: Vec<NetRef>,
        connections: Vec<ConnectionRef>,
        equations: Vec<EquationRef>,
    ) {
        self.nets = nets;
        self.connections = connections;
        self.equations = equations;
    }

    fn initTransient(&mut self, matrix: &mut TransientMatrix) {
        // equation 0: net zero outgoing current
        // 1 * net1.I + 1 * net2.I = 0
        matrix.clear_equation(self.equations[0]);
        *matrix.current_term(self.equations[0], self.connections[0]) = 1.0;
        *matrix.current_term(self.equations[0], self.connections[1]) = 1.0;

        // equation 1: net zero current derivative
        // 1 * net1.dI/dt + 1 * net2.dI/dt = 0
        matrix.clear_equation(self.equations[1]);
        *matrix.current_derivative_term(self.equations[1], self.connections[0]) = 1.0;
        *matrix.current_derivative_term(self.equations[1], self.connections[1]) = 1.0;

        // equation 2: instantaneous voltage difference (initialize to zero)
        // 1 * net1.V - 1 * net2.V = V
        matrix.clear_equation(self.equations[2]);
        *matrix.voltage_term(self.equations[2], self.nets[0]) = 1.0;
        *matrix.voltage_term(self.equations[2], self.nets[1]) = -1.0;

        // equation 3: capacitor operation
        // 1 * net1.dV/dt - 1 * net2.dV/dt + 1/C * net1.I = 0
        matrix.clear_equation(self.equations[3]);
        *matrix.voltage_derivative_term(self.equations[3], self.nets[0]) = 1.0;
        *matrix.voltage_derivative_term(self.equations[3], self.nets[1]) = -1.0;
        *matrix.current_term(self.equations[3], self.connections[0]) = 1.0 / self.value;
    }

    fn updateTransient(
        &mut self,
        matrix: &mut TransientMatrix,
        vector: &TransientVector,
        t: f64,
        step: f64,
    ) {
        // discrete derivative
        let dV1_dt = vector.voltage_derivative(self.nets[0]);
        let dV2_dt = vector.voltage_derivative(self.nets[1]);
        let dV_dt = dV1_dt - dV2_dt;
        *matrix.constant_term(self.equations[2]) += step * dV_dt;
    }
}

impl Capacitor {
    /// Create a capacitor of `value` Farads, connected to `net1` and `net2`.
    pub fn create(circuit: &mut Circuit, net1: NetRef, net2: NetRef, value: f64) -> ComponentRef {
        let component = Self {
            nets: Vec::new(),
            connections: Vec::new(),
            equations: Vec::new(),
            value: value,
        };
        circuit.createBasicComponent(Box::new(component), vec![net1, net2])
    }
}