fenris 0.0.28

A library for advanced finite element computations in Rust
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

//! Functionality and abstractions for mesh refinement.
//!
//! Currently we only provide uniform refinement for select element types through
//! [`refine_mesh`] and [`UniformRefinement`].
use crate::allocators::DimAllocator;
use crate::connectivity::Connectivity;
use crate::mesh::Mesh;
use nalgebra::{DefaultAllocator, DimName, OPoint, RealField};
use std::collections::HashMap;
use std::hash::Hash;

pub mod detail;

#[derive(Debug, Clone)]
pub struct InvalidVertexCount;

pub trait VertexRepresentation: Clone {
    fn construct_vertex<T, D>(&self, all_vertices: &[OPoint<T, D>]) -> OPoint<T, D>
    where
        T: RealField,
        D: DimName,
        DefaultAllocator: DimAllocator<T, D>;
}

/// Defines a refinement scheme for a given connectivity.
pub trait RefineConnectivity<Connectivity> {
    /// An intermediate connectivity type that holds the necessary information
    /// to represent the connectivity in a manner independent of the index labeling of
    /// new vertices.
    ///
    /// This is generally an internal detail.
    type Intermediate;
    /// The resulting connectivity type after refinement.
    type OutputConnectivity;
    /// The kind of label used to define vertices in a globally consistent fashion.
    type VertexLabel: VertexRepresentation;

    /// For a given connectivity, produce a set of intermediate connectivities that represent
    /// refined connectivities.
    fn populate_refined_connectivity(&self, connectivity: &Connectivity, intermediates: &mut Vec<Self::Intermediate>);

    /// Populate a set of vertex labels associated with an intermediate connectivity.
    fn populate_vertex_labels(&self, intermediate: &Self::Intermediate, labels: &mut Vec<Self::VertexLabel>);

    /// Construct the final connectivity from an intermediate given final,
    /// globally consistent vertex indices.
    ///
    /// The implementation must succeed if the number of vertex indices is equal to the
    /// number of vertex labels associated with the intermediate, as defined by
    /// the number of vertex labels produced by
    /// [`populate_vertex_labels`](Self::populate_vertex_labels).
    fn construct_output_connectivity(
        &self,
        intermediate: &Self::Intermediate,
        vertex_indices: &[usize],
    ) -> Result<Self::OutputConnectivity, InvalidVertexCount>;
}

pub struct UniformRefinement;

/// Refine a mesh with the provided refinement scheme.
pub fn refine_mesh<T, D, C, Refinement>(
    mesh: &Mesh<T, D, C>,
    refinement_scheme: Refinement,
) -> Mesh<T, D, Refinement::OutputConnectivity>
where
    T: RealField,
    D: DimName,
    Refinement: RefineConnectivity<C>,
    Refinement::VertexLabel: Eq + Hash,
    DefaultAllocator: DimAllocator<T, D>,
{
    let mut label_to_idx_map = HashMap::new();
    let mut next_vertex_idx = 0;

    let mut new_connectivity = Vec::new();

    // Local buffers
    let mut intermediates = Vec::new();
    let mut vertex_labels = Vec::new();
    let mut new_vertex_indices = Vec::new();
    for connectivity in mesh.connectivity() {
        new_vertex_indices.clear();
        intermediates.clear();
        refinement_scheme.populate_refined_connectivity(&connectivity, &mut intermediates);
        for intermediate in &intermediates {
            vertex_labels.clear();
            new_vertex_indices.clear();
            refinement_scheme.populate_vertex_labels(&intermediate, &mut vertex_labels);
            for label in &vertex_labels {
                let idx = label_to_idx_map.entry(label.clone()).or_insert_with(|| {
                    let idx = next_vertex_idx;
                    next_vertex_idx += 1;
                    idx
                });
                new_vertex_indices.push(*idx);
            }
            let new_cell_connectivity = refinement_scheme
                .construct_output_connectivity(&intermediate, &new_vertex_indices)
                .expect("Must succeed since vertex label count is consistent with vertex index count");
            new_connectivity.push(new_cell_connectivity);
        }
    }

    let mut new_vertices = vec![Default::default(); next_vertex_idx];
    for (label, index) in label_to_idx_map {
        let vertex = label.construct_vertex(mesh.vertices());
        new_vertices[index] = vertex;
    }
    Mesh::from_vertices_and_connectivity(new_vertices, new_connectivity)
}

/// Apply one round of uniform mesh refinement.
///
/// This is a convenience function for `refine_mesh(mesh, UniformRefinement)`.
pub fn refine_uniformly<T, D, C>(mesh: &Mesh<T, D, C>) -> Mesh<T, D, C>
where
    T: RealField,
    D: DimName,
    UniformRefinement: RefineConnectivity<C, OutputConnectivity = C>,
    <UniformRefinement as RefineConnectivity<C>>::VertexLabel: Eq + Hash,
    DefaultAllocator: DimAllocator<T, D>,
{
    refine_mesh(mesh, UniformRefinement)
}

/// Repeatedly applies uniform mesh refinement to the given mesh.
pub fn refine_uniformly_repeat<T, D, C>(mesh: &Mesh<T, D, C>, repeat_times: usize) -> Mesh<T, D, C>
where
    T: RealField,
    D: DimName,
    C: Connectivity,
    UniformRefinement: RefineConnectivity<C, OutputConnectivity = C>,
    <UniformRefinement as RefineConnectivity<C>>::VertexLabel: Eq + Hash,
    DefaultAllocator: DimAllocator<T, D>,
{
    let mut mesh: Mesh<_, _, _> = mesh.clone();
    for _ in 0..repeat_times {
        mesh = refine_uniformly(&mesh);
    }
    mesh
}