Upload 76 files
Browse filesThis view is limited to 50 files because it contains too many changes. See raw diff
- 01.py +4 -0
- 02.py +4 -0
- 03.py +15 -0
- 04.py +16 -0
- 05.py +23 -0
- 06.py +22 -0
- 07.py +21 -0
- 08.py +36 -0
- 09.py +40 -0
- 10.py +19 -0
- 100.py +29 -0
- 11.py +32 -0
- 110.py +26 -0
- 112.py +14 -0
- 12.py +36 -0
- 14.py +3 -0
- 15.py +18 -0
- 16.py +2 -0
- 17.py +2 -0
- 18.py +2 -0
- 19.py +15 -0
- 20.py +28 -0
- 21.py +37 -0
- 22.py +33 -0
- 23.py +37 -0
- 24.py +32 -0
- 25.py +77 -0
- 26.py +75 -0
- 27.py +33 -0
- 28.py +38 -0
- 31.py +23 -0
- 32.py +5 -0
- 33.py +9 -0
- 34.py +11 -0
- 35.py +16 -0
- 36.py +18 -0
- 37.py +18 -0
- 38.py +29 -0
- 39.py +21 -0
- 40.py +25 -0
- 41.py +37 -0
- 42.py +29 -0
- 43.py +29 -0
- 44.py +13 -0
- 45.py +7 -0
- 46.py +19 -0
- 47.py +50 -0
- 48.py +85 -0
- 49.py +8 -0
- 53.py +11 -0
01.py
ADDED
|
@@ -0,0 +1,4 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
def plane_strain_isotropic(e, nu):
|
| 2 |
+
from numpy import array
|
| 3 |
+
d = (array([[1.0 - nu, nu, 0.0],[nu, 1.0 - nu, 0.0],[0.0, 0.0, (1.0 - 2.0 * nu) / 2.0]])* e / ((1.0 + nu) * (1.0 - 2.0 * nu)))
|
| 4 |
+
return d
|
02.py
ADDED
|
@@ -0,0 +1,4 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
def plane_stress_isotropic(e, nu):
|
| 2 |
+
from numpy import array
|
| 3 |
+
d = array([[1.0, nu, 0.0],[nu, 1.0, 0.0],[0.0, 0.0, (1.0 - nu)/ 2.0]]) * e / (1.0 - nu * nu)
|
| 4 |
+
return d
|
03.py
ADDED
|
@@ -0,0 +1,15 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
def iso_quad(element_nodes, xi, eta):
|
| 2 |
+
from numpy import sum,array
|
| 3 |
+
from numpy.linalg import det
|
| 4 |
+
from numpy.linalg import inv
|
| 5 |
+
shape = array([(1.0 - xi) * (1.0 - eta) / 4.0,(1.0 + xi) * (1.0 - eta) / 4.0,(1.0 + xi) * (1.0 + eta) / 4.0,(1.0 - xi) * (1.0 + eta) / 4.0])
|
| 6 |
+
shape_dxi = array([-(1.0 - eta) / 4.0,(1.0 - eta) / 4.0,(1.0 + eta) / 4.0,-(1.0 + eta) / 4.0])
|
| 7 |
+
shape_deta = array([-(1.0 - xi) / 4.0,-(1.0 + xi) / 4.0,(1.0 + xi) / 4.0,(1.0 - xi) / 4.0])
|
| 8 |
+
x = element_nodes[:, 0]
|
| 9 |
+
y = element_nodes[:, 1]
|
| 10 |
+
jacobi = array([[sum(shape_dxi * x), sum(shape_dxi * y)],[sum(shape_deta * x), sum(shape_deta * y)]])
|
| 11 |
+
jacobian = det(jacobi)
|
| 12 |
+
inverted_jacobi = inv(jacobi)
|
| 13 |
+
shape_dx = inverted_jacobi[0, 0] * shape_dxi + inverted_jacobi[0, 1] * shape_deta
|
| 14 |
+
shape_dy = inverted_jacobi[1, 0] * shape_dxi + inverted_jacobi[1, 1] * shape_deta
|
| 15 |
+
return jacobian, shape, shape_dx, shape_dy
|
04.py
ADDED
|
@@ -0,0 +1,16 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
def iso_triangle(element_nodes, xi, eta):
|
| 2 |
+
from numpy import array
|
| 3 |
+
from numpy import sum
|
| 4 |
+
from numpy.linalg import det
|
| 5 |
+
from numpy.linalg import inv
|
| 6 |
+
shape = array([1.0 - xi - eta,xi,eta])
|
| 7 |
+
shape_dxi = array([-1.0,1.0,0.0])
|
| 8 |
+
shape_deta = array([-1.0,0.0,1.0])
|
| 9 |
+
x = element_nodes[:, 0]
|
| 10 |
+
y = element_nodes[:, 1]
|
| 11 |
+
jacobi = array([[sum(shape_dxi * x), sum(shape_dxi * y)],[sum(shape_deta * x), sum(shape_deta * y)]])
|
| 12 |
+
jacobian = det(jacobi)
|
| 13 |
+
inverted_jacobi = inv(jacobi)
|
| 14 |
+
shape_dx = inverted_jacobi[0, 0] * shape_dxi + inverted_jacobi[0, 1] * shape_deta
|
| 15 |
+
shape_dy = inverted_jacobi[1, 0] * shape_dxi + inverted_jacobi[1, 1] * shape_deta
|
| 16 |
+
return jacobian, shape, shape_dx, shape_dy
|
05.py
ADDED
|
@@ -0,0 +1,23 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import array
|
| 2 |
+
def legendre_interval(count):
|
| 3 |
+
from math import sqrt
|
| 4 |
+
if count <= 1:
|
| 5 |
+
p = array([0.0])
|
| 6 |
+
w = array([2.0])
|
| 7 |
+
return p, w
|
| 8 |
+
elif count == 2:
|
| 9 |
+
p = array([-1.0 / sqrt(3.0),1.0 / sqrt(3.0)])
|
| 10 |
+
w = array([1.0,1.0])
|
| 11 |
+
return p, w
|
| 12 |
+
elif count == 3:
|
| 13 |
+
p = array([-sqrt(3.0 / 5.0),0.0,sqrt(3.0 / 5.0)])
|
| 14 |
+
w = array([5.0 / 9.0,8.0 / 9.0,5.0 / 9.0])
|
| 15 |
+
return p, w
|
| 16 |
+
elif count == 4:
|
| 17 |
+
p = array([-sqrt((3.0 + 2.0 * sqrt(6.0 / 5.0)) / 7.0),-sqrt((3.0 - 2.0 * sqrt(6.0 / 5.0)) / 7.0),sqrt((3.0 - 2.0 * sqrt(6.0 / 5.0)) / 7.0), sqrt((3.0 + 2.0 * sqrt(6.0 / 5.0)) / 7.0)])
|
| 18 |
+
w = array([(18.0 - sqrt(30.0)) / 36.0,(18.0 + sqrt(30.0)) / 36.0,(18.0 + sqrt(30.0)) / 36.0,(18.0 - sqrt(30.0)) / 36.0])
|
| 19 |
+
return p, w
|
| 20 |
+
else:
|
| 21 |
+
p = array([-(1.0 / 3.0) * sqrt(5.0 + 2.0 * sqrt(10.0 / 7.0)),-(1.0 / 3.0) * sqrt(5.0 - 2.0 * sqrt(10.0 / 7.0)),0.0,(1.0 / 3.0) * sqrt(5.0 - 2.0 * sqrt(10.0 / 7.0)),(1.0 / 3.0) * sqrt(5.0 + 2.0 * sqrt(10.0 / 7.0))])
|
| 22 |
+
w = array([(322.0 - 13.0 * sqrt(70.0)) / 900.0,(322.0 + 13.0 * sqrt(70.0)) / 900.0,128.0 / 225.0,(322.0 + 13.0 * sqrt(70.0)) / 900.0,(322.0 - 13.0 * sqrt(70.0)) / 900.0])
|
| 23 |
+
return p, w
|
06.py
ADDED
|
@@ -0,0 +1,22 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import array
|
| 2 |
+
def legendre_triangle(order):
|
| 3 |
+
if order <= 1:
|
| 4 |
+
xi = array([1.0 / 3.0])
|
| 5 |
+
eta = array([1.0 / 3.0])
|
| 6 |
+
w = array([1.0 / 2.0])
|
| 7 |
+
return xi, eta, w
|
| 8 |
+
elif order == 2:
|
| 9 |
+
xi = array([1.0 / 2.0, 0.0,1.0 / 2.0])
|
| 10 |
+
eta = array([1.0 / 2.0,1.0 / 2.0,0.0])
|
| 11 |
+
w = array([1.0 / 6.0,1.0 / 6.0,1.0 / 6.0])
|
| 12 |
+
return xi, eta, w
|
| 13 |
+
elif order == 3:
|
| 14 |
+
xi = array([1.0 / 6.0,2.0 / 3.0,1.0 / 6.0])
|
| 15 |
+
eta = array([1.0 / 6.0, 1.0 / 6.0, 2.0 / 3.0])
|
| 16 |
+
w = array([1.0 / 6.0, 1.0 / 6.0, 1.0 / 6.0])
|
| 17 |
+
return xi, eta, w
|
| 18 |
+
else:
|
| 19 |
+
xi = array([1.0 / 3.0, 1.0 / 5.0, 1.0 / 5.0, 3.0 / 5.0])
|
| 20 |
+
eta = array([1.0 / 3.0,3.0 / 5.0,1.0 / 5.0,1.0 / 5.0])
|
| 21 |
+
w = array([-9.0 / 32.0,25.0 / 96.0, 25.0 / 96.0,25.0 / 96.0])
|
| 22 |
+
return xi, eta, w
|
07.py
ADDED
|
@@ -0,0 +1,21 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import array
|
| 2 |
+
def legendre_tetrahedra(order):
|
| 3 |
+
from math import sqrt
|
| 4 |
+
if order <= 1:
|
| 5 |
+
xi = array([0.25])
|
| 6 |
+
eta = array([0.25])
|
| 7 |
+
mu = array([0.25])
|
| 8 |
+
w = array([1.0]) / 6.0
|
| 9 |
+
return xi, eta, mu, w
|
| 10 |
+
elif order == 2:
|
| 11 |
+
xi = array([(5.0 + 3.0 * sqrt(5.0)) / 20.0,(5.0 - sqrt(5.0)) / 20.0, (5.0 - sqrt(5.0)) / 20.0, (5.0 - sqrt(5.0)) / 20.0])
|
| 12 |
+
eta = array([(5.0 - sqrt(5.0)) / 20.0, (5.0 + 3.0 * sqrt(5.0)) / 20.0, (5.0 - sqrt(5.0)) / 20.0, (5.0 - sqrt(5.0)) / 20.0])
|
| 13 |
+
mu = array([(5.0 - sqrt(5.0)) / 20.0, (5.0 - sqrt(5.0)) / 20.0, (5.0 + 3.0 * sqrt(5.0)) / 20.0, (5.0 - sqrt(5.0)) / 20.0])
|
| 14 |
+
w = array([0.25, 0.25,0.25, 0.25]) / 6.0
|
| 15 |
+
return xi, eta, mu, w
|
| 16 |
+
else:
|
| 17 |
+
xi = array([1.0 / 4.0, 1.0 / 2.0, 1.0 / 6.0, 1.0 / 6.0, 1.0 / 6.0])
|
| 18 |
+
eta = array([1.0 / 4.0, 1.0 / 6.0, 1.0 / 2.0, 1.0 / 6.0, 1.0 / 6.0])
|
| 19 |
+
mu = array([1.0 / 4.0, 1.0 / 6.0, 1.0 / 6.0, 1.0 / 2.0,1.0 / 6.0])
|
| 20 |
+
w = array([-4.0 / 5.0, 9.0 / 20.0, 9.0 / 20.0, 9.0 / 20.0,9.0 / 20.0]) / 6.0
|
| 21 |
+
return xi, eta, mu, w
|
08.py
ADDED
|
@@ -0,0 +1,36 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import *
|
| 2 |
+
def legendre_interval(count):
|
| 3 |
+
from math import sqrt
|
| 4 |
+
if count <= 1:
|
| 5 |
+
p = array([0.0])
|
| 6 |
+
w = array([2.0])
|
| 7 |
+
return p, w
|
| 8 |
+
elif count == 2:
|
| 9 |
+
p = array([-1.0 / sqrt(3.0), 1.0 / sqrt(3.0)])
|
| 10 |
+
w = array([1.0, 1.0])
|
| 11 |
+
return p, w
|
| 12 |
+
elif count == 3:
|
| 13 |
+
p = array([-sqrt(3.0 / 5.0), 0.0, sqrt(3.0 / 5.0)])
|
| 14 |
+
w = array([5.0 / 9.0, 8.0 / 9.0, 5.0 / 9.0])
|
| 15 |
+
return p, w
|
| 16 |
+
elif count == 4:
|
| 17 |
+
p = array([-sqrt((3.0 + 2.0 * sqrt(6.0 / 5.0)) / 7.0), -sqrt((3.0 - 2.0 * sqrt(6.0 / 5.0)) / 7.0), sqrt((3.0 - 2.0 * sqrt(6.0 / 5.0)) / 7.0), sqrt((3.0 + 2.0 * sqrt(6.0 / 5.0)) / 7.0)])
|
| 18 |
+
w = array([(18.0 - sqrt(30.0)) / 36.0, (18.0 + sqrt(30.0)) / 36.0, (18.0 + sqrt(30.0)) / 36.0, (18.0 - sqrt(30.0)) / 36.0])
|
| 19 |
+
return p, w
|
| 20 |
+
else:
|
| 21 |
+
p = array([-(1.0 / 3.0) * sqrt(5.0 + 2.0 * sqrt(10.0 / 7.0)), -(1.0 / 3.0) * sqrt(5.0 - 2.0 * sqrt(10.0 / 7.0)), 0.0, (1.0 / 3.0) * sqrt(5.0 - 2.0 * sqrt(10.0 / 7.0)), (1.0 / 3.0) * sqrt(5.0 + 2.0 * sqrt(10.0 / 7.0))])
|
| 22 |
+
w = array([(322.0 - 13.0 * sqrt(70.0)) / 900.0, (322.0 + 13.0 * sqrt(70.0)) / 900.0, 128.0 / 225.0, (322.0 + 13.0 * sqrt(70.0)) / 900.0, (322.0 - 13.0 * sqrt(70.0)) / 900.0])
|
| 23 |
+
return p, w
|
| 24 |
+
def legendre_quad(order):
|
| 25 |
+
from numpy import zeros
|
| 26 |
+
(p, w) = legendre_interval(order)
|
| 27 |
+
size = len(p)
|
| 28 |
+
xi = zeros(size * size)
|
| 29 |
+
eta = zeros(size * size)
|
| 30 |
+
weight = zeros(size * size)
|
| 31 |
+
for i in range(size):
|
| 32 |
+
for j in range(size):
|
| 33 |
+
xi[i * size + j] = p[i]
|
| 34 |
+
eta[i * size + j] = p[j]
|
| 35 |
+
weight[i * size + j] = w[i] * w[j]
|
| 36 |
+
return xi, eta, weight
|
09.py
ADDED
|
@@ -0,0 +1,40 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import *
|
| 2 |
+
def legendre_interval(count):
|
| 3 |
+
from math import sqrt
|
| 4 |
+
if count <= 1:
|
| 5 |
+
p = array([0.0])
|
| 6 |
+
w = array([2.0])
|
| 7 |
+
return p, w
|
| 8 |
+
elif count == 2:
|
| 9 |
+
p = array([-1.0 / sqrt(3.0), 1.0 / sqrt(3.0)])
|
| 10 |
+
w = array([1.0, 1.0])
|
| 11 |
+
return p, w
|
| 12 |
+
elif count == 3:
|
| 13 |
+
p = array([-sqrt(3.0 / 5.0), 0.0, sqrt(3.0 / 5.0)])
|
| 14 |
+
w = array([5.0 / 9.0, 8.0 / 9.0, 5.0 / 9.0])
|
| 15 |
+
return p, w
|
| 16 |
+
elif count == 4:
|
| 17 |
+
p = array([-sqrt((3.0 + 2.0 * sqrt(6.0 / 5.0)) / 7.0), -sqrt((3.0 - 2.0 * sqrt(6.0 / 5.0)) / 7.0), sqrt((3.0 - 2.0 * sqrt(6.0 / 5.0)) / 7.0), sqrt((3.0 + 2.0 * sqrt(6.0 / 5.0)) / 7.0)])
|
| 18 |
+
w = array([(18.0 - sqrt(30.0)) / 36.0, (18.0 + sqrt(30.0)) / 36.0, (18.0 + sqrt(30.0)) / 36.0, (18.0 - sqrt(30.0)) / 36.0])
|
| 19 |
+
return p, w
|
| 20 |
+
else:
|
| 21 |
+
p = array([-(1.0 / 3.0) * sqrt(5.0 + 2.0 * sqrt(10.0 / 7.0)), -(1.0 / 3.0) * sqrt(5.0 - 2.0 * sqrt(10.0 / 7.0)), 0.0, (1.0 / 3.0) * sqrt(5.0 - 2.0 * sqrt(10.0 / 7.0)), (1.0 / 3.0) * sqrt(5.0 + 2.0 * sqrt(10.0 / 7.0))])
|
| 22 |
+
w = array([(322.0 - 13.0 * sqrt(70.0)) / 900.0, (322.0 + 13.0 * sqrt(70.0)) / 900.0, 128.0 / 225.0, (322.0 + 13.0 * sqrt(70.0)) / 900.0, (322.0 - 13.0 * sqrt(70.0)) / 900.0])
|
| 23 |
+
return p, w
|
| 24 |
+
def legendre_hexahedra(order):
|
| 25 |
+
from numpy import zeros
|
| 26 |
+
(p, w) = legendre_interval(order)
|
| 27 |
+
size = len(p)
|
| 28 |
+
xi = zeros(size * size * size)
|
| 29 |
+
eta = zeros(size * size * size)
|
| 30 |
+
mu = zeros(size * size * size)
|
| 31 |
+
weight = zeros(size * size * size)
|
| 32 |
+
size_size = size * size
|
| 33 |
+
for i in range(size):
|
| 34 |
+
for j in range(size):
|
| 35 |
+
for k in range(size):
|
| 36 |
+
xi[i * size_size + j * size + k] = p[i]
|
| 37 |
+
eta[i * size_size + j * size + k] = p[j]
|
| 38 |
+
mu[i * size_size + j * size + k] = p[k]
|
| 39 |
+
weight[i * size_size + j * size + k] = w[i] * w[j] * w[k]
|
| 40 |
+
return xi, eta, mu, weight
|
10.py
ADDED
|
@@ -0,0 +1,19 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
def lobatto_interval(count):
|
| 2 |
+
from math import sqrt
|
| 3 |
+
from numpy import array
|
| 4 |
+
if count <= 2:
|
| 5 |
+
p = array([-1.0, 1.0])
|
| 6 |
+
w = array([1.0, 1.0])
|
| 7 |
+
return p, w
|
| 8 |
+
elif count == 3:
|
| 9 |
+
p = array([-1.0, 0.0, 1.0])
|
| 10 |
+
w = array([1.0 / 3.0, 4.0 / 3.0, 1.0 / 3.0])
|
| 11 |
+
return p, w
|
| 12 |
+
elif count == 4:
|
| 13 |
+
p = array([-1.0, -1.0 / sqrt(5.0), 1.0 / sqrt(5.0), 1.0])
|
| 14 |
+
w = array([1.0 / 6.0, 5.0 / 6.0, 5.0 / 6.0, 1.0 / 6.0])
|
| 15 |
+
return p, w
|
| 16 |
+
else:
|
| 17 |
+
p = array([-1.0, -sqrt(3.0 / 7.0), 0.0, sqrt(3.0 / 7.0), 1.0])
|
| 18 |
+
w = array([1.0 / 10.0, 49.0 / 90.0, 32.0 / 45.0, 49.0 / 90.0, 1.0 / 10.0])
|
| 19 |
+
return p, w
|
100.py
ADDED
|
@@ -0,0 +1,29 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import *
|
| 2 |
+
from scipy.linalg import inv
|
| 3 |
+
from itertools import chain
|
| 4 |
+
def get_D(E, v):
|
| 5 |
+
return (E / (1 - v ** 2)) * array([ [1, v, 0], [v, 1, 0], [0, 0, 0.5 * (1 - v)] ])
|
| 6 |
+
def compute_stress_quad9(disp, material, nodes):
|
| 7 |
+
def partials(xi, eta):
|
| 8 |
+
return 0.25 * array([ [(2 * xi - 1) * eta * (eta - 1), (2 * xi + 1) * eta * (eta - 1), (2 * xi + 1) * eta * (eta + 1), (2 * xi - 1) * eta * (eta + 1), -4 * xi * eta * (eta - 1), 2 * (2 * xi + 1) * (1 - eta ** 2), -4 * xi * eta * (1 + eta), 2 * (2 * xi - 1) * (1 - eta ** 2), -8 * xi * (1 - eta ** 2)], [xi * (xi - 1) * (2 * eta - 1), xi * (xi + 1) * (2 * eta - 1), xi * (xi + 1) * (2 * eta + 1), xi * (xi - 1) * (2 * eta + 1), 2 * (1 - xi ** 2) * (2 * eta - 1), -4 * xi * (xi + 1) * eta, 2 * (1 - xi ** 2) * (2 * eta + 1), -4 * xi * (xi - 1) * eta, -8 * (1 - xi ** 2) * eta] ])
|
| 9 |
+
def Jacobi(xi, eta):
|
| 10 |
+
p = partials(xi, eta)
|
| 11 |
+
coords = row_stack(nodes)
|
| 12 |
+
return dot(p, nodes)
|
| 13 |
+
def partial_xy(xi, eta):
|
| 14 |
+
J = Jacobi(xi, eta)
|
| 15 |
+
partial_xe = partials(xi, eta)
|
| 16 |
+
return dot(inv(J), partial_xe)
|
| 17 |
+
def B(xi, eta):
|
| 18 |
+
p = partial_xy(xi, eta)
|
| 19 |
+
zeros9 = [0 for i in range(9)]
|
| 20 |
+
return array([ list(chain(*zip(p[0, :], zeros9))), list(chain(*zip(zeros9, p[1, :]))), list(chain(*zip(p[1, :], p[0, :]))), ])
|
| 21 |
+
D = get_D(*material)
|
| 22 |
+
strain_at_internal_nodes = [dot(B(0, -1), disp), dot(B(1, 0), disp), dot(B(0, 1), disp), dot(B(-1, 0), disp), dot(B(0, 0), disp)]
|
| 23 |
+
strain_at_gaussian_nodes = [dot(B(-sqrt(3 / 5), -sqrt(3 / 5)), disp), dot(B(sqrt(3 / 5), -sqrt(3 / 5)), disp), dot(B(sqrt(3 / 5), sqrt(3 / 5)), disp), dot(B(-sqrt(3 / 5), sqrt(3 / 5)), disp)]
|
| 24 |
+
p, q = 1 + 1 / sqrt(3), 1 - 1 / sqrt(3)
|
| 25 |
+
weight_matrix = 1 / 4 * array([ [p * p, p * q, q * q, q * p], [p * q, p * p, p * q, q * q], [q * q, p * q, p * p, p * q], [p * q, q * q, p * q, p * p] ])
|
| 26 |
+
stress_at_gaussian_nodes = array([dot(D, e) for e in strain_at_gaussian_nodes])
|
| 27 |
+
stress_at_corner_nodes = dot(inv(weight_matrix), stress_at_gaussian_nodes)
|
| 28 |
+
stress_at_internal_nodes = [dot(D, e) for e in strain_at_internal_nodes]
|
| 29 |
+
return row_stack((stress_at_corner_nodes, stress_at_internal_nodes))
|
11.py
ADDED
|
@@ -0,0 +1,32 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
def lobatto_interval(count):
|
| 2 |
+
from math import sqrt
|
| 3 |
+
from numpy import array
|
| 4 |
+
if count <= 2:
|
| 5 |
+
p = array([-1.0, 1.0])
|
| 6 |
+
w = array([1.0, 1.0])
|
| 7 |
+
return p, w
|
| 8 |
+
elif count == 3:
|
| 9 |
+
p = array([-1.0, 0.0, 1.0])
|
| 10 |
+
w = array([1.0 / 3.0, 4.0 / 3.0, 1.0 / 3.0])
|
| 11 |
+
return p, w
|
| 12 |
+
elif count == 4:
|
| 13 |
+
p = array([-1.0, -1.0 / sqrt(5.0), 1.0 / sqrt(5.0), 1.0])
|
| 14 |
+
w = array([1.0 / 6.0, 5.0 / 6.0, 5.0 / 6.0, 1.0 / 6.0])
|
| 15 |
+
return p, w
|
| 16 |
+
else:
|
| 17 |
+
p = array([-1.0, -sqrt(3.0 / 7.0), 0.0, sqrt(3.0 / 7.0), 1.0])
|
| 18 |
+
w = array([1.0 / 10.0, 49.0 / 90.0, 32.0 / 45.0, 49.0 / 90.0, 1.0 / 10.0])
|
| 19 |
+
return p, w
|
| 20 |
+
def lobatto_quad(order):
|
| 21 |
+
from numpy import zeros
|
| 22 |
+
(p, w) = lobatto_interval(order)
|
| 23 |
+
size = len(p)
|
| 24 |
+
xi = zeros(size * size)
|
| 25 |
+
eta = zeros(size * size)
|
| 26 |
+
weight = zeros(size * size)
|
| 27 |
+
for i in range(size):
|
| 28 |
+
for j in range(size):
|
| 29 |
+
xi[i * size + j] = p[i]
|
| 30 |
+
eta[i * size + j] = p[j]
|
| 31 |
+
weight[i * size + j] = w[i] * w[j]
|
| 32 |
+
return xi, eta, weight
|
110.py
ADDED
|
@@ -0,0 +1,26 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
import numpy as np
|
| 2 |
+
import plotly.graph_objects as go
|
| 3 |
+
import ross as rs
|
| 4 |
+
import plotly.io as pio
|
| 5 |
+
pio.renderers.default = "notebook"
|
| 6 |
+
steel = rs.materials.steel
|
| 7 |
+
number_of_elements = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 40, 60]
|
| 8 |
+
def create_rotor(n_el):
|
| 9 |
+
shaft = [ rs.ShaftElement(1.2 / (n_el), idl=0.03, odl=0.08, material=steel) for i in range(n_el) ]
|
| 10 |
+
disks = [ rs.DiskElement.from_geometry( n=(n_el / 2), material=steel, width=0.08, i_d=0.08, o_d=0.4 ) ]
|
| 11 |
+
bearings = [ rs.BearingElement(0, kxx=1e15, cxx=0), rs.BearingElement(n_el, kxx=1e15, cxx=0), ]
|
| 12 |
+
return rs.Rotor(shaft, disks, bearings)
|
| 13 |
+
def analysis(speed):
|
| 14 |
+
n_eigen = 8
|
| 15 |
+
rotor_80 = create_rotor(80)
|
| 16 |
+
modal_80 = rotor_80.run_modal(speed, num_modes=2 * n_eigen)
|
| 17 |
+
errors = np.zeros([len(number_of_elements), n_eigen])
|
| 18 |
+
for i, n_el in enumerate(number_of_elements):
|
| 19 |
+
rotor = create_rotor(n_el)
|
| 20 |
+
modal = rotor.run_modal(speed, num_modes=2 * n_eigen)
|
| 21 |
+
errors[i, :] = abs( 100 * (modal.wn[:n_eigen] - modal_80.wn[:n_eigen]) / modal_80.wn[:n_eigen] )
|
| 22 |
+
fig = go.Figure()
|
| 23 |
+
for i in range(8):
|
| 24 |
+
fig.add_trace( go.Scatter(x=number_of_elements, y=errors[:, i], name=f"Mode {i}") )
|
| 25 |
+
fig.update_layout( xaxis=dict(title="Number of degrees of freedom"), yaxis=dict(type="log", title="Natural Frequency Error(%)"), )
|
| 26 |
+
return fig
|
112.py
ADDED
|
@@ -0,0 +1,14 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
import ross as rs
|
| 2 |
+
import plotly.io as pio
|
| 3 |
+
pio.renderers.default = "notebook"
|
| 4 |
+
steel = rs.materials.steel
|
| 5 |
+
number_of_elements = [2, 3, 4, 5, 6, 7, 8]
|
| 6 |
+
def create_rotor(n_el, R, shear_effects=False, rotary_inertia=False):
|
| 7 |
+
L_total = 1
|
| 8 |
+
D = R * L_total
|
| 9 |
+
shaft = [ rs.ShaftElement( 1.0 / (n_el), idl=0, odl=D, material=steel, shear_effects=shear_effects, rotary_inertia=rotary_inertia, ) for i in range(n_el) ]
|
| 10 |
+
bearings = [ rs.BearingElement(0, kxx=1e15, cxx=0), rs.BearingElement(n_el, kxx=1e15, cxx=0), ]
|
| 11 |
+
return rs.Rotor(shaft_elements=shaft, bearing_elements=bearings)
|
| 12 |
+
n_eigen = 8
|
| 13 |
+
R = 0.04
|
| 14 |
+
rotor_80 = create_rotor(80, R)
|
12.py
ADDED
|
@@ -0,0 +1,36 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
def lobatto_interval(count):
|
| 2 |
+
from math import sqrt
|
| 3 |
+
from numpy import array
|
| 4 |
+
if count <= 2:
|
| 5 |
+
p = array([-1.0, 1.0])
|
| 6 |
+
w = array([1.0, 1.0])
|
| 7 |
+
return p, w
|
| 8 |
+
elif count == 3:
|
| 9 |
+
p = array([-1.0, 0.0, 1.0])
|
| 10 |
+
w = array([1.0 / 3.0, 4.0 / 3.0, 1.0 / 3.0])
|
| 11 |
+
return p, w
|
| 12 |
+
elif count == 4:
|
| 13 |
+
p = array([-1.0, -1.0 / sqrt(5.0), 1.0 / sqrt(5.0), 1.0])
|
| 14 |
+
w = array([1.0 / 6.0, 5.0 / 6.0, 5.0 / 6.0, 1.0 / 6.0])
|
| 15 |
+
return p, w
|
| 16 |
+
else:
|
| 17 |
+
p = array([-1.0, -sqrt(3.0 / 7.0), 0.0, sqrt(3.0 / 7.0), 1.0])
|
| 18 |
+
w = array([1.0 / 10.0, 49.0 / 90.0, 32.0 / 45.0, 49.0 / 90.0, 1.0 / 10.0])
|
| 19 |
+
return p, w
|
| 20 |
+
def lobatto_hexahedra(order):
|
| 21 |
+
from numpy import zeros
|
| 22 |
+
(p, w) = lobatto_interval(order)
|
| 23 |
+
size = len(p)
|
| 24 |
+
xi = zeros(size * size * size)
|
| 25 |
+
eta = zeros(size * size * size)
|
| 26 |
+
mu = zeros(size * size * size)
|
| 27 |
+
weight = zeros(size * size * size)
|
| 28 |
+
size_size = size * size
|
| 29 |
+
for i in range(size):
|
| 30 |
+
for j in range(size):
|
| 31 |
+
for k in range(size):
|
| 32 |
+
xi[i * size_size + j * size + k] = p[i]
|
| 33 |
+
eta[i * size_size + j * size + k] = p[j]
|
| 34 |
+
mu[i * size_size + j * size + k] = p[k]
|
| 35 |
+
weight[i * size_size + j * size + k] = w[i] * w[j] * w[k]
|
| 36 |
+
return xi, eta, mu, weight
|
14.py
ADDED
|
@@ -0,0 +1,3 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
def progress_bar(step, max_step):
|
| 2 |
+
progress = int(100 * float(step) / float(max_step))
|
| 3 |
+
print( '\r[{0}] {1}%'.format('#'*(progress/10), progress),)
|
15.py
ADDED
|
@@ -0,0 +1,18 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
def plot_coo_matrix(m):
|
| 2 |
+
import matplotlib.pyplot as plt
|
| 3 |
+
from scipy.sparse import coo_matrix
|
| 4 |
+
if not isinstance(m, coo_matrix):
|
| 5 |
+
m = coo_matrix(m)
|
| 6 |
+
fig = plt.figure()
|
| 7 |
+
ax = fig.add_subplot(111, axisbg='black')
|
| 8 |
+
ax.plot(m.col, m.row, '.', color='white', ms=1)
|
| 9 |
+
ax.set_xlim(0, m.shape[1])
|
| 10 |
+
ax.set_ylim(0, m.shape[0])
|
| 11 |
+
ax.set_aspect('equal')
|
| 12 |
+
for spine in ax.spines.values():
|
| 13 |
+
spine.set_visible(False)
|
| 14 |
+
ax.invert_yaxis()
|
| 15 |
+
ax.set_aspect('equal')
|
| 16 |
+
ax.set_xticks([])
|
| 17 |
+
ax.set_yticks([])
|
| 18 |
+
plt.show()
|
16.py
ADDED
|
@@ -0,0 +1,2 @@
|
|
|
|
|
|
|
|
|
|
| 1 |
+
def linear_curve(t, p0, p1):
|
| 2 |
+
return p0 + t * (p1 - p0)
|
17.py
ADDED
|
@@ -0,0 +1,2 @@
|
|
|
|
|
|
|
|
|
|
| 1 |
+
def quadratic_bezier_curve(t, p0, p1, p2):
|
| 2 |
+
return (1.0 - t) ** 2.0 * p0 + 2.0 * (1.0 - t) * t * p1 + t ** 2.0 * p2
|
18.py
ADDED
|
@@ -0,0 +1,2 @@
|
|
|
|
|
|
|
|
|
|
| 1 |
+
def cubic_bezier_curve(t, p0, p1, p2, p3):
|
| 2 |
+
return (1.0 - t) ** 3.0 * p0 + 3.0 * (1.0 - t) ** 2.0 * t * p1 + 3.0 * (1.0 - t) * t * t * p2 + t ** 3.0 * p3
|
19.py
ADDED
|
@@ -0,0 +1,15 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
import numpy as np
|
| 2 |
+
def rectangular_quads(x_count, y_count, x_origin, y_origin, width, height):
|
| 3 |
+
nodes = np.zeros((x_count * y_count, 2), dtype=np.float64)
|
| 4 |
+
elements = np.zeros(((x_count - 1) * (y_count - 1), 4), dtype=np.int32)
|
| 5 |
+
points_x = np.linspace(x_origin, x_origin + width, num=x_count)
|
| 6 |
+
points_y = np.linspace(y_origin, y_origin + height, num=y_count)
|
| 7 |
+
for i in range(x_count):
|
| 8 |
+
for j in range(y_count):
|
| 9 |
+
nodes[i * y_count + j, 0] = points_x[i]
|
| 10 |
+
nodes[i * y_count + j, 1] = points_y[j]
|
| 11 |
+
for i in range(x_count - 1):
|
| 12 |
+
for j in range(y_count - 1):
|
| 13 |
+
elem_idx = i * (y_count - 1) + j
|
| 14 |
+
elements[elem_idx] = [i * y_count + j, (i + 1) * y_count + j, (i + 1) * y_count + (j + 1), i * y_count + (j + 1)]
|
| 15 |
+
return nodes, elements
|
20.py
ADDED
|
@@ -0,0 +1,28 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
import numpy as np
|
| 2 |
+
def rectangular_triangles(x_count, y_count, x_origin, y_origin, width, height):
|
| 3 |
+
nodes = np.zeros((x_count * y_count, 2), dtype=np.float64)
|
| 4 |
+
elements = np.zeros((2 * (x_count - 1) * (y_count - 1), 3), dtype=np.int32)
|
| 5 |
+
points_x = np.linspace(x_origin, x_origin + width, num=x_count)
|
| 6 |
+
points_y = np.linspace(y_origin, y_origin + height, num=y_count)
|
| 7 |
+
cx = x_origin + width / 2.0
|
| 8 |
+
cy = y_origin + height / 2.0
|
| 9 |
+
for i in range(x_count):
|
| 10 |
+
for j in range(y_count):
|
| 11 |
+
nodes[i * y_count + j, 0] = points_x[i]
|
| 12 |
+
nodes[i * y_count + j, 1] = points_y[j]
|
| 13 |
+
for i in range(x_count - 1):
|
| 14 |
+
for j in range(y_count - 1):
|
| 15 |
+
bl = i * y_count + j
|
| 16 |
+
br = (i + 1) * y_count + j
|
| 17 |
+
tr = (i + 1) * y_count + (j + 1)
|
| 18 |
+
tl = i * y_count + (j + 1)
|
| 19 |
+
all_right_top = np.all(nodes[[bl, br, tr, tl], 0] >= cx) and np.all(nodes[[bl, br, tr, tl], 1] >= cy)
|
| 20 |
+
all_left_bottom = np.all(nodes[[bl, br, tr, tl], 0] <= cx) and np.all(nodes[[bl, br, tr, tl], 1] <= cy)
|
| 21 |
+
elem_idx = 2 * (i * (y_count - 1) + j)
|
| 22 |
+
if all_right_top or all_left_bottom:
|
| 23 |
+
elements[elem_idx] = [bl, br, tl]
|
| 24 |
+
elements[elem_idx + 1] = [br, tr, tl]
|
| 25 |
+
else:
|
| 26 |
+
elements[elem_idx] = [bl, br, tr]
|
| 27 |
+
elements[elem_idx + 1] = [bl, tr, tl]
|
| 28 |
+
return nodes, elements
|
21.py
ADDED
|
@@ -0,0 +1,37 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
def annular(xi_count, eta_count, min_radius, max_radius, alpha=None):
|
| 2 |
+
from numpy import zeros, float_, int_, linspace, delete, s_
|
| 3 |
+
from math import cos, sin, sqrt, tanh, pi
|
| 4 |
+
nodes = zeros((xi_count * eta_count, 2), dtype=float_)
|
| 5 |
+
elements = zeros(((xi_count - 1) * (eta_count - 1), 4), dtype=int_)
|
| 6 |
+
hxi = 1.0 / float(xi_count - 1)
|
| 7 |
+
points_xi = linspace(0.0, 1.0, num=xi_count)
|
| 8 |
+
points_eta = linspace(0.0, 1.0, num=eta_count)
|
| 9 |
+
angle = alpha
|
| 10 |
+
if alpha is None:
|
| 11 |
+
angle = 2.0 * pi
|
| 12 |
+
p = sqrt((min_radius - min_radius * cos(angle * hxi)) ** 2.0 + (min_radius * sin(angle * hxi)) ** 2.0)
|
| 13 |
+
q = 2.0 - p
|
| 14 |
+
for i in range(xi_count):
|
| 15 |
+
xi = points_xi[i]
|
| 16 |
+
for j in range(eta_count):
|
| 17 |
+
eta = points_eta[j]
|
| 18 |
+
s = p * eta + (1.0 - p) * (1.0 - tanh(q * (1.0 - eta)) / tanh(q))
|
| 19 |
+
x = (min_radius + (max_radius - min_radius) * s) * cos(angle * xi)
|
| 20 |
+
y = (min_radius + (max_radius - min_radius) * s) * sin(angle * xi)
|
| 21 |
+
nodes[i * eta_count + j, 0] = x
|
| 22 |
+
nodes[i * eta_count + j, 1] = y
|
| 23 |
+
for i in range(xi_count - 1):
|
| 24 |
+
for j in range(eta_count - 1):
|
| 25 |
+
elements[i * (eta_count - 1) + j, 0] = i * eta_count + j
|
| 26 |
+
elements[i * (eta_count - 1) + j, 1] = i * eta_count + (j + 1)
|
| 27 |
+
elements[i * (eta_count - 1) + j, 2] = (i + 1) * eta_count + (j + 1)
|
| 28 |
+
elements[i * (eta_count - 1) + j, 3] = (i + 1) * eta_count + j
|
| 29 |
+
if alpha is None:
|
| 30 |
+
i = xi_count - 2
|
| 31 |
+
for j in range(eta_count - 1):
|
| 32 |
+
elements[i * (eta_count - 1) + j, 0] = i * eta_count + j
|
| 33 |
+
elements[i * (eta_count - 1) + j, 1] = i * eta_count + (j + 1)
|
| 34 |
+
elements[i * (eta_count - 1) + j, 2] = (j + 1)
|
| 35 |
+
elements[i * (eta_count - 1) + j, 3] = j
|
| 36 |
+
nodes = delete(nodes, s_[(xi_count - 1) * eta_count: xi_count * eta_count], 0)
|
| 37 |
+
return nodes, elements
|
22.py
ADDED
|
@@ -0,0 +1,33 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import array
|
| 2 |
+
p00 = array([1.0, 1.0])
|
| 3 |
+
p01 = array([0.0, 2.0])
|
| 4 |
+
p02 = array([1.0, 2.0])
|
| 5 |
+
p03 = array([1.0, 3.0])
|
| 6 |
+
p10 = array([3.0, 1.0])
|
| 7 |
+
p11 = array([4.0, 1.0])
|
| 8 |
+
p12 = array([2.0, 3.0])
|
| 9 |
+
p13 = array([3.5, 4.0])
|
| 10 |
+
def cubic_bezier_curve(t, p0, p1, p2, p3):
|
| 11 |
+
return (1.0 - t) ** 3.0 * p0 + 3.0 * (1.0 - t) ** 2.0 * t * p1 + 3.0 * (1.0 - t) * t * t * p2 + t ** 3.0 * p3
|
| 12 |
+
def left_curve(t):
|
| 13 |
+
return cubic_bezier_curve(t, p0=p00, p1=p01, p2=p02, p3=p03)
|
| 14 |
+
def right_curve(t):
|
| 15 |
+
return cubic_bezier_curve(t, p0=p10, p1=p11, p2=p12, p3=p13)
|
| 16 |
+
import numpy as np
|
| 17 |
+
def two_curved_domain(xi_count, eta_count, left_curve, right_curve):
|
| 18 |
+
nodes = np.zeros((xi_count * eta_count, 2), dtype=np.float64)
|
| 19 |
+
elements = np.zeros(((xi_count - 1) * (eta_count - 1), 4), dtype=np.int32)
|
| 20 |
+
points_xi = np.linspace(0.0, 1.0, num=xi_count)
|
| 21 |
+
points_eta = np.linspace(0.0, 1.0, num=eta_count)
|
| 22 |
+
for i in range(xi_count):
|
| 23 |
+
xi = points_xi[i]
|
| 24 |
+
for j in range(eta_count):
|
| 25 |
+
eta = points_eta[j]
|
| 26 |
+
p = (1.0 - xi) * left_curve(eta) + xi * right_curve(eta)
|
| 27 |
+
nodes[i * eta_count + j, 0] = p[0]
|
| 28 |
+
nodes[i * eta_count + j, 1] = p[1]
|
| 29 |
+
for i in range(xi_count - 1):
|
| 30 |
+
for j in range(eta_count - 1):
|
| 31 |
+
elem_idx = i * (eta_count - 1) + j
|
| 32 |
+
elements[elem_idx] = [i * eta_count + j, (i + 1) * eta_count + j, (i + 1) * eta_count + (j + 1),i * eta_count + j + 1]
|
| 33 |
+
return nodes, elements
|
23.py
ADDED
|
@@ -0,0 +1,37 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import array
|
| 2 |
+
p20 = array([1.0, 1.0])
|
| 3 |
+
p21 = array([2.0, 2.0])
|
| 4 |
+
p22 = array([2.0, 2.0])
|
| 5 |
+
p23 = array([3.0, 1.0])
|
| 6 |
+
p30 = array([1.0, 3.0])
|
| 7 |
+
p31 = array([2.0, 4.0])
|
| 8 |
+
p32 = array([2.0, 4.0])
|
| 9 |
+
p33 = array([3.5, 4.0])
|
| 10 |
+
def cubic_bezier_curve(t, p0, p1, p2, p3):
|
| 11 |
+
return (1.0 - t) ** 3.0 * p0 + 3.0 * (1.0 - t) ** 2.0 * t * p1 + 3.0 * (1.0 - t) * t * t * p2 + t ** 3.0 * p3
|
| 12 |
+
def curve_bottom(t):
|
| 13 |
+
return cubic_bezier_curve(t, p0=p20, p1=p21, p2=p22, p3=p23)
|
| 14 |
+
def curve_top(t):
|
| 15 |
+
return cubic_bezier_curve(t, p0=p30, p1=p31, p2=p32, p3=p33)
|
| 16 |
+
import numpy as np
|
| 17 |
+
def transfinite(xi_count, eta_count, xi_curve_bottom, xi_curve_top, eta_curve_left, eta_curve_right):
|
| 18 |
+
nodes = np.zeros((xi_count * eta_count, 2), dtype=np.float64)
|
| 19 |
+
elements = np.zeros(((xi_count - 1) * (eta_count - 1), 4), dtype=np.int32)
|
| 20 |
+
points_xi = np.linspace(0.0, 1.0, num=xi_count)
|
| 21 |
+
points_eta = np.linspace(0.0, 1.0, num=eta_count)
|
| 22 |
+
a = xi_curve_bottom(0.0)
|
| 23 |
+
b = xi_curve_top(0.0)
|
| 24 |
+
c = xi_curve_bottom(1.0)
|
| 25 |
+
d = xi_curve_top(1.0)
|
| 26 |
+
for i in range(xi_count):
|
| 27 |
+
xi = points_xi[i]
|
| 28 |
+
for j in range(eta_count):
|
| 29 |
+
eta = points_eta[j]
|
| 30 |
+
p = ((1.0 - xi) * eta_curve_left(eta) + xi * eta_curve_right(eta) + (1.0 - eta) * xi_curve_bottom(xi) + eta * xi_curve_top(xi) - (1.0 - xi) * (1.0 - eta) * a - (1.0 - xi) * eta * b - xi * (1.0 - eta) * c - xi * eta * d)
|
| 31 |
+
nodes[i * eta_count + j, 0] = p[0]
|
| 32 |
+
nodes[i * eta_count + j, 1] = p[1]
|
| 33 |
+
for i in range(xi_count - 1):
|
| 34 |
+
for j in range(eta_count - 1):
|
| 35 |
+
elem_idx = i * (eta_count - 1) + j
|
| 36 |
+
elements[elem_idx] = [i * eta_count + j, (i + 1) * eta_count + j, (i + 1) * eta_count + (j + 1),i * eta_count + j + 1]
|
| 37 |
+
return nodes, elements
|
24.py
ADDED
|
@@ -0,0 +1,32 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import *
|
| 2 |
+
def func(x): return 1.0
|
| 3 |
+
def legendre_interval(count):
|
| 4 |
+
from math import sqrt
|
| 5 |
+
if count <= 1:
|
| 6 |
+
p = array([0.0])
|
| 7 |
+
w = array([2.0])
|
| 8 |
+
return p, w
|
| 9 |
+
elif count == 2:
|
| 10 |
+
p = array([-1.0 / sqrt(3.0), 1.0 / sqrt(3.0)])
|
| 11 |
+
w = array([1.0, 1.0])
|
| 12 |
+
return p, w
|
| 13 |
+
elif count == 3:
|
| 14 |
+
p = array([-sqrt(3.0 / 5.0), 0.0, sqrt(3.0 / 5.0)])
|
| 15 |
+
w = array([5.0 / 9.0, 8.0 / 9.0, 5.0 / 9.0])
|
| 16 |
+
return p, w
|
| 17 |
+
elif count == 4:
|
| 18 |
+
p = array([-sqrt((3.0 + 2.0 * sqrt(6.0 / 5.0)) / 7.0), -sqrt((3.0 - 2.0 * sqrt(6.0 / 5.0)) / 7.0), sqrt((3.0 - 2.0 * sqrt(6.0 / 5.0)) / 7.0), sqrt((3.0 + 2.0 * sqrt(6.0 / 5.0)) / 7.0)])
|
| 19 |
+
w = array([(18.0 - sqrt(30.0)) / 36.0, (18.0 + sqrt(30.0)) / 36.0, (18.0 + sqrt(30.0)) / 36.0, (18.0 - sqrt(30.0)) / 36.0])
|
| 20 |
+
return p, w
|
| 21 |
+
else:
|
| 22 |
+
p = array([-(1.0 / 3.0) * sqrt(5.0 + 2.0 * sqrt(10.0 / 7.0)), -(1.0 / 3.0) * sqrt(5.0 - 2.0 * sqrt(10.0 / 7.0)), 0.0, (1.0 / 3.0) * sqrt(5.0 - 2.0 * sqrt(10.0 / 7.0)), (1.0 / 3.0) * sqrt(5.0 + 2.0 * sqrt(10.0 / 7.0))])
|
| 23 |
+
w = array([(322.0 - 13.0 * sqrt(70.0)) / 900.0, (322.0 + 13.0 * sqrt(70.0)) / 900.0, 128.0 / 225.0, (322.0 + 13.0 * sqrt(70.0)) / 900.0, (322.0 - 13.0 * sqrt(70.0)) / 900.0])
|
| 24 |
+
return p, w
|
| 25 |
+
def interval(func, a, b, count):
|
| 26 |
+
from scipy.spatial.distance import euclidean
|
| 27 |
+
(p, w) = legendre_interval(count)
|
| 28 |
+
j = euclidean(a, b) / 2.0
|
| 29 |
+
s = func(0.5 * a * (1.0 - p[0]) + 0.5 * b * (1.0 + p[0])) * w[0] * j
|
| 30 |
+
for i in range(1, count):
|
| 31 |
+
s += func(0.5 * a * (1.0 - p[i]) + 0.5 * b * (1.0 + p[i])) * w[i] * j
|
| 32 |
+
return s
|
25.py
ADDED
|
@@ -0,0 +1,77 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import *
|
| 2 |
+
def legendre_interval(count):
|
| 3 |
+
from math import sqrt
|
| 4 |
+
if count <= 1:
|
| 5 |
+
p = array([0.0])
|
| 6 |
+
w = array([2.0])
|
| 7 |
+
return p, w
|
| 8 |
+
elif count == 2:
|
| 9 |
+
p = array([-1.0 / sqrt(3.0), 1.0 / sqrt(3.0)])
|
| 10 |
+
w = array([1.0, 1.0])
|
| 11 |
+
return p, w
|
| 12 |
+
elif count == 3:
|
| 13 |
+
p = array([-sqrt(3.0 / 5.0), 0.0, sqrt(3.0 / 5.0)])
|
| 14 |
+
w = array([5.0 / 9.0, 8.0 / 9.0, 5.0 / 9.0])
|
| 15 |
+
return p, w
|
| 16 |
+
elif count == 4:
|
| 17 |
+
p = array([-sqrt((3.0 + 2.0 * sqrt(6.0 / 5.0)) / 7.0), -sqrt((3.0 - 2.0 * sqrt(6.0 / 5.0)) / 7.0), sqrt((3.0 - 2.0 * sqrt(6.0 / 5.0)) / 7.0), sqrt((3.0 + 2.0 * sqrt(6.0 / 5.0)) / 7.0)])
|
| 18 |
+
w = array([(18.0 - sqrt(30.0)) / 36.0, (18.0 + sqrt(30.0)) / 36.0, (18.0 + sqrt(30.0)) / 36.0, (18.0 - sqrt(30.0)) / 36.0])
|
| 19 |
+
return p, w
|
| 20 |
+
else:
|
| 21 |
+
p = array([-(1.0 / 3.0) * sqrt(5.0 + 2.0 * sqrt(10.0 / 7.0)), -(1.0 / 3.0) * sqrt(5.0 - 2.0 * sqrt(10.0 / 7.0)), 0.0, (1.0 / 3.0) * sqrt(5.0 - 2.0 * sqrt(10.0 / 7.0)), (1.0 / 3.0) * sqrt(5.0 + 2.0 * sqrt(10.0 / 7.0))])
|
| 22 |
+
w = array([(322.0 - 13.0 * sqrt(70.0)) / 900.0, (322.0 + 13.0 * sqrt(70.0)) / 900.0, 128.0 / 225.0, (322.0 + 13.0 * sqrt(70.0)) / 900.0, (322.0 - 13.0 * sqrt(70.0)) / 900.0])
|
| 23 |
+
return p, w
|
| 24 |
+
def legendre_quad(order):
|
| 25 |
+
from numpy import zeros
|
| 26 |
+
(p, w) = legendre_interval(order)
|
| 27 |
+
size = len(p)
|
| 28 |
+
xi = zeros(size * size)
|
| 29 |
+
eta = zeros(size * size)
|
| 30 |
+
weight = zeros(size * size)
|
| 31 |
+
for i in range(size):
|
| 32 |
+
for j in range(size):
|
| 33 |
+
xi[i * size + j] = p[i]
|
| 34 |
+
eta[i * size + j] = p[j]
|
| 35 |
+
weight[i * size + j] = w[i] * w[j]
|
| 36 |
+
return xi, eta, weight
|
| 37 |
+
def iso_quad(element_nodes, xi, eta):
|
| 38 |
+
from numpy import array
|
| 39 |
+
from numpy import sum
|
| 40 |
+
from numpy.linalg import det
|
| 41 |
+
from numpy.linalg import inv
|
| 42 |
+
shape = array([ (1.0 - xi) * (1.0 - eta) / 4.0, (1.0 + xi) * (1.0 - eta) / 4.0, (1.0 + xi) * (1.0 + eta) / 4.0, (1.0 - xi) * (1.0 + eta) / 4.0 ]) # bilinear shape functions
|
| 43 |
+
shape_dxi = array([ -(1.0 - eta) / 4.0, (1.0 - eta) / 4.0, (1.0 + eta) / 4.0, -(1.0 + eta) / 4.0 ]) # derivatives of the shape functions in the first parametric direction
|
| 44 |
+
shape_deta = array([ -(1.0 - xi) / 4.0, -(1.0 + xi) / 4.0, (1.0 + xi) / 4.0, (1.0 - xi) / 4.0 ]) # derivatives of the shape functions in the second parametric direction
|
| 45 |
+
x = element_nodes[:, 0]
|
| 46 |
+
y = element_nodes[:, 1]
|
| 47 |
+
jacobi = array([ [sum(shape_dxi * x), sum(shape_dxi * y)], [sum(shape_deta * x), sum(shape_deta * y)] ]) # Jacobi matrix
|
| 48 |
+
jacobian = det(jacobi)
|
| 49 |
+
inverted_jacobi = inv(jacobi)
|
| 50 |
+
shape_dx = inverted_jacobi[0, 0] * shape_dxi + inverted_jacobi[0, 1] * shape_deta
|
| 51 |
+
shape_dy = inverted_jacobi[1, 0] * shape_dxi + inverted_jacobi[1, 1] * shape_deta
|
| 52 |
+
return jacobian, shape, shape_dx, shape_dy
|
| 53 |
+
def thermal_force_plate_5(nodes, elements, thicknesses, elasticity_matrices, alpha_t, gauss_order=3):
|
| 54 |
+
from numpy import sum, array
|
| 55 |
+
freedom = 5
|
| 56 |
+
dimension = len(nodes) * freedom
|
| 57 |
+
force = zeros(dimension)
|
| 58 |
+
element_nodes = 4
|
| 59 |
+
(xi, eta, w) = legendre_quad(gauss_order)
|
| 60 |
+
alpha = array([alpha_t, alpha_t, 0.0])
|
| 61 |
+
h = sum(thicknesses)
|
| 62 |
+
for element in elements:
|
| 63 |
+
fe = zeros(element_nodes * freedom)
|
| 64 |
+
vertices = nodes[element[:], :]
|
| 65 |
+
for i in range(len(w)):
|
| 66 |
+
(jacobian, shape, shape_dx, shape_dy) = iso_quad(vertices, xi[i], eta[i])
|
| 67 |
+
bm = array([ [shape_dx[0], 0.0, 0.0, 0.0, 0.0, shape_dx[1], 0.0, 0.0, 0.0, 0.0, shape_dx[2], 0.0, 0.0, 0.0, 0.0, shape_dx[3], 0.0, 0.0, 0.0, 0.0], [0.0, shape_dy[0], 0.0, 0.0, 0.0, 0.0, shape_dy[1], 0.0, 0.0, 0.0, 0.0, shape_dy[2], 0.0, 0.0, 0.0, 0.0, shape_dy[3], 0.0, 0.0, 0.0], [shape_dy[0], shape_dx[0], 0.0, 0.0, 0.0, shape_dy[1], shape_dx[1], 0.0, 0.0, 0.0, shape_dy[2], shape_dx[2], 0.0, 0.0, 0.0, shape_dy[3], shape_dx[3], 0.0, 0.0, 0.0] ])
|
| 68 |
+
z0 = -h / 2.0
|
| 69 |
+
for j in range(len(thicknesses)):
|
| 70 |
+
z1 = z0 + thicknesses[j]
|
| 71 |
+
df = elasticity_matrices[j]
|
| 72 |
+
fe = fe + (z1 - z0) * bm.transpose().dot(df).dot(alpha) * w[i] * jacobian
|
| 73 |
+
z0 = z1
|
| 74 |
+
for i in range(element_nodes * freedom):
|
| 75 |
+
ii = element[i / freedom] * freedom + i % freedom
|
| 76 |
+
force[ii] += fe[i]
|
| 77 |
+
return force
|
26.py
ADDED
|
@@ -0,0 +1,75 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import *
|
| 2 |
+
def legendre_interval(count):
|
| 3 |
+
from math import sqrt
|
| 4 |
+
if count <= 1:
|
| 5 |
+
p = array([0.0])
|
| 6 |
+
w = array([2.0])
|
| 7 |
+
return p, w
|
| 8 |
+
elif count == 2:
|
| 9 |
+
p = array([-1.0 / sqrt(3.0), 1.0 / sqrt(3.0)])
|
| 10 |
+
w = array([1.0, 1.0])
|
| 11 |
+
return p, w
|
| 12 |
+
elif count == 3:
|
| 13 |
+
p = array([-sqrt(3.0 / 5.0), 0.0, sqrt(3.0 / 5.0)])
|
| 14 |
+
w = array([5.0 / 9.0, 8.0 / 9.0, 5.0 / 9.0])
|
| 15 |
+
return p, w
|
| 16 |
+
elif count == 4:
|
| 17 |
+
p = array([-sqrt((3.0 + 2.0 * sqrt(6.0 / 5.0)) / 7.0), -sqrt((3.0 - 2.0 * sqrt(6.0 / 5.0)) / 7.0), sqrt((3.0 - 2.0 * sqrt(6.0 / 5.0)) / 7.0), sqrt((3.0 + 2.0 * sqrt(6.0 / 5.0)) / 7.0)])
|
| 18 |
+
w = array([(18.0 - sqrt(30.0)) / 36.0, (18.0 + sqrt(30.0)) / 36.0, (18.0 + sqrt(30.0)) / 36.0, (18.0 - sqrt(30.0)) / 36.0])
|
| 19 |
+
return p, w
|
| 20 |
+
else:
|
| 21 |
+
p = array([-(1.0 / 3.0) * sqrt(5.0 + 2.0 * sqrt(10.0 / 7.0)), -(1.0 / 3.0) * sqrt(5.0 - 2.0 * sqrt(10.0 / 7.0)), 0.0, (1.0 / 3.0) * sqrt(5.0 - 2.0 * sqrt(10.0 / 7.0)), (1.0 / 3.0) * sqrt(5.0 + 2.0 * sqrt(10.0 / 7.0))])
|
| 22 |
+
w = array([(322.0 - 13.0 * sqrt(70.0)) / 900.0, (322.0 + 13.0 * sqrt(70.0)) / 900.0, 128.0 / 225.0, (322.0 + 13.0 * sqrt(70.0)) / 900.0, (322.0 - 13.0 * sqrt(70.0)) / 900.0])
|
| 23 |
+
return p, w
|
| 24 |
+
def legendre_quad(order):
|
| 25 |
+
from numpy import zeros
|
| 26 |
+
(p, w) = legendre_interval(order)
|
| 27 |
+
size = len(p)
|
| 28 |
+
xi = zeros(size * size)
|
| 29 |
+
eta = zeros(size * size)
|
| 30 |
+
weight = zeros(size * size)
|
| 31 |
+
for i in range(size):
|
| 32 |
+
for j in range(size):
|
| 33 |
+
xi[i * size + j] = p[i]
|
| 34 |
+
eta[i * size + j] = p[j]
|
| 35 |
+
weight[i * size + j] = w[i] * w[j]
|
| 36 |
+
return xi, eta, weight
|
| 37 |
+
def iso_quad(element_nodes, xi, eta):
|
| 38 |
+
from numpy import array
|
| 39 |
+
from numpy import sum
|
| 40 |
+
from numpy.linalg import det
|
| 41 |
+
from numpy.linalg import inv
|
| 42 |
+
shape = array([ (1.0 - xi) * (1.0 - eta) / 4.0, (1.0 + xi) * (1.0 - eta) / 4.0, (1.0 + xi) * (1.0 + eta) / 4.0, (1.0 - xi) * (1.0 + eta) / 4.0 ]) # bilinear shape functions
|
| 43 |
+
shape_dxi = array([ -(1.0 - eta) / 4.0, (1.0 - eta) / 4.0, (1.0 + eta) / 4.0, -(1.0 + eta) / 4.0 ]) # derivatives of the shape functions in the first parametric direction
|
| 44 |
+
shape_deta = array([ -(1.0 - xi) / 4.0, -(1.0 + xi) / 4.0, (1.0 + xi) / 4.0, (1.0 - xi) / 4.0 ]) # derivatives of the shape functions in the second parametric direction
|
| 45 |
+
x = element_nodes[:, 0]
|
| 46 |
+
y = element_nodes[:, 1]
|
| 47 |
+
jacobi = array([ [sum(shape_dxi * x), sum(shape_dxi * y)], [sum(shape_deta * x), sum(shape_deta * y)] ]) # Jacobi matrix
|
| 48 |
+
jacobian = det(jacobi)
|
| 49 |
+
inverted_jacobi = inv(jacobi)
|
| 50 |
+
shape_dx = inverted_jacobi[0, 0] * shape_dxi + inverted_jacobi[0, 1] * shape_deta
|
| 51 |
+
shape_dy = inverted_jacobi[1, 0] * shape_dxi + inverted_jacobi[1, 1] * shape_deta
|
| 52 |
+
return jacobian, shape, shape_dx, shape_dy
|
| 53 |
+
def thermal_force_quads(nodes, elements, thickness, elasticity_matrix, alpha_t, tfunc=None, gauss_order=3):
|
| 54 |
+
from numpy import sum, array
|
| 55 |
+
freedom = 2
|
| 56 |
+
dimension = len(nodes) * freedom
|
| 57 |
+
force = zeros(dimension)
|
| 58 |
+
element_nodes = 4
|
| 59 |
+
(xi, eta, w) = legendre_quad(gauss_order)
|
| 60 |
+
alpha = array([alpha_t, alpha_t, 0.0])
|
| 61 |
+
for element in elements:
|
| 62 |
+
fe = zeros(element_nodes * freedom)
|
| 63 |
+
vertices = nodes[element[:], :]
|
| 64 |
+
for i in range(len(w)):
|
| 65 |
+
(jacobian, shape, shape_dx, shape_dy) = iso_quad(vertices, xi[i], eta[i])
|
| 66 |
+
b = array([ [shape_dx[0], 0.0, shape_dx[1], 0.0, shape_dx[2], 0.0, shape_dx[3], 0.0], [0.0, shape_dy[0], 0.0, shape_dy[1], 0.0, shape_dy[2], 0.0, shape_dy[3]], [shape_dy[0], shape_dx[0], shape_dy[1], shape_dx[1], shape_dy[2], shape_dx[2], shape_dy[3], shape_dx[3]] ])
|
| 67 |
+
if tfunc is None:
|
| 68 |
+
fe = fe + thickness * b.transpose().dot(elasticity_matrix).dot(alpha) * w[i] * jacobian
|
| 69 |
+
else:
|
| 70 |
+
therm = tfunc(sum(vertices[:, 0] * shape), sum(vertices[:, 1] * shape))
|
| 71 |
+
fe = fe + thickness * therm * b.transpose().dot(elasticity_matrix).dot(alpha) * w[i] * jacobian
|
| 72 |
+
for i in range(element_nodes * freedom):
|
| 73 |
+
ii = element[i / freedom] * freedom + i % freedom
|
| 74 |
+
force[ii] += fe[i]
|
| 75 |
+
return force
|
27.py
ADDED
|
@@ -0,0 +1,33 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import *
|
| 2 |
+
def legendre_interval(count):
|
| 3 |
+
from math import sqrt
|
| 4 |
+
if count <= 1:
|
| 5 |
+
p = array([0.0])
|
| 6 |
+
w = array([2.0])
|
| 7 |
+
return p, w
|
| 8 |
+
elif count == 2:
|
| 9 |
+
p = array([-1.0 / sqrt(3.0), 1.0 / sqrt(3.0)])
|
| 10 |
+
w = array([1.0, 1.0])
|
| 11 |
+
return p, w
|
| 12 |
+
elif count == 3:
|
| 13 |
+
p = array([-sqrt(3.0 / 5.0), 0.0, sqrt(3.0 / 5.0)])
|
| 14 |
+
w = array([5.0 / 9.0, 8.0 / 9.0, 5.0 / 9.0])
|
| 15 |
+
return p, w
|
| 16 |
+
elif count == 4:
|
| 17 |
+
p = array([-sqrt((3.0 + 2.0 * sqrt(6.0 / 5.0)) / 7.0), -sqrt((3.0 - 2.0 * sqrt(6.0 / 5.0)) / 7.0), sqrt((3.0 - 2.0 * sqrt(6.0 / 5.0)) / 7.0), sqrt((3.0 + 2.0 * sqrt(6.0 / 5.0)) / 7.0)])
|
| 18 |
+
w = array([(18.0 - sqrt(30.0)) / 36.0, (18.0 + sqrt(30.0)) / 36.0, (18.0 + sqrt(30.0)) / 36.0, (18.0 - sqrt(30.0)) / 36.0])
|
| 19 |
+
return p, w
|
| 20 |
+
else:
|
| 21 |
+
p = array([-(1.0 / 3.0) * sqrt(5.0 + 2.0 * sqrt(10.0 / 7.0)), -(1.0 / 3.0) * sqrt(5.0 - 2.0 * sqrt(10.0 / 7.0)), 0.0, (1.0 / 3.0) * sqrt(5.0 - 2.0 * sqrt(10.0 / 7.0)), (1.0 / 3.0) * sqrt(5.0 + 2.0 * sqrt(10.0 / 7.0))])
|
| 22 |
+
w = array([(322.0 - 13.0 * sqrt(70.0)) / 900.0, (322.0 + 13.0 * sqrt(70.0)) / 900.0, 128.0 / 225.0, (322.0 + 13.0 * sqrt(70.0)) / 900.0, (322.0 - 13.0 * sqrt(70.0)) / 900.0])
|
| 23 |
+
return p, w
|
| 24 |
+
def interval(func, a, b, gauss_order):
|
| 25 |
+
from scipy.spatial.distance import euclidean
|
| 26 |
+
(p, w) = legendre_interval(gauss_order)
|
| 27 |
+
j = euclidean(a, b) / 2.0
|
| 28 |
+
s0 = 0.5 * (1.0 - p[0]) * func(0.5 * a * (1.0 - p[0]) + 0.5 * b * (1.0 + p[0])) * w[0] * j
|
| 29 |
+
s1 = 0.5 * (1.0 + p[0]) * func(0.5 * a * (1.0 - p[0]) + 0.5 * b * (1.0 + p[0])) * w[0] * j
|
| 30 |
+
for i in range(1, gauss_order):
|
| 31 |
+
s0 += 0.5 * (1.0 - p[i]) * func(0.5 * a * (1.0 - p[i]) + 0.5 * b * (1.0 + p[i])) * w[i] * j
|
| 32 |
+
s1 += 0.5 * (1.0 + p[i]) * func(0.5 * a * (1.0 - p[i]) + 0.5 * b * (1.0 + p[i])) * w[i] * j
|
| 33 |
+
return [s0, s1]
|
28.py
ADDED
|
@@ -0,0 +1,38 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import ndarray
|
| 2 |
+
def get_iso_element_type(node_coords: ndarray, dimension: int = -1) -> str:
|
| 3 |
+
element_node_number = node_coords.shape[0]
|
| 4 |
+
if dimension == -1:
|
| 5 |
+
dimension = node_coords.shape[1]
|
| 6 |
+
if dimension == 1:
|
| 7 |
+
if element_node_number == 2:
|
| 8 |
+
return 'line2'
|
| 9 |
+
elif element_node_number == 3:
|
| 10 |
+
return 'line3'
|
| 11 |
+
return None
|
| 12 |
+
elif dimension == 2:
|
| 13 |
+
if element_node_number == 3:
|
| 14 |
+
return 'tria3'
|
| 15 |
+
elif element_node_number == 4:
|
| 16 |
+
return 'quad4'
|
| 17 |
+
elif element_node_number == 6:
|
| 18 |
+
return 'tria6'
|
| 19 |
+
elif element_node_number == 8:
|
| 20 |
+
return 'quad8'
|
| 21 |
+
elif element_node_number == 9:
|
| 22 |
+
return 'quad9'
|
| 23 |
+
return None
|
| 24 |
+
elif dimension == 3:
|
| 25 |
+
if element_node_number == 4:
|
| 26 |
+
return 'tetra4'
|
| 27 |
+
elif element_node_number == 5:
|
| 28 |
+
return 'pyramid5'
|
| 29 |
+
elif element_node_number == 6:
|
| 30 |
+
return 'prism6'
|
| 31 |
+
elif element_node_number == 8:
|
| 32 |
+
return 'hex8'
|
| 33 |
+
elif element_node_number == 18:
|
| 34 |
+
return 'prism18'
|
| 35 |
+
elif element_node_number == 20:
|
| 36 |
+
return 'hex20'
|
| 37 |
+
return None
|
| 38 |
+
return None
|
31.py
ADDED
|
@@ -0,0 +1,23 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import empty, ndarray
|
| 2 |
+
def get_shape_tria6(xi: ndarray) -> tuple[ndarray, ndarray]:
|
| 3 |
+
N = empty(6)
|
| 4 |
+
dNdxi = empty(shape=(2, 6))
|
| 5 |
+
N[0] = 1.0 - xi[0] - xi[1] - 2.0 * xi[0] * (1.0 - xi[0] - xi[1]) - 2.0 * xi[1] * (1.0 - xi[0] - xi[1])
|
| 6 |
+
N[1] = xi[0] - 2.0 * xi[0] * (1.0 - xi[0] - xi[1]) - 2.0 * xi[0] * xi[1]
|
| 7 |
+
N[2] = xi[1] - 2.0 * xi[0] * xi[1] - 2.0 * xi[1] * (1.0 - xi[0] - xi[1])
|
| 8 |
+
N[3] = 4.0 * xi[0] * (1.0 - xi[0] - xi[1])
|
| 9 |
+
N[4] = 4.0 * xi[0] * xi[1]
|
| 10 |
+
N[5] = 4.0 * xi[1] * (1.0 - xi[0] - xi[1])
|
| 11 |
+
dNdxi[0, 0] = -1.0 - 2.0 * (1.0 - xi[0] - xi[1]) + 2.0 * xi[0] + 2.0 * xi[1]
|
| 12 |
+
dNdxi[0, 1] = 1.0 - 2.0 * (1.0 - xi[0] - xi[1]) + 2.0 * xi[0] - 2.0 * xi[1]
|
| 13 |
+
dNdxi[0, 2] = 0.0
|
| 14 |
+
dNdxi[0, 3] = 4.0 * (1.0 - xi[0] - xi[1]) - 4.0 * xi[0]
|
| 15 |
+
dNdxi[0, 4] = 4.0 * xi[1]
|
| 16 |
+
dNdxi[0, 5] = -4.0 * xi[1]
|
| 17 |
+
dNdxi[1, 0] = -1.0 + 2.0 * xi[0] - 2.0 * (1.0 - xi[0] - xi[1]) + 2.0 * xi[1]
|
| 18 |
+
dNdxi[1, 1] = 0.0
|
| 19 |
+
dNdxi[1, 2] = 1.0 - 2.0 * xi[0] - 2.0 * (1.0 - xi[0] - xi[1]) + 2.0 * xi[1]
|
| 20 |
+
dNdxi[1, 3] = -4.0 * xi[0]
|
| 21 |
+
dNdxi[1, 4] = 4.0 * xi[0]
|
| 22 |
+
dNdxi[1, 5] = 4.0 * (1.0 - xi[0] - xi[1]) - 4.0 * xi[1]
|
| 23 |
+
return N, dNdxi
|
32.py
ADDED
|
@@ -0,0 +1,5 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import empty, ndarray, array
|
| 2 |
+
def get_shape_empty(xi: ndarray) -> tuple[ndarray, ndarray]:
|
| 3 |
+
N = empty(0)
|
| 4 |
+
dNdxi = empty(shape=(0, 0))
|
| 5 |
+
return N, dNdxi
|
33.py
ADDED
|
@@ -0,0 +1,9 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import empty, ndarray
|
| 2 |
+
def get_shape_line2(xi: ndarray) -> tuple[ndarray, ndarray]:
|
| 3 |
+
N = empty(2)
|
| 4 |
+
dNdxi = empty(shape=(1, 2))
|
| 5 |
+
N[0] = 0.5 * (1.0 - xi)
|
| 6 |
+
N[1] = 0.5 * (1.0 + xi)
|
| 7 |
+
dNdxi[0, 0] = -0.5
|
| 8 |
+
dNdxi[0, 1] = 0.5
|
| 9 |
+
return N, dNdxi
|
34.py
ADDED
|
@@ -0,0 +1,11 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import empty, ndarray
|
| 2 |
+
def get_shape_line3(xi: ndarray) -> tuple[ndarray, ndarray]:
|
| 3 |
+
N = empty(3)
|
| 4 |
+
dNdxi = empty(shape=(1, 3))
|
| 5 |
+
N[0] = 0.5 * (1.0 - xi) - 0.5 * (1.0 - xi * xi)
|
| 6 |
+
N[1] = 1.0 - xi * xi
|
| 7 |
+
N[2] = 0.5 * (1.0 + xi) - 0.5 * (1.0 - xi * xi)
|
| 8 |
+
dNdxi[0, 0] = -0.5 + xi
|
| 9 |
+
dNdxi[0, 1] = -2.0 * xi
|
| 10 |
+
dNdxi[0, 2] = 0.5 + xi
|
| 11 |
+
return N, dNdxi
|
35.py
ADDED
|
@@ -0,0 +1,16 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import empty, ndarray
|
| 2 |
+
|
| 3 |
+
def get_shape_tria3(xi: ndarray) -> tuple[ndarray, ndarray]:
|
| 4 |
+
N = empty(3)
|
| 5 |
+
dNdxi = empty(shape=(2, 3))
|
| 6 |
+
xi = xi
|
| 7 |
+
N[0] = 1.0 - xi[0] - xi[1]
|
| 8 |
+
N[1] = xi[0]
|
| 9 |
+
N[2] = xi[1]
|
| 10 |
+
dNdxi[0, 0] = -1.0
|
| 11 |
+
dNdxi[0, 1] = 1.0
|
| 12 |
+
dNdxi[0, 2] = 0.0
|
| 13 |
+
dNdxi[1, 0] = -1.0
|
| 14 |
+
dNdxi[1, 1] = 0.0
|
| 15 |
+
dNdxi[1, 2] = 1.0
|
| 16 |
+
return N, dNdxi
|
36.py
ADDED
|
@@ -0,0 +1,18 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import empty, ndarray
|
| 2 |
+
def get_shape_tria3_barycentric(xi: ndarray) -> tuple[ndarray, ndarray]:
|
| 3 |
+
N = empty(3)
|
| 4 |
+
dNdxi = empty(shape=(3, 3))
|
| 5 |
+
xi = xi
|
| 6 |
+
N[0] = xi[0]
|
| 7 |
+
N[1] = xi[1]
|
| 8 |
+
N[2] = xi[2]
|
| 9 |
+
dNdxi[0, 0] = 1.0
|
| 10 |
+
dNdxi[0, 1] = 0.0
|
| 11 |
+
dNdxi[0, 2] = 0.0
|
| 12 |
+
dNdxi[1, 0] = 0.0
|
| 13 |
+
dNdxi[1, 1] = 1.0
|
| 14 |
+
dNdxi[1, 2] = 0.0
|
| 15 |
+
dNdxi[2, 0] = 0.0
|
| 16 |
+
dNdxi[2, 1] = 0.0
|
| 17 |
+
dNdxi[2, 2] = 1.0
|
| 18 |
+
return N, dNdxi
|
37.py
ADDED
|
@@ -0,0 +1,18 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import empty, ndarray
|
| 2 |
+
import numpy as np
|
| 3 |
+
def get_shape_quad4(xi: ndarray) -> tuple[ndarray, ndarray]:
|
| 4 |
+
N = empty(4, dtype=np.float64)
|
| 5 |
+
dNdxi = empty(shape=(2, 4), dtype=np.float64)
|
| 6 |
+
N[0] = 0.25 * (1.0 - xi[0]) * (1.0 - xi[1])
|
| 7 |
+
N[1] = 0.25 * (1.0 + xi[0]) * (1.0 - xi[1])
|
| 8 |
+
N[2] = 0.25 * (1.0 + xi[0]) * (1.0 + xi[1])
|
| 9 |
+
N[3] = 0.25 * (1.0 - xi[0]) * (1.0 + xi[1])
|
| 10 |
+
dNdxi[0, 0] = -0.25 * (1.0 - xi[1])
|
| 11 |
+
dNdxi[0, 1] = 0.25 * (1.0 - xi[1])
|
| 12 |
+
dNdxi[0, 2] = 0.25 * (1.0 + xi[1])
|
| 13 |
+
dNdxi[0, 3] = -0.25 * (1.0 + xi[1])
|
| 14 |
+
dNdxi[1, 0] = -0.25 * (1.0 - xi[0])
|
| 15 |
+
dNdxi[1, 1] = -0.25 * (1.0 + xi[0])
|
| 16 |
+
dNdxi[1, 2] = 0.25 * (1.0 + xi[0])
|
| 17 |
+
dNdxi[1, 3] = 0.25 * (1.0 - xi[0])
|
| 18 |
+
return N, dNdxi
|
38.py
ADDED
|
@@ -0,0 +1,29 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import empty, ndarray
|
| 2 |
+
def get_shape_quad8(xi: ndarray) -> tuple[ndarray, ndarray]:
|
| 3 |
+
N = empty(8)
|
| 4 |
+
dNdxi = empty(shape=(2, 8))
|
| 5 |
+
N[0] = -0.25 * (1.0 - xi[0]) * (1.0 - xi[1]) * (1.0 + xi[0] + xi[1])
|
| 6 |
+
N[1] = -0.25 * (1.0 + xi[0]) * (1.0 - xi[1]) * (1.0 - xi[0] + xi[1])
|
| 7 |
+
N[2] = -0.25 * (1.0 + xi[0]) * (1.0 + xi[1]) * (1.0 - xi[0] - xi[1])
|
| 8 |
+
N[3] = -0.25 * (1.0 - xi[0]) * (1.0 + xi[1]) * (1.0 + xi[0] - xi[1])
|
| 9 |
+
N[4] = 0.5 * (1.0 - xi[0]) * (1.0 + xi[0]) * (1.0 - xi[1])
|
| 10 |
+
N[5] = 0.5 * (1.0 + xi[0]) * (1.0 + xi[1]) * (1.0 - xi[1])
|
| 11 |
+
N[6] = 0.5 * (1.0 - xi[0]) * (1.0 + xi[0]) * (1.0 + xi[1])
|
| 12 |
+
N[7] = 0.5 * (1.0 - xi[0]) * (1.0 + xi[1]) * (1.0 - xi[1])
|
| 13 |
+
dNdxi[0, 0] = -0.25 * (-1.0 + xi[1]) * (2.0 * xi[0] + xi[1])
|
| 14 |
+
dNdxi[0, 1] = 0.25 * (-1.0 + xi[1]) * (-2.0 * xi[0] + xi[1])
|
| 15 |
+
dNdxi[0, 2] = 0.25 * (1.0 + xi[1]) * (2.0 * xi[0] + xi[1])
|
| 16 |
+
dNdxi[0, 3] = -0.25 * (1.0 + xi[1]) * (-2.0 * xi[0] + xi[1])
|
| 17 |
+
dNdxi[0, 4] = xi[0] * (-1.0 + xi[1])
|
| 18 |
+
dNdxi[0, 5] = -0.5 * (1.0 + xi[1]) * (-1.0 + xi[1])
|
| 19 |
+
dNdxi[0, 6] = -xi[0] * (1.0 + xi[1])
|
| 20 |
+
dNdxi[0, 7] = 0.5 * (1.0 + xi[1]) * (-1.0 + xi[1])
|
| 21 |
+
dNdxi[1, 0] = -0.25 * (-1.0 + xi[0]) * (xi[0] + 2.0 * xi[1])
|
| 22 |
+
dNdxi[1, 1] = 0.25 * (1.0 + xi[0]) * (-xi[0] + 2.0 * xi[1])
|
| 23 |
+
dNdxi[1, 2] = 0.25 * (1.0 + xi[0]) * (xi[0] + 2.0 * xi[1])
|
| 24 |
+
dNdxi[1, 3] = -0.25 * (-1.0 + xi[0]) * (-xi[0] + 2.0 * xi[1])
|
| 25 |
+
dNdxi[1, 4] = 0.5 * (1.0 + xi[0]) * (-1.0 + xi[0])
|
| 26 |
+
dNdxi[1, 5] = -xi[1] * (1.0 + xi[0])
|
| 27 |
+
dNdxi[1, 6] = -0.5 * (1.0 + xi[0]) * (-1.0 + xi[0])
|
| 28 |
+
dNdxi[1, 7] = xi[1] * (-1.0 + xi[0])
|
| 29 |
+
return N, dNdxi
|
39.py
ADDED
|
@@ -0,0 +1,21 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import empty, ndarray
|
| 2 |
+
def get_shape_tetra4(xi: ndarray) -> tuple[ndarray, ndarray]:
|
| 3 |
+
N = empty(4)
|
| 4 |
+
dNdxi = empty(shape=(3, 4))
|
| 5 |
+
N[0] = 1.0 - xi[0] - xi[1] - xi[2]
|
| 6 |
+
N[1] = xi[0]
|
| 7 |
+
N[2] = xi[1]
|
| 8 |
+
N[3] = xi[2]
|
| 9 |
+
dNdxi[0, 0] = -1.0
|
| 10 |
+
dNdxi[0, 1] = 1.0
|
| 11 |
+
dNdxi[0, 2] = 0.0
|
| 12 |
+
dNdxi[0, 3] = 0.0
|
| 13 |
+
dNdxi[1, 0] = -1.0
|
| 14 |
+
dNdxi[1, 1] = 0.0
|
| 15 |
+
dNdxi[1, 2] = 1.0
|
| 16 |
+
dNdxi[1, 3] = 0.0
|
| 17 |
+
dNdxi[2, 0] = -1.0
|
| 18 |
+
dNdxi[2, 1] = 0.0
|
| 19 |
+
dNdxi[2, 2] = 0.0
|
| 20 |
+
dNdxi[2, 3] = 1.0
|
| 21 |
+
return N, dNdxi
|
40.py
ADDED
|
@@ -0,0 +1,25 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import empty, ndarray
|
| 2 |
+
def get_shape_tetra4_barycentric(xi: ndarray) -> tuple[ndarray, ndarray]:
|
| 3 |
+
N = empty(4)
|
| 4 |
+
dNdxi = empty(shape=(4, 4))
|
| 5 |
+
N[0] = xi[0]
|
| 6 |
+
N[1] = xi[1]
|
| 7 |
+
N[2] = xi[2]
|
| 8 |
+
N[3] = xi[3]
|
| 9 |
+
dNdxi[0, 0] = 1.0
|
| 10 |
+
dNdxi[0, 1] = 0.0
|
| 11 |
+
dNdxi[0, 2] = 0.0
|
| 12 |
+
dNdxi[0, 3] = 0.0
|
| 13 |
+
dNdxi[1, 0] = 0.0
|
| 14 |
+
dNdxi[1, 1] = 1.0
|
| 15 |
+
dNdxi[1, 2] = 0.0
|
| 16 |
+
dNdxi[1, 3] = 0.0
|
| 17 |
+
dNdxi[2, 0] = 0.0
|
| 18 |
+
dNdxi[2, 1] = 0.0
|
| 19 |
+
dNdxi[2, 2] = 1.0
|
| 20 |
+
dNdxi[2, 3] = 0.0
|
| 21 |
+
dNdxi[3, 0] = 0.0
|
| 22 |
+
dNdxi[3, 1] = 0.0
|
| 23 |
+
dNdxi[3, 2] = 0.0
|
| 24 |
+
dNdxi[3, 3] = 1.0
|
| 25 |
+
return N, dNdxi
|
41.py
ADDED
|
@@ -0,0 +1,37 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import empty, ndarray
|
| 2 |
+
def get_shape_hex8(xi: ndarray) -> tuple[ndarray, ndarray]:
|
| 3 |
+
N = empty(8)
|
| 4 |
+
dNdxi = empty(shape=(3, 8))
|
| 5 |
+
N[0] = 0.125 * (1.0 - xi[0]) * (1.0 - xi[1]) * (1.0 - xi[2])
|
| 6 |
+
N[1] = 0.125 * (1.0 + xi[0]) * (1.0 - xi[1]) * (1.0 - xi[2])
|
| 7 |
+
N[2] = 0.125 * (1.0 + xi[0]) * (1.0 + xi[1]) * (1.0 - xi[2])
|
| 8 |
+
N[3] = 0.125 * (1.0 - xi[0]) * (1.0 + xi[1]) * (1.0 - xi[2])
|
| 9 |
+
N[4] = 0.125 * (1.0 - xi[0]) * (1.0 - xi[1]) * (1.0 + xi[2])
|
| 10 |
+
N[5] = 0.125 * (1.0 + xi[0]) * (1.0 - xi[1]) * (1.0 + xi[2])
|
| 11 |
+
N[6] = 0.125 * (1.0 + xi[0]) * (1.0 + xi[1]) * (1.0 + xi[2])
|
| 12 |
+
N[7] = 0.125 * (1.0 - xi[0]) * (1.0 + xi[1]) * (1.0 + xi[2])
|
| 13 |
+
dNdxi[0, 0] = -0.125 * (1.0 - xi[1]) * (1.0 - xi[2])
|
| 14 |
+
dNdxi[0, 1] = 0.125 * (1.0 - xi[1]) * (1.0 - xi[2])
|
| 15 |
+
dNdxi[0, 2] = 0.125 * (1.0 + xi[1]) * (1.0 - xi[2])
|
| 16 |
+
dNdxi[0, 3] = -0.125 * (1.0 + xi[1]) * (1.0 - xi[2])
|
| 17 |
+
dNdxi[0, 4] = -0.125 * (1.0 - xi[1]) * (1.0 + xi[2])
|
| 18 |
+
dNdxi[0, 5] = 0.125 * (1.0 - xi[1]) * (1.0 + xi[2])
|
| 19 |
+
dNdxi[0, 6] = 0.125 * (1.0 + xi[1]) * (1.0 + xi[2])
|
| 20 |
+
dNdxi[0, 7] = -0.125 * (1.0 + xi[1]) * (1.0 + xi[2])
|
| 21 |
+
dNdxi[1, 0] = -0.125 * (1.0 - xi[0]) * (1.0 - xi[2])
|
| 22 |
+
dNdxi[1, 1] = -0.125 * (1.0 + xi[0]) * (1.0 - xi[2])
|
| 23 |
+
dNdxi[1, 2] = 0.125 * (1.0 + xi[0]) * (1.0 - xi[2])
|
| 24 |
+
dNdxi[1, 3] = 0.125 * (1.0 - xi[0]) * (1.0 - xi[2])
|
| 25 |
+
dNdxi[1, 4] = -0.125 * (1.0 - xi[0]) * (1.0 + xi[2])
|
| 26 |
+
dNdxi[1, 5] = -0.125 * (1.0 + xi[0]) * (1.0 + xi[2])
|
| 27 |
+
dNdxi[1, 6] = 0.125 * (1.0 + xi[0]) * (1.0 + xi[2])
|
| 28 |
+
dNdxi[1, 7] = 0.125 * (1.0 - xi[0]) * (1.0 + xi[2])
|
| 29 |
+
dNdxi[2, 0] = -0.125 * (1.0 - xi[0]) * (1.0 - xi[1])
|
| 30 |
+
dNdxi[2, 1] = -0.125 * (1.0 + xi[0]) * (1.0 - xi[1])
|
| 31 |
+
dNdxi[2, 2] = -0.125 * (1.0 + xi[0]) * (1.0 + xi[1])
|
| 32 |
+
dNdxi[2, 3] = -0.125 * (1.0 - xi[0]) * (1.0 + xi[1])
|
| 33 |
+
dNdxi[2, 4] = 0.125 * (1.0 - xi[0]) * (1.0 - xi[1])
|
| 34 |
+
dNdxi[2, 5] = 0.125 * (1.0 + xi[0]) * (1.0 - xi[1])
|
| 35 |
+
dNdxi[2, 6] = 0.125 * (1.0 + xi[0]) * (1.0 + xi[1])
|
| 36 |
+
dNdxi[2, 7] = 0.125 * (1.0 - xi[0]) * (1.0 + xi[1])
|
| 37 |
+
return N, dNdxi
|
42.py
ADDED
|
@@ -0,0 +1,29 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import empty, ndarray, array
|
| 2 |
+
def get_shape_tria6_barycentric(xi: ndarray) -> tuple[ndarray, ndarray]:
|
| 3 |
+
N = empty(6)
|
| 4 |
+
dNdxi = empty(shape=(3, 6))
|
| 5 |
+
N[0] = xi[0] * (2.0 * xi[0] - 1.0)
|
| 6 |
+
N[1] = xi[1] * (2.0 * xi[1] - 1.0)
|
| 7 |
+
N[2] = xi[2] * (2.0 * xi[2] - 1.0)
|
| 8 |
+
N[3] = 4.0 * xi[0] * xi[1]
|
| 9 |
+
N[4] = 4.0 * xi[1] * xi[2]
|
| 10 |
+
N[5] = 4.0 * xi[2] * xi[0]
|
| 11 |
+
dNdxi[0, 0] = 4.0 * xi[0] - 1.0
|
| 12 |
+
dNdxi[0, 1] = 0.0
|
| 13 |
+
dNdxi[0, 2] = 0.0
|
| 14 |
+
dNdxi[0, 3] = 4.0 * xi[1]
|
| 15 |
+
dNdxi[0, 4] = 0.0
|
| 16 |
+
dNdxi[0, 5] = 4.0 * xi[2]
|
| 17 |
+
dNdxi[1, 0] = 0.0
|
| 18 |
+
dNdxi[1, 1] = 4.0 * xi[1] - 1.0
|
| 19 |
+
dNdxi[1, 2] = 0.0
|
| 20 |
+
dNdxi[1, 3] = 4.0 * xi[0]
|
| 21 |
+
dNdxi[1, 4] = 4.0 * xi[2]
|
| 22 |
+
dNdxi[1, 5] = 0.0
|
| 23 |
+
dNdxi[2, 0] = 0.0
|
| 24 |
+
dNdxi[2, 1] = 0.0
|
| 25 |
+
dNdxi[2, 2] = 4.0 * xi[2] - 1.0
|
| 26 |
+
dNdxi[2, 3] = 0.0
|
| 27 |
+
dNdxi[2, 4] = 4.0 * xi[1]
|
| 28 |
+
dNdxi[2, 5] = 4.0 * xi[0]
|
| 29 |
+
return N, dNdxi
|
43.py
ADDED
|
@@ -0,0 +1,29 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import empty, ndarray
|
| 2 |
+
def get_shape_tria6_barycentric(xi: ndarray) -> tuple[ndarray, ndarray]:
|
| 3 |
+
N = empty(6)
|
| 4 |
+
dNdxi = empty(shape=(3, 6))
|
| 5 |
+
N[0] = xi[0] * (2.0 * xi[0] - 1.0)
|
| 6 |
+
N[1] = xi[1] * (2.0 * xi[1] - 1.0)
|
| 7 |
+
N[2] = xi[2] * (2.0 * xi[2] - 1.0)
|
| 8 |
+
N[3] = 4.0 * xi[0] * xi[1]
|
| 9 |
+
N[4] = 4.0 * xi[1] * xi[2]
|
| 10 |
+
N[5] = 4.0 * xi[2] * xi[0]
|
| 11 |
+
dNdxi[0, 0] = 4.0 * xi[0] - 1.0
|
| 12 |
+
dNdxi[0, 1] = 0.0
|
| 13 |
+
dNdxi[0, 2] = 0.0
|
| 14 |
+
dNdxi[0, 3] = 4.0 * xi[1]
|
| 15 |
+
dNdxi[0, 4] = 0.0
|
| 16 |
+
dNdxi[0, 5] = 4.0 * xi[2]
|
| 17 |
+
dNdxi[1, 0] = 0.0
|
| 18 |
+
dNdxi[1, 1] = 4.0 * xi[1] - 1.0
|
| 19 |
+
dNdxi[1, 2] = 0.0
|
| 20 |
+
dNdxi[1, 3] = 4.0 * xi[0]
|
| 21 |
+
dNdxi[1, 4] = 4.0 * xi[2]
|
| 22 |
+
dNdxi[1, 5] = 0.0
|
| 23 |
+
dNdxi[2, 0] = 0.0
|
| 24 |
+
dNdxi[2, 1] = 0.0
|
| 25 |
+
dNdxi[2, 2] = 4.0 * xi[2] - 1.0
|
| 26 |
+
dNdxi[2, 3] = 0.0
|
| 27 |
+
dNdxi[2, 4] = 4.0 * xi[1]
|
| 28 |
+
dNdxi[2, 5] = 4.0 * xi[0]
|
| 29 |
+
return N, dNdxi
|
44.py
ADDED
|
@@ -0,0 +1,13 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
import numpy as np
|
| 2 |
+
from numpy import zeros, ndarray, array, sum, dot, maximum, tensordot
|
| 3 |
+
from numpy.linalg import inv, norm, eig
|
| 4 |
+
def inverse(qp_jacobis: ndarray, qp_jacobi_dets: ndarray) -> ndarray:
|
| 5 |
+
qp_jacobi_invs = []
|
| 6 |
+
for A, det_A in zip(qp_jacobis, qp_jacobi_dets):
|
| 7 |
+
if A.shape == (2, 2):
|
| 8 |
+
qp_jacobi_invs.append(array([[A[1][1], -A[0][1]], [-A[1][0], A[0][0]]]) / det_A)
|
| 9 |
+
elif A.shape == (3, 3):
|
| 10 |
+
qp_jacobi_invs.append(array([[(A[1][1] * A[2][2] - A[1][2] * A[2][1]), (A[0][2] * A[2][1] - A[0][1] * A[2][2]), (A[0][1] * A[1][2] - A[0][2] * A[1][1])], [(A[1][2] * A[2][0] - A[1][0] * A[2][2]), (A[0][0] * A[2][2] - A[0][2] * A[2][0]), (A[0][2] * A[1][0] - A[0][0] * A[1][2])], [(A[1][0] * A[2][1] - A[1][1] * A[2][0]), (A[0][1] * A[2][0] - A[0][0] * A[2][1]), (A[0][0] * A[1][1] - A[0][1] * A[1][0])]]) / det_A)
|
| 11 |
+
else:
|
| 12 |
+
return inv(qp_jacobis)
|
| 13 |
+
return array(qp_jacobi_invs)
|
45.py
ADDED
|
@@ -0,0 +1,7 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import zeros, ndarray, array, sum, dot, maximum, tensordot
|
| 2 |
+
from numpy.linalg import inv, norm, eig
|
| 3 |
+
def get_transformation(u: ndarray, v: ndarray, w: ndarray, u_prime: ndarray, v_prime: ndarray, w_prime: ndarray) -> ndarray:
|
| 4 |
+
A = array([u, v, w])
|
| 5 |
+
A_prime = array([u_prime, v_prime, w_prime])
|
| 6 |
+
T = dot(A_prime, inv(A))
|
| 7 |
+
return T
|
46.py
ADDED
|
@@ -0,0 +1,19 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import zeros, ndarray
|
| 2 |
+
def voigt_array_to_tensor(voigt_array: ndarray, dimension: int) -> ndarray:
|
| 3 |
+
tensor = zeros(shape=(dimension, dimension))
|
| 4 |
+
if dimension == 2:
|
| 5 |
+
tensor[0, 0] = voigt_array[0]
|
| 6 |
+
tensor[1, 1] = voigt_array[1]
|
| 7 |
+
tensor[0, 1] = voigt_array[2]
|
| 8 |
+
tensor[1, 0] = voigt_array[2]
|
| 9 |
+
elif dimension == 3:
|
| 10 |
+
tensor[0, 0] = voigt_array[0]
|
| 11 |
+
tensor[1, 1] = voigt_array[1]
|
| 12 |
+
tensor[2, 2] = voigt_array[2]
|
| 13 |
+
tensor[0, 1] = voigt_array[3]
|
| 14 |
+
tensor[0, 2] = voigt_array[4]
|
| 15 |
+
tensor[1, 2] = voigt_array[5]
|
| 16 |
+
tensor[1, 0] = voigt_array[3]
|
| 17 |
+
tensor[2, 0] = voigt_array[4]
|
| 18 |
+
tensor[2, 1] = voigt_array[5]
|
| 19 |
+
return tensor
|
47.py
ADDED
|
@@ -0,0 +1,50 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import zeros, ndarray
|
| 2 |
+
import numpy as np
|
| 3 |
+
def get_voigt_transformation(transformation: ndarray) -> ndarray:
|
| 4 |
+
voigt_transformation = zeros(shape=(6, 6), dtype=np.float64)
|
| 5 |
+
a11 = transformation[0][0]
|
| 6 |
+
a12 = transformation[0][1]
|
| 7 |
+
a13 = transformation[0][2]
|
| 8 |
+
a21 = transformation[1][0]
|
| 9 |
+
a22 = transformation[1][1]
|
| 10 |
+
a23 = transformation[1][2]
|
| 11 |
+
a31 = transformation[2][0]
|
| 12 |
+
a32 = transformation[2][1]
|
| 13 |
+
a33 = transformation[2][2]
|
| 14 |
+
voigt_transformation[0][0] = a11 ** 2
|
| 15 |
+
voigt_transformation[0][1] = a12 ** 2
|
| 16 |
+
voigt_transformation[0][2] = a13 ** 2
|
| 17 |
+
voigt_transformation[0][3] = 2 * a11 * a12
|
| 18 |
+
voigt_transformation[0][4] = 2 * a11 * a13
|
| 19 |
+
voigt_transformation[0][5] = 2 * a12 * a13
|
| 20 |
+
voigt_transformation[1][0] = a21 ** 2
|
| 21 |
+
voigt_transformation[1][1] = a22 ** 2
|
| 22 |
+
voigt_transformation[1][2] = a23 ** 2
|
| 23 |
+
voigt_transformation[1][3] = 2 * a21 * a22
|
| 24 |
+
voigt_transformation[1][4] = 2 * a21 * a23
|
| 25 |
+
voigt_transformation[1][5] = 2 * a22 * a23
|
| 26 |
+
voigt_transformation[2][0] = a31 ** 2
|
| 27 |
+
voigt_transformation[2][1] = a32 ** 2
|
| 28 |
+
voigt_transformation[2][2] = a33 ** 2
|
| 29 |
+
voigt_transformation[2][3] = 2 * a31 * a32
|
| 30 |
+
voigt_transformation[2][4] = 2 * a31 * a33
|
| 31 |
+
voigt_transformation[2][5] = 2 * a32 * a33
|
| 32 |
+
voigt_transformation[3][0] = a11 * a21
|
| 33 |
+
voigt_transformation[3][1] = a12 * a22
|
| 34 |
+
voigt_transformation[3][2] = a13 * a23
|
| 35 |
+
voigt_transformation[3][3] = a12 * a21 + a11 * a22
|
| 36 |
+
voigt_transformation[3][4] = a13 * a21 + a11 * a23
|
| 37 |
+
voigt_transformation[3][5] = a13 * a22 + a12 * a23
|
| 38 |
+
voigt_transformation[4][0] = a11 * a31
|
| 39 |
+
voigt_transformation[4][1] = a12 * a32
|
| 40 |
+
voigt_transformation[4][2] = a13 * a33
|
| 41 |
+
voigt_transformation[4][3] = a12 * a31 + a11 * a32
|
| 42 |
+
voigt_transformation[4][4] = a13 * a31 + a11 * a33
|
| 43 |
+
voigt_transformation[4][5] = a13 * a32 + a12 * a33
|
| 44 |
+
voigt_transformation[5][0] = a21 * a31
|
| 45 |
+
voigt_transformation[5][1] = a22 * a32
|
| 46 |
+
voigt_transformation[5][2] = a23 * a33
|
| 47 |
+
voigt_transformation[5][3] = a22 * a31 + a21 * a32
|
| 48 |
+
voigt_transformation[5][4] = a23 * a31 + a21 * a33
|
| 49 |
+
voigt_transformation[5][5] = a23 * a32 + a22 * a33
|
| 50 |
+
return voigt_transformation
|
48.py
ADDED
|
@@ -0,0 +1,85 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
from numpy import zeros, ndarray, sum
|
| 2 |
+
from numpy.linalg import eig
|
| 3 |
+
def voigt_array_to_tensor(voigt_array: ndarray, dimension: int) -> ndarray:
|
| 4 |
+
tensor = zeros(shape=(dimension, dimension))
|
| 5 |
+
if dimension == 2:
|
| 6 |
+
tensor[0, 0] = voigt_array[0]
|
| 7 |
+
tensor[1, 1] = voigt_array[1]
|
| 8 |
+
tensor[0, 1] = voigt_array[2]
|
| 9 |
+
tensor[1, 0] = voigt_array[2]
|
| 10 |
+
elif dimension == 3:
|
| 11 |
+
tensor[0, 0] = voigt_array[0]
|
| 12 |
+
tensor[1, 1] = voigt_array[1]
|
| 13 |
+
tensor[2, 2] = voigt_array[2]
|
| 14 |
+
tensor[0, 1] = voigt_array[3]
|
| 15 |
+
tensor[0, 2] = voigt_array[4]
|
| 16 |
+
tensor[1, 2] = voigt_array[5]
|
| 17 |
+
tensor[1, 0] = voigt_array[3]
|
| 18 |
+
tensor[2, 0] = voigt_array[4]
|
| 19 |
+
tensor[2, 1] = voigt_array[5]
|
| 20 |
+
return tensor
|
| 21 |
+
def get_decompose_energy(strain: ndarray, stress: ndarray, dimension: int):
|
| 22 |
+
E = 1.0e5
|
| 23 |
+
nu = 0.25
|
| 24 |
+
mu = E / (2.0 * (1.0 + nu))
|
| 25 |
+
lame = (E * nu) / ((1.0 + nu) * (1.0 - 2.0 * nu))
|
| 26 |
+
strain = voigt_array_to_tensor(strain, dimension)
|
| 27 |
+
principle_strain_value, principle_strain_vector = eig(strain)
|
| 28 |
+
energy_positive = 0.0
|
| 29 |
+
energy_negative = 0.0
|
| 30 |
+
if dimension == 2:
|
| 31 |
+
ep1 = max(principle_strain_value)
|
| 32 |
+
ep2 = min(principle_strain_value)
|
| 33 |
+
eq_sum = sum(principle_strain_value)
|
| 34 |
+
if ep1 > 0.0:
|
| 35 |
+
ep1_p = (abs(ep1) + ep1) / 2.0
|
| 36 |
+
ep1_n = 0.0
|
| 37 |
+
else:
|
| 38 |
+
ep1_p = 0.0
|
| 39 |
+
ep1_n = (abs(ep1) - ep1) / 2.0
|
| 40 |
+
if ep2 > 0.0:
|
| 41 |
+
ep2_p = (abs(ep2) + ep2) / 2.0
|
| 42 |
+
ep2_n = 0.0
|
| 43 |
+
else:
|
| 44 |
+
ep2_p = 0.0
|
| 45 |
+
ep2_n = (abs(ep2) - ep2) / 2.0
|
| 46 |
+
if eq_sum > 0.0:
|
| 47 |
+
eq_sum_p = (abs(eq_sum) + eq_sum) / 2.0
|
| 48 |
+
eq_sum_n = 0.0
|
| 49 |
+
else:
|
| 50 |
+
eq_sum_p = 0.0
|
| 51 |
+
eq_sum_n = (abs(eq_sum) - eq_sum) / 2.0
|
| 52 |
+
energy_positive = lame / 2.0 * eq_sum_p ** 2.0 + mu * (ep1_p ** 2.0 + ep2_p ** 2.0)
|
| 53 |
+
energy_negative = lame / 2.0 * eq_sum_n ** 2.0 + mu * (ep1_n ** 2.0 + ep2_n ** 2.0)
|
| 54 |
+
elif dimension == 3:
|
| 55 |
+
ep1 = max(principle_strain_value)
|
| 56 |
+
ep3 = min(principle_strain_value)
|
| 57 |
+
eq_sum = sum(principle_strain_value)
|
| 58 |
+
ep2 = eq_sum - ep1 - ep3
|
| 59 |
+
if ep1 > 0.0:
|
| 60 |
+
ep1_p = (abs(ep1) + ep1) / 2.0
|
| 61 |
+
ep1_n = 0.0
|
| 62 |
+
else:
|
| 63 |
+
ep1_p = 0.0
|
| 64 |
+
ep1_n = (abs(ep1) - ep1) / 2.0
|
| 65 |
+
if ep2 > 0.0:
|
| 66 |
+
ep2_p = (abs(ep2) + ep2) / 2.0
|
| 67 |
+
ep2_n = 0.0
|
| 68 |
+
else:
|
| 69 |
+
ep2_p = 0.0
|
| 70 |
+
ep2_n = (abs(ep2) - ep2) / 2.0
|
| 71 |
+
if ep3 > 0.0:
|
| 72 |
+
ep3_p = (abs(ep3) + ep3) / 2.0
|
| 73 |
+
ep3_n = 0.0
|
| 74 |
+
else:
|
| 75 |
+
ep3_p = 0.0
|
| 76 |
+
ep3_n = (abs(ep3) - ep3) / 2.0
|
| 77 |
+
if eq_sum > 0.0:
|
| 78 |
+
eq_sum_p = (abs(eq_sum) + eq_sum) / 2.0
|
| 79 |
+
eq_sum_n = 0.0
|
| 80 |
+
else:
|
| 81 |
+
eq_sum_p = 0.0
|
| 82 |
+
eq_sum_n = (abs(eq_sum) - eq_sum) / 2.0
|
| 83 |
+
energy_positive = lame / 2.0 * eq_sum_p ** 2.0 + mu * (ep1_p ** 2.0 + ep2_p ** 2.0 + ep3_p ** 2.0)
|
| 84 |
+
energy_negative = lame / 2.0 * eq_sum_n ** 2.0 + mu * (ep1_n ** 2.0 + ep2_n ** 2.0 + ep3_n ** 2.0)
|
| 85 |
+
return energy_positive, energy_negative
|
49.py
ADDED
|
@@ -0,0 +1,8 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
import numpy as np
|
| 2 |
+
from numpy import zeros, ndarray, array, dot
|
| 3 |
+
def operations_for_symtensor_antisymtensor(sym_tensor: ndarray, antisym_tensor: ndarray) -> ndarray:
|
| 4 |
+
result = zeros(shape=(len(antisym_tensor), 6), dtype=np.float64)
|
| 5 |
+
for i in range(len(antisym_tensor)):
|
| 6 |
+
T = array([[0, 0, 0, 2 * antisym_tensor[i, 3], 2 * antisym_tensor[i, 4], 0], [0, 0, 0, -2 * antisym_tensor[i, 3], 0, 2 * antisym_tensor[i, 5]], [0, 0, 0, 0, -2 * antisym_tensor[i, 4], -2 * antisym_tensor[i, 5]], [-antisym_tensor[i, 3], antisym_tensor[i, 3], 0, 0, antisym_tensor[i, 5], antisym_tensor[i, 4]], [-antisym_tensor[i, 4], 0, antisym_tensor[i, 4], -antisym_tensor[i, 5], 0, antisym_tensor[i, 3]], [0, -antisym_tensor[i, 5], antisym_tensor[i, 5], -antisym_tensor[i, 4], -antisym_tensor[i, 3], 0]])
|
| 7 |
+
result[i, :] = dot(T, sym_tensor)
|
| 8 |
+
return result
|
53.py
ADDED
|
@@ -0,0 +1,11 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
def get_ordinal_number(num: int) -> str:
|
| 2 |
+
if num % 100 in [11, 12, 13]:
|
| 3 |
+
return str(num) + "th"
|
| 4 |
+
elif num % 10 == 1:
|
| 5 |
+
return str(num) + "st"
|
| 6 |
+
elif num % 10 == 2:
|
| 7 |
+
return str(num) + "nd"
|
| 8 |
+
elif num % 10 == 3:
|
| 9 |
+
return str(num) + "rd"
|
| 10 |
+
else:
|
| 11 |
+
return str(num) + "th"
|