#Python Programming Language

# Isoparametric Mindlin plate-element

import numpy as np
import pandas as pd

# x1, y1, x2, y2, x3, y3, x4, y4

c = np.array([0, 0, 1, 0, 1, 1, 0, 1])

e = 2100000 # elasticity_modulus
v = 0.2 # poissons_ratio
t = 0.2 #thickness

# Plane-stress Elasticity Matrix

E = e/(1-v**2) * np.array([[1, v, 0],
[v, 1, 0],
[0, 0, (1-v)/2]])

g = e/(2*(1+v))

G = g * np.array([[1, 0],
[0, 1]])

d = e*t**3 / (12 * (1 - v**2))

E = d * np.array([[1, v, 0],
[v, 1, 0],
[0, 0, (1-v)/2]])

G = t*g*np.array([[1, 0],
[0, 1]])

print(E)
print(G)

# Shape function matrix

def shape_function(zeta, eta):
n1 = 0.25*(1-zeta)*(1-eta)
n2 = 0.25*(1+zeta)*(1-eta)
n3 = 0.25*(1+zeta)*(1+eta)
n4 = 0.25*(1-zeta)*(1+eta)
return np.array([[n1, 0, n2, 0, n3, 0, n4, 0],
[0, n1, 0, n2, 0, n3, 0, n4]])

# Jacobian
def jacobian(zeta, eta):
 return 0.25*np.dot(np.array([[-(1-eta), (1-eta), (1+eta), -(1+eta)],
[-(1-zeta), -(1+zeta), (1+zeta), (1-zeta)]]),
c.reshape(4, 2))

# strain-displacement matrix [B]

def B(zeta, eta) -> np.ndarray:

jacobian_inverse = np.linalg.inv(jacobian(zeta, eta))

dzeta_dx = jacobian_inverse[0, 0]
deta_dx = jacobian_inverse[0, 1]
dzeta_dy = jacobian_inverse[1, 0]
deta_dy = jacobian_inverse[1, 1]

dn1_dzeta = -0.25 * (1 - eta)

dn2_dzeta = 0.25 * (1 - eta)
dn3_dzeta = 0.25 * (1 + eta)
dn4_dzeta = -0.25 * (1 + eta)
dn1_deta = -0.25 * (1 - zeta)
dn2_deta = -0.25 * (1 + zeta)
dn3_deta = 0.25 * (1 + zeta)
dn4_deta = 0.25 * (1 - zeta)

dn1_dx = dzeta_dx * dn1_dzeta + deta_dx * dn1_deta

dn2_dx = dzeta_dx * dn2_dzeta + deta_dx * dn2_deta
dn3_dx = dzeta_dx * dn3_dzeta + deta_dx * dn3_deta
dn4_dx = dzeta_dx * dn4_dzeta + deta_dx * dn4_deta

dn1_dy = dzeta_dy * dn1_dzeta + deta_dy * dn1_deta

dn2_dy = dzeta_dy * dn2_dzeta + deta_dy * dn2_deta
dn3_dy = dzeta_dy * dn3_dzeta + deta_dy * dn3_deta
dn4_dy = dzeta_dy * dn4_dzeta + deta_dy * dn4_deta

n1 = 0.25*(1-zeta)*(1-eta)
n2 = 0.25*(1+zeta)*(1-eta)
n3 = 0.25*(1+zeta)*(1+eta)
n4 = 0.25*(1-zeta)*(1+eta)

B_matrix = np.array([[0, dn1_dx, 0, 0, dn2_dx, 0, 0, dn3_dx, 0, 0, dn4_dx, 0],

[0, 0, dn1_dy, 0, 0, dn2_dy, 0, 0, dn3_dy, 0, 0, dn4_dy],
[0, dn1_dy, dn1_dx, 0, dn2_dy, dn2_dx, 0, dn3_dy, dn3_dx, 0,
dn4_dy, dn4_dx],
[dn1_dx, -n1, 0, dn2_dx, -n2, 0, dn3_dx, -n3, 0, dn4_dx,
-n4, 0],
[dn1_dy, 0, -n1, dn2_dy, 0, -n2, dn3_dy, 0, -n3, dn4_dy, 0,
-n4]])

df = pd.DataFrame(B_matrix)
df.to_csv("B_Matrix (zeta = {0:.2f}, eta = {1:.2f}).csv".format(zeta, eta))
 return B_matrix

# stiffness matrix to be evaluated at a gauss sampling point

def kb(zeta, eta):
j = np.linalg.det(jacobian(zeta, eta))
Bb = B(zeta, eta)[0:3, :]
return (t**3)/12 * j * Bb.T.dot(E.dot(Bb))

def ks(zeta, eta):

j = np.linalg.det(jacobian(zeta, eta))
Bs = B(zeta, eta)[3:, :]
return t * j * Bs.T.dot(G.dot(Bs))

# gauss quadrature
def bending_stiffness_matrix():
point = 1/3**0.5
sampling_points = [point, -point]
K = np.zeros((12, 12))
for zeta in sampling_points:
for eta in sampling_points:
df = pd.DataFrame(kb(zeta, eta))
df.to_csv("Stiffness_Matrix (zeta = {0:.2f}, eta =
{1:.2f}).csv".format(zeta, eta))
K += kb(zeta, eta)
return K

def shear_stiffness_matrix():
K = np.zeros((12, 12))
zeta = 0
eta = 0
K += ks(zeta, eta)
return K

df = pd.DataFrame(bending_stiffness_matrix())
df.to_csv("Bending Stiffness_Matrix.csv")

df = pd.DataFrame(shear_stiffness_matrix())
df.to_csv("Shear Stiffness_Matrix.csv")

df = pd.DataFrame(bending_stiffness_matrix() + shear_stiffness_matrix())
df.to_csv("Total Stiffness_Matrix.csv")