conspire/domain/fem/block/solid/elastic/
mod.rs

1pub mod internal_variables;
2
3use crate::{
4    constitutive::solid::elastic::Elastic,
5    fem::{
6        ElementModelError, NodalCoordinates,
7        block::{
8            Block,
9            element::{
10                FiniteElementError, planar::PlanarElasticFiniteElement,
11                solid::elastic::ElasticFiniteElement,
12            },
13        },
14        solid::{NodalForcesSolid, NodalStiffnessesSolid, elastic::ElasticElements},
15    },
16};
17
18impl<C, F, const G: usize, const M: usize, const N: usize, const P: usize> ElasticElements<3>
19    for Block<C, F, G, M, N, P>
20where
21    C: Elastic,
22    F: ElasticFiniteElement<C, G, M, N, P>,
23{
24    fn nodal_forces_into(
25        &self,
26        nodal_coordinates: &NodalCoordinates<3>,
27        nodal_forces: &mut NodalForcesSolid<3>,
28    ) -> Result<(), ElementModelError> {
29        self.elements()
30            .iter()
31            .zip(self.connectivity())
32            .try_for_each(|(element, nodes)| {
33                element
34                    .nodal_forces(
35                        self.constitutive_model(),
36                        &Self::element_coordinates(nodal_coordinates, nodes),
37                    )?
38                    .into_iter()
39                    .zip(nodes)
40                    .for_each(|(nodal_force, &node)| nodal_forces[node] += nodal_force);
41                Ok::<(), FiniteElementError>(())
42            })
43            .map_err(|error| ElementModelError::upstream(error, self))
44    }
45    fn nodal_stiffnesses_into(
46        &self,
47        nodal_coordinates: &NodalCoordinates<3>,
48        nodal_stiffnesses: &mut NodalStiffnessesSolid<3>,
49    ) -> Result<(), ElementModelError> {
50        self.elements()
51            .iter()
52            .zip(self.connectivity())
53            .try_for_each(|(element, nodes)| {
54                element
55                    .nodal_stiffnesses(
56                        self.constitutive_model(),
57                        &Self::element_coordinates(nodal_coordinates, nodes),
58                    )?
59                    .into_iter()
60                    .zip(nodes)
61                    .for_each(|(object, &node_a)| {
62                        object
63                            .into_iter()
64                            .zip(nodes)
65                            .for_each(|(nodal_stiffness, &node_b)| {
66                                nodal_stiffnesses[node_a][node_b] += nodal_stiffness
67                            })
68                    });
69                Ok::<(), FiniteElementError>(())
70            })
71            .map_err(|error| ElementModelError::upstream(error, self))
72    }
73}
74
75impl<C, F, const G: usize, const N: usize, const P: usize> ElasticElements<2>
76    for Block<C, F, G, 2, N, P>
77where
78    C: Elastic,
79    F: PlanarElasticFiniteElement<C, G, N, P>,
80{
81    fn nodal_forces_into(
82        &self,
83        nodal_coordinates: &NodalCoordinates<2>,
84        nodal_forces: &mut NodalForcesSolid<2>,
85    ) -> Result<(), ElementModelError> {
86        self.elements()
87            .iter()
88            .zip(self.connectivity())
89            .try_for_each(|(element, nodes)| {
90                element
91                    .nodal_forces(
92                        self.constitutive_model(),
93                        &Self::element_coordinates(nodal_coordinates, nodes),
94                    )?
95                    .into_iter()
96                    .zip(nodes)
97                    .for_each(|(nodal_force, &node)| nodal_forces[node] += nodal_force);
98                Ok::<(), FiniteElementError>(())
99            })
100            .map_err(|error| ElementModelError::upstream(error, self))
101    }
102    fn nodal_stiffnesses_into(
103        &self,
104        nodal_coordinates: &NodalCoordinates<2>,
105        nodal_stiffnesses: &mut NodalStiffnessesSolid<2>,
106    ) -> Result<(), ElementModelError> {
107        self.elements()
108            .iter()
109            .zip(self.connectivity())
110            .try_for_each(|(element, nodes)| {
111                element
112                    .nodal_stiffnesses(
113                        self.constitutive_model(),
114                        &Self::element_coordinates(nodal_coordinates, nodes),
115                    )?
116                    .into_iter()
117                    .zip(nodes)
118                    .for_each(|(object, &node_a)| {
119                        object
120                            .into_iter()
121                            .zip(nodes)
122                            .for_each(|(nodal_stiffness, &node_b)| {
123                                nodal_stiffnesses[node_a][node_b] += nodal_stiffness
124                            })
125                    });
126                Ok::<(), FiniteElementError>(())
127            })
128            .map_err(|error| ElementModelError::upstream(error, self))
129    }
130}
conspire/domain/fem/block/solid/elastic/mod.rs

conspire/domain/fem/block/solid/elastic/
mod.rs
