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): # define basic, needed parameters. self.b1 = getBasis(1) self.numD = 1 self.strain = 0.1 self.deform1 = [0, self.strain] # deform. of two nodes in 1D self.ien1 = get_ien(1) self.enum1 = 0 self.xa1 = [[0, 0, 0], [1, 0, 0]] # real coordinats of the nodes self.Bmats1, self.scale1 = getBandScale(self.numD, self.b1, 0, self.xa1) self.b2 = getBasis(2) # deformation of four nodes in 2D self.deform2 = [0, 0, 0.1, 0, 0, -0.03, 0.1, -0.03] self.ien2 = get_ien(1, 1) self.enum2 = 0 self.i2 = 0 self.xa2 = [[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0]] self.Bmats2, scale2 = getBandScale(2, self.b2, 0, self.xa2) self.b3 = getBasis(3) # deformation of four nodes in 2D 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 ] self.ien3 = get_ien(1, 1, 1) self.enum3 = 0 self.i3 = 0 self.xa3 = [[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0], [0, 0, 1], [1, 0, 1], [0, 1, 1], [1, 1, 1]] self.Bmats3, scale3 = getBandScale(3, self.b3, 0, self.xa3)
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 setUp(self): self.b1 = getBasis(1) self.deform1 = [0, 0.1] # deformation of two nodes in 1D self.ien1 = get_ien(1) self.enum1 = 0 self.i1 = 0 self.xa1 = [[0, 0, 0], [1, 0, 0]] self.b2 = getBasis(2) # deformation of four nodes in 2D self.deform2 = [0, 0, 0.1, 0, 0, -0.03, 0.1, -0.03] self.ien2 = get_ien(1, 1) self.enum2 = 0 self.i2 = 0 self.xa2 = [[0, 0, 0], [1, 0, 0], [0, 1, 0], [1, 1, 0]]
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_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 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 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.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 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 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.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 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_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)
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))