diff --git a/01.py b/01.py new file mode 100644 index 0000000000000000000000000000000000000000..300500bf23fd2cb37b7bc7a2835771955def6ee7 --- /dev/null +++ b/01.py @@ -0,0 +1,4 @@ +def plane_strain_isotropic(e, nu): + from numpy import array + 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))) + return d \ No newline at end of file diff --git a/02.py b/02.py new file mode 100644 index 0000000000000000000000000000000000000000..c8faff9d81a0139e171c6a7e55c8dcd91ad65d53 --- /dev/null +++ b/02.py @@ -0,0 +1,4 @@ +def plane_stress_isotropic(e, nu): + from numpy import array + 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) + return d \ No newline at end of file diff --git a/03.py b/03.py new file mode 100644 index 0000000000000000000000000000000000000000..dd597a468bf8ea258c27ad484cdb58fcf30104e1 --- /dev/null +++ b/03.py @@ -0,0 +1,15 @@ +def iso_quad(element_nodes, xi, eta): + from numpy import sum,array + from numpy.linalg import det + from numpy.linalg import inv + 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]) + shape_dxi = array([-(1.0 - eta) / 4.0,(1.0 - eta) / 4.0,(1.0 + eta) / 4.0,-(1.0 + eta) / 4.0]) + shape_deta = array([-(1.0 - xi) / 4.0,-(1.0 + xi) / 4.0,(1.0 + xi) / 4.0,(1.0 - xi) / 4.0]) + x = element_nodes[:, 0] + y = element_nodes[:, 1] + jacobi = array([[sum(shape_dxi * x), sum(shape_dxi * y)],[sum(shape_deta * x), sum(shape_deta * y)]]) + jacobian = det(jacobi) + inverted_jacobi = inv(jacobi) + shape_dx = inverted_jacobi[0, 0] * shape_dxi + inverted_jacobi[0, 1] * shape_deta + shape_dy = inverted_jacobi[1, 0] * shape_dxi + inverted_jacobi[1, 1] * shape_deta + return jacobian, shape, shape_dx, shape_dy \ No newline at end of file diff --git a/04.py b/04.py new file mode 100644 index 0000000000000000000000000000000000000000..e291668f697feb198301aecdf586e9b673dc8562 --- /dev/null +++ b/04.py @@ -0,0 +1,16 @@ +def iso_triangle(element_nodes, xi, eta): + from numpy import array + from numpy import sum + from numpy.linalg import det + from numpy.linalg import inv + shape = array([1.0 - xi - eta,xi,eta]) + shape_dxi = array([-1.0,1.0,0.0]) + shape_deta = array([-1.0,0.0,1.0]) + x = element_nodes[:, 0] + y = element_nodes[:, 1] + jacobi = array([[sum(shape_dxi * x), sum(shape_dxi * y)],[sum(shape_deta * x), sum(shape_deta * y)]]) + jacobian = det(jacobi) + inverted_jacobi = inv(jacobi) + shape_dx = inverted_jacobi[0, 0] * shape_dxi + inverted_jacobi[0, 1] * shape_deta + shape_dy = inverted_jacobi[1, 0] * shape_dxi + inverted_jacobi[1, 1] * shape_deta + return jacobian, shape, shape_dx, shape_dy \ No newline at end of file diff --git a/05.py b/05.py new file mode 100644 index 0000000000000000000000000000000000000000..767a774bb62a61a1f83b11087552eaf901095b71 --- /dev/null +++ b/05.py @@ -0,0 +1,23 @@ +from numpy import array +def legendre_interval(count): + from math import sqrt + if count <= 1: + p = array([0.0]) + w = array([2.0]) + return p, w + elif count == 2: + p = array([-1.0 / sqrt(3.0),1.0 / sqrt(3.0)]) + w = array([1.0,1.0]) + return p, w + elif count == 3: + p = array([-sqrt(3.0 / 5.0),0.0,sqrt(3.0 / 5.0)]) + w = array([5.0 / 9.0,8.0 / 9.0,5.0 / 9.0]) + return p, w + elif count == 4: + 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)]) + 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]) + return p, w + else: + 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))]) + 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]) + return p, w \ No newline at end of file diff --git a/06.py b/06.py new file mode 100644 index 0000000000000000000000000000000000000000..cff06c56914c7c8413200ae74ee82226357106d1 --- /dev/null +++ b/06.py @@ -0,0 +1,22 @@ +from numpy import array +def legendre_triangle(order): + if order <= 1: + xi = array([1.0 / 3.0]) + eta = array([1.0 / 3.0]) + w = array([1.0 / 2.0]) + return xi, eta, w + elif order == 2: + xi = array([1.0 / 2.0, 0.0,1.0 / 2.0]) + eta = array([1.0 / 2.0,1.0 / 2.0,0.0]) + w = array([1.0 / 6.0,1.0 / 6.0,1.0 / 6.0]) + return xi, eta, w + elif order == 3: + xi = array([1.0 / 6.0,2.0 / 3.0,1.0 / 6.0]) + eta = array([1.0 / 6.0, 1.0 / 6.0, 2.0 / 3.0]) + w = array([1.0 / 6.0, 1.0 / 6.0, 1.0 / 6.0]) + return xi, eta, w + else: + xi = array([1.0 / 3.0, 1.0 / 5.0, 1.0 / 5.0, 3.0 / 5.0]) + eta = array([1.0 / 3.0,3.0 / 5.0,1.0 / 5.0,1.0 / 5.0]) + w = array([-9.0 / 32.0,25.0 / 96.0, 25.0 / 96.0,25.0 / 96.0]) + return xi, eta, w \ No newline at end of file diff --git a/07.py b/07.py new file mode 100644 index 0000000000000000000000000000000000000000..fc8314e58826bac76f7158b4f7519701fdf420ec --- /dev/null +++ b/07.py @@ -0,0 +1,21 @@ +from numpy import array +def legendre_tetrahedra(order): + from math import sqrt + if order <= 1: + xi = array([0.25]) + eta = array([0.25]) + mu = array([0.25]) + w = array([1.0]) / 6.0 + return xi, eta, mu, w + elif order == 2: + 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]) + 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]) + 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]) + w = array([0.25, 0.25,0.25, 0.25]) / 6.0 + return xi, eta, mu, w + else: + xi = array([1.0 / 4.0, 1.0 / 2.0, 1.0 / 6.0, 1.0 / 6.0, 1.0 / 6.0]) + eta = array([1.0 / 4.0, 1.0 / 6.0, 1.0 / 2.0, 1.0 / 6.0, 1.0 / 6.0]) + mu = array([1.0 / 4.0, 1.0 / 6.0, 1.0 / 6.0, 1.0 / 2.0,1.0 / 6.0]) + w = array([-4.0 / 5.0, 9.0 / 20.0, 9.0 / 20.0, 9.0 / 20.0,9.0 / 20.0]) / 6.0 + return xi, eta, mu, w \ No newline at end of file diff --git a/08.py b/08.py new file mode 100644 index 0000000000000000000000000000000000000000..382978d8fd5d857625b010ce64f35d0742ebcdbf --- /dev/null +++ b/08.py @@ -0,0 +1,36 @@ +from numpy import * +def legendre_interval(count): + from math import sqrt + if count <= 1: + p = array([0.0]) + w = array([2.0]) + return p, w + elif count == 2: + p = array([-1.0 / sqrt(3.0), 1.0 / sqrt(3.0)]) + w = array([1.0, 1.0]) + return p, w + elif count == 3: + p = array([-sqrt(3.0 / 5.0), 0.0, sqrt(3.0 / 5.0)]) + w = array([5.0 / 9.0, 8.0 / 9.0, 5.0 / 9.0]) + return p, w + elif count == 4: + 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)]) + 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]) + return p, w + else: + 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))]) + 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]) + return p, w +def legendre_quad(order): + from numpy import zeros + (p, w) = legendre_interval(order) + size = len(p) + xi = zeros(size * size) + eta = zeros(size * size) + weight = zeros(size * size) + for i in range(size): + for j in range(size): + xi[i * size + j] = p[i] + eta[i * size + j] = p[j] + weight[i * size + j] = w[i] * w[j] + return xi, eta, weight \ No newline at end of file diff --git a/09.py b/09.py new file mode 100644 index 0000000000000000000000000000000000000000..076a44743dbb1f34401a2c626841b4b08a6ae1d0 --- /dev/null +++ b/09.py @@ -0,0 +1,40 @@ +from numpy import * +def legendre_interval(count): + from math import sqrt + if count <= 1: + p = array([0.0]) + w = array([2.0]) + return p, w + elif count == 2: + p = array([-1.0 / sqrt(3.0), 1.0 / sqrt(3.0)]) + w = array([1.0, 1.0]) + return p, w + elif count == 3: + p = array([-sqrt(3.0 / 5.0), 0.0, sqrt(3.0 / 5.0)]) + w = array([5.0 / 9.0, 8.0 / 9.0, 5.0 / 9.0]) + return p, w + elif count == 4: + 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)]) + 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]) + return p, w + else: + 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))]) + 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]) + return p, w +def legendre_hexahedra(order): + from numpy import zeros + (p, w) = legendre_interval(order) + size = len(p) + xi = zeros(size * size * size) + eta = zeros(size * size * size) + mu = zeros(size * size * size) + weight = zeros(size * size * size) + size_size = size * size + for i in range(size): + for j in range(size): + for k in range(size): + xi[i * size_size + j * size + k] = p[i] + eta[i * size_size + j * size + k] = p[j] + mu[i * size_size + j * size + k] = p[k] + weight[i * size_size + j * size + k] = w[i] * w[j] * w[k] + return xi, eta, mu, weight \ No newline at end of file diff --git a/10.py b/10.py new file mode 100644 index 0000000000000000000000000000000000000000..ff188d2c736da90857328d0b6283d8097e85446a --- /dev/null +++ b/10.py @@ -0,0 +1,19 @@ +def lobatto_interval(count): + from math import sqrt + from numpy import array + if count <= 2: + p = array([-1.0, 1.0]) + w = array([1.0, 1.0]) + return p, w + elif count == 3: + p = array([-1.0, 0.0, 1.0]) + w = array([1.0 / 3.0, 4.0 / 3.0, 1.0 / 3.0]) + return p, w + elif count == 4: + p = array([-1.0, -1.0 / sqrt(5.0), 1.0 / sqrt(5.0), 1.0]) + w = array([1.0 / 6.0, 5.0 / 6.0, 5.0 / 6.0, 1.0 / 6.0]) + return p, w + else: + p = array([-1.0, -sqrt(3.0 / 7.0), 0.0, sqrt(3.0 / 7.0), 1.0]) + w = array([1.0 / 10.0, 49.0 / 90.0, 32.0 / 45.0, 49.0 / 90.0, 1.0 / 10.0]) + return p, w \ No newline at end of file diff --git a/100.py b/100.py new file mode 100644 index 0000000000000000000000000000000000000000..ab61c05f77c5a0b5ec696348d6d88d3df9d14888 --- /dev/null +++ b/100.py @@ -0,0 +1,29 @@ +from numpy import * +from scipy.linalg import inv +from itertools import chain +def get_D(E, v): + return (E / (1 - v ** 2)) * array([ [1, v, 0], [v, 1, 0], [0, 0, 0.5 * (1 - v)] ]) +def compute_stress_quad9(disp, material, nodes): + def partials(xi, eta): + 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] ]) + def Jacobi(xi, eta): + p = partials(xi, eta) + coords = row_stack(nodes) + return dot(p, nodes) + def partial_xy(xi, eta): + J = Jacobi(xi, eta) + partial_xe = partials(xi, eta) + return dot(inv(J), partial_xe) + def B(xi, eta): + p = partial_xy(xi, eta) + zeros9 = [0 for i in range(9)] + return array([ list(chain(*zip(p[0, :], zeros9))), list(chain(*zip(zeros9, p[1, :]))), list(chain(*zip(p[1, :], p[0, :]))), ]) + D = get_D(*material) + 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)] + 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)] + p, q = 1 + 1 / sqrt(3), 1 - 1 / sqrt(3) + 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] ]) + stress_at_gaussian_nodes = array([dot(D, e) for e in strain_at_gaussian_nodes]) + stress_at_corner_nodes = dot(inv(weight_matrix), stress_at_gaussian_nodes) + stress_at_internal_nodes = [dot(D, e) for e in strain_at_internal_nodes] + return row_stack((stress_at_corner_nodes, stress_at_internal_nodes)) \ No newline at end of file diff --git a/11.py b/11.py new file mode 100644 index 0000000000000000000000000000000000000000..c268cc0fc6cb8e14a12d6058e506c4042aba0954 --- /dev/null +++ b/11.py @@ -0,0 +1,32 @@ +def lobatto_interval(count): + from math import sqrt + from numpy import array + if count <= 2: + p = array([-1.0, 1.0]) + w = array([1.0, 1.0]) + return p, w + elif count == 3: + p = array([-1.0, 0.0, 1.0]) + w = array([1.0 / 3.0, 4.0 / 3.0, 1.0 / 3.0]) + return p, w + elif count == 4: + p = array([-1.0, -1.0 / sqrt(5.0), 1.0 / sqrt(5.0), 1.0]) + w = array([1.0 / 6.0, 5.0 / 6.0, 5.0 / 6.0, 1.0 / 6.0]) + return p, w + else: + p = array([-1.0, -sqrt(3.0 / 7.0), 0.0, sqrt(3.0 / 7.0), 1.0]) + w = array([1.0 / 10.0, 49.0 / 90.0, 32.0 / 45.0, 49.0 / 90.0, 1.0 / 10.0]) + return p, w +def lobatto_quad(order): + from numpy import zeros + (p, w) = lobatto_interval(order) + size = len(p) + xi = zeros(size * size) + eta = zeros(size * size) + weight = zeros(size * size) + for i in range(size): + for j in range(size): + xi[i * size + j] = p[i] + eta[i * size + j] = p[j] + weight[i * size + j] = w[i] * w[j] + return xi, eta, weight \ No newline at end of file diff --git a/110.py b/110.py new file mode 100644 index 0000000000000000000000000000000000000000..df3ffd74ad12c421ab7458850d07570fa567de2d --- /dev/null +++ b/110.py @@ -0,0 +1,26 @@ +import numpy as np +import plotly.graph_objects as go +import ross as rs +import plotly.io as pio +pio.renderers.default = "notebook" +steel = rs.materials.steel +number_of_elements = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 40, 60] +def create_rotor(n_el): + shaft = [ rs.ShaftElement(1.2 / (n_el), idl=0.03, odl=0.08, material=steel) for i in range(n_el) ] + disks = [ rs.DiskElement.from_geometry( n=(n_el / 2), material=steel, width=0.08, i_d=0.08, o_d=0.4 ) ] + bearings = [ rs.BearingElement(0, kxx=1e15, cxx=0), rs.BearingElement(n_el, kxx=1e15, cxx=0), ] + return rs.Rotor(shaft, disks, bearings) +def analysis(speed): + n_eigen = 8 + rotor_80 = create_rotor(80) + modal_80 = rotor_80.run_modal(speed, num_modes=2 * n_eigen) + errors = np.zeros([len(number_of_elements), n_eigen]) + for i, n_el in enumerate(number_of_elements): + rotor = create_rotor(n_el) + modal = rotor.run_modal(speed, num_modes=2 * n_eigen) + errors[i, :] = abs( 100 * (modal.wn[:n_eigen] - modal_80.wn[:n_eigen]) / modal_80.wn[:n_eigen] ) + fig = go.Figure() + for i in range(8): + fig.add_trace( go.Scatter(x=number_of_elements, y=errors[:, i], name=f"Mode {i}") ) + fig.update_layout( xaxis=dict(title="Number of degrees of freedom"), yaxis=dict(type="log", title="Natural Frequency Error(%)"), ) + return fig \ No newline at end of file diff --git a/112.py b/112.py new file mode 100644 index 0000000000000000000000000000000000000000..266847f7bd5d645575f23e99655e957b1744fb10 --- /dev/null +++ b/112.py @@ -0,0 +1,14 @@ +import ross as rs +import plotly.io as pio +pio.renderers.default = "notebook" +steel = rs.materials.steel +number_of_elements = [2, 3, 4, 5, 6, 7, 8] +def create_rotor(n_el, R, shear_effects=False, rotary_inertia=False): + L_total = 1 + D = R * L_total + 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) ] + bearings = [ rs.BearingElement(0, kxx=1e15, cxx=0), rs.BearingElement(n_el, kxx=1e15, cxx=0), ] + return rs.Rotor(shaft_elements=shaft, bearing_elements=bearings) +n_eigen = 8 +R = 0.04 +rotor_80 = create_rotor(80, R) \ No newline at end of file diff --git a/12.py b/12.py new file mode 100644 index 0000000000000000000000000000000000000000..3d195b4145a1f60d4e992ea2eed2b864980ebb6e --- /dev/null +++ b/12.py @@ -0,0 +1,36 @@ +def lobatto_interval(count): + from math import sqrt + from numpy import array + if count <= 2: + p = array([-1.0, 1.0]) + w = array([1.0, 1.0]) + return p, w + elif count == 3: + p = array([-1.0, 0.0, 1.0]) + w = array([1.0 / 3.0, 4.0 / 3.0, 1.0 / 3.0]) + return p, w + elif count == 4: + p = array([-1.0, -1.0 / sqrt(5.0), 1.0 / sqrt(5.0), 1.0]) + w = array([1.0 / 6.0, 5.0 / 6.0, 5.0 / 6.0, 1.0 / 6.0]) + return p, w + else: + p = array([-1.0, -sqrt(3.0 / 7.0), 0.0, sqrt(3.0 / 7.0), 1.0]) + w = array([1.0 / 10.0, 49.0 / 90.0, 32.0 / 45.0, 49.0 / 90.0, 1.0 / 10.0]) + return p, w +def lobatto_hexahedra(order): + from numpy import zeros + (p, w) = lobatto_interval(order) + size = len(p) + xi = zeros(size * size * size) + eta = zeros(size * size * size) + mu = zeros(size * size * size) + weight = zeros(size * size * size) + size_size = size * size + for i in range(size): + for j in range(size): + for k in range(size): + xi[i * size_size + j * size + k] = p[i] + eta[i * size_size + j * size + k] = p[j] + mu[i * size_size + j * size + k] = p[k] + weight[i * size_size + j * size + k] = w[i] * w[j] * w[k] + return xi, eta, mu, weight \ No newline at end of file diff --git a/14.py b/14.py new file mode 100644 index 0000000000000000000000000000000000000000..7c294d6b26acf52faf86fee06b1e9dc6a34329a9 --- /dev/null +++ b/14.py @@ -0,0 +1,3 @@ +def progress_bar(step, max_step): + progress = int(100 * float(step) / float(max_step)) + print( '\r[{0}] {1}%'.format('#'*(progress/10), progress),) \ No newline at end of file diff --git a/15.py b/15.py new file mode 100644 index 0000000000000000000000000000000000000000..f7b5ac70817cfd80857d7eea3b77c023f00601ce --- /dev/null +++ b/15.py @@ -0,0 +1,18 @@ +def plot_coo_matrix(m): + import matplotlib.pyplot as plt + from scipy.sparse import coo_matrix + if not isinstance(m, coo_matrix): + m = coo_matrix(m) + fig = plt.figure() + ax = fig.add_subplot(111, axisbg='black') + ax.plot(m.col, m.row, '.', color='white', ms=1) + ax.set_xlim(0, m.shape[1]) + ax.set_ylim(0, m.shape[0]) + ax.set_aspect('equal') + for spine in ax.spines.values(): + spine.set_visible(False) + ax.invert_yaxis() + ax.set_aspect('equal') + ax.set_xticks([]) + ax.set_yticks([]) + plt.show() \ No newline at end of file diff --git a/16.py b/16.py new file mode 100644 index 0000000000000000000000000000000000000000..61f4f73b13059ec81756486f70c3e5aa6e11529e --- /dev/null +++ b/16.py @@ -0,0 +1,2 @@ +def linear_curve(t, p0, p1): + return p0 + t * (p1 - p0) \ No newline at end of file diff --git a/17.py b/17.py new file mode 100644 index 0000000000000000000000000000000000000000..897719aa018fb91cbce03b896ea8c04437dfc7dd --- /dev/null +++ b/17.py @@ -0,0 +1,2 @@ +def quadratic_bezier_curve(t, p0, p1, p2): + return (1.0 - t) ** 2.0 * p0 + 2.0 * (1.0 - t) * t * p1 + t ** 2.0 * p2 \ No newline at end of file diff --git a/18.py b/18.py new file mode 100644 index 0000000000000000000000000000000000000000..d35c0a1e7f79859a68b42d08c7111ccaad40db3d --- /dev/null +++ b/18.py @@ -0,0 +1,2 @@ +def cubic_bezier_curve(t, p0, p1, p2, p3): + 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 \ No newline at end of file diff --git a/19.py b/19.py new file mode 100644 index 0000000000000000000000000000000000000000..4c7a327e63d5d55dd525554810814ee12c0fb323 --- /dev/null +++ b/19.py @@ -0,0 +1,15 @@ +import numpy as np +def rectangular_quads(x_count, y_count, x_origin, y_origin, width, height): + nodes = np.zeros((x_count * y_count, 2), dtype=np.float64) + elements = np.zeros(((x_count - 1) * (y_count - 1), 4), dtype=np.int32) + points_x = np.linspace(x_origin, x_origin + width, num=x_count) + points_y = np.linspace(y_origin, y_origin + height, num=y_count) + for i in range(x_count): + for j in range(y_count): + nodes[i * y_count + j, 0] = points_x[i] + nodes[i * y_count + j, 1] = points_y[j] + for i in range(x_count - 1): + for j in range(y_count - 1): + elem_idx = i * (y_count - 1) + j + elements[elem_idx] = [i * y_count + j, (i + 1) * y_count + j, (i + 1) * y_count + (j + 1), i * y_count + (j + 1)] + return nodes, elements \ No newline at end of file diff --git a/20.py b/20.py new file mode 100644 index 0000000000000000000000000000000000000000..5957f4b12463acbfac6708362bdf8b0bdb46d0e4 --- /dev/null +++ b/20.py @@ -0,0 +1,28 @@ +import numpy as np +def rectangular_triangles(x_count, y_count, x_origin, y_origin, width, height): + nodes = np.zeros((x_count * y_count, 2), dtype=np.float64) + elements = np.zeros((2 * (x_count - 1) * (y_count - 1), 3), dtype=np.int32) + points_x = np.linspace(x_origin, x_origin + width, num=x_count) + points_y = np.linspace(y_origin, y_origin + height, num=y_count) + cx = x_origin + width / 2.0 + cy = y_origin + height / 2.0 + for i in range(x_count): + for j in range(y_count): + nodes[i * y_count + j, 0] = points_x[i] + nodes[i * y_count + j, 1] = points_y[j] + for i in range(x_count - 1): + for j in range(y_count - 1): + bl = i * y_count + j + br = (i + 1) * y_count + j + tr = (i + 1) * y_count + (j + 1) + tl = i * y_count + (j + 1) + all_right_top = np.all(nodes[[bl, br, tr, tl], 0] >= cx) and np.all(nodes[[bl, br, tr, tl], 1] >= cy) + all_left_bottom = np.all(nodes[[bl, br, tr, tl], 0] <= cx) and np.all(nodes[[bl, br, tr, tl], 1] <= cy) + elem_idx = 2 * (i * (y_count - 1) + j) + if all_right_top or all_left_bottom: + elements[elem_idx] = [bl, br, tl] + elements[elem_idx + 1] = [br, tr, tl] + else: + elements[elem_idx] = [bl, br, tr] + elements[elem_idx + 1] = [bl, tr, tl] + return nodes, elements \ No newline at end of file diff --git a/21.py b/21.py new file mode 100644 index 0000000000000000000000000000000000000000..b04e1f50f9423698c92228f8c5707061a51a81fa --- /dev/null +++ b/21.py @@ -0,0 +1,37 @@ +def annular(xi_count, eta_count, min_radius, max_radius, alpha=None): + from numpy import zeros, float_, int_, linspace, delete, s_ + from math import cos, sin, sqrt, tanh, pi + nodes = zeros((xi_count * eta_count, 2), dtype=float_) + elements = zeros(((xi_count - 1) * (eta_count - 1), 4), dtype=int_) + hxi = 1.0 / float(xi_count - 1) + points_xi = linspace(0.0, 1.0, num=xi_count) + points_eta = linspace(0.0, 1.0, num=eta_count) + angle = alpha + if alpha is None: + angle = 2.0 * pi + p = sqrt((min_radius - min_radius * cos(angle * hxi)) ** 2.0 + (min_radius * sin(angle * hxi)) ** 2.0) + q = 2.0 - p + for i in range(xi_count): + xi = points_xi[i] + for j in range(eta_count): + eta = points_eta[j] + s = p * eta + (1.0 - p) * (1.0 - tanh(q * (1.0 - eta)) / tanh(q)) + x = (min_radius + (max_radius - min_radius) * s) * cos(angle * xi) + y = (min_radius + (max_radius - min_radius) * s) * sin(angle * xi) + nodes[i * eta_count + j, 0] = x + nodes[i * eta_count + j, 1] = y + for i in range(xi_count - 1): + for j in range(eta_count - 1): + elements[i * (eta_count - 1) + j, 0] = i * eta_count + j + elements[i * (eta_count - 1) + j, 1] = i * eta_count + (j + 1) + elements[i * (eta_count - 1) + j, 2] = (i + 1) * eta_count + (j + 1) + elements[i * (eta_count - 1) + j, 3] = (i + 1) * eta_count + j + if alpha is None: + i = xi_count - 2 + for j in range(eta_count - 1): + elements[i * (eta_count - 1) + j, 0] = i * eta_count + j + elements[i * (eta_count - 1) + j, 1] = i * eta_count + (j + 1) + elements[i * (eta_count - 1) + j, 2] = (j + 1) + elements[i * (eta_count - 1) + j, 3] = j + nodes = delete(nodes, s_[(xi_count - 1) * eta_count: xi_count * eta_count], 0) + return nodes, elements diff --git a/22.py b/22.py new file mode 100644 index 0000000000000000000000000000000000000000..08f0ff251ab37163d6458b2982827d5364c81940 --- /dev/null +++ b/22.py @@ -0,0 +1,33 @@ +from numpy import array +p00 = array([1.0, 1.0]) +p01 = array([0.0, 2.0]) +p02 = array([1.0, 2.0]) +p03 = array([1.0, 3.0]) +p10 = array([3.0, 1.0]) +p11 = array([4.0, 1.0]) +p12 = array([2.0, 3.0]) +p13 = array([3.5, 4.0]) +def cubic_bezier_curve(t, p0, p1, p2, p3): + 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 +def left_curve(t): + return cubic_bezier_curve(t, p0=p00, p1=p01, p2=p02, p3=p03) +def right_curve(t): + return cubic_bezier_curve(t, p0=p10, p1=p11, p2=p12, p3=p13) +import numpy as np +def two_curved_domain(xi_count, eta_count, left_curve, right_curve): + nodes = np.zeros((xi_count * eta_count, 2), dtype=np.float64) + elements = np.zeros(((xi_count - 1) * (eta_count - 1), 4), dtype=np.int32) + points_xi = np.linspace(0.0, 1.0, num=xi_count) + points_eta = np.linspace(0.0, 1.0, num=eta_count) + for i in range(xi_count): + xi = points_xi[i] + for j in range(eta_count): + eta = points_eta[j] + p = (1.0 - xi) * left_curve(eta) + xi * right_curve(eta) + nodes[i * eta_count + j, 0] = p[0] + nodes[i * eta_count + j, 1] = p[1] + for i in range(xi_count - 1): + for j in range(eta_count - 1): + elem_idx = i * (eta_count - 1) + j + elements[elem_idx] = [i * eta_count + j, (i + 1) * eta_count + j, (i + 1) * eta_count + (j + 1),i * eta_count + j + 1] + return nodes, elements diff --git a/23.py b/23.py new file mode 100644 index 0000000000000000000000000000000000000000..280fd826f468e0b708d09e23205434c3a2122813 --- /dev/null +++ b/23.py @@ -0,0 +1,37 @@ +from numpy import array +p20 = array([1.0, 1.0]) +p21 = array([2.0, 2.0]) +p22 = array([2.0, 2.0]) +p23 = array([3.0, 1.0]) +p30 = array([1.0, 3.0]) +p31 = array([2.0, 4.0]) +p32 = array([2.0, 4.0]) +p33 = array([3.5, 4.0]) +def cubic_bezier_curve(t, p0, p1, p2, p3): + 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 +def curve_bottom(t): + return cubic_bezier_curve(t, p0=p20, p1=p21, p2=p22, p3=p23) +def curve_top(t): + return cubic_bezier_curve(t, p0=p30, p1=p31, p2=p32, p3=p33) +import numpy as np +def transfinite(xi_count, eta_count, xi_curve_bottom, xi_curve_top, eta_curve_left, eta_curve_right): + nodes = np.zeros((xi_count * eta_count, 2), dtype=np.float64) + elements = np.zeros(((xi_count - 1) * (eta_count - 1), 4), dtype=np.int32) + points_xi = np.linspace(0.0, 1.0, num=xi_count) + points_eta = np.linspace(0.0, 1.0, num=eta_count) + a = xi_curve_bottom(0.0) + b = xi_curve_top(0.0) + c = xi_curve_bottom(1.0) + d = xi_curve_top(1.0) + for i in range(xi_count): + xi = points_xi[i] + for j in range(eta_count): + eta = points_eta[j] + 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) + nodes[i * eta_count + j, 0] = p[0] + nodes[i * eta_count + j, 1] = p[1] + for i in range(xi_count - 1): + for j in range(eta_count - 1): + elem_idx = i * (eta_count - 1) + j + elements[elem_idx] = [i * eta_count + j, (i + 1) * eta_count + j, (i + 1) * eta_count + (j + 1),i * eta_count + j + 1] + return nodes, elements \ No newline at end of file diff --git a/24.py b/24.py new file mode 100644 index 0000000000000000000000000000000000000000..688047dd7b2725f59adab47bb3956d2a2505c3a7 --- /dev/null +++ b/24.py @@ -0,0 +1,32 @@ +from numpy import * +def func(x): return 1.0 +def legendre_interval(count): + from math import sqrt + if count <= 1: + p = array([0.0]) + w = array([2.0]) + return p, w + elif count == 2: + p = array([-1.0 / sqrt(3.0), 1.0 / sqrt(3.0)]) + w = array([1.0, 1.0]) + return p, w + elif count == 3: + p = array([-sqrt(3.0 / 5.0), 0.0, sqrt(3.0 / 5.0)]) + w = array([5.0 / 9.0, 8.0 / 9.0, 5.0 / 9.0]) + return p, w + elif count == 4: + 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)]) + 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]) + return p, w + else: + 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))]) + 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]) + return p, w +def interval(func, a, b, count): + from scipy.spatial.distance import euclidean + (p, w) = legendre_interval(count) + j = euclidean(a, b) / 2.0 + s = func(0.5 * a * (1.0 - p[0]) + 0.5 * b * (1.0 + p[0])) * w[0] * j + for i in range(1, count): + s += func(0.5 * a * (1.0 - p[i]) + 0.5 * b * (1.0 + p[i])) * w[i] * j + return s \ No newline at end of file diff --git a/25.py b/25.py new file mode 100644 index 0000000000000000000000000000000000000000..bd0468a7ecc0d480e28b2f28179dd73caa5a8d7d --- /dev/null +++ b/25.py @@ -0,0 +1,77 @@ +from numpy import * +def legendre_interval(count): + from math import sqrt + if count <= 1: + p = array([0.0]) + w = array([2.0]) + return p, w + elif count == 2: + p = array([-1.0 / sqrt(3.0), 1.0 / sqrt(3.0)]) + w = array([1.0, 1.0]) + return p, w + elif count == 3: + p = array([-sqrt(3.0 / 5.0), 0.0, sqrt(3.0 / 5.0)]) + w = array([5.0 / 9.0, 8.0 / 9.0, 5.0 / 9.0]) + return p, w + elif count == 4: + 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)]) + 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]) + return p, w + else: + 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))]) + 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]) + return p, w +def legendre_quad(order): + from numpy import zeros + (p, w) = legendre_interval(order) + size = len(p) + xi = zeros(size * size) + eta = zeros(size * size) + weight = zeros(size * size) + for i in range(size): + for j in range(size): + xi[i * size + j] = p[i] + eta[i * size + j] = p[j] + weight[i * size + j] = w[i] * w[j] + return xi, eta, weight +def iso_quad(element_nodes, xi, eta): + from numpy import array + from numpy import sum + from numpy.linalg import det + from numpy.linalg import inv + 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 + 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 + 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 + x = element_nodes[:, 0] + y = element_nodes[:, 1] + jacobi = array([ [sum(shape_dxi * x), sum(shape_dxi * y)], [sum(shape_deta * x), sum(shape_deta * y)] ]) # Jacobi matrix + jacobian = det(jacobi) + inverted_jacobi = inv(jacobi) + shape_dx = inverted_jacobi[0, 0] * shape_dxi + inverted_jacobi[0, 1] * shape_deta + shape_dy = inverted_jacobi[1, 0] * shape_dxi + inverted_jacobi[1, 1] * shape_deta + return jacobian, shape, shape_dx, shape_dy +def thermal_force_plate_5(nodes, elements, thicknesses, elasticity_matrices, alpha_t, gauss_order=3): + from numpy import sum, array + freedom = 5 + dimension = len(nodes) * freedom + force = zeros(dimension) + element_nodes = 4 + (xi, eta, w) = legendre_quad(gauss_order) + alpha = array([alpha_t, alpha_t, 0.0]) + h = sum(thicknesses) + for element in elements: + fe = zeros(element_nodes * freedom) + vertices = nodes[element[:], :] + for i in range(len(w)): + (jacobian, shape, shape_dx, shape_dy) = iso_quad(vertices, xi[i], eta[i]) + 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] ]) + z0 = -h / 2.0 + for j in range(len(thicknesses)): + z1 = z0 + thicknesses[j] + df = elasticity_matrices[j] + fe = fe + (z1 - z0) * bm.transpose().dot(df).dot(alpha) * w[i] * jacobian + z0 = z1 + for i in range(element_nodes * freedom): + ii = element[i / freedom] * freedom + i % freedom + force[ii] += fe[i] + return force \ No newline at end of file diff --git a/26.py b/26.py new file mode 100644 index 0000000000000000000000000000000000000000..0e62f49e10c619ac533148f2a8bf70ed223c2280 --- /dev/null +++ b/26.py @@ -0,0 +1,75 @@ +from numpy import * +def legendre_interval(count): + from math import sqrt + if count <= 1: + p = array([0.0]) + w = array([2.0]) + return p, w + elif count == 2: + p = array([-1.0 / sqrt(3.0), 1.0 / sqrt(3.0)]) + w = array([1.0, 1.0]) + return p, w + elif count == 3: + p = array([-sqrt(3.0 / 5.0), 0.0, sqrt(3.0 / 5.0)]) + w = array([5.0 / 9.0, 8.0 / 9.0, 5.0 / 9.0]) + return p, w + elif count == 4: + 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)]) + 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]) + return p, w + else: + 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))]) + 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]) + return p, w +def legendre_quad(order): + from numpy import zeros + (p, w) = legendre_interval(order) + size = len(p) + xi = zeros(size * size) + eta = zeros(size * size) + weight = zeros(size * size) + for i in range(size): + for j in range(size): + xi[i * size + j] = p[i] + eta[i * size + j] = p[j] + weight[i * size + j] = w[i] * w[j] + return xi, eta, weight +def iso_quad(element_nodes, xi, eta): + from numpy import array + from numpy import sum + from numpy.linalg import det + from numpy.linalg import inv + 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 + 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 + 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 + x = element_nodes[:, 0] + y = element_nodes[:, 1] + jacobi = array([ [sum(shape_dxi * x), sum(shape_dxi * y)], [sum(shape_deta * x), sum(shape_deta * y)] ]) # Jacobi matrix + jacobian = det(jacobi) + inverted_jacobi = inv(jacobi) + shape_dx = inverted_jacobi[0, 0] * shape_dxi + inverted_jacobi[0, 1] * shape_deta + shape_dy = inverted_jacobi[1, 0] * shape_dxi + inverted_jacobi[1, 1] * shape_deta + return jacobian, shape, shape_dx, shape_dy +def thermal_force_quads(nodes, elements, thickness, elasticity_matrix, alpha_t, tfunc=None, gauss_order=3): + from numpy import sum, array + freedom = 2 + dimension = len(nodes) * freedom + force = zeros(dimension) + element_nodes = 4 + (xi, eta, w) = legendre_quad(gauss_order) + alpha = array([alpha_t, alpha_t, 0.0]) + for element in elements: + fe = zeros(element_nodes * freedom) + vertices = nodes[element[:], :] + for i in range(len(w)): + (jacobian, shape, shape_dx, shape_dy) = iso_quad(vertices, xi[i], eta[i]) + 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]] ]) + if tfunc is None: + fe = fe + thickness * b.transpose().dot(elasticity_matrix).dot(alpha) * w[i] * jacobian + else: + therm = tfunc(sum(vertices[:, 0] * shape), sum(vertices[:, 1] * shape)) + fe = fe + thickness * therm * b.transpose().dot(elasticity_matrix).dot(alpha) * w[i] * jacobian + for i in range(element_nodes * freedom): + ii = element[i / freedom] * freedom + i % freedom + force[ii] += fe[i] + return force \ No newline at end of file diff --git a/27.py b/27.py new file mode 100644 index 0000000000000000000000000000000000000000..3e512af7b838cc2b8c07210ca6c5f43ad7d41e41 --- /dev/null +++ b/27.py @@ -0,0 +1,33 @@ +from numpy import * +def legendre_interval(count): + from math import sqrt + if count <= 1: + p = array([0.0]) + w = array([2.0]) + return p, w + elif count == 2: + p = array([-1.0 / sqrt(3.0), 1.0 / sqrt(3.0)]) + w = array([1.0, 1.0]) + return p, w + elif count == 3: + p = array([-sqrt(3.0 / 5.0), 0.0, sqrt(3.0 / 5.0)]) + w = array([5.0 / 9.0, 8.0 / 9.0, 5.0 / 9.0]) + return p, w + elif count == 4: + 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)]) + 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]) + return p, w + else: + 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))]) + 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]) + return p, w +def interval(func, a, b, gauss_order): + from scipy.spatial.distance import euclidean + (p, w) = legendre_interval(gauss_order) + j = euclidean(a, b) / 2.0 + 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 + 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 + for i in range(1, gauss_order): + 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 + 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 + return [s0, s1] \ No newline at end of file diff --git a/28.py b/28.py new file mode 100644 index 0000000000000000000000000000000000000000..3e30db9ee1108000ed286bed0efb931f63c724e9 --- /dev/null +++ b/28.py @@ -0,0 +1,38 @@ +from numpy import ndarray +def get_iso_element_type(node_coords: ndarray, dimension: int = -1) -> str: + element_node_number = node_coords.shape[0] + if dimension == -1: + dimension = node_coords.shape[1] + if dimension == 1: + if element_node_number == 2: + return 'line2' + elif element_node_number == 3: + return 'line3' + return None + elif dimension == 2: + if element_node_number == 3: + return 'tria3' + elif element_node_number == 4: + return 'quad4' + elif element_node_number == 6: + return 'tria6' + elif element_node_number == 8: + return 'quad8' + elif element_node_number == 9: + return 'quad9' + return None + elif dimension == 3: + if element_node_number == 4: + return 'tetra4' + elif element_node_number == 5: + return 'pyramid5' + elif element_node_number == 6: + return 'prism6' + elif element_node_number == 8: + return 'hex8' + elif element_node_number == 18: + return 'prism18' + elif element_node_number == 20: + return 'hex20' + return None + return None diff --git a/31.py b/31.py new file mode 100644 index 0000000000000000000000000000000000000000..f9ece55ff272722e70c328f20687d1e2dd7a4b3a --- /dev/null +++ b/31.py @@ -0,0 +1,23 @@ +from numpy import empty, ndarray +def get_shape_tria6(xi: ndarray) -> tuple[ndarray, ndarray]: + N = empty(6) + dNdxi = empty(shape=(2, 6)) + 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]) + N[1] = xi[0] - 2.0 * xi[0] * (1.0 - xi[0] - xi[1]) - 2.0 * xi[0] * xi[1] + N[2] = xi[1] - 2.0 * xi[0] * xi[1] - 2.0 * xi[1] * (1.0 - xi[0] - xi[1]) + N[3] = 4.0 * xi[0] * (1.0 - xi[0] - xi[1]) + N[4] = 4.0 * xi[0] * xi[1] + N[5] = 4.0 * xi[1] * (1.0 - xi[0] - xi[1]) + dNdxi[0, 0] = -1.0 - 2.0 * (1.0 - xi[0] - xi[1]) + 2.0 * xi[0] + 2.0 * xi[1] + dNdxi[0, 1] = 1.0 - 2.0 * (1.0 - xi[0] - xi[1]) + 2.0 * xi[0] - 2.0 * xi[1] + dNdxi[0, 2] = 0.0 + dNdxi[0, 3] = 4.0 * (1.0 - xi[0] - xi[1]) - 4.0 * xi[0] + dNdxi[0, 4] = 4.0 * xi[1] + dNdxi[0, 5] = -4.0 * xi[1] + dNdxi[1, 0] = -1.0 + 2.0 * xi[0] - 2.0 * (1.0 - xi[0] - xi[1]) + 2.0 * xi[1] + dNdxi[1, 1] = 0.0 + dNdxi[1, 2] = 1.0 - 2.0 * xi[0] - 2.0 * (1.0 - xi[0] - xi[1]) + 2.0 * xi[1] + dNdxi[1, 3] = -4.0 * xi[0] + dNdxi[1, 4] = 4.0 * xi[0] + dNdxi[1, 5] = 4.0 * (1.0 - xi[0] - xi[1]) - 4.0 * xi[1] + return N, dNdxi \ No newline at end of file diff --git a/32.py b/32.py new file mode 100644 index 0000000000000000000000000000000000000000..c5000f9f3419ba06a36f15fb5177aab71092d6bc --- /dev/null +++ b/32.py @@ -0,0 +1,5 @@ +from numpy import empty, ndarray, array +def get_shape_empty(xi: ndarray) -> tuple[ndarray, ndarray]: + N = empty(0) + dNdxi = empty(shape=(0, 0)) + return N, dNdxi \ No newline at end of file diff --git a/33.py b/33.py new file mode 100644 index 0000000000000000000000000000000000000000..0852571e2bfb38b2dda674ad99d86ff0bb861d6b --- /dev/null +++ b/33.py @@ -0,0 +1,9 @@ +from numpy import empty, ndarray +def get_shape_line2(xi: ndarray) -> tuple[ndarray, ndarray]: + N = empty(2) + dNdxi = empty(shape=(1, 2)) + N[0] = 0.5 * (1.0 - xi) + N[1] = 0.5 * (1.0 + xi) + dNdxi[0, 0] = -0.5 + dNdxi[0, 1] = 0.5 + return N, dNdxi \ No newline at end of file diff --git a/34.py b/34.py new file mode 100644 index 0000000000000000000000000000000000000000..c51c76a1fbe48806f8fbc74a65ee7fc9031fa246 --- /dev/null +++ b/34.py @@ -0,0 +1,11 @@ +from numpy import empty, ndarray +def get_shape_line3(xi: ndarray) -> tuple[ndarray, ndarray]: + N = empty(3) + dNdxi = empty(shape=(1, 3)) + N[0] = 0.5 * (1.0 - xi) - 0.5 * (1.0 - xi * xi) + N[1] = 1.0 - xi * xi + N[2] = 0.5 * (1.0 + xi) - 0.5 * (1.0 - xi * xi) + dNdxi[0, 0] = -0.5 + xi + dNdxi[0, 1] = -2.0 * xi + dNdxi[0, 2] = 0.5 + xi + return N, dNdxi \ No newline at end of file diff --git a/35.py b/35.py new file mode 100644 index 0000000000000000000000000000000000000000..bab0d98c2cdf2dbf062a9dabee620f40a280ee6e --- /dev/null +++ b/35.py @@ -0,0 +1,16 @@ +from numpy import empty, ndarray + +def get_shape_tria3(xi: ndarray) -> tuple[ndarray, ndarray]: + N = empty(3) + dNdxi = empty(shape=(2, 3)) + xi = xi + N[0] = 1.0 - xi[0] - xi[1] + N[1] = xi[0] + N[2] = xi[1] + dNdxi[0, 0] = -1.0 + dNdxi[0, 1] = 1.0 + dNdxi[0, 2] = 0.0 + dNdxi[1, 0] = -1.0 + dNdxi[1, 1] = 0.0 + dNdxi[1, 2] = 1.0 + return N, dNdxi \ No newline at end of file diff --git a/36.py b/36.py new file mode 100644 index 0000000000000000000000000000000000000000..ff62cd6aaee58afd62887a8f43c30043c635727f --- /dev/null +++ b/36.py @@ -0,0 +1,18 @@ +from numpy import empty, ndarray +def get_shape_tria3_barycentric(xi: ndarray) -> tuple[ndarray, ndarray]: + N = empty(3) + dNdxi = empty(shape=(3, 3)) + xi = xi + N[0] = xi[0] + N[1] = xi[1] + N[2] = xi[2] + dNdxi[0, 0] = 1.0 + dNdxi[0, 1] = 0.0 + dNdxi[0, 2] = 0.0 + dNdxi[1, 0] = 0.0 + dNdxi[1, 1] = 1.0 + dNdxi[1, 2] = 0.0 + dNdxi[2, 0] = 0.0 + dNdxi[2, 1] = 0.0 + dNdxi[2, 2] = 1.0 + return N, dNdxi \ No newline at end of file diff --git a/37.py b/37.py new file mode 100644 index 0000000000000000000000000000000000000000..6ad075c237f9acedae96b6e3760605605bf202c1 --- /dev/null +++ b/37.py @@ -0,0 +1,18 @@ +from numpy import empty, ndarray +import numpy as np +def get_shape_quad4(xi: ndarray) -> tuple[ndarray, ndarray]: + N = empty(4, dtype=np.float64) + dNdxi = empty(shape=(2, 4), dtype=np.float64) + N[0] = 0.25 * (1.0 - xi[0]) * (1.0 - xi[1]) + N[1] = 0.25 * (1.0 + xi[0]) * (1.0 - xi[1]) + N[2] = 0.25 * (1.0 + xi[0]) * (1.0 + xi[1]) + N[3] = 0.25 * (1.0 - xi[0]) * (1.0 + xi[1]) + dNdxi[0, 0] = -0.25 * (1.0 - xi[1]) + dNdxi[0, 1] = 0.25 * (1.0 - xi[1]) + dNdxi[0, 2] = 0.25 * (1.0 + xi[1]) + dNdxi[0, 3] = -0.25 * (1.0 + xi[1]) + dNdxi[1, 0] = -0.25 * (1.0 - xi[0]) + dNdxi[1, 1] = -0.25 * (1.0 + xi[0]) + dNdxi[1, 2] = 0.25 * (1.0 + xi[0]) + dNdxi[1, 3] = 0.25 * (1.0 - xi[0]) + return N, dNdxi \ No newline at end of file diff --git a/38.py b/38.py new file mode 100644 index 0000000000000000000000000000000000000000..2c67b5bd8eaeeb756f03f89066805e9d4cef032d --- /dev/null +++ b/38.py @@ -0,0 +1,29 @@ +from numpy import empty, ndarray +def get_shape_quad8(xi: ndarray) -> tuple[ndarray, ndarray]: + N = empty(8) + dNdxi = empty(shape=(2, 8)) + N[0] = -0.25 * (1.0 - xi[0]) * (1.0 - xi[1]) * (1.0 + xi[0] + xi[1]) + N[1] = -0.25 * (1.0 + xi[0]) * (1.0 - xi[1]) * (1.0 - xi[0] + xi[1]) + N[2] = -0.25 * (1.0 + xi[0]) * (1.0 + xi[1]) * (1.0 - xi[0] - xi[1]) + N[3] = -0.25 * (1.0 - xi[0]) * (1.0 + xi[1]) * (1.0 + xi[0] - xi[1]) + N[4] = 0.5 * (1.0 - xi[0]) * (1.0 + xi[0]) * (1.0 - xi[1]) + N[5] = 0.5 * (1.0 + xi[0]) * (1.0 + xi[1]) * (1.0 - xi[1]) + N[6] = 0.5 * (1.0 - xi[0]) * (1.0 + xi[0]) * (1.0 + xi[1]) + N[7] = 0.5 * (1.0 - xi[0]) * (1.0 + xi[1]) * (1.0 - xi[1]) + dNdxi[0, 0] = -0.25 * (-1.0 + xi[1]) * (2.0 * xi[0] + xi[1]) + dNdxi[0, 1] = 0.25 * (-1.0 + xi[1]) * (-2.0 * xi[0] + xi[1]) + dNdxi[0, 2] = 0.25 * (1.0 + xi[1]) * (2.0 * xi[0] + xi[1]) + dNdxi[0, 3] = -0.25 * (1.0 + xi[1]) * (-2.0 * xi[0] + xi[1]) + dNdxi[0, 4] = xi[0] * (-1.0 + xi[1]) + dNdxi[0, 5] = -0.5 * (1.0 + xi[1]) * (-1.0 + xi[1]) + dNdxi[0, 6] = -xi[0] * (1.0 + xi[1]) + dNdxi[0, 7] = 0.5 * (1.0 + xi[1]) * (-1.0 + xi[1]) + dNdxi[1, 0] = -0.25 * (-1.0 + xi[0]) * (xi[0] + 2.0 * xi[1]) + dNdxi[1, 1] = 0.25 * (1.0 + xi[0]) * (-xi[0] + 2.0 * xi[1]) + dNdxi[1, 2] = 0.25 * (1.0 + xi[0]) * (xi[0] + 2.0 * xi[1]) + dNdxi[1, 3] = -0.25 * (-1.0 + xi[0]) * (-xi[0] + 2.0 * xi[1]) + dNdxi[1, 4] = 0.5 * (1.0 + xi[0]) * (-1.0 + xi[0]) + dNdxi[1, 5] = -xi[1] * (1.0 + xi[0]) + dNdxi[1, 6] = -0.5 * (1.0 + xi[0]) * (-1.0 + xi[0]) + dNdxi[1, 7] = xi[1] * (-1.0 + xi[0]) + return N, dNdxi \ No newline at end of file diff --git a/39.py b/39.py new file mode 100644 index 0000000000000000000000000000000000000000..2c06f15bbb34b8adebcb8d3307ede28de0407988 --- /dev/null +++ b/39.py @@ -0,0 +1,21 @@ +from numpy import empty, ndarray +def get_shape_tetra4(xi: ndarray) -> tuple[ndarray, ndarray]: + N = empty(4) + dNdxi = empty(shape=(3, 4)) + N[0] = 1.0 - xi[0] - xi[1] - xi[2] + N[1] = xi[0] + N[2] = xi[1] + N[3] = xi[2] + dNdxi[0, 0] = -1.0 + dNdxi[0, 1] = 1.0 + dNdxi[0, 2] = 0.0 + dNdxi[0, 3] = 0.0 + dNdxi[1, 0] = -1.0 + dNdxi[1, 1] = 0.0 + dNdxi[1, 2] = 1.0 + dNdxi[1, 3] = 0.0 + dNdxi[2, 0] = -1.0 + dNdxi[2, 1] = 0.0 + dNdxi[2, 2] = 0.0 + dNdxi[2, 3] = 1.0 + return N, dNdxi \ No newline at end of file diff --git a/40.py b/40.py new file mode 100644 index 0000000000000000000000000000000000000000..d99758110d0adb469dd349d05200b91d8568fa71 --- /dev/null +++ b/40.py @@ -0,0 +1,25 @@ +from numpy import empty, ndarray +def get_shape_tetra4_barycentric(xi: ndarray) -> tuple[ndarray, ndarray]: + N = empty(4) + dNdxi = empty(shape=(4, 4)) + N[0] = xi[0] + N[1] = xi[1] + N[2] = xi[2] + N[3] = xi[3] + dNdxi[0, 0] = 1.0 + dNdxi[0, 1] = 0.0 + dNdxi[0, 2] = 0.0 + dNdxi[0, 3] = 0.0 + dNdxi[1, 0] = 0.0 + dNdxi[1, 1] = 1.0 + dNdxi[1, 2] = 0.0 + dNdxi[1, 3] = 0.0 + dNdxi[2, 0] = 0.0 + dNdxi[2, 1] = 0.0 + dNdxi[2, 2] = 1.0 + dNdxi[2, 3] = 0.0 + dNdxi[3, 0] = 0.0 + dNdxi[3, 1] = 0.0 + dNdxi[3, 2] = 0.0 + dNdxi[3, 3] = 1.0 + return N, dNdxi \ No newline at end of file diff --git a/41.py b/41.py new file mode 100644 index 0000000000000000000000000000000000000000..0619116c0afdb61d0f782f0aa5d0c716a902ea5d --- /dev/null +++ b/41.py @@ -0,0 +1,37 @@ +from numpy import empty, ndarray +def get_shape_hex8(xi: ndarray) -> tuple[ndarray, ndarray]: + N = empty(8) + dNdxi = empty(shape=(3, 8)) + N[0] = 0.125 * (1.0 - xi[0]) * (1.0 - xi[1]) * (1.0 - xi[2]) + N[1] = 0.125 * (1.0 + xi[0]) * (1.0 - xi[1]) * (1.0 - xi[2]) + N[2] = 0.125 * (1.0 + xi[0]) * (1.0 + xi[1]) * (1.0 - xi[2]) + N[3] = 0.125 * (1.0 - xi[0]) * (1.0 + xi[1]) * (1.0 - xi[2]) + N[4] = 0.125 * (1.0 - xi[0]) * (1.0 - xi[1]) * (1.0 + xi[2]) + N[5] = 0.125 * (1.0 + xi[0]) * (1.0 - xi[1]) * (1.0 + xi[2]) + N[6] = 0.125 * (1.0 + xi[0]) * (1.0 + xi[1]) * (1.0 + xi[2]) + N[7] = 0.125 * (1.0 - xi[0]) * (1.0 + xi[1]) * (1.0 + xi[2]) + dNdxi[0, 0] = -0.125 * (1.0 - xi[1]) * (1.0 - xi[2]) + dNdxi[0, 1] = 0.125 * (1.0 - xi[1]) * (1.0 - xi[2]) + dNdxi[0, 2] = 0.125 * (1.0 + xi[1]) * (1.0 - xi[2]) + dNdxi[0, 3] = -0.125 * (1.0 + xi[1]) * (1.0 - xi[2]) + dNdxi[0, 4] = -0.125 * (1.0 - xi[1]) * (1.0 + xi[2]) + dNdxi[0, 5] = 0.125 * (1.0 - xi[1]) * (1.0 + xi[2]) + dNdxi[0, 6] = 0.125 * (1.0 + xi[1]) * (1.0 + xi[2]) + dNdxi[0, 7] = -0.125 * (1.0 + xi[1]) * (1.0 + xi[2]) + dNdxi[1, 0] = -0.125 * (1.0 - xi[0]) * (1.0 - xi[2]) + dNdxi[1, 1] = -0.125 * (1.0 + xi[0]) * (1.0 - xi[2]) + dNdxi[1, 2] = 0.125 * (1.0 + xi[0]) * (1.0 - xi[2]) + dNdxi[1, 3] = 0.125 * (1.0 - xi[0]) * (1.0 - xi[2]) + dNdxi[1, 4] = -0.125 * (1.0 - xi[0]) * (1.0 + xi[2]) + dNdxi[1, 5] = -0.125 * (1.0 + xi[0]) * (1.0 + xi[2]) + dNdxi[1, 6] = 0.125 * (1.0 + xi[0]) * (1.0 + xi[2]) + dNdxi[1, 7] = 0.125 * (1.0 - xi[0]) * (1.0 + xi[2]) + dNdxi[2, 0] = -0.125 * (1.0 - xi[0]) * (1.0 - xi[1]) + dNdxi[2, 1] = -0.125 * (1.0 + xi[0]) * (1.0 - xi[1]) + dNdxi[2, 2] = -0.125 * (1.0 + xi[0]) * (1.0 + xi[1]) + dNdxi[2, 3] = -0.125 * (1.0 - xi[0]) * (1.0 + xi[1]) + dNdxi[2, 4] = 0.125 * (1.0 - xi[0]) * (1.0 - xi[1]) + dNdxi[2, 5] = 0.125 * (1.0 + xi[0]) * (1.0 - xi[1]) + dNdxi[2, 6] = 0.125 * (1.0 + xi[0]) * (1.0 + xi[1]) + dNdxi[2, 7] = 0.125 * (1.0 - xi[0]) * (1.0 + xi[1]) + return N, dNdxi \ No newline at end of file diff --git a/42.py b/42.py new file mode 100644 index 0000000000000000000000000000000000000000..cba03ea20d725ac375bf560a8efc65343e619fda --- /dev/null +++ b/42.py @@ -0,0 +1,29 @@ +from numpy import empty, ndarray, array +def get_shape_tria6_barycentric(xi: ndarray) -> tuple[ndarray, ndarray]: + N = empty(6) + dNdxi = empty(shape=(3, 6)) + N[0] = xi[0] * (2.0 * xi[0] - 1.0) + N[1] = xi[1] * (2.0 * xi[1] - 1.0) + N[2] = xi[2] * (2.0 * xi[2] - 1.0) + N[3] = 4.0 * xi[0] * xi[1] + N[4] = 4.0 * xi[1] * xi[2] + N[5] = 4.0 * xi[2] * xi[0] + dNdxi[0, 0] = 4.0 * xi[0] - 1.0 + dNdxi[0, 1] = 0.0 + dNdxi[0, 2] = 0.0 + dNdxi[0, 3] = 4.0 * xi[1] + dNdxi[0, 4] = 0.0 + dNdxi[0, 5] = 4.0 * xi[2] + dNdxi[1, 0] = 0.0 + dNdxi[1, 1] = 4.0 * xi[1] - 1.0 + dNdxi[1, 2] = 0.0 + dNdxi[1, 3] = 4.0 * xi[0] + dNdxi[1, 4] = 4.0 * xi[2] + dNdxi[1, 5] = 0.0 + dNdxi[2, 0] = 0.0 + dNdxi[2, 1] = 0.0 + dNdxi[2, 2] = 4.0 * xi[2] - 1.0 + dNdxi[2, 3] = 0.0 + dNdxi[2, 4] = 4.0 * xi[1] + dNdxi[2, 5] = 4.0 * xi[0] + return N, dNdxi \ No newline at end of file diff --git a/43.py b/43.py new file mode 100644 index 0000000000000000000000000000000000000000..97139992ce57490d2b1d188fbdbf2649e27facb7 --- /dev/null +++ b/43.py @@ -0,0 +1,29 @@ +from numpy import empty, ndarray +def get_shape_tria6_barycentric(xi: ndarray) -> tuple[ndarray, ndarray]: + N = empty(6) + dNdxi = empty(shape=(3, 6)) + N[0] = xi[0] * (2.0 * xi[0] - 1.0) + N[1] = xi[1] * (2.0 * xi[1] - 1.0) + N[2] = xi[2] * (2.0 * xi[2] - 1.0) + N[3] = 4.0 * xi[0] * xi[1] + N[4] = 4.0 * xi[1] * xi[2] + N[5] = 4.0 * xi[2] * xi[0] + dNdxi[0, 0] = 4.0 * xi[0] - 1.0 + dNdxi[0, 1] = 0.0 + dNdxi[0, 2] = 0.0 + dNdxi[0, 3] = 4.0 * xi[1] + dNdxi[0, 4] = 0.0 + dNdxi[0, 5] = 4.0 * xi[2] + dNdxi[1, 0] = 0.0 + dNdxi[1, 1] = 4.0 * xi[1] - 1.0 + dNdxi[1, 2] = 0.0 + dNdxi[1, 3] = 4.0 * xi[0] + dNdxi[1, 4] = 4.0 * xi[2] + dNdxi[1, 5] = 0.0 + dNdxi[2, 0] = 0.0 + dNdxi[2, 1] = 0.0 + dNdxi[2, 2] = 4.0 * xi[2] - 1.0 + dNdxi[2, 3] = 0.0 + dNdxi[2, 4] = 4.0 * xi[1] + dNdxi[2, 5] = 4.0 * xi[0] + return N, dNdxi \ No newline at end of file diff --git a/44.py b/44.py new file mode 100644 index 0000000000000000000000000000000000000000..aacb4c238e122b06db4e0a47d3a68ff738373509 --- /dev/null +++ b/44.py @@ -0,0 +1,13 @@ +import numpy as np +from numpy import zeros, ndarray, array, sum, dot, maximum, tensordot +from numpy.linalg import inv, norm, eig +def inverse(qp_jacobis: ndarray, qp_jacobi_dets: ndarray) -> ndarray: + qp_jacobi_invs = [] + for A, det_A in zip(qp_jacobis, qp_jacobi_dets): + if A.shape == (2, 2): + qp_jacobi_invs.append(array([[A[1][1], -A[0][1]], [-A[1][0], A[0][0]]]) / det_A) + elif A.shape == (3, 3): + 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) + else: + return inv(qp_jacobis) + return array(qp_jacobi_invs) \ No newline at end of file diff --git a/45.py b/45.py new file mode 100644 index 0000000000000000000000000000000000000000..a2548ec42832c3ed9c2bbc1d28600539a9083283 --- /dev/null +++ b/45.py @@ -0,0 +1,7 @@ +from numpy import zeros, ndarray, array, sum, dot, maximum, tensordot +from numpy.linalg import inv, norm, eig +def get_transformation(u: ndarray, v: ndarray, w: ndarray, u_prime: ndarray, v_prime: ndarray, w_prime: ndarray) -> ndarray: + A = array([u, v, w]) + A_prime = array([u_prime, v_prime, w_prime]) + T = dot(A_prime, inv(A)) + return T \ No newline at end of file diff --git a/46.py b/46.py new file mode 100644 index 0000000000000000000000000000000000000000..92b1004c9b401148851d491a709fda4c52cf1aba --- /dev/null +++ b/46.py @@ -0,0 +1,19 @@ +from numpy import zeros, ndarray +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 \ No newline at end of file diff --git a/47.py b/47.py new file mode 100644 index 0000000000000000000000000000000000000000..80af29f880715add1eada3de1bc1c7ab71110228 --- /dev/null +++ b/47.py @@ -0,0 +1,50 @@ +from numpy import zeros, ndarray +import numpy as np +def get_voigt_transformation(transformation: ndarray) -> ndarray: + voigt_transformation = zeros(shape=(6, 6), dtype=np.float64) + a11 = transformation[0][0] + a12 = transformation[0][1] + a13 = transformation[0][2] + a21 = transformation[1][0] + a22 = transformation[1][1] + a23 = transformation[1][2] + a31 = transformation[2][0] + a32 = transformation[2][1] + a33 = transformation[2][2] + voigt_transformation[0][0] = a11 ** 2 + voigt_transformation[0][1] = a12 ** 2 + voigt_transformation[0][2] = a13 ** 2 + voigt_transformation[0][3] = 2 * a11 * a12 + voigt_transformation[0][4] = 2 * a11 * a13 + voigt_transformation[0][5] = 2 * a12 * a13 + voigt_transformation[1][0] = a21 ** 2 + voigt_transformation[1][1] = a22 ** 2 + voigt_transformation[1][2] = a23 ** 2 + voigt_transformation[1][3] = 2 * a21 * a22 + voigt_transformation[1][4] = 2 * a21 * a23 + voigt_transformation[1][5] = 2 * a22 * a23 + voigt_transformation[2][0] = a31 ** 2 + voigt_transformation[2][1] = a32 ** 2 + voigt_transformation[2][2] = a33 ** 2 + voigt_transformation[2][3] = 2 * a31 * a32 + voigt_transformation[2][4] = 2 * a31 * a33 + voigt_transformation[2][5] = 2 * a32 * a33 + voigt_transformation[3][0] = a11 * a21 + voigt_transformation[3][1] = a12 * a22 + voigt_transformation[3][2] = a13 * a23 + voigt_transformation[3][3] = a12 * a21 + a11 * a22 + voigt_transformation[3][4] = a13 * a21 + a11 * a23 + voigt_transformation[3][5] = a13 * a22 + a12 * a23 + voigt_transformation[4][0] = a11 * a31 + voigt_transformation[4][1] = a12 * a32 + voigt_transformation[4][2] = a13 * a33 + voigt_transformation[4][3] = a12 * a31 + a11 * a32 + voigt_transformation[4][4] = a13 * a31 + a11 * a33 + voigt_transformation[4][5] = a13 * a32 + a12 * a33 + voigt_transformation[5][0] = a21 * a31 + voigt_transformation[5][1] = a22 * a32 + voigt_transformation[5][2] = a23 * a33 + voigt_transformation[5][3] = a22 * a31 + a21 * a32 + voigt_transformation[5][4] = a23 * a31 + a21 * a33 + voigt_transformation[5][5] = a23 * a32 + a22 * a33 + return voigt_transformation \ No newline at end of file diff --git a/48.py b/48.py new file mode 100644 index 0000000000000000000000000000000000000000..330db892393b9046f6a6feec474c41a2c48b5d12 --- /dev/null +++ b/48.py @@ -0,0 +1,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 \ No newline at end of file diff --git a/49.py b/49.py new file mode 100644 index 0000000000000000000000000000000000000000..0cfc3ad38eac540b2099d160afb57600fd834052 --- /dev/null +++ b/49.py @@ -0,0 +1,8 @@ +import numpy as np +from numpy import zeros, ndarray, array, dot +def operations_for_symtensor_antisymtensor(sym_tensor: ndarray, antisym_tensor: ndarray) -> ndarray: + result = zeros(shape=(len(antisym_tensor), 6), dtype=np.float64) + for i in range(len(antisym_tensor)): + 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]]) + result[i, :] = dot(T, sym_tensor) + return result \ No newline at end of file diff --git a/53.py b/53.py new file mode 100644 index 0000000000000000000000000000000000000000..be4149121099425afe1a9074f767c1a6198b6712 --- /dev/null +++ b/53.py @@ -0,0 +1,11 @@ +def get_ordinal_number(num: int) -> str: + if num % 100 in [11, 12, 13]: + return str(num) + "th" + elif num % 10 == 1: + return str(num) + "st" + elif num % 10 == 2: + return str(num) + "nd" + elif num % 10 == 3: + return str(num) + "rd" + else: + return str(num) + "th" \ No newline at end of file diff --git a/55.py b/55.py new file mode 100644 index 0000000000000000000000000000000000000000..a4f79d23c0de63bbef7cc9284630e7687a432f1f --- /dev/null +++ b/55.py @@ -0,0 +1,15 @@ +def quads_to_tris(quads): + tris = [[None for j in range(3)] for i in range(2*len(quads))] + for i in range(len(quads)): + j = 2*i + n0 = quads[i][0] + n1 = quads[i][1] + n2 = quads[i][2] + n3 = quads[i][3] + tris[j][0] = n0 + tris[j][1] = n1 + tris[j][2] = n2 + tris[j + 1][0] = n2 + tris[j + 1][1] = n3 + tris[j + 1][2] = n0 + return tris \ No newline at end of file diff --git a/59.py b/59.py new file mode 100644 index 0000000000000000000000000000000000000000..49fe655d1233fc0884ae2c52300b8ad3566d748b --- /dev/null +++ b/59.py @@ -0,0 +1,12 @@ +import numpy as np +def stiffnessAssembling(nodeIndex, kList, node2Element, ndim=2, Nnum=4): + nodeNum = len(nodeIndex) + elementNum = len(node2Element) + k_global = np.zeros(shape=(nodeNum, ndim, nodeNum, ndim), dtype=np.float) + for p in range(elementNum): + ktemp = kList[p] + elementNode = node2Element[p] + for m in range(Nnum): + for n in range(Nnum): + k_global[elementNode[m], :, elementNode[n], :] += ktemp[m, :, n, :] + return k_global \ No newline at end of file diff --git a/67.py b/67.py new file mode 100644 index 0000000000000000000000000000000000000000..b9bdd395faf18175493bce04684bfc04660a6adb --- /dev/null +++ b/67.py @@ -0,0 +1,28 @@ +import numpy as np +import sympy as sym +def setPressurreNew(node, boundary, pressure, index, x, y, f): + m = node.shape[1] + s = sym.symbols("s") + N1 = (1 - s) / 2 + N2 = (1 + s) / 2 + N = sym.Matrix([N1, N2]).T + for i in range(len(boundary) - 1): + point1 = node[:, boundary[i][1]] + point2 = node[:, boundary[i+1][1]] + vector = point2 - point1 + length = np.sqrt(np.dot(vector, vector)) + base = np.vstack([point1, point2]) + temp = np.sqrt(1 / 3) + N_val1 = np.array([float(N1.subs(s, -temp)), float(N2.subs(s, -temp))]) + N_val2 = np.array([float(N1.subs(s, temp)), float(N2.subs(s, temp))]) + gaussian_point1 = np.dot(N_val1, base) + gaussian_point2 = np.dot(N_val2, base) + pressure1 = float(pressure.subs([(x, gaussian_point1[0]), (y, gaussian_point1[1])])) + pressure2 = float(pressure.subs([(x, gaussian_point2[0]), (y, gaussian_point2[1])])) + pressure_base = np.array([pressure1, pressure2]) + f1 = np.dot(N_val1, pressure_base) * length / 2 + f2 = np.dot(N_val2, pressure_base) * length / 2 + name1 = boundary[i][0] * m + boundary[i][1] + name2 = boundary[i+1][0] * m + boundary[i+1][1] + f[name1, index] += f1 + f[name2, index] += f2 \ No newline at end of file diff --git a/68.py b/68.py new file mode 100644 index 0000000000000000000000000000000000000000..94a92aa382e22b0903b28e7fe1ed32e5d44a9fae --- /dev/null +++ b/68.py @@ -0,0 +1,34 @@ +import numpy as np +from numpy import zeros, ones, ix_ +def assembleArray(nodes_coords, elements, dofs_map, state, Dstate, element_props, rank, action): + n_dofs = len(state) + A = zeros((n_dofs, n_dofs)) + B = zeros(n_dofs) + for elem_idx, elem_nodes in enumerate(elements): + el_coords = nodes_coords[elem_nodes] + el_dofs = dofs_map[elem_nodes].flatten() + el_state = state[el_dofs] + el_Dstate = Dstate[el_dofs] + nDof = len(el_dofs) + stiff = np.zeros((nDof, nDof)) + fint = np.zeros(nDof) + mass = np.zeros((nDof, nDof)) + lumped = np.zeros(nDof) + if action == 'getInternalForce': + fint = el_state * 2.0 + elif action == 'getTangentStiffness': + stiff = np.eye(nDof) * 1000.0 + fint = el_state * 2.0 + elif action == 'getMassMatrix': + mass = np.eye(nDof) * 10.0 + lumped = np.ones(nDof) * 10.0 + if rank == 1: + B[el_dofs] += fint + elif rank == 2: + if action == "getTangentStiffness": + A[ix_(el_dofs, el_dofs)] += stiff + B[el_dofs] += fint + elif action == "getMassMatrix": + A[ix_(el_dofs, el_dofs)] += mass + B[el_dofs] += lumped + return B if rank == 1 else (A, B) \ No newline at end of file diff --git a/69.py b/69.py new file mode 100644 index 0000000000000000000000000000000000000000..3c640af957d8f66d3806fdc2fe1d7a12793ae69b --- /dev/null +++ b/69.py @@ -0,0 +1,45 @@ +import numpy as np +from numpy import zeros, ones, ix_ +def createElementData(elstate, elDstate): + nDof = len(elstate) + return {'state': elstate, 'Dstate': elDstate, 'stiff': np.zeros(shape=(nDof, nDof)), 'fint': np.zeros(shape=(nDof)), 'mass': np.zeros(shape=(nDof, nDof)), 'lumped': np.zeros(shape=(nDof)), 'outlabel': []} +def assembleArray(props, globdat, rank, action): + A = zeros(len(globdat.dofs) * ones(2, dtype=int)) + B = zeros(len(globdat.dofs) * ones(1, dtype=int)) + globdat.resetNodalOutput() + for elementGroup in globdat.elements.iterGroupNames(): + el_props = getattr(props, elementGroup) + for element in globdat.elements.iterElementGroup(elementGroup): + el_nodes = element.getNodes() + el_coords = globdat.nodes.getNodeCoords(el_nodes) + el_dofs = globdat.dofs.get(el_nodes) + el_a = globdat.state[el_dofs] + el_Da = globdat.Dstate[el_dofs] + elemdat = createElementData(el_a, el_Da) + elemdat['coords'] = el_coords + elemdat['nodes'] = el_nodes + elemdat['props'] = el_props + if hasattr(element, "matProps"): + elemdat['matprops'] = element.matProps + if hasattr(element, "mat"): + element.mat.reset() + getattr(element, action)(elemdat) + for label in elemdat['outlabel']: + element.appendNodalOutput(label, globdat, elemdat['outdata']) + if rank == 1: + B[el_dofs] += elemdat['fint'] + elif rank == 2 and action == "getTangentStiffness": + A[ix_(el_dofs, el_dofs)] += elemdat['stiff'] + B[el_dofs] += elemdat['fint'] + elif rank == 2 and action == "getMassMatrix": + A[ix_(el_dofs, el_dofs)] += elemdat['mass'] + B[el_dofs] += elemdat['lumped'] + else: + raise NotImplementedError('assembleArray is only implemented for vectors and matrices.') + return B if rank == 1 else (A, B) +def assembleMassMatrix(props, globdat): + return assembleArray(props, globdat, rank=2, action='getMassMatrix') +def assembleTangentStiffness(props, globdat): + return assembleArray(props, globdat, rank=2, action='getTangentStiffness') +def assembleInternalForce(props, globdat): + return assembleArray(props, globdat, rank=1, action='getInternalForce') \ No newline at end of file diff --git a/70.py b/70.py new file mode 100644 index 0000000000000000000000000000000000000000..3d023f9e47290fdf7f7155e3058808b9e0d4adab --- /dev/null +++ b/70.py @@ -0,0 +1,10 @@ +def containsValue(db, val): + keys = db.keys() + for key in keys: + if type(db[key]) == dict: + if containsValue(db[key], val): + return True + else: + if db[key] == val: + return True + return False \ No newline at end of file diff --git a/71.py b/71.py new file mode 100644 index 0000000000000000000000000000000000000000..bb4f0fa15f0c2af579fa3be29dfe7c4b42e12898 --- /dev/null +++ b/71.py @@ -0,0 +1,10 @@ +def getType(a): + if a == 'true': + return True + elif a == 'false': + return False + else: + try: + return eval(a) + except: + return a \ No newline at end of file diff --git a/72.py b/72.py new file mode 100644 index 0000000000000000000000000000000000000000..445d9d09e7403e88cf583b7b43a9a49e8c61aa04 --- /dev/null +++ b/72.py @@ -0,0 +1,8 @@ +def storeValue(db, key, a): + if type(a) == list: + tmp = [] + for v in a: + tmp.append(type(v)) + db.store(key, tmp) + else: + db.store(key, type(a)) \ No newline at end of file diff --git a/73.py b/73.py new file mode 100644 index 0000000000000000000000000000000000000000..c708a1801dac7a32a4079276d4a69cb62e7c8d36 --- /dev/null +++ b/73.py @@ -0,0 +1,11 @@ +import numpy as np +def getShapeLine2(xi): + if type(xi) != float: + raise NotImplementedError('1D only') + h = np.empty(2) + dhdxi = np.empty(shape=(2, 1)) + h[0] = 0.5 * (1.0 - xi) + h[1] = 0.5 * (1.0 + xi) + dhdxi[0, 0] = -0.5 + dhdxi[1, 0] = 0.5 + return {'h': h, 'dhdxi': dhdxi, 'xi': xi} \ No newline at end of file diff --git a/74.py b/74.py new file mode 100644 index 0000000000000000000000000000000000000000..71e45b31f2e91a7d768890cc1c955c187466235c --- /dev/null +++ b/74.py @@ -0,0 +1,34 @@ +import numpy as np +def getShapeQuad9(xi): + if len(xi) != 2: + raise NotImplementedError('2D only') + h = np.empty(9) + dhdxi = np.empty(shape=(9, 2)) + h[0] = -0.25 * (1.0 - xi[0]) * (1.0 - xi[1]) * (1.0 + xi[0] + xi[1]) + h[1] = 0.5 * (1.0 - xi[0]) * (1.0 + xi[0]) * (1.0 - xi[1]) + h[2] = -0.25 * (1.0 + xi[0]) * (1.0 - xi[1]) * (1.0 - xi[0] + xi[1]) + h[3] = 0.5 * (1.0 + xi[0]) * (1.0 + xi[1]) * (1.0 - xi[1]) + h[4] = -0.25 * (1.0 + xi[0]) * (1.0 + xi[1]) * (1.0 - xi[0] - xi[1]) + h[5] = 0.5 * (1.0 - xi[0]) * (1.0 + xi[0]) * (1.0 + xi[1]) + h[6] = -0.25 * (1.0 - xi[0]) * (1.0 + xi[1]) * (1.0 + xi[0] - xi[1]) + h[7] = 0.5 * (1.0 - xi[0]) * (1.0 + xi[1]) * (1.0 - xi[1]) + h[8] = 0.5 * (1.0 - xi[0]) * (1.0 + xi[1]) * (1.0 - xi[1]) + dhdxi[0, 0] = -0.25 * (-1.0 + xi[1]) * (2.0 * xi[0] + xi[1]) + dhdxi[1, 0] = xi[0] * (-1.0 + xi[1]) + dhdxi[2, 0] = 0.25 * (-1.0 + xi[1]) * (-2.0 * xi[0] + xi[1]) + dhdxi[3, 0] = -0.5 * (1.0 + xi[1]) * (-1.0 + xi[1]) + dhdxi[4, 0] = 0.25 * (1.0 + xi[1]) * (2.0 * xi[0] + xi[1]) + dhdxi[5, 0] = -xi[0] * (1.0 + xi[1]) + dhdxi[6, 0] = -0.25 * (1.0 + xi[1]) * (-2.0 * xi[0] + xi[1]) + dhdxi[7, 0] = 0.5 * (1.0 + xi[1]) * (-1.0 + xi[1]) + dhdxi[8, 0] = 0.5 * (1.0 + xi[1]) * (-1.0 + xi[1]) + dhdxi[0, 1] = -0.25 * (-1.0 + xi[0]) * (xi[0] + 2.0 * xi[1]) + dhdxi[1, 1] = 0.5 * (1.0 + xi[0]) * (-1.0 + xi[0]) + dhdxi[2, 1] = 0.25 * (1.0 + xi[0]) * (-xi[0] + 2.0 * xi[1]) + dhdxi[3, 1] = -xi[1] * (1.0 + xi[0]) + dhdxi[4, 1] = 0.25 * (1.0 + xi[0]) * (xi[0] + 2.0 * xi[1]) + dhdxi[5, 1] = -0.5 * (1.0 + xi[0]) * (-1.0 + xi[0]) + dhdxi[6, 1] = -0.25 * (-1.0 + xi[0]) * (-xi[0] + 2.0 * xi[1]) + dhdxi[7, 1] = xi[1] * (-1.0 + xi[0]) + dhdxi[8, 1] = xi[1] * (-1.0 + xi[0]) + return {'h': h, 'dhdxi': dhdxi, 'xi': xi} \ No newline at end of file diff --git a/76.py b/76.py new file mode 100644 index 0000000000000000000000000000000000000000..ddcd41881f5e8972fb4cf8293422f7a6418ef92a --- /dev/null +++ b/76.py @@ -0,0 +1,10 @@ +def macauley(x): + if x >= 0.: + return x + else: + return 0. +def sign(x): + if x < 0.: + return -1.0 + else: + return 0.0 \ No newline at end of file diff --git a/77.py b/77.py new file mode 100644 index 0000000000000000000000000000000000000000..589d18eaab889e0eaf7abc4542939369016cee34 --- /dev/null +++ b/77.py @@ -0,0 +1,11 @@ +from numpy import zeros, ones, dot, transpose +from math import sin, cos, pi, sqrt, tan, atan +def stressTransformation(sigma, theta): + signew = zeros(3) + rad = theta * pi / 180. + c = cos(rad) + s = sin(rad) + signew[0] = sigma[0] * c * c + sigma[1] * s * s + 2. * sigma[2] * c * s + signew[1] = sigma[0] * s * s + sigma[1] * c * c - 2. * sigma[2] * c * s + signew[2] = (sigma[1] - sigma[0]) * c * s + sigma[2] * (c * c - s * s) + return signew \ No newline at end of file diff --git a/78.py b/78.py new file mode 100644 index 0000000000000000000000000000000000000000..f656f4b896848824fefa5e714c4a076048050b6d --- /dev/null +++ b/78.py @@ -0,0 +1,9 @@ +from numpy import zeros +def getlam4(lam): + lam4 = zeros(shape=(3, 3, 3, 3)) + for i in range(3): + for j in range(3): + for k in range(3): + for l in range(3): + lam4[i, j, k, l] = lam[i, k] * lam[j, l] + return lam4 \ No newline at end of file diff --git a/79.py b/79.py new file mode 100644 index 0000000000000000000000000000000000000000..69bb0f56777f29b741e84c4738c1c50a37219e37 --- /dev/null +++ b/79.py @@ -0,0 +1,10 @@ +import numpy as np +def iso2locbase(iso, lam4): + loc = np.zeros(6) + loc[0] = iso[0]*lam4[0,0,0,0] + iso[1]*lam4[1,1,0,0] + iso[2]*lam4[2,2,0,0] + iso[3]*0.5*(lam4[0,1,0,0]+lam4[1,0,0,0]) + iso[4]*0.5*(lam4[1,2,0,0]+lam4[2,1,0,0]) + iso[5]*0.5*(lam4[2,0,0,0]+lam4[0,2,0,0]) + loc[1] = iso[0]*lam4[0,0,1,1] + iso[1]*lam4[1,1,1,1] + iso[2]*lam4[2,2,1,1] + iso[3]*0.5*(lam4[0,1,1,1]+lam4[1,0,1,1]) + iso[4]*0.5*(lam4[1,2,1,1]+lam4[2,1,1,1]) + iso[5]*0.5*(lam4[2,0,1,1]+lam4[0,2,1,1]) + loc[2] = iso[0]*lam4[0,0,2,2] + iso[1]*lam4[1,1,2,2] + iso[2]*lam4[2,2,2,2] + iso[3]*0.5*(lam4[0,1,2,2]+lam4[1,0,2,2]) + iso[4]*0.5*(lam4[1,2,2,2]+lam4[2,1,2,2]) + iso[5]*0.5*(lam4[2,0,2,2]+lam4[0,2,2,2]) + loc[3] = iso[0]*(lam4[0,0,0,1]+lam4[0,0,1,0]) + iso[1]*(lam4[1,1,0,1]+lam4[1,1,1,0]) + iso[2]*(lam4[2,2,0,1]+lam4[2,2,1,0]) + iso[3]*0.5*(lam4[0,1,0,1]+lam4[0,1,1,0]+lam4[1,0,0,1]+lam4[1,0,1,0]) + iso[4]*0.5*(lam4[1,2,0,1]+lam4[1,2,1,0]+lam4[2,1,0,1]+lam4[2,1,1,0]) + iso[5]*0.5*(lam4[2,0,0,1]+lam4[2,0,1,0]+lam4[0,2,0,1]+lam4[0,2,1,0]) + loc[4] = iso[0]*(lam4[0,0,1,2]+lam4[0,0,2,1]) + iso[1]*(lam4[1,1,1,2]+lam4[1,1,2,1]) + iso[2]*(lam4[2,2,1,2]+lam4[2,2,2,1]) + iso[3]*0.5*(lam4[0,1,1,2]+lam4[0,1,2,1]+lam4[1,0,1,2]+lam4[1,0,2,1]) + iso[4]*0.5*(lam4[1,2,1,2]+lam4[1,2,2,1]+lam4[2,1,1,2]+lam4[2,1,2,1]) + iso[5]*0.5*(lam4[2,0,1,2]+lam4[2,0,2,1]+lam4[0,2,1,2]+lam4[0,2,2,1]) + loc[5] = iso[0]*(lam4[0,0,2,0]+lam4[0,0,0,2]) + iso[1]*(lam4[1,1,2,0]+lam4[1,1,0,2]) + iso[2]*(lam4[2,2,2,0]+lam4[2,2,0,2]) + iso[3]*0.5*(lam4[0,1,2,0]+lam4[0,1,0,2]+lam4[1,0,2,0]+lam4[1,0,0,2]) + iso[4]*0.5*(lam4[1,2,2,0]+lam4[1,2,0,2]+lam4[2,1,2,0]+lam4[2,1,0,2]) + iso[5]*0.5*(lam4[2,0,2,0]+lam4[2,0,0,2]+lam4[0,2,2,0]+lam4[0,2,0,2]) + return loc \ No newline at end of file diff --git a/82.py b/82.py new file mode 100644 index 0000000000000000000000000000000000000000..cec52da3b4213362183f34d427d8d57cfcac8be5 --- /dev/null +++ b/82.py @@ -0,0 +1,12 @@ +import numpy as np +def vonMisesStress(s): + if len(s) == 3: + return np.sqrt(s[0]**2 + s[1]**2 - s[0]*s[1] + 3*s[2]**2) + elif len(s) == 6: + smises = (s[0] - s[1])**2 + (s[1] - s[2])**2 + (s[2] - s[0])**2 + smises += 6.0 * np.dot(s[3:], s[3:]) + return np.sqrt(0.5 * smises) + else: + raise ValueError(f"Invalid stress vector length: {len(s)}") +def hydrostaticStress(s): + return np.sum(s[:3]) / 3.0 \ No newline at end of file diff --git a/83.py b/83.py new file mode 100644 index 0000000000000000000000000000000000000000..37ba56f831967841bb70eefffee08a90e48b1871 --- /dev/null +++ b/83.py @@ -0,0 +1,16 @@ +from numpy import dot, zeros, insert, array, ones +def transform2To3(s): + return array([s[0], s[1], 0., 0., 0., s[2]]) +def transform3To2(s, t): + return array([s[0], s[1], s[5]]), \ + array([(t[0, 0], t[0, 1], t[0, 5]), \ + (t[1, 0], t[1, 1], t[1, 5]), \ + (t[5, 0], t[5, 1], t[5, 5])]) +def hydroStatic(s): + return sum(s[:3]) / 3.0 +def splitStrains(eps): + theta = hydroStatic(eps) + deps = zeros(6) + deps[:3] = eps[:3] - theta * ones(3) + deps[3:] = 0.5 * eps[3:] + return theta, deps \ No newline at end of file diff --git a/84.py b/84.py new file mode 100644 index 0000000000000000000000000000000000000000..cb4cfa5ced4298c00563b269f70e5d0545bf1f56 --- /dev/null +++ b/84.py @@ -0,0 +1,9 @@ +from numpy import sqrt +from scipy.linalg import det +def calcWeight(jac): + n = jac.shape + if n[0] == n[1]: + return det(jac) + elif n[0] == 1 and n[1] == 2: + return sqrt(sum(sum(jac * jac))) + return None diff --git a/85.py b/85.py new file mode 100644 index 0000000000000000000000000000000000000000..b4e0ca788f95aa656f47aed78a47fbe867dfa671 --- /dev/null +++ b/85.py @@ -0,0 +1,10 @@ +def cleanVariable(a): + if a == 'true': + return True + elif a == 'false': + return False + else: + try: + return eval(a) + except: + return a diff --git a/86.py b/86.py new file mode 100644 index 0000000000000000000000000000000000000000..b5954d654c1b3ef0fabe01e4b9ac6c3427af9ce0 --- /dev/null +++ b/86.py @@ -0,0 +1,10 @@ +def macauley(x): + if x >= 0.: + return x + else: + return 0. +def sign(x): + if x < 0.: + return -1.0 + else: + return 0.0 diff --git a/89.py b/89.py new file mode 100644 index 0000000000000000000000000000000000000000..675a4758609eb0466662bf5252eda89bcf211344 --- /dev/null +++ b/89.py @@ -0,0 +1,60 @@ +import numpy as np +import matplotlib.pyplot as plt +from scipy.integrate import quad +from scipy.interpolate import interp1d +def genBasis(p): + if p == 1: + B = [lambda xi: 1.0] + dB = [lambda xi: 0.0] + elif p == 2: + B = [lambda xi: 0.5 * (1 - xi), lambda xi: 0.5 * (1 + xi)] + dB = [lambda xi: -0.5, lambda xi: 0.5] + elif p == 3: + B = [lambda xi: -0.5 * xi * (1 - xi), lambda xi: (1 - xi) * (1 + xi), lambda xi: 0.5 * xi * (1 + xi)] + dB = [lambda xi: -0.5 + xi, lambda xi: -2 * xi, lambda xi: 0.5 + xi] + else: + raise NotImplementedError(f"Basis functions for p={p} not implemented") + return B, dB +def DG(N, p, xb, f0, a, b, q): + h = xb / N + f = np.zeros(N) + fe = np.zeros(N + 1) + fe[0] = f0 + x = np.linspace(0, xb, N + 1) + fnodes = None + for i in range(N): + B, dB = genBasis(p) + xglob = np.linspace(x[i], x[i + 1], p) + X = lambda xi: sum([xglob[j] * B[j](xi) for j in range(p)]) + J = lambda xi: sum([xglob[j] * dB[j](xi) for j in range(p)]) + A = np.zeros((p, p)) + rhs = np.zeros(p) + for j in range(p): + for k in range(p): + func = lambda xi: B[j](xi) * B[k](xi) * J(xi) + Mjk = quad(func, -1, 1)[0] + func = lambda xi: dB[j](xi) * B[k](xi) + Sjk = quad(func, -1, 1)[0] + A[j, k] = -a * Sjk + b * Mjk + rhs[j] += Mjk * q(xglob[j]) + A[-1, -1] += a * B[-1](1) + if i != 0: + rhs[0] += a * B[0](-1) * fnodes[-1] + else: + rhs[0] += a * B[0](-1) * f0 + fnodes = np.linalg.solve(A, rhs) + f_func = lambda xi: sum([B[j](xi) * fnodes[j] for j in range(p)]) + f[i] = f_func(0) + fe[i + 1] = fnodes[-1] + return x, fe +def order(p, xb, f0, a, b, q, f_mms): + Nrun = 4 + N = np.array([int(n) for n in np.logspace(1, 2, Nrun)]) + err = np.zeros(Nrun) + for i in range(Nrun): + x, f = DG(N[i], p, xb, f0, a, b, q) + interp = interp1d(x, f) + err[i] = np.max(np.fabs(f - f_mms(x))) + fit = np.polyfit(np.log(xb / N), np.log(err), 1) + plt.loglog(xb / N, err, '-o', label=str(p)) + return fit \ No newline at end of file diff --git a/90.py b/90.py new file mode 100644 index 0000000000000000000000000000000000000000..802bfb4550eada543871f48ba4f3e769034700ec --- /dev/null +++ b/90.py @@ -0,0 +1,37 @@ +import numpy as np +def genBasis(N): + x = np.linspace(-1, 1, N) + coef = np.zeros((N, N)) + for k in range(N): + A = np.zeros((N, N)) + for i in range(N): + for j in range(N): + A[i,j] = x[i]**j + b = np.zeros(N) + b[k] = 1 + coef[k,:] = np.linalg.solve(A, b) + B = [] + dB = [] + x2 = np.linspace(-1, 1) + for i in range(N): + B.append(np.poly1d(coef[i,::-1])) + dB.append(B[i].deriv()) + return B, dB +def genBasis2D(): + pts = np.array([[-1,-1], [1,-1], [1,1], [-1,1]]) + coef = np.zeros((4,4)) + for i in range(4): + A = np.zeros((4,4)) + for j in range(4): + A[j,:] = np.array([1, pts[j,0], pts[j,1], pts[j,0]*pts[j,1]]) + b = np.zeros(4) + b[i] = 1 + coef[i,:] = np.linalg.solve(A, b) + B = [] + dBxi = [] + dBeta = [] + for i in range(4): + B.append(lambda x, y: coef[i,0] + coef[i,1]*x + coef[i,2]*y + coef[i,3]*x*y) + dBxi.append(lambda x, y: coef[i,1] + coef[i,3]*y) + dBeta.append(lambda x, y: coef[i,2] + coef[i,3]*x) + return B, dBxi, dBeta \ No newline at end of file diff --git a/91.py b/91.py new file mode 100644 index 0000000000000000000000000000000000000000..562c66e68be1bdfe5666a794761395c77aff014d --- /dev/null +++ b/91.py @@ -0,0 +1,60 @@ +import numpy as np +from scipy.integrate import quad +def genBasis(N): + x = np.linspace(-1, 1, N) + coef = np.zeros((N, N)) + for k in range(N): + A = np.zeros((N, N)) + for i in range(N): + for j in range(N): + A[i,j] = x[i]**j + b = np.zeros(N) + b[k] = 1 + coef[k,:] = np.linalg.solve(A, b) + B = [] + dB = [] + x2 = np.linspace(-1, 1) + for i in range(N): + B.append(np.poly1d(coef[i,::-1])) + dB.append(B[i].deriv()) + return B, dB +def TDG(Nx, Nt, xb, tb, p, f0x, f0t, a, b, c, q): + alpha = 1 + h = xb/Nx + dt = tb/Nt + f = np.zeros(Nx) + x = np.linspace(0, xb, Nx+1) + t = np.linspace(0, tb, Nt+1) + fprev_new = np.ones((Nx, p))*f0t + for l in range(1, Nt): + fprev = np.copy(fprev_new) + for i in range(Nx): + B, dB = genBasis(p) + xglob = np.linspace(x[i], x[i+1], p) + X = lambda xi: sum([xglob[j]*B[j](xi) for j in range(p)]) + J = lambda xi: sum([xglob[j]*dB[j](xi) for j in range(p)]) + A = np.zeros((p,p)) + rhs = np.zeros(p) + for j in range(p): + for k in range(p): + func = lambda xi: B[j](xi) * B[k](xi) * J(xi) + Mjk = quad(func, -1, 1)[0] + func = lambda xi: dB[j](xi) * B[k](xi) + Sjk = quad(func, -1, 1)[0] + A[j,k] = a/dt*Mjk + alpha*(-b*Sjk + c*Mjk + b*B[j](1)*B[k](1)) + rhs[j] += fprev[i,k]*(a/dt*Mjk - (1-alpha)*(-b*Sjk + c*Mjk + b*B[j](1)*B[k](1))) + rhs[j] += (alpha*q(xglob[j], t[l]) + (1-alpha)*q(xglob[j], t[l-1]))*Mjk + if (i == 0): + fnodes = np.ones(p)*f0x + rhs[j] += b*B[j](-1)*B[k](-1)*(alpha*fnodes[-1] + (1-alpha)*fprev[i-1,-1]) + fnodes = np.linalg.solve(A, rhs) + f_func = lambda xi: sum([B[j](xi)*fnodes[j] for j in range(p)]) + f[i] = f_func(0) + fprev_new[i,:] = fnodes + xc = np.linspace(h/2, xb-h/2, Nx) + file = open('data/'+str(l)+'.curve', 'w') + file.write('# curve\n') + for i in range(Nx): + file.write('{} {}\n'.format(xc[i], f[i])) + file.close() + return np.linspace(h/2, xb-h/2, Nx), f \ No newline at end of file diff --git a/93.py b/93.py new file mode 100644 index 0000000000000000000000000000000000000000..28d1d09e4b5d2a74a3f12d6a030a46d677816496 --- /dev/null +++ b/93.py @@ -0,0 +1,10 @@ +import numpy as np +def jacobian(dN, summits): + J = np.dot(dN, summits) + Jdet = np.linalg.det(J) + Jinv = np.linalg.inv(J) + return Jdet, Jinv +from numpy import diag +def conductivity_matrix(ax_conductivity): + K = diag(ax_conductivity) + return K \ No newline at end of file diff --git a/96.py b/96.py new file mode 100644 index 0000000000000000000000000000000000000000..b0b276b28e6e0fcf4ca7daf653805d0c86d767d7 --- /dev/null +++ b/96.py @@ -0,0 +1,16 @@ +from itertools import product +from numpy import * +def dbl_gauss_quad(func, k): + if k == 1: + return 4 * func(0, 0) + if k == 2: + p = sqrt(1/3) + return func(-p, -p) + func(-p, p) + func(p, -p) + func(p, p) + if k == 3: + p = [-sqrt(3/5), 0, sqrt(3/5)] + w = [5/9, 8/9, 5/9] + sum = func(0, 0) - func(0, 0) # get the 0 element of the addition + for i, j in product(range(3), range(3)): + sum += func(p[i], p[j]) * w[i] * w[j] + return sum + return None \ No newline at end of file diff --git a/97.py b/97.py new file mode 100644 index 0000000000000000000000000000000000000000..61f45f4af8cad330f7b5b5b0ef7d16ccfb1f111c --- /dev/null +++ b/97.py @@ -0,0 +1,5 @@ +from numpy import * +def get_D(E, v): + return (E / (1 - v ** 2)) * array([ [1, v, 0], [v, 1, 0], [0, 0, 0.5 * (1 - v)] ]) +def partials_quad4(xi, eta): + return 0.25 * array([ [eta - 1, 1 - eta, 1 + eta, -1 - eta], [xi - 1, -1 - xi, 1 + xi, 1 - xi] ]) \ No newline at end of file diff --git a/99.py b/99.py new file mode 100644 index 0000000000000000000000000000000000000000..2a12361b6e0c23b98c9781419d62e4d62710c8a4 --- /dev/null +++ b/99.py @@ -0,0 +1,21 @@ +from numpy import * +from scipy.linalg import inv +def get_D(E, v): + return (E / (1 - v ** 2)) * array([ [1, v, 0], [v, 1, 0], [0, 0, 0.5 * (1 - v)] ]) +def compute_stress_quad4(disp, material, nodes): + def partials(xi, eta): + return 0.25 * array([ [eta - 1, 1 - eta, 1 + eta, -1 - eta], [xi - 1, -1 - xi, 1 + xi, 1 - xi] ]) + def Jacobi(xi, eta): + coords = row_stack(nodes) + return dot(partials(xi, eta), nodes) + def partial_xy(xi, eta): + return dot(inv(Jacobi(xi, eta)), partials(xi, eta)) + def B(xi, eta): + p = partial_xy(xi, eta) + return array([ [p[0, 0], 0, p[0, 1], 0, p[0, 2], 0, p[0, 3], 0], [0, p[1, 0], 0, p[1, 1], 0, p[1, 2], 0, p[1, 3]], [p[1, 0], p[0, 0], p[1, 1], p[0, 1], p[1, 2], p[0, 2], p[1, 3], p[0, 3]], ]) + strain_at_gaussian_nodes = [dot(B(-1 / sqrt(3), -1 / sqrt(3)), disp), dot(B(1 / sqrt(3), -1 / sqrt(3)), disp), dot(B(1 / sqrt(3), 1 / sqrt(3)), disp), dot(B(-1 / sqrt(3), 1 / sqrt(3)), disp)] + p, q = 1 + 1 / sqrt(3), 1 - 1 / sqrt(3) + 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] ]) + D = get_D(*material) + stress_at_gaussian_nodes = array([dot(D, e) for e in strain_at_gaussian_nodes]) + return dot(inv(weight_matrix), stress_at_gaussian_nodes) \ No newline at end of file