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.ptube.get_index(self.property_id)
A = self.model.ptube.A[i]
mid = self.model.ptube.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 CTUBE 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 = (Lambda.T @ m) @ Lambda
Mi, Mj = M.shape
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),
# torsion -> NA
]
self.model.log.info('dofs = %s' % dofs)
return(M, dofs, n_ijv)
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 CTUBE 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 = []
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),
(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')
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
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., -1.], [-1., 1.]]) # 1D rod
Lambda = _Lambda(dxyz12, debug=False)
K = (Lambda.T @ 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 = Lambda.T @ 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)
