Skip to main content

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

1use crate::{
2    constitutive::solid::elastic::Elastic,
3    fem::{ElementModelError, solid::elastic::ElasticElements},
4    vem::{
5        NodalCoordinates,
6        block::{
7            Block,
8            element::{VirtualElementError, solid::elastic::ElasticVirtualElement},
9            solid::{NodalForcesSolid, NodalStiffnessesSolid},
10        },
11    },
12};
13
14impl<C, F> ElasticElements<3> for Block<C, F>
15where
16    C: Elastic,
17    F: ElasticVirtualElement<C>,
18{
19    fn nodal_forces_into(
20        &self,
21        nodal_coordinates: &NodalCoordinates,
22        nodal_forces: &mut NodalForcesSolid,
23    ) -> Result<(), ElementModelError> {
24        match self
25            .elements()
26            .iter()
27            .zip(self.elements_nodes())
28            .try_for_each(|(element, nodes)| {
29                element
30                    .nodal_forces(
31                        self.constitutive_model(),
32                        Self::element_coordinates(nodal_coordinates, nodes),
33                    )?
34                    .into_iter()
35                    .zip(nodes)
36                    .for_each(|(nodal_force, &node)| nodal_forces[node] += nodal_force);
37                Ok::<(), VirtualElementError>(())
38            }) {
39            Ok(()) => Ok(()),
40            Err(error) => Err(ElementModelError::Upstream(
41                format!("{error}"),
42                format!("{self:?}"),
43            )),
44        }
45    }
46    fn nodal_stiffnesses_into(
47        &self,
48        nodal_coordinates: &NodalCoordinates,
49        nodal_stiffnesses: &mut NodalStiffnessesSolid,
50    ) -> Result<(), ElementModelError> {
51        match self
52            .elements()
53            .iter()
54            .zip(self.elements_nodes())
55            .try_for_each(|(element, nodes)| {
56                element
57                    .nodal_stiffnesses(
58                        self.constitutive_model(),
59                        Self::element_coordinates(nodal_coordinates, nodes),
60                    )?
61                    .into_iter()
62                    .zip(nodes)
63                    .for_each(|(object, &node_a)| {
64                        object
65                            .into_iter()
66                            .zip(nodes)
67                            .for_each(|(nodal_stiffness, &node_b)| {
68                                nodal_stiffnesses[node_a][node_b] += nodal_stiffness
69                            })
70                    });
71                Ok::<(), VirtualElementError>(())
72            }) {
73            Ok(()) => Ok(()),
74            Err(error) => Err(ElementModelError::Upstream(
75                format!("{error}"),
76                format!("{self:?}"),
77            )),
78        }
79    }
80}