conspire 0.6.0

The Rust interface to conspire.
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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192

use crate::{
    constitutive::{ConstitutiveError, solid::elastic_hyperviscous::ElasticHyperviscous},
    fem::block::element::{
        Element, ElementNodalCoordinates, ElementNodalVelocities, FiniteElementError,
        solid::viscoelastic::ViscoelasticFiniteElement, surface::SurfaceElement,
    },
    math::{Scalar, Tensor},
};

pub trait ElasticHyperviscousFiniteElement<
    C,
    const G: usize,
    const M: usize,
    const N: usize,
    const P: usize,
> where
    C: ElasticHyperviscous,
    Self: ViscoelasticFiniteElement<C, G, M, N, P>,
{
    fn viscous_dissipation(
        &self,
        constitutive_model: &C,
        nodal_coordinates: &ElementNodalCoordinates<N>,
        nodal_velocities: &ElementNodalVelocities<N>,
    ) -> Result<Scalar, FiniteElementError>;
    fn dissipation_potential(
        &self,
        constitutive_model: &C,
        nodal_coordinates: &ElementNodalCoordinates<N>,
        nodal_velocities: &ElementNodalVelocities<N>,
    ) -> Result<Scalar, FiniteElementError>;
}

impl<C, const G: usize, const N: usize, const O: usize, const P: usize>
    ElasticHyperviscousFiniteElement<C, G, 3, N, P> for Element<G, N, O>
where
    C: ElasticHyperviscous,
    Self: ViscoelasticFiniteElement<C, G, 3, N, P>,
{
    fn viscous_dissipation(
        &self,
        constitutive_model: &C,
        nodal_coordinates: &ElementNodalCoordinates<N>,
        nodal_velocities: &ElementNodalVelocities<N>,
    ) -> Result<Scalar, FiniteElementError> {
        viscous_dissipation::<_, _, _, _, _, O, _>(
            self,
            constitutive_model,
            nodal_coordinates,
            nodal_velocities,
        )
    }
    fn dissipation_potential(
        &self,
        constitutive_model: &C,
        nodal_coordinates: &ElementNodalCoordinates<N>,
        nodal_velocities: &ElementNodalVelocities<N>,
    ) -> Result<Scalar, FiniteElementError> {
        dissipation_potential::<_, _, _, _, _, O, _>(
            self,
            constitutive_model,
            nodal_coordinates,
            nodal_velocities,
        )
    }
}

impl<C, const G: usize, const N: usize, const O: usize, const P: usize>
    ElasticHyperviscousFiniteElement<C, G, 2, N, P> for SurfaceElement<G, N, O>
where
    C: ElasticHyperviscous,
    Self: ViscoelasticFiniteElement<C, G, 2, N, P>,
{
    fn viscous_dissipation(
        &self,
        constitutive_model: &C,
        nodal_coordinates: &ElementNodalCoordinates<N>,
        nodal_velocities: &ElementNodalVelocities<N>,
    ) -> Result<Scalar, FiniteElementError> {
        viscous_dissipation::<_, _, _, _, _, O, _>(
            self,
            constitutive_model,
            nodal_coordinates,
            nodal_velocities,
        )
    }
    fn dissipation_potential(
        &self,
        constitutive_model: &C,
        nodal_coordinates: &ElementNodalCoordinates<N>,
        nodal_velocities: &ElementNodalVelocities<N>,
    ) -> Result<Scalar, FiniteElementError> {
        dissipation_potential::<_, _, _, _, _, O, _>(
            self,
            constitutive_model,
            nodal_coordinates,
            nodal_velocities,
        )
    }
}

fn viscous_dissipation<
    C,
    F,
    const G: usize,
    const M: usize,
    const N: usize,
    const O: usize,
    const P: usize,
>(
    element: &F,
    constitutive_model: &C,
    nodal_coordinates: &ElementNodalCoordinates<N>,
    nodal_velocities: &ElementNodalVelocities<N>,
) -> Result<Scalar, FiniteElementError>
where
    C: ElasticHyperviscous,
    F: ViscoelasticFiniteElement<C, G, M, N, P>,
{
    match element
        .deformation_gradients(nodal_coordinates)
        .iter()
        .zip(
            element
                .deformation_gradient_rates(nodal_coordinates, nodal_velocities)
                .iter()
                .zip(element.integration_weights()),
        )
        .map(
            |(deformation_gradient, (deformation_gradient_rate, integration_weight))| {
                Ok::<_, ConstitutiveError>(
                    constitutive_model
                        .viscous_dissipation(deformation_gradient, deformation_gradient_rate)?
                        * integration_weight,
                )
            },
        )
        .sum()
    {
        Ok(helmholtz_free_energy) => Ok(helmholtz_free_energy),
        Err(error) => Err(FiniteElementError::Upstream(
            format!("{error}"),
            format!("{element:?}"),
        )),
    }
}

fn dissipation_potential<
    C,
    F,
    const G: usize,
    const M: usize,
    const N: usize,
    const O: usize,
    const P: usize,
>(
    element: &F,
    constitutive_model: &C,
    nodal_coordinates: &ElementNodalCoordinates<N>,
    nodal_velocities: &ElementNodalVelocities<N>,
) -> Result<Scalar, FiniteElementError>
where
    C: ElasticHyperviscous,
    F: ViscoelasticFiniteElement<C, G, M, N, P>,
{
    match element
        .deformation_gradients(nodal_coordinates)
        .iter()
        .zip(
            element
                .deformation_gradient_rates(nodal_coordinates, nodal_velocities)
                .iter()
                .zip(element.integration_weights()),
        )
        .map(
            |(deformation_gradient, (deformation_gradient_rate, integration_weight))| {
                Ok::<_, ConstitutiveError>(
                    constitutive_model
                        .dissipation_potential(deformation_gradient, deformation_gradient_rate)?
                        * integration_weight,
                )
            },
        )
        .sum()
    {
        Ok(helmholtz_free_energy) => Ok(helmholtz_free_energy),
        Err(error) => Err(FiniteElementError::Upstream(
            format!("{error}"),
            format!("{element:?}"),
        )),
    }
}