Datasets:

License:
File size: 3,138 Bytes
76cb30c
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
from numpy import zeros, ndarray, sum
from numpy.linalg import eig
def voigt_array_to_tensor(voigt_array: ndarray, dimension: int) -> ndarray:
    tensor = zeros(shape=(dimension, dimension))
    if dimension == 2:
        tensor[0, 0] = voigt_array[0]
        tensor[1, 1] = voigt_array[1]
        tensor[0, 1] = voigt_array[2]
        tensor[1, 0] = voigt_array[2]
    elif dimension == 3:
        tensor[0, 0] = voigt_array[0]
        tensor[1, 1] = voigt_array[1]
        tensor[2, 2] = voigt_array[2]
        tensor[0, 1] = voigt_array[3]
        tensor[0, 2] = voigt_array[4]
        tensor[1, 2] = voigt_array[5]
        tensor[1, 0] = voigt_array[3]
        tensor[2, 0] = voigt_array[4]
        tensor[2, 1] = voigt_array[5]
    return tensor
def get_decompose_energy(strain: ndarray, stress: ndarray, dimension: int):
    E = 1.0e5
    nu = 0.25
    mu = E / (2.0 * (1.0 + nu))
    lame = (E * nu) / ((1.0 + nu) * (1.0 - 2.0 * nu))
    strain = voigt_array_to_tensor(strain, dimension)
    principle_strain_value, principle_strain_vector = eig(strain)
    energy_positive = 0.0
    energy_negative = 0.0
    if dimension == 2:
        ep1 = max(principle_strain_value)
        ep2 = min(principle_strain_value)
        eq_sum = sum(principle_strain_value)
        if ep1 > 0.0:
            ep1_p = (abs(ep1) + ep1) / 2.0
            ep1_n = 0.0
        else:
            ep1_p = 0.0
            ep1_n = (abs(ep1) - ep1) / 2.0
        if ep2 > 0.0:
            ep2_p = (abs(ep2) + ep2) / 2.0
            ep2_n = 0.0
        else:
            ep2_p = 0.0
            ep2_n = (abs(ep2) - ep2) / 2.0
        if eq_sum > 0.0:
            eq_sum_p = (abs(eq_sum) + eq_sum) / 2.0
            eq_sum_n = 0.0
        else:
            eq_sum_p = 0.0
            eq_sum_n = (abs(eq_sum) - eq_sum) / 2.0
        energy_positive = lame / 2.0 * eq_sum_p ** 2.0 + mu * (ep1_p ** 2.0 + ep2_p ** 2.0)
        energy_negative = lame / 2.0 * eq_sum_n ** 2.0 + mu * (ep1_n ** 2.0 + ep2_n ** 2.0)
    elif dimension == 3:
        ep1 = max(principle_strain_value)
        ep3 = min(principle_strain_value)
        eq_sum = sum(principle_strain_value)
        ep2 = eq_sum - ep1 - ep3
        if ep1 > 0.0:
            ep1_p = (abs(ep1) + ep1) / 2.0
            ep1_n = 0.0
        else:
            ep1_p = 0.0
            ep1_n = (abs(ep1) - ep1) / 2.0
        if ep2 > 0.0:
            ep2_p = (abs(ep2) + ep2) / 2.0
            ep2_n = 0.0
        else:
            ep2_p = 0.0
            ep2_n = (abs(ep2) - ep2) / 2.0
        if ep3 > 0.0:
            ep3_p = (abs(ep3) + ep3) / 2.0
            ep3_n = 0.0
        else:
            ep3_p = 0.0
            ep3_n = (abs(ep3) - ep3) / 2.0
        if eq_sum > 0.0:
            eq_sum_p = (abs(eq_sum) + eq_sum) / 2.0
            eq_sum_n = 0.0
        else:
            eq_sum_p = 0.0
            eq_sum_n = (abs(eq_sum) - eq_sum) / 2.0
        energy_positive = lame / 2.0 * eq_sum_p ** 2.0 + mu * (ep1_p ** 2.0 + ep2_p ** 2.0 + ep3_p ** 2.0)
        energy_negative = lame / 2.0 * eq_sum_n ** 2.0 + mu * (ep1_n ** 2.0 + ep2_n ** 2.0 + ep3_n ** 2.0)
    return energy_positive, energy_negative