neapolitan 0.2.0

Easily model and solve circuit-like problems
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

/// Std modules
use std::cell::RefCell;
use std::collections::HashMap;
use std::rc::Rc;

/// 3rd party modules
use gmatlib::col_vec;

/// Local modules 
use crate::Matrix;
use crate::modelling::element::GenericElement;

/// A struct representing a node in a nodal analysis problem.
/// 
/// # Concept:
/// Nodes are points where continuity/equilibrium must be enforced in a nodal 
/// analysis problem. For example, in circuitry problems, nodes are analogous 
/// to wires. In hydraulics problems, nodes are analogous to sections of hose 
/// not divided by a valve or other pressure-drop-inducing element. 
/// 
/// While not pertinent to *using* the neapolitan framework, *understanding* 
/// how nodes work is not very complicated. All `GenericElement` objects have
/// a `get_flux` method that returns a flux quantity. Based on whether elements
/// are connected to a node as an input or output, they add or subtract their flux 
/// quantities in a flux balance. This is similar to an "energy balance", "force
/// balance", "flow balance", etc. done in any number of engineering or physics 
/// courses, and enforces the continuity/equilibrium condition mentioned earlier at 
/// each node. The solver engine makes gradual changes to each nodes potential to
/// guide the nodal flux discrepancy of every node in the system to 0.
#[derive(Clone, Debug)]
pub struct GenericNode
{
    pub (in crate) potential: Matrix<f64>,
    pub (in crate) inputs: Vec<Rc<GenericElement>>,
    pub (in crate) outputs: Vec<Rc<GenericElement>>,
    pub (in crate) is_locked: bool,
    pub (in crate) _metadata: Option<HashMap<String, f64>>, 
}
impl GenericNode
{

    pub fn new() -> Rc<RefCell<GenericNode>>
    {
        Rc::new(RefCell::new(GenericNode
        {
            potential: col_vec![1f64],
            inputs: vec![],
            outputs: vec![],
            is_locked: false,
            _metadata: None,
        }))
    }

    pub fn get_flux_discrepancy(&self) -> anyhow::Result<Matrix<f64>>
    {
        let mut inputs = Matrix::new(
            self.potential.get_rows(),
            self.potential.get_cols(),
        ); 

        let mut outputs = inputs.clone();

        for elem in &self.inputs
        {
            inputs += elem.get_flux()?;
        }

        for elem in &self.outputs
        {
            outputs += elem.get_flux()?;
        }

        let discrepancy = inputs - outputs;
        Ok(discrepancy)
    } 
}