flavio 0.5.0

flavio welcomes you
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

use crate::{
    constitutive::cohesive::{test::SMITHFERRANTEPARAMETERS, SmithFerrante},
    math::test::TestError,
    EPSILON,
};

use super::*;

fn get_reference_coordinates() -> ReferenceNodalCoordinates<N> {
    ReferenceNodalCoordinates::new([
        [0.0, 0.0, 0.0],
        [1.0, 0.0, 0.0],
        [0.0, 1.0, 0.0],
        [0.0, 0.0, 0.0],
        [1.0, 0.0, 0.0],
        [0.0, 1.0, 0.0],
    ])
}

fn get_coordinates() -> NodalCoordinates<N> {
    NodalCoordinates::new([
        [0.0, 0.0, 0.0],
        [1.0, 0.0, 0.0],
        [0.0, 1.0, 0.0],
        [0.0, 0.0, 1.0],
        [1.0, 0.0, 2.0],
        [0.0, 1.0, 3.0],
    ])
}

fn get_velocities() -> NodalVelocities<N> {
    NodalVelocities::new([
        [0.0, 0.0, 0.0],
        [1.0, 0.0, 0.0],
        [0.0, 1.0, 0.0],
        [0.0, 0.0, 1.0],
        [1.0, 0.0, 2.0],
        [0.0, 1.0, 3.0],
    ])
}

#[test]
fn zero() -> Result<(), TestError> {
    let element = Wedge::<SmithFerrante>::new(SMITHFERRANTEPARAMETERS, get_reference_coordinates());
    element
        .calculate_nodal_forces(&get_reference_coordinates().into())?
        .iter()
        .for_each(|nodal_force| {
            nodal_force
                .iter()
                .for_each(|nodal_force_i| assert_eq!(nodal_force_i, &0.0))
        });
    Ok(())
}

#[test]
fn finite_difference() -> Result<(), TestError> {
    let element = Wedge::<SmithFerrante>::new(SMITHFERRANTEPARAMETERS, get_reference_coordinates());
    let mut finite_difference = 0.0;
    element
        .calculate_nodal_stiffnesses(&get_coordinates())?
        .iter()
        .enumerate()
        .try_for_each(|(a, nodal_stiffness_a)| {
            nodal_stiffness_a
                .iter()
                .enumerate()
                .try_for_each(|(b, nodal_stiffness_ab)| {
                    nodal_stiffness_ab.iter().enumerate().try_for_each(
                        |(i, nodal_stiffness_ab_i)| {
                            nodal_stiffness_ab_i.iter().enumerate().try_for_each(
                                |(j, nodal_stiffness_ab_ij)| {
                                    let mut nodal_coordinates = get_coordinates();
                                    nodal_coordinates[b][j] += 0.5 * EPSILON;
                                    finite_difference =
                                        element.calculate_nodal_forces(&nodal_coordinates)?[a][i];
                                    nodal_coordinates[b][j] -= EPSILON;
                                    finite_difference -=
                                        element.calculate_nodal_forces(&nodal_coordinates)?[a][i];
                                    finite_difference /= EPSILON;
                                    assert!(
                                        (nodal_stiffness_ab_ij / finite_difference - 1.0).abs()
                                            < EPSILON
                                    );
                                    Ok(())
                                },
                            )
                        },
                    )
                })
        })
}

#[test]
#[should_panic]
fn calculate_deformation_gradient() {
    Wedge::<SmithFerrante>::new(SMITHFERRANTEPARAMETERS, get_reference_coordinates())
        .calculate_deformation_gradient(&get_coordinates());
}

#[test]
#[should_panic]
fn calculate_deformation_gradient_rate() {
    Wedge::<SmithFerrante>::new(SMITHFERRANTEPARAMETERS, get_reference_coordinates())
        .calculate_deformation_gradient_rate(&get_coordinates(), &get_velocities());
}

#[test]
#[should_panic]
fn calculate_gradient_vectors() {
    Wedge::<SmithFerrante>::calculate_gradient_vectors(
        &Wedge::<SmithFerrante>::calculate_midplane(&get_reference_coordinates()),
    );
}

#[test]
#[should_panic]
fn get_gradient_vectors() {
    Wedge::<SmithFerrante>::new(SMITHFERRANTEPARAMETERS, get_reference_coordinates())
        .get_gradient_vectors();
}

#[test]
#[should_panic]
fn calculate_deformation_gradient_linear_surface_element() {
    Wedge::<SmithFerrante>::new(SMITHFERRANTEPARAMETERS, get_reference_coordinates())
        .calculate_deformation_gradient_linear_surface_element(
            &Wedge::<SmithFerrante>::calculate_midplane(&get_coordinates()),
        );
}

#[test]
#[should_panic]
fn calculate_deformation_gradient_rate_linear_surface_element() {
    Wedge::<SmithFerrante>::new(SMITHFERRANTEPARAMETERS, get_reference_coordinates())
        .calculate_deformation_gradient_rate_linear_surface_element(
            &Wedge::<SmithFerrante>::calculate_midplane(&get_coordinates()),
            &Wedge::<SmithFerrante>::calculate_midplane(&get_velocities()),
        );
}

#[test]
#[should_panic]
fn calculate_gradient_vectors_linear_surface_element() {
    Wedge::<SmithFerrante>::calculate_gradient_vectors_linear_surface_element(&Wedge::<
        SmithFerrante,
    >::calculate_midplane(
        &get_reference_coordinates(),
    ));
}

#[test]
#[should_panic]
fn get_reference_normal() {
    Wedge::<SmithFerrante>::new(SMITHFERRANTEPARAMETERS, get_reference_coordinates())
        .get_reference_normal();
}