runmat-meshing-size 0.6.0

Sizing field query service for RunMat meshing
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

use serde::{Deserialize, Serialize};

use crate::refinement::{MeshRefinementOptions, RefinementStrategy};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum AdaptiveConvergenceStatus {
    NotStarted,
    Disabled,
    Pending,
    Converged,
    MaxIterationsReached,
    ElementBudgetReached,
}

#[derive(Debug, Clone, Copy, PartialEq, Default)]
pub struct AdaptiveConvergenceMetrics {
    pub completed_iterations: usize,
    pub element_budget_reached: bool,
    pub previous_node_count: Option<usize>,
    pub current_node_count: Option<usize>,
    pub previous_element_count: Option<usize>,
    pub current_element_count: Option<usize>,
    pub field_change: Option<f64>,
    pub energy_change: Option<f64>,
    pub residual: Option<f64>,
}

pub fn evaluate_adaptive_convergence(
    options: &MeshRefinementOptions,
    metrics: AdaptiveConvergenceMetrics,
) -> AdaptiveConvergenceStatus {
    if matches!(
        options.strategy,
        RefinementStrategy::None | RefinementStrategy::Uniform
    ) {
        return AdaptiveConvergenceStatus::Disabled;
    }
    if metrics.element_budget_reached {
        return AdaptiveConvergenceStatus::ElementBudgetReached;
    }
    if metrics.completed_iterations >= options.max_iterations {
        return AdaptiveConvergenceStatus::MaxIterationsReached;
    }
    if metrics.completed_iterations > 0
        && matches!(
            (
                metrics.previous_node_count,
                metrics.current_node_count,
                metrics.previous_element_count,
                metrics.current_element_count,
            ),
            (Some(previous_nodes), Some(current_nodes), Some(previous_elements), Some(current_elements))
                if current_nodes <= previous_nodes && current_elements <= previous_elements
        )
    {
        return AdaptiveConvergenceStatus::Converged;
    }

    let mut considered_metric = false;
    let mut converged = true;

    if let Some(field_change) = metrics.field_change {
        considered_metric = true;
        converged &=
            field_change.is_finite() && field_change <= options.convergence.field_change_tolerance;
    }
    if let Some(energy_change) = metrics.energy_change {
        considered_metric = true;
        converged &= energy_change.is_finite()
            && energy_change <= options.convergence.energy_change_tolerance;
    }
    if let (Some(residual), Some(tolerance)) =
        (metrics.residual, options.convergence.residual_tolerance)
    {
        considered_metric = true;
        converged &= residual.is_finite() && residual <= tolerance;
    }

    if considered_metric && converged {
        AdaptiveConvergenceStatus::Converged
    } else {
        AdaptiveConvergenceStatus::Pending
    }
}