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 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_SubsetSelection(self):
s0 = nsel('z', 'n', 1.5, 0.01, self.nodes) # get a new set
s1 = nsel('x', 's', 0, 0.01, self.nodes, s0) # intersect with new set
s2 = nsel('y', 's', 1.5, 0.01, self.nodes,
s0) # intersect with new set
correct = [[18, 21, 24], [24, 25, 26]]
for i in range(len(s1)): # for each component...
self.assertAlmostEqual(correct[0][i], s1[i])
for i in range(len(s2)): # for each component...
self.assertAlmostEqual(correct[1][i], s2[i])
def test_AdditionalSelection(self):
s0 = nsel('z', 'n', 1.5, 0.01, self.nodes) # get a new set
s1 = nsel('x', 'a', 0, 0.01, self.nodes, s0) # intersect with new set
s2 = nsel('y', 'a', 1.5, 0.01, self.nodes,
s0) # intersect with new set
correct = [[0, 3, 6, 9, 12, 15, 18, 19, 20, 21, 22, 23, 24, 25, 26],
[6, 7, 8, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26]]
for i in range(len(s1)): # for each component...
self.assertAlmostEqual(correct[0][i], s1[i])
for i in range(len(s2)): # for each component...
self.assertAlmostEqual(correct[1][i], s2[i])
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 setUp(self):
self.nodes = nodeList(1, 1, 1, 1, 1, 1)
self.ien = get_ien(1, 1, 1)
self.nnums = np.linspace(0, len(self.nodes) - 1, len(self.nodes))
self.s0 = nsel('x', 'n', 1, 0.01, self.nodes)
self.ida, self.ncons, self.cons, loads = constrain(
self.nodes, self.s0, self.ien, 'y', 0)
def test_NormalSelection(self):
s1 = nsel('x', 'n', 0.75, 0.01, self.nodes)
s2 = nsel('y', 'n', 1.5, 0.01, self.nodes)
s3 = nsel('z', 'n', 1.5, 1, self.nodes)
correct = [[0, 3, 6, 9, 12, 15, 18, 21, 24],
[6, 7, 8, 15, 16, 17, 24, 25, 26],
[
9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22,
23, 24, 25, 26
]]
for i in range(len(s1)): # for each component...
self.assertAlmostEqual(correct[0][i] + 1, s1[i])
for i in range(len(s2)): # for each component...
self.assertAlmostEqual(correct[1][i], s2[i])
for i in range(len(s3)): # for each component...
self.assertAlmostEqual(correct[2][i], s3[i])
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_accuracyPressCylinSol(self):
ps = nsel('y', 'n', 0, 0.01, self.nodes)
dsol = [] # stores the nodal values
rsol = [] # stores the node radial location
error = 0 # stores the total solution error
E = 2.0e11
nu = 0.3
for i in range(len(ps)): # for every node...
s = 2 * ps[i] # starting position of the node displacement
e = 2 * ps[i] + 2 # ending position of the node displacement
# the magnitude of the nodal displacement
dsol.append(np.linalg.norm(np.array(self.deform[s:e])))
v = self.nodes[ps[i]] # a vector position of the node
rsol.append(v[0]) # the radius of the point
for i in range(self.nr): # for every radial element...
# Here, we calculate the exact solution
d = 1.0 / 3**0.5 # the absolute distance of 2-point gauss quadrature
es = rsol[i + 1] - rsol[i] # element size
r0 = rsol[i] + (1 - d) * es / 2.0 # first gauss quadrature point
r1 = rsol[i] + (1 + d) * es / 2.0 # second gauss quadrature point
a = self.p * self.ri**2 / (E *
(self.ro**2 - self.ri**2)) # first part
b0 = ((1 - nu) * r0 + self.ro**2 * (1 + nu) / r0) # second part
b1 = ((1 - nu) * r1 + self.ro**2 * (1 + nu) / r1)
u0 = a * b0 # the exact solution at the first gauss quadrature point
u1 = a * b1 # the exact solution at the second gauss quadrature point
us0 = 0.5 * (1 + d) * dsol[i] + 0.5 * (
1 - d) * dsol[i + 1] # solution deform
us1 = 0.5 * (1 - d) * dsol[i] + 0.5 * (
1 + d) * dsol[i + 1] # solution deform
error += ((us0 - u0)**2 + (us1 - u1)**2) * es / 2.0
print('Error at the first Gauss point:', abs(us0 - u0))
self.assertLess(error, 8.0e-6)
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)
def test_SphericalSelection(self):
s0 = nsel('r', 'n', 1.5, 0.01, self.nodes)
correct = [2, 6, 18]
for i in range(len(s0)): # for each component...
self.assertEqual(correct[i], s0[i])
