eki 0.2.0

Eki is a solver for steady and transient flow in fluid networks.
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use crate::nodes::{
    pressure::Pressure,
    flow::Flow,
    connection::Connection,
};

#[derive(Clone, PartialEq, Debug, serde::Deserialize, serde::Serialize)]
pub enum Node {
    Pressure(Pressure),         // Assigned Boundary Pressure
    Flow(Flow),                 // Assigned Boundary Flow
    Connection(Connection),     // Connection Node
}

impl Default for Node {
    fn default() -> Self {
        Node::Pressure( Pressure::default() )
    }
}

impl std::fmt::Display for Node {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Node::Pressure(_node) => write!(f, "Pressure"),
            Node::Flow(_node) => write!(f, "Flow"),
            Node::Connection(_node) => write!(f, "Connection"),
        }
    }
}

impl Node {

    pub fn id(&self) -> usize {
        match self {
            Node::Pressure(node) => node.id,
            Node::Flow(node) => node.id,
            Node::Connection(node) => node.id,
        }
    }

    pub fn is_connection(&self) -> bool { 
        matches!(self, Node::Connection(_node))
    }

    pub fn is_known_pressure(&self) -> bool {
        matches!(self, Node::Pressure(_node))
    }

    pub fn is_known_flow(&self) -> bool {
        matches!(self, Node::Flow(_node))  
    }

    pub fn elevation(&mut self) -> &mut f64 {
        match self {
            Node::Pressure(node) => &mut node.elevation,
            Node::Flow(node) => &mut node.elevation,
            Node::Connection(node) => &mut node.elevation,
        }
    }

    pub fn pressure(&mut self) -> &mut Vec<f64> {
        match self {
            Node::Pressure(node) => &mut node.pressure,
            Node::Flow(node) => &mut node.pressure,
            Node::Connection(node) => &mut node.pressure,
        }
    }

    pub fn steady_pressure(&mut self) -> &mut f64 {
        &mut self.pressure()[0]
    }

    pub fn current_pressure(&mut self) -> f64 {
        *self.pressure().last().unwrap()
    }

    pub fn consumption(&mut self) -> &mut Vec<f64> {
        match self {
            Node::Pressure(node) => &mut node.consumption,
            Node::Flow(node) => &mut node.consumption,
            Node::Connection(node) => &mut node.consumption,
        }
    }

    pub fn steady_consumption(&mut self) -> &mut f64 {
        &mut self.consumption()[0]
    }

    pub fn head(&mut self, g: f64, density: f64 ) -> Vec<f64> {
        let elevation = *self.elevation();
        let pressure = self.pressure();
        let mut head = vec![0.0; pressure.len()];
        for (i, p) in pressure.iter().enumerate() {
            head[i] = elevation + ((*p) / (g * density)) ;
        }
        head
    }

    pub fn steady_head(&mut self, g: f64, density: f64 ) -> f64 {
        let elevation = *self.elevation();
        let pressure = self.steady_pressure();
        let mut head = elevation;
        head += (*pressure) / (g * density) ;
        head
    }

    pub fn update_id(&mut self, id: usize ) {
        match self {
            Node::Pressure(node) => node.id = id,
            Node::Flow(node) => node.id = id,
            Node::Connection(node) => node.id = id,
        }
    }

    pub fn add_boundary_value(&mut self, value: f64 ) {
        match self {
            Node::Pressure(node) => node.pressure.push(value),
            Node::Flow(node) => node.consumption.push(value),
            Node::Connection(_node) => {},
        }
    }
 
}