fem_2d 0.2.2

2D Finite Element Method Toolkit
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

use super::super::space::Point;
use super::elem::Elem;
use json::{object, JsonValue};
use std::collections::BTreeMap;

/// A point in Real 2D space
///
/// Nodes keep track of all adjacent `Elem`s and are responsible for identifying whether or not they can support node-type Degrees of Freedom (not fully implemented yet)
///
/// ## Layout
///
/// The indices of `Elem`s and `Edge`s relative to a Node are described as follows:
///
/// ```text
///         1
///         |
///       1 | 0
///   2-----*-----3
///       3 | 2
///         |
///         0
/// ```
#[derive(Debug, Clone)]
pub struct Node {
    pub id: usize,
    pub coords: Point,
    pub boundary: bool,
    elems: [BTreeMap<[u8; 2], usize>; 4],
    // active_elems: Option<[usize; 4]>,
}

impl Node {
    /// construct a new Node defined by its location in real space
    pub fn new(id: usize, coords: Point, boundary: bool) -> Self {
        Self {
            id,
            coords,
            boundary,
            elems: [
                BTreeMap::new(),
                BTreeMap::new(),
                BTreeMap::new(),
                BTreeMap::new(),
            ],
            // active_elems: None,
        }
    }

    pub(crate) fn connect_elem(&mut self, elem: &Elem) {
        if let Some(index_of_self) = elem.nodes.iter().position(|node_id| node_id == &self.id) {
            let address = elem.h_levels.node_ranking();

            if let Some(prev_elem_id) = self.elems[index_of_self].insert(address, elem.id) {
                assert_eq!(
                    prev_elem_id, elem.id,
                    "Node {} is already connected to Elem {} at {:?} ({}); cannot connect to Elem {}",
                    self.id,
                    prev_elem_id,
                    address,
                    index_of_self,
                    elem.id,
                );
            }
        } else {
            panic!(
                "Elem {} is not connected to Node {}; cannot reciprocate connection!",
                elem.id, self.id
            );
        }
    }

    // pub(crate) fn active_elems(&self) -> Option<[usize; 4]> {
    //     self.active_elems
    // }

    // TODO: implement note-type shape function matching

    // pub(crate) fn reset_activation(&mut self) {
    //     self.active_elems = None;
    // }

    // pub(crate) fn set_activation(&mut self) -> bool {
    //     let mut combination_sets: [BTreeMap<[usize; 2], u8>; 4] = [
    //         BTreeMap::new(), // "edge" 0 : [0, 1] -> v level
    //         BTreeMap::new(), // "edge" 1 : [2, 3] -> v level
    //         BTreeMap::new(), // "edge" 2 : [0, 2] -> u level
    //         BTreeMap::new(), // "edge" 3 : [1, 3] -> u level
    //     ];

    //     for (edge_idx, elem_indices, check_index) in [
    //         (0, [0, 1], 1),
    //         (1, [2, 3], 1),
    //         (2, [0, 2], 0),
    //         (3, [1, 3], 0),
    //     ] {
    //         for (key_0, elem_id_0) in self.elems[elem_indices[0]].iter() {
    //             for (key_1, elem_id_1) in self.elems[elem_indices[1]].iter() {
    //                 if key_0[check_index] == key_1[check_index] {
    //                     combination_sets[edge_idx]
    //                         .insert([*elem_id_0, *elem_id_1], key_0[check_index]);
    //                 }
    //             }
    //         }
    //     }

    //     unimplemented!()
    // }

    /// Produce a Json Object that describes this Node
    #[cfg(feature = "json_export")]
    pub fn to_json(&self) -> JsonValue {
        object! {
            "id": self.id,
            "boundary": self.boundary,
            "point": self.coords,
            "elems": JsonValue::from(self.elems.iter().map(|elem_list| {
                elem_list.values().copied().collect()
            }).collect::<Vec<Vec<usize>>>())
        }
    }
}