def setUp(self):
self.nodes = nodeList(1, 1, 1, 2, 2, 2)
self.nodes1 = nodeList(1, 1, 1, 1)
self.ien = get_ien(2, 2, 2)
self.ien1 = get_ien(1)
self.nnums = np.linspace(0, len(self.nodes) - 1, len(self.nodes))
self.nnums1 = [0, 1]
def setUp(self):
self.numD = [1, 2, 3] # the number of problem dimensions
enum = [1, 2] # number of elements
self.nodes1 = nodeList(1, 1, 1, enum[0])
self.ien1 = get_ien(enum[0])
self.cons1, self.load1 = load_and_cons(enum[0], len(self.nodes1),
self.numD[0])
self.cons1[0][0] = 0.0
self.load1[2][0] = [2.0e6, 0, 0] # load to right end
self.ida1, self.ncons1 = getIDArray(self.cons1)
# Here, we set up inputs for a two-element problem with a traction,
# displacement or pressure load. First, the traction load case.
self.nodes2 = nodeList(1, 1, 1, enum[1])
self.ien2 = get_ien(enum[1])
self.cons2, self.load2 = load_and_cons(enum[1], len(self.nodes2),
self.numD[0])
self.cons2[0][0] = 0.0
self.load2[2][1] = [2.0e6, 0, 0] # load to right end
self.ida2, self.ncons2 = getIDArray(self.cons2)
# for the displacement load sub-case...
self.cons3, self.load3 = load_and_cons(enum[1], len(self.nodes2),
self.numD[0])
self.cons3[0][0] = 0.0
self.cons3[0][2] = 1.0e-5
self.ida3, self.ncons3 = getIDArray(self.cons3)
# now, we test the pressure load sub-case.
self.cons4, self.load4 = load_and_cons(enum[1], len(self.nodes2),
self.numD[0])
self.cons4[0][0] = 0.0
self.load4[2][1] = 2.0e6
self.ida4, self.ncons4 = getIDArray(self.cons4)
def setUp(self):
self.numD = 2 # the number of problem dimensions
enum = [1, 2] # number of elements
self.nodes1 = nodeList(1, 1, 1, enum[0], enum[0])
self.ien1 = get_ien(enum[0], enum[0])
self.cons1, self.load1 = load_and_cons(enum[0], len(self.nodes1),
self.numD)
self.cons1[0][0] = 0.0
self.cons1[1][0] = 0.0
self.cons1[0][2] = 0.0
self.load1[2][0] = [2.0e6, 0, 0] # load to right end
self.ida1, self.ncons1 = getIDArray(self.cons1)
# For the pressure load...
self.cons2, self.load2 = load_and_cons(enum[0], len(self.nodes1),
self.numD)
self.cons2[0][0] = 0.0
self.cons2[1][0] = 0.0
self.cons2[1][1] = 0.0
self.load2[4][0] = 2.0e6 # pressure load to the top
self.ida2, self.ncons2 = getIDArray(self.cons2)
# for a 2x2 element array...
self.nodes3 = nodeList(1, 1, 1, enum[1], enum[1])
self.ien3 = get_ien(enum[1], enum[1])
self.cons3, self.load3 = load_and_cons(enum[1]**2, len(self.nodes3),
self.numD)
self.cons3[0][0] = 0.0
self.cons3[1][0] = 0.0
self.cons3[0][3] = 0.0
self.cons3[0][6] = 0.0
self.load3[2][1] = [2.0e6, 0, 0] # load to right end
self.load3[2][3] = [2.0e6, 0, 0]
self.ida3, self.ncons3 = getIDArray(self.cons3)
# for a 2x2 element array deformation load...
self.cons4, self.load4 = load_and_cons(enum[1]**2, len(self.nodes3),
self.numD)
self.cons4[0][0] = 0.0
self.cons4[1][0] = 0.0
self.cons4[0][2] = 1.0e-5
self.cons4[0][3] = 0.0
self.cons4[0][5] = 1.0e-5
self.cons4[0][6] = 0.0
self.cons4[0][8] = 1.0e-5
self.ida4, self.ncons4 = getIDArray(self.cons4)
def test_strainVecSimpleNormal(self):
nodes = nodeList(1, 1, 1, 1, 1, 1) # single 3D element
ien = get_ien(1, 1, 1)
e = 0 # element number
numD = numDims(1, 1, 1) # the number of dimensions
basis = getBasis(numD)
xa = getXaArray(e, nodes,
ien) # get the global coordinates of the element nodes
# In this section, we test normal strain computations where 'epsilon = 0.12' in each direction
for m in range(3): # for every direction...
deform = numD * len(nodes) * [0.0] # the deformation vector
for i in range(len(nodes)): # for every element node...
for j in range(numD): # for every dimension
if j == m: # for the x-direction...
deform[numD * i +
j] = nodes[i][j] * 0.12 # add a strain
for k in range(len(basis[0])): # for every integration point...
Bmats, scale = getBandScale(numD, basis, k, xa)
strain = strainVec(numD, e, deform, ien, Bmats)
strain0 = np.array([[0.0], [0.0], [0.0], [0.0], [0.0], [0.0]])
strain0[m] = 0.12
for i in range(len(strain)):
self.assertAlmostEqual(strain[i], strain0[i], places=4)
def test_stressVecShear(self):
nodes = nodeList(1, 1, 1, 1, 1, 1) # single 3D element
ien = get_ien(1, 1, 1)
e = 0 # element number
numD = numDims(1, 1, 1) # the number of dimensions
basis = getBasis(numD)
xa = getXaArray(e, nodes,
ien) # get the global coordinates of the element nodes
for m in range(numD): # for every direction...
deform = numD * len(nodes) * [0.0] # the deformation vector
for i in range(len(nodes)): # for every element node...
for j in range(numD): # for every dimension
if j == m: # for the x-direction...
deform[numD * i + (j + 1) %
numD] = nodes[i][j] * 0.12 # add a strain
for k in range(len(basis[0])): # for every integration point...
Bmats, scale = getBandScale(numD, basis, k, xa)
strain = strainVec(numD, e, deform, ien, Bmats)
stress = stressVec(numD, strain)
stress0 = np.array(6 * [0.0])
stress0[3 + (2 + m) % numD] = 200 * 10**9 / (2 *
(1 + 0.3)) * 0.12
for i in range(len(strain)):
self.assertAlmostEqual(stress[i], stress0[i], places=4)
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):
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 setUp(self):
self.nodes1 = nodeList(1, 1, 1, 1) # for one dimension...
self.ien1 = get_ien(1)
self.ndim1 = 1
self.numE1 = 1
self.deform1 = [0, 0.1]
cons, loads = load_and_cons(self.numE1, len(self.nodes1), 1)
cons[0][0] = 0 # set arbitrary constraints
self.ida1, self.ncons1 = getIDArray(cons)
self.nodes2 = nodeList(1, 1, 1, 1, 1) # for one dimension...
self.ien2 = get_ien(1, 1)
self.ndim2 = 2
self.numE2 = 1
self.deform2 = [0, 0, 0.1, 0, 0, -0.03, 0.1, -0.03]
cons, loads = load_and_cons(self.numE2, len(self.nodes2),
2) # 2 dimensions
cons[0][0] = 0
cons[1][0] = 0
cons[0][3] = 0
cons[1][3] = 0
self.ida2, self.ncons2 = getIDArray(cons)
self.nodes3 = nodeList(1, 1, 1, 1, 1, 1) # for one dimension...
self.ien3 = get_ien(1, 1, 1)
self.ndim3 = 3
self.numE3 = 1
self.deform3 = [
0, 0, 0, 0.1, 0, 0, 0, -0.03, 0, 0.1, -0.03, 0, 0, 0, -0.03, 0.1,
0, -0.03, 0, -0.03, -0.03, 0.1, -0.03, -0.03
]
cons, loads = load_and_cons(self.numE3, len(self.nodes3),
3) # 2 dimensions
cons[0][0] = 0
cons[1][0] = 0
cons[2][0] = 0
cons[0][3] = 0
cons[1][3] = 0
cons[2][3] = 0
cons[0][6] = 0
self.ida3, self.ncons3 = getIDArray(cons)
def setUp(self):
self.numD = [1, 2, 3] # the number of problem dimensions
enum = [1, 2] # number of elements
self.nodes1 = nodeList(1, 1, 1, enum[0])
self.ien1 = get_ien(enum[0])
self.cons1, self.load1 = load_and_cons(enum[0], len(self.nodes1),
self.numD[0])
self.cons1[0][0] = 0.0
self.load1[2][0] = [2.0e6, 0, 0] # load to right end
self.ida1, self.ncons1 = getIDArray(self.cons1)
# now the 3D problem setup
self.nodes3 = nodeList(1, 1, 1, enum[0], enum[0], enum[0])
self.ien3 = get_ien(enum[0], enum[0], enum[0])
self.cons3, self.load3 = load_and_cons(enum[0], len(self.nodes3),
self.numD[2])
self.cons3[1][0] = 0.0 # constrain node 0 in all dof
self.cons3[2][0] = 0.0
self.cons3[2][2] = 0.0 # prevent rotation about x
for i in [0, 2, 4, 6]: # for every constrained node
self.cons3[0][i] = 0.0
self.loadTxy = copy.deepcopy(self.load3)
self.loadTxz = copy.deepcopy(self.load3)
self.loadVM = copy.deepcopy(self.load3)
self.load3[2][0] = [2.0e8, 0, 0] # load to right end
self.loadTxy[2][0] = [0, 2.0e8, 0] # shear at the right face
self.loadTxy[1][0] = [0, -2.0e8, 0]
self.loadTxy[3][0] = [-2.0e8, 0, 0]
self.loadTxy[4][0] = [2.0e8, 0, 0]
self.loadTxz[1][0] = [0, 0, -2.0e8]
self.loadTxz[2][0] = [0, 0, 2.0e8]
self.loadTxz[5][0] = [-2.0e8, 0, 0]
self.loadTxz[6][0] = [2.0e8, 0, 0]
self.loadVM[1][0] = [1260.0, 0, -500.0] # von Mises load
self.loadVM[2][0] = [-1260.0, 0, 500.0]
self.loadVM[5][0] = [-500.0, 0, -800.0]
self.loadVM[6][0] = [500.0, 0, 800.0]
self.ida3, self.ncons3 = getIDArray(self.cons3)
def initialize(M, N, P, m, n=0, p=0):
nodes = nodeList(M, N, P, m, n, p) # get the nodes for the problem
ien = get_ien(m, n, p) # get the ien array
numD = numDims(m, n, p) # get the number of problem dimensions
numE = numElements(m, n, p)
deformation = numD * len(nodes) * [
0
] # initialize the deformation array of size [# nodes]x[# dimensions]
Fint = intForceVec(nodes, ien, numD, numE, deformation)
def setUp(self):
self.numD = 3 # the number of problem dimensions
enum = [1, 2] # number of elements
self.nodes1 = nodeList(1, 1, 1, enum[0], enum[0], enum[0])
self.ien1 = get_ien(enum[0], enum[0], enum[0])
self.cons1, self.load1 = load_and_cons(enum[0], len(self.nodes1),
self.numD)
self.cons1[1][0] = 0.0 # constrain node 0 in all dof
self.cons1[2][0] = 0.0
self.cons1[2][2] = 0.0 # prevent rotation about x
for i in [0, 2, 4, 6]: # for every constrained node
self.cons1[0][i] = 0.0
self.load1[2][0] = [2.0e8, 0, 0] # load to right end
self.ida1, self.ncons1 = getIDArray(self.cons1)
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_contourPlot(self):
nodes = nodeList(1, 1, 1, 60, 60, 60)
def setUp(self):
# 3D mesh
self.nodes = nodeList(1.5, 1.5, 1.5, 2, 2, 2)
self.ien = get_ien(2, 2, 2)
self.nnums = np.linspace(0, len(self.nodes) - 1, len(self.nodes))
