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)
