def _rebuild(self):
assert self.panel1.model == self.panel2.model
assert self.panel1.r == self.panel2.r
assert self.panel1.alphadeg == self.panel2.alphadeg
a = None
b = None
if self.panel1 is not None:
a = self.panel1.a
b = self.panel1.b
elif self.panel2 is not None:
a = self.panel2.a
b = self.panel2.b
if a is not None and b is not None:
if a / b > 10.:
if self.base.m <= 15 and self.flange.m <= 15:
raise RuntimeError(
'For a/b > 10. use base.m and flange.m > 15')
else:
warn(
'For a/b > 10. be sure to check convergence for base.m and flange.m'
)
self.flange.lam = laminate.read_stack(
self.flange.stack,
plyts=self.flange.plyts,
laminaprops=self.flange.laminaprops)
#NOTE below offset is not needed since it is already considered in the
# connectivity matrices, using dpb
h = 0.5 * sum(self.panel1.plyts) + 0.5 * sum(self.panel2.plyts)
hb = sum(self.base.plyts)
self.dpb = h / 2. + hb / 2.
self.base.lam = laminate.read_stack(self.base.stack,
plyts=self.base.plyts,
laminaprops=self.base.laminaprops,
offset=0.)
def _rebuild(self):
assert self.panel1.model == self.panel2.model
assert self.panel1.r == self.panel2.r
assert self.panel1.alphadeg == self.panel2.alphadeg
a = None
b = None
if self.panel1 is not None:
a = self.panel1.a
b = self.panel1.b
elif self.panel2 is not None:
a = self.panel2.a
b = self.panel2.b
if a is not None and b is not None:
if a / b > 10.:
if self.base.m <= 15 and self.flange.m <= 15:
raise RuntimeError('For a/b > 10. use base.m and flange.m > 15')
else:
warn('For a/b > 10. be sure to check convergence for base.m and flange.m')
self.flange.lam = laminate.read_stack(self.flange.stack,
plyts=self.flange.plyts, laminaprops=self.flange.laminaprops)
#NOTE below offset is not needed since it is already considered in the
# connectivity matrices, using dpb
h = 0.5*sum(self.panel1.plyts) + 0.5*sum(self.panel2.plyts)
hb = sum(self.base.plyts)
self.dpb = h/2. + hb/2.
self.base.lam = laminate.read_stack(self.base.stack,
plyts=self.base.plyts, laminaprops=self.base.laminaprops,
offset=0.)
def rebuild(self):
if self.fstack != []:
self.flam = laminate.read_stack(self.fstack, plyts=self.fplyts,
laminaprops=self.flaminaprops)
self.flam.calc_equivalent_modulus()
self.hf = self.flam.t
# flange type 1
if True:
self.Exx = self.flam.e1
self.Gxy = self.flam.g12
if False:
Exx = 0
Gxy = 0
for ply in self.flam.plies:
Exx += (ply.matobj.e1*np.cos(np.deg2rad(ply.theta)) +
ply.matobj.e2*np.sin(np.deg2rad(ply.theta)))*ply.t/self.flam.t
Gxy += ply.matobj.g12*ply.t/self.flam.t
self.Exx = Exx
self.Gxy = self.flam.g12
if self.bstack != []:
self.blam = laminate.read_stack(self.bstack, plyts=self.bplyts,
laminaprops=self.blaminaprops)
self.hb = self.blam.t
#TODO check offset effect on curved panels
self.df = -(self.bf/2. + self.hb + sum(self.panel.plyts)/2.)
self.Iyy = self.hf*self.bf**3/12.
#self.Iyy = self.hf*self.bf**3/12. + self.hf*self.bf*self.df**2
self.Jxx = self.hf*self.bf**3/12. + self.bf*self.hf**3/12.
self.Asb = self.bb*self.hb
self.Asf = self.bf*self.hf
self.As = self.Asb + self.Asf
if self.fstack != []:
# flange type 2
self.E1 = 0
#E3 = 0
self.S1 = 0
self.Je = 0
#TODO check this geometric correction factor
s = 1.
yply = self.flam.plies[0].t/2.
for i, ply in enumerate(self.flam.plies):
if i > 0:
yply += self.flam.plies[i].t
q = ply.QL
self.E1 += ply.t*(q[0,0] - q[0,1]**2/q[1,1])
#E3 += ply.t*(q[2,2] - q[1,2]**2/q[1,1])
self.S1 += -yply*ply.t*(q[1,2]-q[0,1]*q[1,2]/q[1,1])
self.Je += yply**2*ply.t*(q[2,2] - q[1,2]**2/q[1,1])
self.F1 = self.bf**2/12.*self.E1
def _rebuild(self):
if self.fstack is not None:
self.hf = sum(self.fplyts)
self.Asf = self.bf*self.hf
self.flam = laminate.read_stack(self.fstack, plyts=self.fplyts,
laminaprops=self.flaminaprops)
self.flam.calc_equivalent_modulus()
h = 0.5*sum(self.panel1.plyts) + 0.5*sum(self.panel2.plyts)
if self.bstack is not None:
hb = sum(self.bplyts)
self.blam = laminate.read_stack(self.bstack, plyts=self.bplyts,
laminaprops=self.blaminaprops,
offset=(-h/2.-hb/2.))
self.hb = hb
self.Asb = self.bb*self.hb
#TODO check offset effect on curved panels
self.df = self.bf/2. + self.hb + h/2.
self.Iyy = self.hf*self.bf**3/12.
self.Jxx = self.hf*self.bf**3/12. + self.bf*self.hf**3/12.
Asb = self.Asb if self.Asb is not None else 0.
Asf = self.Asf if self.Asf is not None else 0.
self.As = Asb + Asf
if self.fstack is not None:
self.E1 = 0
#E3 = 0
self.S1 = 0
yply = self.flam.plies[0].t/2.
for i, ply in enumerate(self.flam.plies):
if i > 0:
yply += self.flam.plies[i-1].t/2. + self.flam.plies[i].t/2.
q = ply.QL
self.E1 += ply.t*(q[0,0] - q[0,1]**2/q[1,1])
#E3 += ply.t*(q[2,2] - q[1,2]**2/q[1,1])
self.S1 += -yply*ply.t*(q[0,2] - q[0,1]*q[1,2]/q[1,1])
self.F1 = self.bf**2/12.*self.E1
assert self.panel1.model == self.panel2.model
assert self.panel1.m == self.panel2.m
assert self.panel1.n == self.panel2.n
assert self.panel1.r == self.panel2.r
assert self.panel1.alphadeg == self.panel2.alphadeg
def _rebuild(self):
assert self.panel1.model == self.panel2.model
assert self.panel1.m == self.panel2.m
assert self.panel1.n == self.panel2.n
assert self.panel1.r == self.panel2.r
assert self.panel1.alphadeg == self.panel2.alphadeg
if self.flange is not None:
self.flange.lam = laminate.read_stack(self.flange.stack, plyts=self.flange.plyts,
laminaprops=self.flange.laminaprops)
self.flange.lam.calc_equivalent_modulus()
if self.base is not None:
h = 0.5*sum(self.panel1.plyts) + 0.5*sum(self.panel2.plyts)
hb = sum(self.bplyts)
self.dpb = h/2. + hb/2.
self.base.lam = laminate.read_stack(self.bstack, plyts=self.bplyts,
laminaprops=self.blaminaprops,
offset=(-h/2.-hb/2.))
def _rebuild(self):
assert self.panel1.model == self.panel2.model
assert self.panel1.m == self.panel2.m
assert self.panel1.n == self.panel2.n
assert self.panel1.r == self.panel2.r
assert self.panel1.alphadeg == self.panel2.alphadeg
if self.fstack is not None:
self.hf = sum(self.fplyts)
self.Asf = self.bf*self.hf
self.flam = laminate.read_stack(self.fstack, plyts=self.fplyts,
laminaprops=self.flaminaprops)
self.flam.calc_equivalent_modulus()
h = 0.5*sum(self.panel1.plyts) + 0.5*sum(self.panel2.plyts)
hb = 0.
if self.bstack is not None:
hb = sum(self.bplyts)
y1 = self.ys - self.bb/2.
y2 = self.ys + self.bb/2.
self.base = Panel(a=bay.a, b=bay.b, r=bay.r, alphadeg=bay.alphadeg,
stack=self.bstack, plyts=self.bplyts,
mu=self.mu, m=bay.m, n=bay.n,
laminaprops=self.blaminaprops, offset=(-h/2.-hb/2.),
u1tx=bay.u1tx, u1rx=bay.u1rx, u2tx=bay.u2tx, u2rx=bay.u2rx,
v1tx=bay.v1tx, v1rx=bay.v1rx, v2tx=bay.v2tx, v2rx=bay.v2rx,
w1tx=bay.w1tx, w1rx=bay.w1rx, w2tx=bay.w2tx, w2rx=bay.w2rx,
u1ty=bay.u1ty, u1ry=bay.u1ry, u2ty=bay.u2ty, u2ry=bay.u2ry,
v1ty=bay.v1ty, v1ry=bay.v1ry, v2ty=bay.v2ty, v2ry=bay.v2ry,
w1ty=bay.w1ty, w1ry=bay.w1ry, w2ty=bay.w2ty, w2ry=bay.w2ry,
y1=y1, y2=y2)
self.Asb = self.bb*hb
#TODO check offset effect on curved panels
self.dbf = self.bf/2. + hb + h/2.
self.Iyy = self.hf*self.bf**3/12.
self.Jxx = self.hf*self.bf**3/12. + self.bf*self.hf**3/12.
Asb = self.Asb if self.Asb is not None else 0.
Asf = self.Asf if self.Asf is not None else 0.
self.As = Asb + Asf
if self.fstack is not None:
self.E1 = 0
#E3 = 0
self.S1 = 0
yply = self.flam.plies[0].t/2.
for i, ply in enumerate(self.flam.plies):
if i > 0:
yply += self.flam.plies[i-1].t/2. + self.flam.plies[i].t/2.
q = ply.QL
self.E1 += ply.t*(q[0,0] - q[0,1]**2/q[1,1])
#E3 += ply.t*(q[2,2] - q[1,2]**2/q[1,1])
self.S1 += -yply*ply.t*(q[0,2] - q[0,1]*q[1,2]/q[1,1])
self.F1 = self.bf**2/12.*self.E1
def _rebuild(self):
if self.fstack is not None:
self.hf = sum(self.fplyts)
self.flam = laminate.read_stack(self.fstack, plyts=self.fplyts,
laminaprops=self.flaminaprops)
self.flam.calc_equivalent_modulus()
h = 0.5*sum(self.panel1.plyts) + 0.5*sum(self.panel2.plyts)
if self.bstack is not None:
hb = sum(self.bplyts)
self.db = abs(-h/2.-hb/2.)
self.blam = laminate.read_stack(self.bstack, plyts=self.bplyts,
laminaprops=self.blaminaprops,
offset=(-h/2.-hb/2.))
self.hb = hb
assert self.panel1.model == self.panel2.model
assert self.panel1.m == self.panel2.m
assert self.panel1.n == self.panel2.n
assert self.panel1.r == self.panel2.r
assert self.panel1.alphadeg == self.panel2.alphadeg
def _rebuild(self):
assert self.panel1.model == self.panel2.model
assert self.panel1.m == self.panel2.m
assert self.panel1.n == self.panel2.n
assert self.panel1.r == self.panel2.r
assert self.panel1.alphadeg == self.panel2.alphadeg
if self.flange is not None:
self.flange.lam = laminate.read_stack(
self.flange.stack,
plyts=self.flange.plyts,
laminaprops=self.flange.laminaprops)
self.flange.lam.calc_equivalent_modulus()
if self.base is not None:
h = 0.5 * sum(self.panel1.plyts) + 0.5 * sum(self.panel2.plyts)
hb = sum(self.bplyts)
self.dpb = h / 2. + hb / 2.
self.base.lam = laminate.read_stack(self.bstack,
plyts=self.bplyts,
laminaprops=self.blaminaprops,
offset=(-h / 2. - hb / 2.))
def build_panel_lam(panel):
panel._rebuild()
if panel.lam is not None:
return
if panel.stack is None:
raise ValueError('Panel defined without stacking sequence')
if panel.plyts is None:
raise ValueError('Panel defined without ply thicknesses')
if panel.laminaprops is None:
raise ValueError('Panel defined without laminae properties')
panel.lam = laminate.read_stack(panel.stack, plyts=panel.plyts,
laminaprops=panel.laminaprops)
return
def build_panel_lam(panel):
panel._rebuild()
if panel.lam is not None:
return
if panel.stack is None:
raise ValueError('Panel defined without stacking sequence')
if panel.plyts is None:
raise ValueError('Panel defined without ply thicknesses')
if panel.laminaprops is None:
raise ValueError('Panel defined without laminae properties')
panel.lam = laminate.read_stack(panel.stack,
plyts=panel.plyts,
laminaprops=panel.laminaprops)
return
def calc_linear_matrices(self, combined_load_case=None, silent=False,
calc_kG0=True, calc_kA=True, calc_kM=True):
self._rebuild()
msg('Calculating linear matrices... ', level=2, silent=silent)
fk0, fkG0, fkAx, fkAy, fcA, fkM, fk0edges, fk0sb, fk0sf, fk0sf2, fkMsb, fkMsf = \
modelDB.get_linear_matrices(self)
model = self.model
a = self.a
b = self.b
r = self.r
m1 = self.m1
n1 = self.n1
laminaprops = self.laminaprops
plyts = self.plyts
h = sum(plyts)
stack = self.stack
mu = self.mu
if calc_kA and self.beta is None:
if self.Mach < 1:
raise ValueError('Mach number must be >= 1')
elif self.Mach == 1:
self.Mach = 1.0001
M = self.Mach
beta = self.rho_air * self.V**2 / (M**2 - 1)**0.5
gamma = beta*1./(2.*r*(M**2 - 1)**0.5)
ainf = self.speed_sound
aeromu = beta/(M*ainf)*(M**2 - 2)/(M**2 - 1)
elif calc_kA and self.beta is not None:
beta = self.beta
gamma = self.gamma if self.gamma is not None else 0.
aeromu = self.aeromu if self.aeromu is not None else 0.
elif not calc_kA:
pass
else:
raise NotImplementedError('check here')
if stack != []:
lam = laminate.read_stack(stack, plyts=plyts,
laminaprops=laminaprops)
if 'clpt' in model:
if lam is not None:
F = lam.ABD
elif 'fsdt' in model:
if lam is not None:
F = lam.ABDE
F[6:, 6:] *= self.K
self.lam = lam
self.F = F
k0 = fk0(a, b, r, F, m1, n1)
if (self.model == 'clpt_donnell_bc1'
or self.model == 'clpt_sanders_bc1'):
k0edges = fk0edges(m1, n1, a, b,
self.kphixBot, self.kphixTop,
self.kphiyLeft, self.kphiyRight)
elif self.model == 'fsdt_donnell_bc1':
k0edges = fk0edges(m1, n1, a, b,
self.kphixBot, self.kphixTop,
self.kphiyBot, self.kphiyTop,
self.kphixLeft, self.kphixRight,
self.kphiyLeft, self.kphiyRight)
else:
raise
if calc_kA:
if self.flow == 'x':
kA = fkAx(beta, gamma, a, b, m1, n1)
elif self.flow == 'y':
kA = fkAy(beta, a, b, m1, n1)
if fcA is None:
cA = None
else:
cA = fcA(aeromu, a, b, m1, n1)
cA = cA*(0+1j)
if calc_kM:
if self.model == 'fsdt_donnell_bc1':
raise NotImplementedError('There is a bug with kM for model %s'
% self.model)
kM = fkM(mu, h, a, b, m1, n1)
if calc_kG0:
Fx = self.Fx if self.Fx is not None else 0.
Fy = self.Fy if self.Fy is not None else 0.
Fxy = self.Fxy if self.Fxy is not None else 0.
Fyx = self.Fyx if self.Fyx is not None else 0.
if not combined_load_case:
kG0 = fkG0(Fx, Fy, Fxy, Fyx, a, b, r, m1, n1)
else:
kG0_Fx = fkG0(Fx, 0, 0, 0, a, b, r, m1, n1)
kG0_Fy = fkG0(0, Fy, 0, 0, a, b, r, m1, n1)
kG0_Fxy = fkG0(0, 0, Fxy, 0, a, b, r, m1, n1)
kG0_Fyx = fkG0(0, 0, 0, Fyx, a, b, r, m1, n1)
# contributions from stiffeners
#TODO summing up coo_matrix objects may be very slow!
for s in self.stiffeners:
if s.blam is not None:
Fsb = s.blam.ABD
k0 += fk0sb(s.ys, s.bb, a, b, r, m1, n1, Fsb)
if s.flange_formulation == 1:
k0 += fk0sf(s.ys, a, b, r, m1, n1, s.Exx, s.Gxy, s.Jxx, s.Iyy)
elif s.flange_formulation == 2:
k0 += fk0sf2(s.bf, s.df, s.ys, a, b, r, m1, n1, s.E1, s.F1,
s.S1, s.Jxx)
if s.blam is not None:
kM += fkMsb(s.mu, s.ys, s.db, s.hb, a, b, m1, n1)
kM += fkMsf(s.mu, s.ys, s.df, s.Asf, a, b, s.Iyy, s.Jxx, m1, n1)
# performing checks for the linear stiffness matrices
assert np.any(np.isnan(k0.data)) == False
assert np.any(np.isinf(k0.data)) == False
if calc_kA:
assert np.any(np.isnan(kA.data)) == False
assert np.any(np.isinf(kA.data)) == False
if cA is not None:
assert np.any(np.isnan(cA.data)) == False
assert np.any(np.isinf(cA.data)) == False
if calc_kM:
assert np.any(np.isnan(kM.data)) == False
assert np.any(np.isinf(kM.data)) == False
k0 = csr_matrix(make_symmetric(k0))
if calc_kA:
kA = csr_matrix(make_skew_symmetric(kA))
if cA is not None:
cA = csr_matrix(make_symmetric(cA))
if calc_kM:
kM = csr_matrix(make_symmetric(kM))
assert np.any(np.isnan(k0edges.data)) == False
assert np.any(np.isinf(k0edges.data)) == False
k0edges = csr_matrix(make_symmetric(k0edges))
k0 = k0 + k0edges
self.k0 = k0
if calc_kA:
self.kA = kA
self.cA = cA
if calc_kM:
self.kM = kM
if calc_kG0:
if not combined_load_case:
assert np.any((np.isnan(kG0.data) | np.isinf(kG0.data))) == False
kG0 = csr_matrix(make_symmetric(kG0))
self.kG0 = kG0
else:
assert np.any((np.isnan(kG0_Fx.data)
| np.isinf(kG0_Fx.data))) == False
assert np.any((np.isnan(kG0_Fy.data)
| np.isinf(kG0_Fy.data))) == False
assert np.any((np.isnan(kG0_Fxy.data)
| np.isinf(kG0_Fxy.data))) == False
assert np.any((np.isnan(kG0_Fyx.data)
| np.isinf(kG0_Fyx.data))) == False
kG0_Fx = csr_matrix(make_symmetric(kG0_Fx))
kG0_Fy = csr_matrix(make_symmetric(kG0_Fy))
kG0_Fxy = csr_matrix(make_symmetric(kG0_Fxy))
kG0_Fyx = csr_matrix(make_symmetric(kG0_Fyx))
self.kG0_Fx = kG0_Fx
self.kG0_Fy = kG0_Fy
self.kG0_Fxy = kG0_Fxy
self.kG0_Fyx = kG0_Fyx
#NOTE forcing Python garbage collector to clean the memory
# it DOES make a difference! There is a memory leak not
# identified, probably in the csr_matrix process
gc.collect()
msg('finished!', level=2, silent=silent)
def __init__(self, stack, plyts, laminaprops):
from compmech.composite.laminate import read_stack
super(Property, self).__init__()
lam = read_stack(stack, plyts=plyts, laminaprops=laminaprops)
self.C = lam.ABDE[np.triu_indices_from(lam.ABDE)]
self.psize = len(self.C)
def test_4panels_kt_kr():
"""Compare result of 4 assembled panels with single-domain results
The panel assembly looks like::
_________ _____
| | |
| | |
| p01 | p02 |
| | |
|_________|_____|
| p03 | p04 |
| | |
| | |
| | |
| | |
| | |
|_________|_____|
"""
print('Testing validity of the default kt and kr values')
plyt = 1.e-3 * 0.125
laminaprop=(142.5e9, 8.7e9, 0.28, 5.1e9, 5.1e9, 5.1e9)
stack=[0, 45, -45, 90, -45, 45, 0]
lam = laminate.read_stack(stack=stack, plyt=plyt, laminaprop=laminaprop)
mu=1.3e3
r = 10.
m = 8
n = 8
a1 = 1.5
a2 = 1.5
a3 = 2.5
a4 = 2.5
b1 = 1.5
b2 = 0.5
b3 = 1.5
b4 = 0.5
A11 = lam.ABD[0, 0]
A22 = lam.ABD[1, 1]
D11 = lam.ABD[3, 3]
D22 = lam.ABD[4, 4]
p01 = Panel(group='panels', x0=a3, y0=b2, a=a1, b=b1, r=r, m=m, n=n, plyt=plyt, stack=stack, laminaprop=laminaprop, mu=mu)
p02 = Panel(group='panels', x0=a3, y0=0, a=a2, b=b2, r=r, m=m, n=n, plyt=plyt, stack=stack, laminaprop=laminaprop, mu=mu)
p03 = Panel(group='panels', x0=0, y0=b2, a=a3, b=b3, r=r, m=m, n=n, plyt=plyt, stack=stack, laminaprop=laminaprop, mu=mu)
p04 = Panel(group='panels', x0=0, y0=0, a=a4, b=b4, r=r, m=m, n=n, plyt=plyt, stack=stack, laminaprop=laminaprop, mu=mu)
kt13, kr13 = connections.calc_kt_kr(p01, p03, 'xcte')
kt24, kr24 = connections.calc_kt_kr(p02, p04, 'xcte')
kt12, kr12 = connections.calc_kt_kr(p01, p02, 'ycte')
kt34, kr34 = connections.calc_kt_kr(p03, p04, 'ycte')
# boundary conditions
p01.u1tx = 1 ; p01.u1rx = 1 ; p01.u2tx = 0 ; p01.u2rx = 1
p01.v1tx = 1 ; p01.v1rx = 1 ; p01.v2tx = 0 ; p01.v2rx = 1
p01.w1tx = 1 ; p01.w1rx = 1 ; p01.w2tx = 0 ; p01.w2rx = 1
p01.u1ty = 1 ; p01.u1ry = 1 ; p01.u2ty = 0 ; p01.u2ry = 1
p01.v1ty = 1 ; p01.v1ry = 1 ; p01.v2ty = 0 ; p01.v2ry = 1
p01.w1ty = 1 ; p01.w1ry = 1 ; p01.w2ty = 0 ; p01.w2ry = 1
p02.u1tx = 1 ; p02.u1rx = 1 ; p02.u2tx = 0 ; p02.u2rx = 1
p02.v1tx = 1 ; p02.v1rx = 1 ; p02.v2tx = 0 ; p02.v2rx = 1
p02.w1tx = 1 ; p02.w1rx = 1 ; p02.w2tx = 0 ; p02.w2rx = 1
p02.u1ty = 0 ; p02.u1ry = 1 ; p02.u2ty = 1 ; p02.u2ry = 1
p02.v1ty = 0 ; p02.v1ry = 1 ; p02.v2ty = 1 ; p02.v2ry = 1
p02.w1ty = 0 ; p02.w1ry = 1 ; p02.w2ty = 1 ; p02.w2ry = 1
p03.u1tx = 0 ; p03.u1rx = 1 ; p03.u2tx = 1 ; p03.u2rx = 1
p03.v1tx = 0 ; p03.v1rx = 1 ; p03.v2tx = 1 ; p03.v2rx = 1
p03.w1tx = 0 ; p03.w1rx = 1 ; p03.w2tx = 1 ; p03.w2rx = 1
p03.u1ty = 1 ; p03.u1ry = 1 ; p03.u2ty = 0 ; p03.u2ry = 1
p03.v1ty = 1 ; p03.v1ry = 1 ; p03.v2ty = 0 ; p03.v2ry = 1
p03.w1ty = 1 ; p03.w1ry = 1 ; p03.w2ty = 0 ; p03.w2ry = 1
p04.u1tx = 0 ; p04.u1rx = 1 ; p04.u2tx = 1 ; p04.u2rx = 1
p04.v1tx = 0 ; p04.v1rx = 1 ; p04.v2tx = 1 ; p04.v2rx = 1
p04.w1tx = 0 ; p04.w1rx = 1 ; p04.w2tx = 1 ; p04.w2rx = 1
p04.u1ty = 0 ; p04.u1ry = 1 ; p04.u2ty = 1 ; p04.u2ry = 1
p04.v1ty = 0 ; p04.v1ry = 1 ; p04.v2ty = 1 ; p04.v2ry = 1
p04.w1ty = 0 ; p04.w1ry = 1 ; p04.w2ty = 1 ; p04.w2ry = 1
conndict = [
dict(p1=p01, p2=p02, func='SSycte', ycte1=0, ycte2=p02.b, kt=kt12, kr=kr12),
dict(p1=p01, p2=p03, func='SSxcte', xcte1=0, xcte2=p03.a, kt=kt13, kr=kr13),
dict(p1=p02, p2=p04, func='SSxcte', xcte1=0, xcte2=p04.a, kt=kt24, kr=kr24),
dict(p1=p03, p2=p04, func='SSycte', ycte1=0, ycte2=p04.b, kt=kt34, kr=kr34),
]
panels = [p01, p02, p03, p04]
size = sum([3*p.m*p.n for p in panels])
k0 = 0
kM = 0
row0 = 0
col0 = 0
for p in panels:
k0 += p.calc_k0(row0=row0, col0=col0, size=size, silent=True, finalize=False)
kM += p.calc_kM(row0=row0, col0=col0, size=size, silent=True, finalize=False)
p.row_start = row0
p.col_start = col0
row0 += 3*p.m*p.n
col0 += 3*p.m*p.n
p.row_end = row0
p.col_end = col0
for conn in conndict:
if conn.get('has_deffect'): # connecting if there is no deffect
continue
p1 = conn['p1']
p2 = conn['p2']
if conn['func'] == 'SSycte':
k0 += connections.kCSSycte.fkCSSycte11(
conn['kt'], conn['kr'], p1, conn['ycte1'],
size, p1.row_start, col0=p1.col_start)
k0 += connections.kCSSycte.fkCSSycte12(
conn['kt'], conn['kr'], p1, p2, conn['ycte1'], conn['ycte2'],
size, p1.row_start, col0=p2.col_start)
k0 += connections.kCSSycte.fkCSSycte22(
conn['kt'], conn['kr'], p1, p2, conn['ycte2'],
size, p2.row_start, col0=p2.col_start)
elif conn['func'] == 'SSxcte':
k0 += connections.kCSSxcte.fkCSSxcte11(
conn['kt'], conn['kr'], p1, conn['xcte1'],
size, p1.row_start, col0=p1.col_start)
k0 += connections.kCSSxcte.fkCSSxcte12(
conn['kt'], conn['kr'], p1, p2, conn['xcte1'], conn['xcte2'],
size, p1.row_start, col0=p2.col_start)
k0 += connections.kCSSxcte.fkCSSxcte22(
conn['kt'], conn['kr'], p1, p2, conn['xcte2'],
size, p2.row_start, col0=p2.col_start)
assert np.any(np.isnan(k0.data)) == False
assert np.any(np.isinf(k0.data)) == False
k0 = csr_matrix(make_symmetric(k0))
assert np.any(np.isnan(kM.data)) == False
assert np.any(np.isinf(kM.data)) == False
kM = csr_matrix(make_symmetric(kM))
eigvals, eigvecs = freq(k0, kM, tol=0, sparse_solver=True, silent=True,
sort=True, reduced_dof=False,
num_eigvalues=25, num_eigvalues_print=5)
# Results for single panel
m = 15
n = 15
singlepanel = Panel(a=(a1+a3), b=(b1+b2), r=r, m=m, n=n, plyt=plyt, stack=stack, laminaprop=laminaprop, mu=mu)
singlepanel.freq(silent=True)
assert np.isclose(eigvals[0], singlepanel.eigvals[0], atol=0.01, rtol=0.01)
def calc_linear_matrices(self, combined_load_case=None, silent=False,
calc_kG0=True, calc_kA=True, calc_kM=True):
self._rebuild()
msg('Calculating linear matrices... ', level=2, silent=silent)
fk0, fkG0, fkA, fkM, k0edges = modelDB.get_linear_matrices(self)
model = self.model
a = self.a
b = self.b
m1 = self.m1
n1 = self.n1
laminaprops = self.laminaprops
plyts = self.plyts
h = sum(plyts)
stack = self.stack
mu = self.mu
if calc_kA and self.beta is None:
if self.M < 1:
raise ValueError('Mach number must be >= 1')
elif self.M == 1:
self.M = 1.0001
self.beta = self.rho * self.V**2 / (self.M**2 - 1)**0.5
beta = self.beta
if stack != []:
lam = laminate.read_stack(stack, plyts=plyts,
laminaprops=laminaprops)
if 'clpt' in model:
if lam is not None:
F = lam.ABD
elif 'fsdt' in model:
if lam is not None:
F = lam.ABDE
F[6:, 6:] *= self.K
if self.force_orthotropic_laminate:
msg('')
msg('Forcing orthotropic laminate...', level=2)
F[0, 2] = 0. # A16
F[1, 2] = 0. # A26
F[2, 0] = 0. # A61
F[2, 1] = 0. # A62
F[0, 5] = 0. # B16
F[5, 0] = 0. # B61
F[1, 5] = 0. # B26
F[5, 1] = 0. # B62
F[3, 2] = 0. # B16
F[2, 3] = 0. # B61
F[4, 2] = 0. # B26
F[2, 4] = 0. # B62
F[3, 5] = 0. # D16
F[4, 5] = 0. # D26
F[5, 3] = 0. # D61
F[5, 4] = 0. # D62
if F.shape[0] == 8:
F[6, 7] = 0. # A45
F[7, 6] = 0. # A54
self.lam = lam
self.F = F
k0 = fk0(a, b, F, m1, n1)
if calc_kA:
kA = fkA(beta, a, b, m1, n1)
if calc_kM:
kM = fkM(mu, h, a, b, m1, n1)
if calc_kG0:
Fx = self.Fx if self.Fx is not None else 0.
Fy = self.Fy if self.Fy is not None else 0.
Fxy = self.Fxy if self.Fxy is not None else 0.
Fyx = self.Fyx if self.Fyx is not None else 0.
if not combined_load_case:
kG0 = fkG0(Fx, Fy, Fxy, Fyx, a, b, m1, n1)
else:
kG0_Fx = fkG0(Fx, 0, 0, 0, a, b, m1, n1)
kG0_Fy = fkG0(0, Fy, 0, 0, a, b, m1, n1)
kG0_Fxy = fkG0(0, 0, Fxy, 0, a, b, m1, n1)
kG0_Fyx = fkG0(0, 0, 0, Fyx, a, b, m1, n1)
# performing checks for the linear stiffness matrices
assert np.any(np.isnan(k0.data)) == False
assert np.any(np.isnan(k0.data)) == False
if calc_kA:
assert np.any(np.isinf(kA.data)) == False
assert np.any(np.isinf(kA.data)) == False
if calc_kM:
assert np.any(np.isinf(kM.data)) == False
assert np.any(np.isinf(kM.data)) == False
k0 = csr_matrix(make_symmetric(k0))
if calc_kA:
kA = csr_matrix(make_skew_symmetric(kA))
if calc_kM:
kM = csr_matrix(make_symmetric(kM))
if k0edges is not None:
assert np.any((np.isnan(k0edges.data)
| np.isinf(k0edges.data))) == False
k0edges = csr_matrix(make_symmetric(k0edges))
if k0edges is not None:
k0 = k0 + k0edges
self.k0 = k0
if calc_kA:
self.kA = kA
if calc_kM:
self.kM = kM
if calc_kG0:
if not combined_load_case:
assert np.any((np.isnan(kG0.data) | np.isinf(kG0.data))) == False
kG0 = csr_matrix(make_symmetric(kG0))
self.kG0 = kG0
else:
assert np.any((np.isnan(kG0_Fx.data)
| np.isinf(kG0_Fx.data))) == False
assert np.any((np.isnan(kG0_Fy.data)
| np.isinf(kG0_Fy.data))) == False
assert np.any((np.isnan(kG0_Fxy.data)
| np.isinf(kG0_Fxy.data))) == False
assert np.any((np.isnan(kG0_Fyx.data)
| np.isinf(kG0_Fyx.data))) == False
kG0_Fx = csr_matrix(make_symmetric(kG0_Fx))
kG0_Fy = csr_matrix(make_symmetric(kG0_Fy))
kG0_Fxy = csr_matrix(make_symmetric(kG0_Fxy))
kG0_Fyx = csr_matrix(make_symmetric(kG0_Fyx))
self.kG0_Fx = kG0_Fx
self.kG0_Fy = kG0_Fy
self.kG0_Fxy = kG0_Fxy
self.kG0_Fyx = kG0_Fyx
#NOTE forcing Python garbage collector to clean the memory
# it DOES make a difference! There is a memory leak not
# identified, probably in the csr_matrix process
gc.collect()
msg('finished!', level=2, silent=silent)
import sys
sys.path.append(r'C:\repos\compmech')
import numpy as np
from compmech.composite.laminate import read_stack
from compmech.plates import Plate
stack = [-45, +45, 0, 0, -30, +30, +30, -30, 0, 0, +45, -45]
# prop format (E1, E2, nu12, G12, G13, G23)
prop = (152.4e3, 8.8e3, 0.31, 4.9e3, 4.9e3, 4.9e3)
lam = read_stack(stack, plyts=[0.125 for i in stack],
laminaprops=[prop for i in stack])
np.savetxt('laminate_ABD_matrix.txt', lam.ABD, fmt='%1.8f')
import sys
sys.path.append(r'C:\repos\compmech')
import numpy as np
from compmech.composite.laminate import read_stack
from compmech.plates import Plate
stack = [-45, +45, 0, 0, -30, +30, +30, -30, 0, 0, +45, -45]
# prop format (E1, E2, nu12, G12, G13, G23)
prop = (152.4e3, 8.8e3, 0.31, 4.9e3, 4.9e3, 4.9e3)
lam = read_stack(stack,
plyts=[0.125 for i in stack],
laminaprops=[prop for i in stack])
np.savetxt('laminate_ABD_matrix.txt', lam.ABD, fmt='%1.8f')
def test_4panels_kt_kr():
"""Compare result of 4 assembled panels with single-domain results
The panel assembly looks like::
_________ _____
| | |
| | |
| p01 | p02 |
| | |
|_________|_____|
| p03 | p04 |
| | |
| | |
| | |
| | |
| | |
|_________|_____|
"""
print('Testing validity of the default kt and kr values')
plyt = 1.e-3 * 0.125
laminaprop = (142.5e9, 8.7e9, 0.28, 5.1e9, 5.1e9, 5.1e9)
stack = [0, 45, -45, 90, -45, 45, 0]
lam = laminate.read_stack(stack=stack, plyt=plyt, laminaprop=laminaprop)
mu = 1.3e3
r = 10.
m = 8
n = 8
a1 = 1.5
a2 = 1.5
a3 = 2.5
a4 = 2.5
b1 = 1.5
b2 = 0.5
b3 = 1.5
b4 = 0.5
A11 = lam.ABD[0, 0]
A22 = lam.ABD[1, 1]
D11 = lam.ABD[3, 3]
D22 = lam.ABD[4, 4]
p01 = Panel(group='panels',
x0=a3,
y0=b2,
a=a1,
b=b1,
r=r,
m=m,
n=n,
plyt=plyt,
stack=stack,
laminaprop=laminaprop,
mu=mu)
p02 = Panel(group='panels',
x0=a3,
y0=0,
a=a2,
b=b2,
r=r,
m=m,
n=n,
plyt=plyt,
stack=stack,
laminaprop=laminaprop,
mu=mu)
p03 = Panel(group='panels',
x0=0,
y0=b2,
a=a3,
b=b3,
r=r,
m=m,
n=n,
plyt=plyt,
stack=stack,
laminaprop=laminaprop,
mu=mu)
p04 = Panel(group='panels',
x0=0,
y0=0,
a=a4,
b=b4,
r=r,
m=m,
n=n,
plyt=plyt,
stack=stack,
laminaprop=laminaprop,
mu=mu)
kt13, kr13 = connections.calc_kt_kr(p01, p03, 'xcte')
kt24, kr24 = connections.calc_kt_kr(p02, p04, 'xcte')
kt12, kr12 = connections.calc_kt_kr(p01, p02, 'ycte')
kt34, kr34 = connections.calc_kt_kr(p03, p04, 'ycte')
# boundary conditions
p01.u1tx = 1
p01.u1rx = 1
p01.u2tx = 0
p01.u2rx = 1
p01.v1tx = 1
p01.v1rx = 1
p01.v2tx = 0
p01.v2rx = 1
p01.w1tx = 1
p01.w1rx = 1
p01.w2tx = 0
p01.w2rx = 1
p01.u1ty = 1
p01.u1ry = 1
p01.u2ty = 0
p01.u2ry = 1
p01.v1ty = 1
p01.v1ry = 1
p01.v2ty = 0
p01.v2ry = 1
p01.w1ty = 1
p01.w1ry = 1
p01.w2ty = 0
p01.w2ry = 1
p02.u1tx = 1
p02.u1rx = 1
p02.u2tx = 0
p02.u2rx = 1
p02.v1tx = 1
p02.v1rx = 1
p02.v2tx = 0
p02.v2rx = 1
p02.w1tx = 1
p02.w1rx = 1
p02.w2tx = 0
p02.w2rx = 1
p02.u1ty = 0
p02.u1ry = 1
p02.u2ty = 1
p02.u2ry = 1
p02.v1ty = 0
p02.v1ry = 1
p02.v2ty = 1
p02.v2ry = 1
p02.w1ty = 0
p02.w1ry = 1
p02.w2ty = 1
p02.w2ry = 1
p03.u1tx = 0
p03.u1rx = 1
p03.u2tx = 1
p03.u2rx = 1
p03.v1tx = 0
p03.v1rx = 1
p03.v2tx = 1
p03.v2rx = 1
p03.w1tx = 0
p03.w1rx = 1
p03.w2tx = 1
p03.w2rx = 1
p03.u1ty = 1
p03.u1ry = 1
p03.u2ty = 0
p03.u2ry = 1
p03.v1ty = 1
p03.v1ry = 1
p03.v2ty = 0
p03.v2ry = 1
p03.w1ty = 1
p03.w1ry = 1
p03.w2ty = 0
p03.w2ry = 1
p04.u1tx = 0
p04.u1rx = 1
p04.u2tx = 1
p04.u2rx = 1
p04.v1tx = 0
p04.v1rx = 1
p04.v2tx = 1
p04.v2rx = 1
p04.w1tx = 0
p04.w1rx = 1
p04.w2tx = 1
p04.w2rx = 1
p04.u1ty = 0
p04.u1ry = 1
p04.u2ty = 1
p04.u2ry = 1
p04.v1ty = 0
p04.v1ry = 1
p04.v2ty = 1
p04.v2ry = 1
p04.w1ty = 0
p04.w1ry = 1
p04.w2ty = 1
p04.w2ry = 1
conndict = [
dict(p1=p01,
p2=p02,
func='SSycte',
ycte1=0,
ycte2=p02.b,
kt=kt12,
kr=kr12),
dict(p1=p01,
p2=p03,
func='SSxcte',
xcte1=0,
xcte2=p03.a,
kt=kt13,
kr=kr13),
dict(p1=p02,
p2=p04,
func='SSxcte',
xcte1=0,
xcte2=p04.a,
kt=kt24,
kr=kr24),
dict(p1=p03,
p2=p04,
func='SSycte',
ycte1=0,
ycte2=p04.b,
kt=kt34,
kr=kr34),
]
panels = [p01, p02, p03, p04]
size = sum([3 * p.m * p.n for p in panels])
k0 = 0
kM = 0
row0 = 0
col0 = 0
for p in panels:
k0 += p.calc_k0(row0=row0,
col0=col0,
size=size,
silent=True,
finalize=False)
kM += p.calc_kM(row0=row0,
col0=col0,
size=size,
silent=True,
finalize=False)
p.row_start = row0
p.col_start = col0
row0 += 3 * p.m * p.n
col0 += 3 * p.m * p.n
p.row_end = row0
p.col_end = col0
for conn in conndict:
if conn.get('has_deffect'): # connecting if there is no deffect
continue
p1 = conn['p1']
p2 = conn['p2']
if conn['func'] == 'SSycte':
k0 += connections.kCSSycte.fkCSSycte11(conn['kt'],
conn['kr'],
p1,
conn['ycte1'],
size,
p1.row_start,
col0=p1.col_start)
k0 += connections.kCSSycte.fkCSSycte12(conn['kt'],
conn['kr'],
p1,
p2,
conn['ycte1'],
conn['ycte2'],
size,
p1.row_start,
col0=p2.col_start)
k0 += connections.kCSSycte.fkCSSycte22(conn['kt'],
conn['kr'],
p1,
p2,
conn['ycte2'],
size,
p2.row_start,
col0=p2.col_start)
elif conn['func'] == 'SSxcte':
k0 += connections.kCSSxcte.fkCSSxcte11(conn['kt'],
conn['kr'],
p1,
conn['xcte1'],
size,
p1.row_start,
col0=p1.col_start)
k0 += connections.kCSSxcte.fkCSSxcte12(conn['kt'],
conn['kr'],
p1,
p2,
conn['xcte1'],
conn['xcte2'],
size,
p1.row_start,
col0=p2.col_start)
k0 += connections.kCSSxcte.fkCSSxcte22(conn['kt'],
conn['kr'],
p1,
p2,
conn['xcte2'],
size,
p2.row_start,
col0=p2.col_start)
assert np.any(np.isnan(k0.data)) == False
assert np.any(np.isinf(k0.data)) == False
k0 = csr_matrix(make_symmetric(k0))
assert np.any(np.isnan(kM.data)) == False
assert np.any(np.isinf(kM.data)) == False
kM = csr_matrix(make_symmetric(kM))
eigvals, eigvecs = freq(k0,
kM,
tol=0,
sparse_solver=True,
silent=True,
sort=True,
reduced_dof=False,
num_eigvalues=25,
num_eigvalues_print=5)
# Results for single panel
m = 15
n = 15
singlepanel = Panel(a=(a1 + a3),
b=(b1 + b2),
r=r,
m=m,
n=n,
plyt=plyt,
stack=stack,
laminaprop=laminaprop,
mu=mu)
singlepanel.freq(silent=True)
assert np.isclose(eigvals[0], singlepanel.eigvals[0], atol=0.01, rtol=0.01)
def calc_linear_matrices(self, combined_load_case=None):
self._rebuild()
msg('Calculating linear matrices... ', level=2)
fk0, fkG0, k0edges = modelDB.get_linear_matrices(self)
model = self.model
a = self.a
b = self.b
m1 = self.m1
n1 = self.n1
laminaprops = self.laminaprops
plyts = self.plyts
stack = self.stack
if stack != []:
lam = laminate.read_stack(stack, plyts=plyts,
laminaprops=laminaprops)
if 'clpt' in model:
if lam is not None:
F = lam.ABD
elif 'fsdt' in model:
if lam is not None:
F = lam.ABDE
F[6:, 6:] *= self.K
if self.force_orthotropic_laminate:
msg('')
msg('Forcing orthotropic laminate...', level=2)
F[0, 2] = 0. # A16
F[1, 2] = 0. # A26
F[2, 0] = 0. # A61
F[2, 1] = 0. # A62
F[0, 5] = 0. # B16
F[5, 0] = 0. # B61
F[1, 5] = 0. # B26
F[5, 1] = 0. # B62
F[3, 2] = 0. # B16
F[2, 3] = 0. # B61
F[4, 2] = 0. # B26
F[2, 4] = 0. # B62
F[3, 5] = 0. # D16
F[4, 5] = 0. # D26
F[5, 3] = 0. # D61
F[5, 4] = 0. # D62
if F.shape[0] == 8:
F[6, 7] = 0. # A45
F[7, 6] = 0. # A54
self.lam = lam
self.F = F
k0 = fk0(a, b, F, m1, n1)
Fx = self.Fx if self.Fx is not None else 0.
Fy = self.Fy if self.Fy is not None else 0.
Fxy = self.Fxy if self.Fxy is not None else 0.
Fyx = self.Fyx if self.Fyx is not None else 0.
if not combined_load_case:
kG0 = fkG0(Fx, Fy, Fxy, Fyx, a, b, m1, n1)
else:
kG0_Fx = fkG0(Fx, 0, 0, 0, a, b, m1, n1)
kG0_Fy = fkG0(0, Fy, 0, 0, a, b, m1, n1)
kG0_Fxy = fkG0(0, 0, Fxy, 0, a, b, m1, n1)
kG0_Fyx = fkG0(0, 0, 0, Fyx, a, b, m1, n1)
# performing checks for the linear stiffness matrices
assert np.any(np.isnan(k0.data)) == False
assert np.any(np.isinf(k0.data)) == False
k0 = csr_matrix(make_symmetric(k0))
if k0edges is not None:
assert np.any((np.isnan(k0edges.data)
| np.isinf(k0edges.data))) == False
k0edges = csr_matrix(make_symmetric(k0edges))
if k0edges is not None:
msg('Applying elastic constraints!', level=3)
#FIXME improve the way to consider the elastic constraints for the
# case of infinity stiffnesses
k0max = np.abs(k0).max()
k0 = k0 + k0edges/np.abs(k0edges).max()*100*k0max
self.k0 = k0
if not combined_load_case:
assert np.any((np.isnan(kG0.data) | np.isinf(kG0.data))) == False
kG0 = csr_matrix(make_symmetric(kG0))
self.kG0 = kG0
else:
assert np.any((np.isnan(kG0_Fx.data)
| np.isinf(kG0_Fx.data))) == False
assert np.any((np.isnan(kG0_Fy.data)
| np.isinf(kG0_Fy.data))) == False
assert np.any((np.isnan(kG0_Fxy.data)
| np.isinf(kG0_Fxy.data))) == False
assert np.any((np.isnan(kG0_Fyx.data)
| np.isinf(kG0_Fyx.data))) == False
kG0_Fx = csr_matrix(make_symmetric(kG0_Fx))
kG0_Fy = csr_matrix(make_symmetric(kG0_Fy))
kG0_Fxy = csr_matrix(make_symmetric(kG0_Fxy))
kG0_Fyx = csr_matrix(make_symmetric(kG0_Fyx))
self.kG0_Fx = kG0_Fx
self.kG0_Fy = kG0_Fy
self.kG0_Fxy = kG0_Fxy
self.kG0_Fyx = kG0_Fyx
#NOTE forcing Python garbage collector to clean the memory
# it DOES make a difference! There is a memory leak not
# identified, probably in the csr_matrix process
gc.collect()
msg('finished!', level=2)
