conspire 0.7.6

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

//! Elastic cohesive constitutive models.

use crate::{
    constitutive::{Constitutive, ConstitutiveError, cohesive::Cohesive},
    math::{Current, Quantity, Tensor, TensorArray, TensorRank2, TensorTuple},
    mechanics::{Normal, Separation, Traction},
    units::{Length, Stress, StressPerLength},
};

type Dyad = TensorRank2<3, Current, Current>;
type DyadSeparation = TensorRank2<3, Current, Current, Length>;

pub(crate) type StiffnessCohesive = TensorTuple<
    TensorRank2<3, Current, Current, StressPerLength>,
    TensorRank2<3, Current, Current, Stress>,
>;

/// Required methods for elastic cohesive constitutive models.
pub trait Elastic
where
    Self: Cohesive,
{
    fn traction(
        &self,
        separation: Separation,
        normal: Normal,
    ) -> Result<Traction, ConstitutiveError> {
        let normal_component = &separation * &normal;
        let normal_separation = &normal * normal_component;
        let tangential_separation = separation - normal_separation;
        let tangential_component = tangential_separation.norm();
        let (normal_traction, tangential_traction) =
            self.tractions(normal_component, tangential_component)?;
        if !tangential_component.is_zero() {
            Ok(normal * normal_traction
                + (tangential_separation / tangential_component) * tangential_traction)
        } else {
            Ok(normal * normal_traction)
        }
    }
    /// Calculates and returns the normal and tangential tractions.
    fn tractions(
        &self,
        normal_separation: Quantity<Length>,
        tangential_separation: Quantity<Length>,
    ) -> Result<(Quantity<Stress>, Quantity<Stress>), ConstitutiveError>;
    fn stiffness(
        &self,
        separation: Separation,
        normal: Normal,
    ) -> Result<StiffnessCohesive, ConstitutiveError> {
        let normal_component = &separation * &normal;
        let normal_separation = &normal * normal_component;
        let tangential_separation = &separation - normal_separation;
        let tangential_component = tangential_separation.norm();
        let (normal_traction, tangential_traction) =
            self.tractions(normal_component, tangential_component)?;
        let (k_nn, k_tt) = self.stiffnesses(normal_component, tangential_component)?;
        let (tangent, ratio, q_t) = if !tangential_component.is_zero() {
            (
                tangential_separation / tangential_component,
                normal_component / tangential_component,
                tangential_traction / tangential_component,
            )
        } else {
            (Normal::zero(), Quantity::zero(), k_tt)
        };
        let nn = Dyad::from((&normal, &normal));
        let nu = DyadSeparation::from((&normal, &separation));
        let tt = Dyad::from((&tangent, &tangent));
        let tu = DyadSeparation::from((&tangent, &separation));
        let identity = Dyad::identity();
        let stiffness_u = nn * (k_nn - q_t) + tt * (k_tt - q_t) + &identity * q_t;
        let stiffness_n = nu * (k_nn - q_t)
            + identity * (normal_traction - tangential_traction * ratio)
            - tu * ((k_tt - q_t) * ratio);
        Ok(TensorTuple(stiffness_u, stiffness_n))
    }
    /// Calculates and returns the normal and tangential stiffnesses.
    fn stiffnesses(
        &self,
        normal_separation: Quantity<Length>,
        tangential_separation: Quantity<Length>,
    ) -> Result<(Quantity<StressPerLength>, Quantity<StressPerLength>), ConstitutiveError>;
}

/// The linear elastic cohesive constitutive model.
#[derive(Clone, Debug)]
pub struct LinearElastic {
    /// The normal stiffness $`k_n`$.
    pub normal_stiffness: Quantity<StressPerLength>,
    /// The tangential stiffness $`k_t`$.
    pub tangential_stiffness: Quantity<StressPerLength>,
}

impl Constitutive for LinearElastic {}

impl Cohesive for LinearElastic {}

impl LinearElastic {
    /// Returns the normal stiffness.
    fn normal_stiffness(&self) -> Quantity<StressPerLength> {
        self.normal_stiffness
    }
    /// Returns the tangential stiffness.
    fn tangential_stiffness(&self) -> Quantity<StressPerLength> {
        self.tangential_stiffness
    }
}

impl Elastic for LinearElastic {
    fn tractions(
        &self,
        normal_separation: Quantity<Length>,
        tangential_separation: Quantity<Length>,
    ) -> Result<(Quantity<Stress>, Quantity<Stress>), ConstitutiveError> {
        Ok((
            self.normal_stiffness() * normal_separation,
            self.tangential_stiffness() * tangential_separation,
        ))
    }
    fn stiffnesses(
        &self,
        _normal_separation: Quantity<Length>,
        _tangential_separation: Quantity<Length>,
    ) -> Result<(Quantity<StressPerLength>, Quantity<StressPerLength>), ConstitutiveError> {
        Ok((self.normal_stiffness(), self.tangential_stiffness()))
    }
}