codes/material.py at master · meierms1/codes · GitHub

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
# Author: Maycon Meier
# Source: https://en.wikipedia.org/wiki/Shear_modulus

# Description: Computes all property values for a given material

# Parameters: Provide at least 2 from K, G, E, lame, Poisson
# Attribuites: K, G, E, lame, Poisson, display, display_long
# Methods: UpdateAll, BulkModulus, YoungModulus, LameFirst, ShearModulus, vPoisson

# Usage: from material import material; variable_name = material(K = num1, G = num2); variable_name.display

import numpy as np

class material:
    def __init__(self, K = -1, E = -1, lame = -1, G = -1, Poisson = -1):
        self.K = K
        self.E = E
        self.lame = lame
        self.G = G
        self.Poisson = Poisson

        count = 0
        for i in [self.K, self.E, self.lame, self.G, self.Poisson]:
            if i == -1:
                count += 1
        if count > 3:
            raise TypeError("Provide at least two property values from the list: (K, E, G, lame, Poisson)")

        self.var = ""
        if   (self.K >= 0):
            if   (self.E >= 0): self.var = "K,E"
            elif (self.lame >= 0): self.var = "K,lame"
            elif (self.G >= 0): self.var = "K,G"
            elif (self.Poisson >= 0): self.var = "K,Poisson"
        elif (self.E >= 0):
            if   (self.lame >= 0): self.var = "E,lame"
            elif (self.G >= 0): self.var = "E,G"
            elif (self.Poisson >= 0): self.var = "E,Poisson"
        elif (self.lame >= 0):
            if   (self.G >= 0): self.var = "lame,G"
            elif (self.Poisson >= 0): self.var = "lame,Poisson"
        elif (self.G >= 0 and self.Poisson >= 0): self.var = "G,Poisson"
        else: raise TypeError("Wrong Input Parameters")

        self.UpdateAll()

        self.display = "Bulk Modulus = " + str(float("{:.2f}".format(self.K)))  + " | Young Modulus = " + str(float("{:.2f}".format(self.E))) + " | Shear Modulus = " + str(float("{:.2f}".format(self.G))) + " | Lame First Parameter = " + str(float("{:.2f}".format(self.lame))) + " | Poisson Coeficient = " + str(float("{:.2f}".format(self.Poisson)))
        self.display_long = "Bulk Modulus = " + str(self.K)  + " | Young Modulus = " + str(self.E) + " | Shear Modulus = " + str(self.G) + " | Lame First Parameter = " + str(self.lame) + " | Poisson Coeficient = " + str(self.Poisson)

    def UpdateAll(self):
        self.K = self.BulkModulus()
        self.E = self.YoungModulus()
        self.lame = self.LameFirst()
        self.G = self.ShearModulus()
        self.Poisson = self.vPoisson()
        return

    def BulkModulus(self):
        if (self.K != -1): return self.K

        if   (self.var == "E,lame"):
            R = np.sqrt(self.E ** 2 + 9.0 * self.lame ** 2 + 2.0 * self.E * self.lame)
            return (self.E + self.lame * 3.0 + R) / 6.0
        elif (self.var == "E,G"):
            return (self.E * self.G) / 3.0 / (3.0 * self.G - self.E)
        elif (self.var == "E,Poisson"):
            return self.E / 3.0 / (1.0 - 2.0 * self.Poisson)
        elif (self.var == "lame,G"):
            return self.lame + ((2.0 * self.G) / 3.0)
        elif (self.var == "lame,Poisson"):
            return self.lame * (1.0 +self.Poisson) / (3.0 * self.Poisson)
        elif (self.var == "G,Poisson"):
            return 2.0 * self.G * (1.0 + self.Poisson) / 3.0 / (1.0 - 2.0 * self.Poisson)
        else: raise TypeError("Wrong Input Parameters")

    def YoungModulus(self):
        if (self.E != -1): return self.E

        if   (self.var == "K,lame"):
            return 9.0 * self.K * (self.K - self.lame) / (3.0 * self.K - self.lame)
        elif (self.var == "K,G"):
            return 9.0 * self.K * self.G / (3.0 * self.K + self.G)
        elif (self.var == "K,Poisson"):
            return 3.0 * self.K * (1.0 - 2.0 * self.Poisson)
        elif (self.var == "lame,G"):
            return self.G * (3.0 * self.lame + 2.0 * self.G) / (self.lame + self.G)
        elif (self.var == "lame,Poisson"):
            return self.lame * (1.0 - self.Poisson) * (1.0 - 2.0 * self.Poisson) / self.Poisson
        elif (self.var == "G,Poisson"):
            return 2.0 * self.G * (1.0 + self.Poisson)
        else: raise TypeError("Wrong Input Parameters")

    def LameFirst(self):
        if (self.lame != -1): return self.lame

        if   (self.var == "K,E"):
            return 3.0 * self.K * (3.0 * self.K - self.E) / (9.0 * self.K - self.E)
        elif (self.var == "K,G"):
            return self.K - 2.0 * self.G / 3.0
        elif (self.var == "K,Poisson"):
            return 3.0 * self.K * self.Poisson / (1.0 + self.Poisson)
        elif (self.var == "E,G"):
            return self.G * (self.E - 2.0 * self.G) / (3.0 * self.G - self.E)
        elif (self.var == "E,Poisson"):
            return self.E * self.Poisson / ((1.0 + self.Poisson) * (1.0 - 2.0 * self.Poisson))
        elif (self.var == "G,Poisson"):
            return 2.0 * self.G * self.Poisson / (1.0 - 2.0 * self.Poisson)
        else: raise TypeError("Wrong Input Parameters")

    def ShearModulus(self):
        if (self.G != -1): return self.G

        if   (self.var == "K,E"):
            return 3.0 * self.K * self.E / (9.0 * self.K - self.E)
        elif (self.var == "K,lame"):
            return 3.0 * (self.K - self.lame) / 2.0
        elif (self.var == "K,Poisson"):
            return 3.0 * self.K * (1.0 - 2.0 * self.Poisson) / 2.0 / (1.0 + self.Poisson)
        elif (self.var == "E,lame"):
            R = np.sqrt(self.E ** 2 + 9.0 * self.lame ** 2 + 2.0 * self.E * self.lame)
            return (self.E - 3.0 * self.lame + R) / 4.0
        elif (self.var == "E,Poisson"):
            return self.E / 2.0 / (1.0 + self.Poisson)
        elif (self.var == "lame,Poisson"):
            return self.lame * (1.0 - 2.0 * self.Poisson) / 2.0 / self.Poisson
        else: raise TypeError("Wrong Input Parameters")

    def vPoisson(self):
        if (self.Poisson != -1): return self.Poisson

        if   (self.var == "K,E"):
            return (3.0 * self.K - self.E) / 6.0 / self.K
        elif (self.var == "K,lame"):
            return self.lame / (3.0 * self.K - self.lame)
        elif (self.var == "K,G"):
            return (3.0 * self.K - 2.0 * self.G) / 2.0 / (3.0 * self.K + self.G)
        elif (self.var == "E,lame"):
            R = np.sqrt(self.E ** 2 + 9.0 * self.lame ** 2 + 2.0 * self.E * self.lame)
            return 2.0 * self.lame / (self.E + self.lame + R)
        elif (self.var == "E,G"):
            return (self.E / 2.0 / self.G) - 1.0
        elif (self.var == "lame,G"):
            return self.lame / 2.0 / (self.lame + self.G)
        else: raise TypeError("Wrong Input Parameters")