def setUp(self):
# Here, we generate the mesh
thetaDomain = pi / 2.0 # quarter circle of the pipe
self.ri = 1.2 # the inner radius of the pipe
self.ro = 1.8 # the outer radius of the pipe
self.nr = 8 # the number of elements in the radial direction
self.nt = 16 # the number of elements in the circumfrential direction
self.nodes = [] # stores the nodes in the cylindrical mesh
self.p = -2.0e6 # the pressure (Pa) (against the surface normal)
for i in range(self.nr + 1): # for every node in the r-direction...
for j in range(self.nt +
1): # for every node in the theta-direction...
radius = i * (self.ro - self.ri) / self.nr + self.ri
theta = j * thetaDomain / self.nt
self.nodes.append(
[radius * sin(theta), radius * cos(theta), 0])
self.ien = get_ien(self.nt, self.nr)
# now the fun begins. We solve this problem using roller constraints on
# the straight faces and pressure loads on the inner face.
s0 = nsel('y', 'n', 0, 0.01, self.nodes)
s1 = nsel('x', 'n', 0, 0.01, self.nodes)
ida, ncons, cons0, loads = constrain(self.nodes, s0, self.ien, 'y', 0)
ida, ncons, cons, loads = constrain(self.nodes, s1, self.ien, 'x', 0,
cons0)
for i in range(self.nt): # for every inner element...
loads[3][i] = self.p
self.deform, i = solver(2, loads, self.nodes, self.ien, ida, ncons,
cons)
self.ps0 = nsel('y', 'n', 0, 0.01, self.nodes)
def test_OnePart1(self):
numD = 2 # number of dimensions
enum = 2 # number of elements in each dof
nodes = nodeList(1, 1, 1, enum, enum)
ien = get_ien(enum, enum)
cc = [1.0, 0.0]
wall = nsel('x', 'n', 0, 0.01, nodes) # select the wall
edge = nsel('x', 'n', 1, 0.01, nodes) # select free edge
ida, ncons, cons0, loads = constrain(nodes, wall, ien, 'x', 0)
ida, ncons, cons1, loads = constrain(nodes, wall, ien, 'y', 0.0, cons0)
ida, ncons, cons2, loads = constrain(nodes, edge, ien, 'x', 1.0, cons1)
deform, i = solver(numD, loads, nodes, ien, ida, ncons, cons2, cc)
correct = [0, 0, 0.5, 0, 1, 0, 0, 0, 0.5, 0, 1, 0, 0, 0, 0.5, 0, 1, 0]
for i in range(len(deform)): # for every item in the solution...
self.assertAlmostEqual((correct[i] + 1) / (correct[i] + 1), 1)
c = contourPlot(deform, ien, nodes, 'sigma_x', 'z', cc)
c = contourPlot(deform, ien, nodes, 'sigma_y', 'z', cc)
c = contourPlot(deform, ien, nodes, 'tau_xy', 'z', cc)
c = contourPlot(deform, ien, nodes, 'd_x', 'z', cc)
c = contourPlot(deform, ien, nodes, 'd_y', 'z', cc)
def test_1Elem1DPlot(self):
s0 = nsel('x', 'n', 0, 0.01, self.nodes1)
ida, ncons, cons, loads = constrain(self.nodes1, s0, self.ien1, 'x', 0)
loads[2][0] = 1.0e8 #Pa
deform, i = solver(1, loads, self.nodes1, self.ien1, ida, ncons, cons)
#c = plotResults(deform, self.nodes1, self.nnums1, [1, 0, 0], 'x')
self.assertEqual(0, 0)
def test_solver1D2ElemPressure(self):
result, steps = solver(self.numD[0], self.load4, self.nodes2,
self.ien2, self.ida4, self.ncons4, self.cons4)
correct = [0.0, 5.0e-6, 1.0e-5]
for i in range(len(result)): # for every component...
self.assertAlmostEqual((result[i] + 1) / (correct[i] + 1), 1)
def test_solver_1D1Elem(self):
result, steps = solver(self.numD[0], self.load1, self.nodes1,
self.ien1, self.ida1, self.ncons1, self.cons1)
correct = [0.0, self.load1[2][0][0] / (200e9)]
for i in range(len(result)): # for every component...
self.assertAlmostEqual((result[i] + 1) / (correct[i] + 1), 1)
def test_2DPress1Elem(self):
result, steps = solver(self.numD, self.load2, self.nodes1, self.ien1,
self.ida2, self.ncons2, self.cons2)
correct = [0.0, 0.0, -0.3e-5, 0.0, 0.0, 1.0e-5, -0.3e-5, 1.0e-5]
for i in range(len(result)): # for every component...
self.assertAlmostEqual((result[i] + 1) / (correct[i] + 1), 1)
def test_stressSolution1D1Elem(self):
result, steps = solver(self.numD[0], self.load1, self.nodes1,
self.ien1, self.ida1, self.ncons1, self.cons1)
stress = get_stress_sol(result, self.ien1, self.nodes1, 'sigma_x')
correct = [2.0e6, 2.0e6]
for i in range(len(correct)): # for each node...
self.assertAlmostEqual(correct[i], stress[i])
def test_stressSol3D1ElemVM(self):
result, steps = solver(self.numD[2], self.loadVM, self.nodes3,
self.ien3, self.ida3, self.ncons3, self.cons3)
stress = get_stress_sol(result, self.ien3, self.nodes3, 'von Mises')
correct = 8 * [1996.4]
for i in range(len(correct)): # for each node...
self.assertAlmostEqual(correct[i], stress[i], 1)
def test_stressSol3D1ElemZ(self):
result, steps = solver(self.numD[2], self.load3, self.nodes3,
self.ien3, self.ida3, self.ncons3, self.cons3)
stress = get_stress_sol(result, self.ien3, self.nodes3, 'sigma_z')
correct = 8 * [0.0]
for i in range(len(correct)): # for each node...
self.assertAlmostEqual(correct[i], stress[i], 3)
def test_2DBody1Elem(self):
self.load1[2][0] = 'n'
self.load1[0][0] = [2.0e6, 0, 0] # body force
result, steps = solver(self.numD, self.load1, self.nodes1, self.ien1,
self.ida1, self.ncons1, self.cons1)
correct = [0.0, 0.0, 5.0e-6, 0.0, 0.0, -1.5e-6, 5.0e-6, -1.5e-6]
for i in range(len(result)): # for every component...
self.assertAlmostEqual((result[i] + 1) / (correct[i] + 1), 1)
def test_2DDef4Elem(self):
result, steps = solver(self.numD, self.load4, self.nodes3, self.ien3,
self.ida4, self.ncons4, self.cons4)
correct = [
0.0, 0.0, 5.0e-6, 0.0, 1.0e-5, 0.0, 0.0, -1.5e-6, 5.0e-6, -1.5e-6,
1.0e-5, -1.5e-6, 0.0, -3.0e-6, 5.0e-6, -3.0e-6, 1.0e-5, -3.0e-6
]
for i in range(len(result)): # for every component...
self.assertAlmostEqual((result[i] + 1) / (correct[i] + 1), 1)
def test_solver1D2ElemTrac(self):
result, steps = solver(self.numD[0], self.load2, self.nodes2,
self.ien2, self.ida2, self.ncons2, self.cons2)
correct = [
0.0, 0.5 * self.load1[2][0][0] / (200e9),
self.load1[2][0][0] / (200e9)
]
for i in range(len(result)): # for every component...
self.assertAlmostEqual((result[i] + 1) / (correct[i] + 1), 1)
def test_3DTrac1Elem(self):
result, steps = solver(self.numD, self.load1, self.nodes1, self.ien1,
self.ida1, self.ncons1, self.cons1)
dd = 1.0e-3
nn = 3.0e-4
correct = [
0.0, 0.0, 0.0, dd, 0.0, 0.0, 0.0, -nn, 0.0, dd, -nn, 0.0, 0.0, 0.0,
-nn, dd, 0.0, -nn, 0.0, -nn, -nn, dd, -nn, -nn
]
for i in range(len(result)): # for every component...
self.assertAlmostEqual((result[i] + 1) / (correct[i] + 1), 1)
def setUp(self):
self.nodes = [[1.0, 2.0, 0.0], [2.0, 1.0, 0.0], [2.0, 3.0, 0.0],
[3.0, 2.0, 0.0]]
p = 2.0e6 # pressure load
self.ien = get_ien(1, 1)
selset = [2, 3] # selected node numbers
ida, ncons, cons0, loads = constrain(self.nodes, selset, self.ien, 'x',
0)
ida, ncons, cons, loads = constrain(self.nodes, selset, self.ien, 'y',
0, cons0)
loads[3][0] = p
self.deform, i = solver(2, loads, self.nodes, self.ien, ida, ncons,
cons)
def test_1Elem3DPlot(self):
s0 = nsel('x', 'n', 0, 0.01, self.nodes)
ida, ncons, cons, loads = constrain(self.nodes, s0, self.ien, 'x', 0)
s1 = nsel('z', 's', 0, 0.01, self.nodes, s0)
ida, ncons, cons, loads = constrain(self.nodes, s1, self.ien, 'z', 0,
cons)
s2 = nsel('y', 's', 0, 0.01, self.nodes, s1)
ida, ncons, cons, loads = constrain(self.nodes, s2, self.ien, 'y', 0,
cons)
loads[2][1] = 1.0e8 #Pa
loads[2][3] = 1.0e8
loads[2][5] = 1.0e8
loads[2][7] = 1.0e8
deform, i = solver(3, loads, self.nodes, self.ien, ida, ncons, cons)
ps0 = nsel('y', 'n', 0, 0.01, self.nodes)
ps1 = nsel('z', 's', 0, 0.01, self.nodes, ps0)
#c = plotResults(deform, self.nodes, ps1, [1, 0, 0], 'x')
self.assertEqual(0, 0)
def test_CylinderPlot(self):
# Here, we generate the mesh
thetaDomain = pi / 2.0 # quarter circle of the pipe
self.ri = 1.2 # the inner radius of the pipe
self.ro = 1.8 # the outer radius of the pipe
self.nr = 16 # the number of elements in the radial direction
self.nt = 32 # the number of elements in the circumfrential direction
self.nodes = [] # stores the nodes in the cylindrical mesh
self.p = -2.0e6 # the pressure (Pa)
cc = [2.0e11, 0.3] # [Young's Modulus, Poisson's Ratio]
for i in range(self.nr + 1): # for every node in the r-direction...
for j in range(self.nt +
1): # for every node in the theta-direction...
radius = i * (self.ro - self.ri) / self.nr + self.ri
theta = j * thetaDomain / self.nt
self.nodes.append(
[radius * sin(theta), radius * cos(theta), 0])
self.ien = get_ien(self.nt, self.nr)
self.nnums = np.linspace(0, len(self.nodes) - 1, len(self.nodes))
# now the fun begins. We solve this problem using roller constraints on
# the straight faces and pressure loads on the inner face.
s0 = nsel('y', 'n', 0, 0.01, self.nodes)
s1 = nsel('x', 'n', 0, 0.01, self.nodes)
ida, ncons, cons0, loads = constrain(self.nodes, s0, self.ien, 'y', 0)
ida, ncons, cons, loads = constrain(self.nodes, s1, self.ien, 'x', 0,
cons0)
for i in range(self.nt): # for every inner element...
loads[3][i] = self.p
self.deform, i = solver(2, loads, self.nodes, self.ien, ida, ncons,
cons)
ps0 = nsel('y', 'n', 0, 0.01, self.nodes)
#c = plotResults(deform, self.nodes, ps0, [1, 0, 0], 'x')
c = contourPlot(self.deform, self.ien, self.nodes, 'sigma_t', 'z', cc)
def test_OnePart2(self):
numD = 2 # number of dimensions
enum = 10 # number of elements in each dof
nodes = nodeList(1, 1, 1, enum, enum)
ien = get_ien(enum, enum)
cc = [1.0e7, 0.3]
wall = nsel('x', 'n', 0, 0.01, nodes) # select the wall
ida, ncons, cons0, loads = constrain(nodes, wall, ien, 'x', 0)
ida, ncons, cons1, loads = constrain(nodes, wall, ien, 'y', 0.0, cons0)
for i in range(enum): # for every element on a side...
loads[2][enum * (i + 1) - 1] = 1000.0 # traction on the right
deform, i = solver(numD, loads, nodes, ien, ida, ncons, cons1, cc)
c = contourPlot(deform, ien, nodes, 'd_abs', 'z', cc)
c = contourPlot(deform, ien, nodes, 'd_x', 'z', cc)
c = contourPlot(deform, ien, nodes, 'd_y', 'z', cc)
c = contourPlot(deform, ien, nodes, 'sigma_x', 'z', cc)
c = contourPlot(deform, ien, nodes, 'sigma_y', 'z', cc)
c = contourPlot(deform, ien, nodes, 'tau_xy', 'z', cc)
self.assertEqual(c, 0)
