def get_mass_matrix(self, i, model, positions, index0s, knorm=1.0): # CROD/CONROD """ Lumped: ======= mi = 1/2 * rho * A * L [ 1 0 ] M = mi [ 0 1 ] Consistent: =========== mi = 1/6 * rho * A * L [ 2 1 ] M = mi [ 1 2 ] """ i = self.model.prod.get_index(self.property_id) A = self.model.prod.A[i] mid = self.model.prod.material_id[i] rho = self.model.materials.get_density_by_material_id(mid) #======================== xyz_cid0 = None #xyz1, xyz2 = self._node_locations(xyz_cid0) if self.n == 1: n1, n2 = self.node_ids[0, :] else: n1, n2 = self.node_ids[i, :] i1 = index0s[n1] i2 = index0s[n2] p1 = positions[n1] p2 = positions[n2] v1 = p1 - p2 L = norm(v1) if L == 0.0: msg = 'invalid CROD length=0.0\n%s' % self.__repr__() raise ZeroDivisionError(msg) #======================== nsm = self.get_non_structural_mass(self.property_id[i]) mi = (rho * A * L + nsm) / 6. m = array([[2., 1.], [1., 2.]]) # 1D rod Lambda = _Lambda(v1, debug=False) M = dot(dot(transpose(Lambda), m), Lambda) Mi, Mj = M.shape dofs = array([ i1, i1+1, i1+2, i2, i2+1, i2+2, ], 'int32') nIJV = [ # axial (n1, 1), (n1, 2), (n1, 3), (n2, 1), (n2, 2), (n2, 3), # torsion -> NA ] self.model.log.info('dofs = %s' % dofs) return(M, dofs, nIJV)
def get_mass_matrix(self, i, model, positions, index0s, knorm=1.0): # CROD/CONROD """ Lumped: ======= mi = 1/2 * rho * A * L [ 1 0 ] M = mi [ 0 1 ] Consistent: =========== mi = 1/6 * rho * A * L [ 2 1 ] M = mi [ 1 2 ] """ i = self.model.prod.get_index(self.property_id) A = self.model.prod.A[i] mid = self.model.prod.material_id[i] rho = self.model.materials.get_density_by_material_id(mid) #======================== xyz_cid0 = None #xyz1, xyz2 = self._node_locations(xyz_cid0) if self.n == 1: n1, n2 = self.node_ids[0, :] else: n1, n2 = self.node_ids[i, :] i1 = index0s[n1] i2 = index0s[n2] p1 = positions[n1] p2 = positions[n2] v1 = p1 - p2 L = norm(v1) if L == 0.0: msg = 'invalid CONROD length=0.0\n%s' % self.__repr__() raise ZeroDivisionError(msg) #======================== nsm = self.get_non_structural_mass(self.property_id[i]) mi = (rho * A * L + nsm) / 6. m = array([[2., 1.], [1., 2.]]) # 1D rod Lambda = _Lambda(v1, debug=False) M = dot(dot(transpose(Lambda), m), Lambda) Mi, Mj = M.shape dofs = array([ i1, i1+1, i1+2, i2, i2+1, i2+2, ], 'int32') nIJV = [ # axial (n1, 1), (n1, 2), (n1, 3), (n2, 1), (n2, 2), (n2, 3), # torsion -> NA ] self.model.log.info('dofs = %s' % dofs) return(M, dofs, nIJV)
def get_stiffness(self, i, model, positions, index0s, fnorm=1.0): # CELAS1/CONROD #print("----------------") ipid = where(self.model.pelas.property_id == self.property_id[i])[0][0] prop = self.model.pelas ki = prop.K[ipid] #======================== n0, n1 = self.node_ids[i, :] i0, i1 = index0s p0 = positions[n0] p1 = positions[n1] v1 = p0 - p1 L = norm(v1) if L == 0.0: msg = 'invalid CELAS1 length=0.0\n%s' % (self.__repr__()) raise ZeroDivisionError(msg) try: Lambda = _Lambda(v1, debug=True) except ZeroDivisionError: raise ZeroDivisionError("CELAS2 xyz[%i]=%s; xyz[%i]=%s" % (n0, p0, n1, p1)) #======================== k = ki * array([[ 1, -1, ], [-1, 1]]) K = dot(dot(transpose(Lambda), k), Lambda) c1, c2 = self.components[i, :] delta1 = 0 if c1 in [1, 2, 3] else 3 delta2 = 0 if c2 in [1, 2, 3] else 3 nIJV = [ (n0, 1 + delta1), (n0, 2 + delta1), (n0, 3 + delta1), (n1, 1 + delta2), (n1, 2 + delta2), (n1, 3 + delta2), ] dofs = nIJV return (K, dofs, nIJV)
def displacement_stress(self, model, positions, q, dofs, ni, e1, f1, o1): n = self.n du_axial = zeros(n, 'float64') for i in range(self.n): (n0, n1) = self.node_ids[i, :] if n0 == n1: raise RuntimeError('CELAS2 eid=%s n1=%s n2=%s' % (self.element_id[i], n0, n1)) p0 = positions[n0] p1 = positions[n1] v1 = p0 - p1 L = norm(v1) try: Lambda = _Lambda(v1, debug=True) except ZeroDivisionError: raise ZeroDivisionError("CELAS2 xyz[%i]=%s; xyz[%i]=%s" % (n0, p0, n1, p1)) n01 = dofs[(n0, 1)] n11 = dofs[(n1, 1)] n02 = dofs[(n0, 2)] n12 = dofs[(n1, 2)] n03 = dofs[(n0, 3)] n13 = dofs[(n1, 3)] q_axial = array([ q[n01], q[n02], q[n03], q[n11], q[n12], q[n13] ]) u_axial = dot(Lambda, q_axial) du_axial[i] = u_axial[0] - u_axial[1] print("len(pelas) = %s" % self.model.pelas.n) i = searchsorted(self.model.pelas.property_id, self.property_id) k = self.model.pelas.K[i] s = self.model.pelas.s[i] print("k=%s s=%s du_axial=%s" % (k, s, du_axial)) e1[ni: ni+n] = du_axial * s f1[ni: ni+n] = k * du_axial o1[ni: ni+n] = f1[ni: ni+n] * s #return (axial_strain, axial_stress, axial_force)
def get_stiffness(self, i, model, positions, index0s, fnorm=1.0): # CELAS3 ki = self.K[i] k = ki * array([[ 1, -1, ], [-1, 1]]) n0, n1 = self.node_ids[i, :] p0 = positions[n0] p1 = positions[n1] v1 = p0 - p1 L = norm(v1) if L == 0.0: msg = 'invalid CELAS3 length=0.0\n%s' % (self.__repr__()) raise ZeroDivisionError(msg) try: Lambda = _Lambda(v1, debug=True) except ZeroDivisionError: raise ZeroDivisionError("CELAS3 xyz[%i]=%s; xyz[%i]=%s" % (n0, p0, n1, p1)) #======================== K = dot(dot(transpose(Lambda), k), Lambda) c0, c1 = self.components[i, :] n0, n1 = self.node_ids[i, :] delta0 = 0 if c0 in [1, 2, 3] else 3 delta1 = 0 if c1 in [1, 2, 3] else 3 nIJV = [ (n0, 1 + delta0), (n0, 2 + delta0), (n0, 3 + delta0), (n1, 1 + delta1), (n1, 2 + delta1), (n1, 3 + delta1), ] dofs = nIJV return (K, dofs, nIJV)
def displacement_stress(self, model, positions, q, dofs, ni, e1, f1, o1): n = self.n du_axial = zeros(n, 'float64') for i in range(self.n): (n0, n1) = self.node_ids[i, :] if n0 == n1: raise RuntimeError('CELAS2 eid=%s n1=%s n2=%s' % (self.element_id[i], n0, n1)) p0 = positions[n0] p1 = positions[n1] v1 = p0 - p1 L = norm(v1) try: Lambda = _Lambda(v1, debug=True) except ZeroDivisionError: raise ZeroDivisionError("CELAS2 xyz[%i]=%s; xyz[%i]=%s" % (n0, p0, n1, p1)) n01 = dofs[(n0, 1)] n11 = dofs[(n1, 1)] n02 = dofs[(n0, 2)] n12 = dofs[(n1, 2)] n03 = dofs[(n0, 3)] n13 = dofs[(n1, 3)] q_axial = array([q[n01], q[n02], q[n03], q[n11], q[n12], q[n13]]) u_axial = dot(Lambda, q_axial) du_axial[i] = u_axial[0] - u_axial[1] print("len(pelas) = %s" % self.model.pelas.n) i = searchsorted(self.model.pelas.property_id, self.property_id) k = self.model.pelas.K[i] s = self.model.pelas.s[i] print("k=%s s=%s du_axial=%s" % (k, s, du_axial)) e1[ni:ni + n] = du_axial * s f1[ni:ni + n] = k * du_axial o1[ni:ni + n] = f1[ni:ni + n] * s
def displacement_stress(self, model, positions, q, dofs, ni, e1, f1, o1): n = self.n du_axial = zeros(n, 'float64') for i in range(self.n): n0, n1 = self.node_ids[i, :] if n0 == n1: raise RuntimeError('CELAS4 eid=%s n1=%s n2=%s' % (self.element_id[i], n0, n1)) p0 = positions[n0] p1 = positions[n1] v1 = p0 - p1 L = norm(v1) try: Lambda = _Lambda(v1, debug=True) except ZeroDivisionError: raise ZeroDivisionError("CELAS4 xyz[%i]=%s; xyz[%i]=%s" % (n0, p0, n1, p1)) n01 = dofs[(n0, 1)] n11 = dofs[(n1, 1)] n02 = dofs[(n0, 2)] n12 = dofs[(n1, 2)] n03 = dofs[(n0, 3)] n13 = dofs[(n1, 3)] q_axial = array([ q[n01], q[n02], q[n03], q[n11], q[n12], q[n13] ]) u_axial = dot(Lambda, q_axial) du_axial[i] = u_axial[0] - u_axial[1] s = self.s ki = self.K e1[ni : ni+n] = du_axial * s f1[ni : ni+n] = ki * du_axial o1[ni : ni+n] = f1[ni: ni+n] * s
def displacement_stress(self, model, positions, q, dofs, ni, e1, f1, o1): n = self.n du_axial = zeros(n, 'float64') for i in range(self.n): n0, n1 = self.node_ids[i, :] if n0 == n1: raise RuntimeError('CELAS2 eid=%s n1=%s n2=%s' % (self.element_id[i], n0, n1)) p0 = positions[n0] p1 = positions[n1] v1 = p0 - p1 L = norm(v1) try: Lambda = _Lambda(v1, debug=True) except ZeroDivisionError: raise ZeroDivisionError("CELAS2 xyz[%i]=%s; xyz[%i]=%s" % (n0, p0, n1, p1)) n01 = dofs[(n0, 1)] n11 = dofs[(n1, 1)] n02 = dofs[(n0, 2)] n12 = dofs[(n1, 2)] n03 = dofs[(n0, 3)] n13 = dofs[(n1, 3)] q_axial = array([ q[n01], q[n02], q[n03], q[n11], q[n12], q[n13] ]) u_axial = dot(Lambda, q_axial) du_axial[i] = u_axial[0] - u_axial[1] s = self.s ki = self.K e1[ni : ni+n] = du_axial * s f1[ni : ni+n] = ki * du_axial o1[ni : ni+n] = f1[ni: ni+n] * s
def get_stiffness(self, i, model, positions, index0s, fnorm=1.0): # CELAS1/CONROD #print("----------------") ipid = where(self.model.pelas.property_id==self.property_id[i])[0][0] prop = self.model.pelas ki = prop.K[ipid] #======================== n0, n1 = self.node_ids[i, :] i0, i1 = index0s p0 = positions[n0] p1 = positions[n1] v1 = p0 - p1 L = norm(v1) if L == 0.0: msg = 'invalid CELAS1 length=0.0\n%s' % (self.__repr__()) raise ZeroDivisionError(msg) try: Lambda = _Lambda(v1, debug=True) except ZeroDivisionError: raise ZeroDivisionError("CELAS2 xyz[%i]=%s; xyz[%i]=%s" % (n0, p0, n1, p1)) #======================== k = ki * array([[1, -1,], [-1, 1]]) K = dot(dot(transpose(Lambda), k), Lambda) c1, c2 = self.components[i, :] delta1 = 0 if c1 in [1, 2, 3] else 3 delta2 = 0 if c2 in [1, 2, 3] else 3 nIJV = [ (n0, 1 + delta1), (n0, 2 + delta1), (n0, 3 + delta1), (n1, 1 + delta2), (n1, 2 + delta2), (n1, 3 + delta2), ] dofs = nIJV return (K, dofs, nIJV)
def get_stiffness(self, i, model, positions, index0s, fnorm=1.0): # CELAS4 ki = self.K[i] k = ki * array([[1, -1,], [-1, 1]]) n0, n1 = self.node_ids[i, :] p0 = positions[n0] p1 = positions[n1] v1 = p0 - p1 L = norm(v1) if L == 0.0: msg = 'invalid CELAS4 length=0.0\n%s' % (self.__repr__()) raise ZeroDivisionError(msg) try: Lambda = _Lambda(v1, debug=True) except ZeroDivisionError: raise ZeroDivisionError("CELAS4 xyz[%i]=%s; xyz[%i]=%s" % (n0, p0, n1, p1)) #======================== K = dot(dot(transpose(Lambda), k), Lambda) c0, c1 = self.components[i, :] n0, n1 = self.node_ids[i, :] delta0 = 0 if c0 in [1, 2, 3] else 3 delta1 = 0 if c1 in [1, 2, 3] else 3 nIJV = [ (n0, 1 + delta0), (n0, 2 + delta0), (n0, 3 + delta0), (n1, 1 + delta1), (n1, 2 + delta1), (n1, 3 + delta1), ] dofs = nIJV return (K, dofs, nIJV)
def displacement_stress(self, model, positions, q, dofs): n = self.n o1 = zeros(n, "float64") e1 = zeros(n, "float64") f1 = zeros(n, "float64") o4 = zeros(n, "float64") e4 = zeros(n, "float64") f4 = zeros(n, "float64") # As = self.get_area_by_element_id(self.property_id) # Es = self.get_E_by_element_id(self.property_id) # Gs = self.get_G_by_element_id(self.property_id) # Js = self.get_J_by_element_id(self.property_id) # Cs = self.get_c_by_element_id(self.property_id) i = self.get_element_index_by_element_id(self.element_id) As = self.get_area_by_element_index(i) Gs = self.model.prod.get_G_by_property_id(self.property_id) Es = self.model.prod.get_E_by_property_id(self.property_id) Js = self.model.prod.get_J_by_property_id(self.property_id) Cs = self.model.prod.get_c_by_property_id(self.property_id) for i in range(n): A = As[i] E = Es[i] G = Gs[i] E = Es[i] J = Js[i] C = Cs[i] n1, n2 = self.node_ids[i, :] xyz1 = positions[n1] xyz2 = positions[n2] v1 = xyz1 - xyz2 L = norm(xyz1 - xyz2) if L == 0.0: msg = "invalid CROD length=0.0\n%s" % (self.__repr__()) raise ZeroDivisionError(msg) # ======================== # mat = self.get_material_from_index(i) # jmat = searchsorted(mat.material_id, self.material_id[i]) # E = mat.E[jmat] # G = mat.G[jmat] # G = self.G() # print("A=%g E=%g G=%g J=%g L=%g" % (A, E, G, J, L)) k_axial = A * E / L k_torsion = G * J / L # k_axial = 1.0 # k_torsion = 2.0 # k = array([[1., -1.], # [-1., 1.]]) # 1D rod Lambda = _Lambda(v1, debug=False) # print("**dofs =", dofs) n11 = dofs[(n1, 1)] n21 = dofs[(n2, 1)] n12 = dofs[(n1, 2)] n22 = dofs[(n2, 2)] n13 = dofs[(n1, 3)] n23 = dofs[(n2, 3)] # moments n14 = dofs[(n1, 4)] n24 = dofs[(n2, 4)] n15 = dofs[(n1, 5)] n25 = dofs[(n2, 5)] n16 = dofs[(n1, 6)] n26 = dofs[(n2, 6)] q_axial = array([q[n11], q[n12], q[n13], q[n21], q[n22], q[n23]]) q_torsion = array([q[n14], q[n15], q[n16], q[n24], q[n25], q[n26]]) # print("type=%s n1=%s n2=%s" % (self.type, n1, n2)) # print("n11=%s n12=%s n21=%s n22=%s" %(n11,n12,n21,n22)) # print("q2[%s] = %s" % (self.eid, q2)) # print("Lambda = \n"+str(Lambda)) # print("Lsize = ", Lambda.shape) # print("qsize = ", q.shape) u_axial = dot(array(Lambda), q_axial) du_axial = u_axial[0] - u_axial[1] u_torsion = dot(array(Lambda), q_torsion) du_torsion = u_torsion[0] - u_torsion[1] # L = self.Length() # E = self.E() # A = self.area() # C = self.C() # J = self.J() # G = self.G() axial_strain = du_axial / L torsional_strain = du_torsion * C / L axial_stress = E * axial_strain torsional_stress = G * torsional_strain axial_force = axial_stress * A torsional_moment = du_torsion * G * J / L # print("axial_strain = %s [psi]" % axial_strain) # print("axial_stress = %s [psi]" % axial_stress) # print("axial_force = %s [lb]\n" % axial_force) o1[i] = axial_stress o4[i] = torsional_stress e1[i] = axial_strain e4[i] = torsional_strain f1[i] = axial_force f4[i] = torsional_moment return (e1, e4, o1, o4, f1, f4)
def get_stiffness_matrix(self, i, model, positions, index0s, knorm=1.0): # print("----------------") pid = self.property_id[i] assert isinstance(pid, int), pid element_id = self.element_id[i] i = self.get_element_index_by_element_id(element_id) A = self.get_area_by_element_index(i) G = self.model.prod.get_G_by_property_id(pid) E = self.model.prod.get_E_by_property_id(pid) J = self.model.prod.get_J_by_property_id(pid) # A = self.get_area_by_element_id(pid) # E = self.get_E_by_element_id(pid) # G = self.get_G_by_element_id(pid) # J = self.get_J_by_element_id(pid) # print('A=%s E=%s G=%s J=%s' % (A, E, G, J)) # ======================== # (n1, n2) = self.node_ids() i = np.asarray(i) nids = self.node_ids[i, :] n1, n2 = nids.squeeze() i1 = index0s[n1] i2 = index0s[n2] xyz1 = positions[n1] xyz2 = positions[n2] # p1 = model.Node(n1).xyz dxyz12 = xyz1 - xyz2 L = norm(dxyz12) if L == 0.0: msg = "invalid CROD length=0.0\n%s" % (self.__repr__()) raise ZeroDivisionError(msg) # ======================== # print("A=%g E=%g G=%g J=%g L=%g" % (A, E, G, J, L)) k_axial = A * E / L k_torsion = G * J / L # k_axial = 1.0 # k_torsion = 2.0 k = array([[1.0, -1.0], [-1.0, 1.0]]) # 1D rod Lambda = _Lambda(dxyz12, debug=False) K = dot(dot(transpose(Lambda), k), Lambda) Ki, Kj = K.shape K2 = zeros((Ki * 2, Kj * 2), "float64") if k_axial == 0.0 and k_torsion == 0.0: dofs = [] n_ijv = [] K2 = [] elif k_torsion == 0.0: # axial; 2D or 3D K2 = K * k_axial dofs = array([i1, i1 + 1, i1 + 2, i2, i2 + 1, i2 + 2], "int32") n_ijv = [ # axial (n1, 1), (n1, 2), (n1, 3), (n2, 1), (n2, 2), (n2, 3), ] elif k_axial == 0.0: # torsion; assume 3D K2 = K * k_torsion dofs = array([i1 + 3, i1 + 4, i1 + 5, i2 + 3, i2 + 4, i2 + 5], "int32") n_ijv = [ # torsion (n1, 4), (n1, 5), (n1, 6), (n2, 4), (n2, 5), (n2, 6), ] else: # axial + torsion; assume 3D # u1fx, u1fy, u1fz, u2fx, u2fy, u2fz K2[:Ki, :Ki] = K * k_axial # u1mx, u1my, u1mz, u2mx, u2my, u2mz K2[Ki:, Ki:] = K * k_torsion dofs = array( [i1, i1 + 1, i1 + 2, i2, i2 + 1, i2 + 2, i1 + 3, i1 + 4, i1 + 5, i2 + 3, i2 + 4, i2 + 5], "int32" ) n_ijv = [ # axial (n1, 1), (n1, 2), (n1, 3), (n2, 1), (n2, 2), (n2, 3), # torsion (n1, 4), (n1, 5), (n1, 6), (n2, 4), (n2, 5), (n2, 6), ] # Fg = dot(dot(transpose(Lambda), grav), Lambda) # print("K=\n", K / knorm) # print("K2=\n", K2 / knorm) # ======================== # print(K / knorm) # print("K[%s] = \n%s\n" % (self.eid, list_print(K/knorm))) self.model.log.info("dofs = %s" % dofs) self.model.log.info("K =\n%s" % list_print(K / knorm)) return (K2, dofs, n_ijv)
def get_stiffness_matrix(self, i, model, positions, index0s, knorm=1.0): #print("----------------") pid = self.property_id[i] assert isinstance(pid, int), pid A = self.get_area_by_element_id(pid) E = self.get_E_by_element_id(pid) G = self.get_G_by_element_id(pid) J = self.get_J_by_element_id(pid) #print('A=%s E=%s G=%s J=%s' % (A, E, G, J)) #======================== #(n1, n2) = self.node_ids() n1 = self.node_ids[i, 0] n2 = self.node_ids[i, 1] i1 = index0s[n1] i2 = index0s[n2] #print("n0", n0) #print("n1", n1) n1 = positions[n1] n2 = positions[n2] #p1 = model.Node(n1).xyz v1 = n1 - n2 L = norm(v1) if L == 0.0: msg = 'invalid CROD length=0.0\n%s' % (self.__repr__()) raise ZeroDivisionError(msg) #======================== #print("A=%g E=%g G=%g J=%g L=%g" % (A, E, G, J, L)) k_axial = A * E / L k_torsion = G * J / L #k_axial = 1.0 #k_torsion = 2.0 k = array([[1., -1.], [-1., 1.]]) # 1D rod Lambda = _Lambda(v1, debug=True) K = dot(dot(transpose(Lambda), k), Lambda) Ki, Kj = K.shape # for testing #K = ones((Ki, Ki), 'float64') K2 = zeros((Ki*2, Kj*2), 'float64') if k_axial == 0.0 and k_torsion == 0.0: dofs = [] nIJV = [] K2 = [] elif k_torsion == 0.0: # axial; 2D or 3D K2 = K * k_axial dofs = array([ i1, i1+1, i1+2, i2, i2+1, i2+2, ], 'int32') nIJV = [ # axial (n1, 1), (n1, 2), (n1, 3), (n2, 1), (n2, 2), (n2, 3), ] elif k_axial == 0.0: # torsion; assume 3D K2 = K * k_torsion dofs = array([ i1+3, i1+4, i1+5, i2+3, i2+4, i2+5, ], 'int32') nIJV = [ # torsion (n1, 4), (n1, 5), (n2, 6), (n2, 4), (n2, 5), (n1, 6), ] else: # axial + torsion; assume 3D # u1fx, u1fy, u1fz, u2fx, u2fy, u2fz K2[:Ki, :Ki] = K * k_axial # u1mx, u1my, u1mz, u2mx, u2my, u2mz K2[Ki:, Ki:] = K * k_torsion dofs = array([ i1, i1+1, i1+2, i2, i2+1, i2+2, i1+3, i1+4, i1+5, i2+3, i2+4, i2+5, ], 'int32') nIJV = [ # axial (n1, 1), (n1, 2), (n1, 3), (n2, 1), (n2, 2), (n2, 3), # torsion (n1, 4), (n1, 5), (n1, 6), (n2, 4), (n2, 5), (n2, 6), ] #Fg = dot(dot(transpose(Lambda), grav), Lambda) #print("K=\n", K / knorm) #print("K2=\n", K2 / knorm) #======================== #print(K / knorm) #print("K[%s] = \n%s\n" % (self.eid, list_print(K/knorm))) self.model.log.info('dofs = %s' % dofs) self.model.log.info('K =\n%s' % list_print(K / knorm)) return(K2, dofs, nIJV)
def displacement_stress(self, model, positions, q, dofs): n = self.n o1 = zeros(n, 'float64') e1 = zeros(n, 'float64') f1 = zeros(n, 'float64') o4 = zeros(n, 'float64') e4 = zeros(n, 'float64') f4 = zeros(n, 'float64') As = self.get_Area_by_element_id(self.property_id) Es = self.get_E_by_element_id(self.property_id) Gs = self.get_G_by_element_id(self.property_id) Js = self.get_J_by_element_id(self.property_id) Cs = self.get_c_by_element_id(self.property_id) for i in range(n): A = As[i] E = Es[i] G = Gs[i] E = Es[i] J = Js[i] C = Cs[i] n1, n2 = self.node_ids[i, :] p1 = positions[n1] p2 = positions[n2] v1 = p1 - p2 L = norm(p1 - p2) if L == 0.0: msg = 'invalid CROD length=0.0\n%s' % (self.__repr__()) raise ZeroDivisionError(msg) #======================== #mat = self.get_material_from_index(i) #jmat = searchsorted(mat.material_id, self.material_id[i]) #E = mat.E[jmat] #G = mat.G[jmat] #G = self.G() #print("A=%g E=%g G=%g J=%g L=%g" % (A, E, G, J, L)) k_axial = A * E / L k_torsion = G * J / L #k_axial = 1.0 #k_torsion = 2.0 #k = array([[1., -1.], [-1., 1.]]) # 1D rod Lambda = _Lambda(v1, debug=False) #print("**dofs =", dofs) n11 = dofs[(n1, 1)] n21 = dofs[(n2, 1)] n12 = dofs[(n1, 2)] n22 = dofs[(n2, 2)] n13 = dofs[(n1, 3)] n23 = dofs[(n2, 3)] # moments n14 = dofs[(n1, 4)] n24 = dofs[(n2, 4)] n15 = dofs[(n1, 5)] n25 = dofs[(n2, 5)] n16 = dofs[(n1, 6)] n26 = dofs[(n2, 6)] q_axial = array([ q[n11], q[n12], q[n13], q[n21], q[n22], q[n23] ]) q_torsion = array([ q[n14], q[n15], q[n16], q[n24], q[n25], q[n26] ]) #print("type=%s n1=%s n2=%s" % (self.type, n1, n2)) #print("n11=%s n12=%s n21=%s n22=%s" %(n11,n12,n21,n22)) #print("q2[%s] = %s" % (self.eid, q2)) #print("Lambda = \n"+str(Lambda)) #print("Lsize = ", Lambda.shape) #print("qsize = ", q.shape) u_axial = dot(array(Lambda), q_axial) du_axial = -u_axial[0] + u_axial[1] u_torsion = dot(array(Lambda), q_torsion) du_torsion = -u_torsion[0] + u_torsion[1] #L = self.Length() #E = self.E() #A = self.Area() #C = self.C() #J = self.J() #G = self.G() axial_strain = du_axial / L torsional_strain = du_torsion * C / L axial_stress = E * axial_strain torsional_stress = G * torsional_strain axial_force = axial_stress * A torsional_moment = du_torsion * G * J / L #print("axial_strain = %s [psi]" % axial_strain) #print("axial_stress = %s [psi]" % axial_stress) #print("axial_force = %s [lb]\n" % axial_force) o1[i] = axial_stress o4[i] = torsional_stress e1[i] = axial_strain e4[i] = torsional_strain f1[i] = axial_force f4[i] = torsional_moment return (e1, e4, o1, o4, f1, f4)
def get_stiffness_matrix(self, i, model, positions, index0s, knorm=1.0): #print("----------------") pid = self.property_id[i] assert isinstance(pid, int), pid A = self.get_Area_by_element_id(pid) E = self.get_E_by_element_id(pid) G = self.get_G_by_element_id(pid) J = self.get_J_by_element_id(pid) #print('A=%s E=%s G=%s J=%s' % (A, E, G, J)) #======================== #(n1, n2) = self.node_ids() n1 = self.node_ids[i, 0] n2 = self.node_ids[i, 1] i1 = index0s[n1] i2 = index0s[n2] #print("n0", n0) #print("n1", n1) n1 = positions[n1] n2 = positions[n2] #p1 = model.Node(n1).xyz v1 = n1 - n2 L = norm(v1) if L == 0.0: msg = 'invalid CROD length=0.0\n%s' % (self.__repr__()) raise ZeroDivisionError(msg) #======================== #print("A=%g E=%g G=%g J=%g L=%g" % (A, E, G, J, L)) k_axial = A * E / L k_torsion = G * J / L #k_axial = 1.0 #k_torsion = 2.0 k = array([[1., -1.], [-1., 1.]]) # 1D rod Lambda = _Lambda(v1, debug=True) K = dot(dot(transpose(Lambda), k), Lambda) Ki, Kj = K.shape # for testing #K = ones((Ki, Ki), 'float64') K2 = zeros((Ki*2, Kj*2), 'float64') if k_axial == 0.0 and k_torsion == 0.0: dofs = [] nIJV = [] K2 = [] elif k_torsion == 0.0: # axial; 2D or 3D K2 = K * k_axial dofs = array([ i1, i1+1, i1+2, i2, i2+1, i2+2, ], 'int32') nIJV = [ # axial (n1, 1), (n1, 2), (n1, 3), (n2, 1), (n2, 2), (n2, 3), ] elif k_axial == 0.0: # torsion; assume 3D K2 = K * k_torsion dofs = array([ i1+3, i1+4, i1+5, i2+3, i2+4, i2+5, ], 'int32') nIJV = [ # torsion (n1, 4), (n1, 5), (n2, 6), (n2, 4), (n2, 5), (n1, 6), ] else: # axial + torsion; assume 3D # u1fx, u1fy, u1fz, u2fx, u2fy, u2fz K2[:Ki, :Ki] = K * k_axial # u1mx, u1my, u1mz, u2mx, u2my, u2mz K2[Ki:, Ki:] = K * k_torsion dofs = array([ i1, i1+1, i1+2, i2, i2+1, i2+2, i1+3, i1+4, i1+5, i2+3, i2+4, i2+5, ], 'int32') nIJV = [ # axial (n1, 1), (n1, 2), (n1, 3), (n2, 1), (n2, 2), (n2, 3), # torsion (n1, 4), (n1, 5), (n1, 6), (n2, 4), (n2, 5), (n2, 6), ] #Fg = dot(dot(transpose(Lambda), grav), Lambda) #print("K=\n", K / knorm) #print("K2=\n", K2 / knorm) #======================== #print(K / knorm) #print("K[%s] = \n%s\n" % (self.eid, list_print(K/knorm))) self.model.log.info('dofs = %s' % dofs) self.model.log.info('K =\n%s' % list_print(K / knorm)) return(K2, dofs, nIJV)