aeon-tk 0.3.3

Toolkit for running finite difference simulations with adaptive mesh refinement
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

//! A crate for approximating numerical operators on uniform rectangular meshes using finite differencing.

#![allow(clippy::needless_range_loop)]

mod boundary;
mod convolution;
mod element;
mod node;
mod weights;

pub use boundary::{
    BoundaryClass, BoundaryConds, BoundaryKind, DirichletParams, EmptyConditions, RadiativeParams,
    ScalarConditions, SystemBoundaryConds, is_boundary_compatible,
};
pub use convolution::{Convolution, Gradient, Hessian};
pub use element::Element;
pub use node::{
    NodeCartesianIter, NodePlaneIter, NodeSpace, NodeWindow, node_from_vertex, vertex_from_node,
};
pub use weights::{Derivative, Dissipation, Interpolation, SecondDerivative, Unimplemented, Value};

use crate::IRef;

// **************************
// Border *******************
// **************************

#[derive(Debug, Clone, Copy)]
pub enum Border {
    Negative(usize),
    Positive(usize),
}

impl Border {
    pub fn side(self) -> bool {
        match self {
            Border::Negative(_) => false,
            Border::Positive(_) => true,
        }
    }
}

// *****************************
// Kernel **********************
// *****************************

pub trait Kernel {
    fn border_width(&self) -> usize;
    fn interior(&self) -> &[f64];
    fn free(&self, border: Border) -> &[f64];
    fn scale(&self, spacing: f64) -> f64;
}

impl<'a, T: Kernel> Kernel for IRef<'a, T> {
    fn border_width(&self) -> usize {
        self.0.border_width()
    }

    fn interior(&self) -> &[f64] {
        self.0.interior()
    }

    fn free(&self, border: Border) -> &[f64] {
        self.0.free(border)
    }

    fn scale(&self, spacing: f64) -> f64 {
        self.0.scale(spacing)
    }
}

pub trait Interpolant {
    fn border_width(&self) -> usize;
    fn interior(&self) -> &[f64];
    fn free(&self, border: Border) -> &[f64];
    fn scale(&self) -> f64;
}

impl<'a, T: Interpolant> Interpolant for IRef<'a, T> {
    fn border_width(&self) -> usize {
        self.0.border_width()
    }

    fn interior(&self) -> &[f64] {
        self.0.interior()
    }

    fn free(&self, border: Border) -> &[f64] {
        self.0.free(border)
    }

    fn scale(&self) -> f64 {
        self.0.scale()
    }
}