def calc_kM(self, size=None, row0=0, col0=0, silent=False, finalize=True):
"""Calculate the mass matrix
"""
self._rebuild()
msg('Calculating kM... ', level=2, silent=silent)
rowf = row0 + self.base.get_size()
colf = col0 + self.base.get_size()
kM = 0.
kM += self.base.calc_kM(size=size,
row0=row0,
col0=col0,
silent=True,
finalize=False)
kM += self.flange.calc_kM(size=size,
row0=rowf,
col0=colf,
silent=True,
finalize=False)
if finalize:
kM = finalize_symmetric_matrix(kM)
self.kM = kM
#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 calc_kG0(self,
size=None,
row0=0,
col0=0,
silent=False,
finalize=True,
c=None,
NLgeom=False):
"""Calculate the linear geometric stiffness matrix
"""
self._rebuild()
msg('Calculating kG0... ', level=2, silent=silent)
kG0 = 0.
if self.base is not None:
#TODO include kG0 for pad-up and Nxx load that arrives there
pass
if self.flange is not None:
kG0 += self.flange.calc_kG0(size=size,
row0=row0,
col0=col0,
silent=True,
finalize=False,
NLgeom=NLgeom)
if finalize:
kG0 = finalize_symmetric_matrix(kG0)
self.kG0 = kG0
#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 calc_kG0(self, size=None, row0=0, col0=0, silent=False, finalize=True,
c=None):
"""Calculate the linear geometric stiffness matrix
"""
#TODO
if c is not None:
raise NotImplementedError('numerical kG0 not implemented')
self._rebuild()
msg('Calculating kG0... ', level=2, silent=silent)
kG0 = 0.
if self.base is not None:
# TODO include kG0 for padup
# now it is assumed that all the load goes to the flange
pass
if self.flam is not None:
Fx = self.Fx if self.Fx is not None else 0.
mod = modelDB.db[self.model]['matrices']
bay = self.bay
kG0 += mod.fkG0f(self.ys, Fx, bay.a, bay.b, self.bf, bay.m, bay.n,
bay.w1tx, bay.w1rx, bay.w2tx, bay.w2rx,
bay.w1ty, bay.w1ry, bay.w2ty, bay.w2ry,
size, row0, col0)
if finalize:
kG0 = finalize_symmetric_matrix(kG0)
self.kG0 = kG0
#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 calc_k0(self, size=None, row0=0, col0=0, silent=False, finalize=True):
"""Calculate the linear constitutive stiffness matrix
"""
self._rebuild()
msg('Calculating k0... ', level=2, silent=silent)
k0 = 0.
if self.base is not None:
k0 += self.base.calc_k0(size=size, row0=row0, col0=col0,
silent=True, finalize=False)
if self.flam is not None:
mod = modelDB.db[self.model]['matrices']
bay = self.bay
k0 += mod.fk0f(self.ys, bay.a, bay.b, self.bf, self.dbf, self.E1, self.F1,
self.S1, self.Jxx, bay.m, bay.n,
bay.u1tx, bay.u1rx, bay.u2tx, bay.u2rx,
bay.w1tx, bay.w1rx, bay.w2tx, bay.w2rx,
bay.u1ty, bay.u1ry, bay.u2ty, bay.u2ry,
bay.w1ty, bay.w1ry, bay.w2ty, bay.w2ry,
size=size, row0=row0, col0=col0)
if finalize:
k0 = finalize_symmetric_matrix(k0)
self.k0 = k0
#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 calc_kM(self, size=None, row0=0, col0=0, silent=False, finalize=True):
"""Calculate the mass matrix
"""
self._rebuild()
msg('Calculating kM... ', level=2, silent=silent)
rowf = row0 + self.base.get_size()
colf = col0 + self.base.get_size()
kM = 0.
kM += self.base.calc_kM(size=size, row0=row0, col0=col0, silent=True,
finalize=False)
kM += self.flange.calc_kM(size=size, row0=rowf, col0=colf, silent=True,
finalize=False)
if finalize:
kM = finalize_symmetric_matrix(kM)
self.kM = kM
#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 calc_kM(self, size=None, row0=0, col0=0, silent=False, finalize=True):
"""Calculate the mass matrix
"""
self._rebuild()
msg('Calculating kM... ', level=2, silent=silent)
mod = modelDB.db[self.model]['matrices']
kM = 0.
if self.base is not None:
kM += self.base.calc_kM(size=size, row0=row0, col0=col0, silent=silent, finalize=False)
if self.flam is not None:
bay = self.bay
h = 0.5*sum(self.panel1.plyts) + 0.5*sum(self.panel2.plyts)
kM += mod.fkMf(self.ys, self.mu, h, self.hb, self.hf, bay.a, bay.b,
self.bf, self.dbf, bay.m, bay.n,
bay.u1tx, bay.u1rx, bay.u2tx, bay.u2rx,
bay.v1tx, bay.v1rx, bay.v2tx, bay.v2rx,
bay.w1tx, bay.w1rx, bay.w2tx, bay.w2rx,
bay.u1ty, bay.u1ry, bay.u2ty, bay.u2ry,
bay.v1ty, bay.v1ry, bay.v2ty, bay.v2ry,
bay.w1ty, bay.w1ry, bay.w2ty, bay.w2ry,
size=size, row0=row0, col0=col0)
if finalize:
kM = finalize_symmetric_matrix(kM)
self.kM = kM
#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 calc_kG0(self, c=None, silent=False, finalize=True):
"""Calculate the geometric stiffness matrix of the assembly
Parameters
----------
c : array-like or None, optional
This must be the result of a static analysis, used to compute
non-linear terms based on the actual displacement field.
silent : bool, optional
A boolean to tell whether the log messages should be printed.
finalize : bool, optional
Asserts validity of output data and makes the output matrix
symmetric, should be ``False`` when assemblying.
"""
size = self.get_size()
if c is None:
msg('Calculating kG0 for assembly...', level=2, silent=silent)
else:
check_c(c, size)
msg('Calculating kG for assembly...', level=2, silent=silent)
kG0 = 0.
for p in self.panels:
if p.row_start is None or p.col_start is None:
raise ValueError('Panel attributes "row_start" and "col_start" must be defined!')
kG0 += p.calc_kG0(c=c, row0=p.row_start, col0=p.col_start, size=size,
silent=True, finalize=False)
if finalize:
kG0 = finalize_symmetric_matrix(kG0)
self.kG0 = kG0
msg('finished!', level=2, silent=silent)
return kG0
def calc_kT(self, c=None, silent=False, finalize=True, inc=None):
msg('Calculating kT for assembly...', level=2, silent=silent)
size = self.get_size()
kT = 0
#TODO use multiprocessing.Pool here
for p in self.panels:
if p.row_start is None or p.col_start is None:
raise ValueError(
'Panel attributes "row_start" and "col_start" must be defined!'
)
kT += p.calc_k0(c=c,
size=size,
row0=p.row_start,
col0=p.col_start,
silent=True,
finalize=False,
inc=inc,
NLgeom=True)
kT += p.calc_kG0(c=c,
size=size,
row0=p.row_start,
col0=p.col_start,
silent=True,
finalize=False,
NLgeom=True)
if finalize:
kT = finalize_symmetric_matrix(kT)
k0_conn = self.get_k0_conn()
kT += k0_conn
self.kT = kT
msg('finished!', level=2, silent=silent)
return kT
def calc_kG0(self, size=None, row0=0, col0=0, silent=False, finalize=True,
c=None, NLgeom=False):
"""Calculate the linear geometric stiffness matrix
"""
self._rebuild()
msg('Calculating kG0... ', level=2, silent=silent)
kG0 = 0.
if self.base is not None:
#TODO include kG0 for pad-up and Nxx load that arrives there
pass
if self.flange is not None:
kG0 += self.flange.calc_kG0(size=size, row0=row0, col0=col0,
silent=True, finalize=False, NLgeom=NLgeom)
if finalize:
kG0 = finalize_symmetric_matrix(kG0)
self.kG0 = kG0
#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 calc_kG0(self,
size=None,
row0=0,
col0=0,
silent=False,
finalize=True,
c=None,
NLgeom=False):
"""Calculate the linear geometric stiffness matrix
See :meth:`.Panel.calc_k0` for details on each parameter.
"""
self._rebuild()
if c is None:
msg('Calculating kG0... ', level=2, silent=silent)
else:
msg('Calculating kG... ', level=2, silent=silent)
# NOTE:
# - row0 and col0 define where the stiffener's base matrix starts
# - rowf and colf define where the stiffener's flange matrix starts
rowf = row0 + self.base.get_size()
colf = col0 + self.base.get_size()
kG0 = 0.
kG0 += self.base.calc_kG0(c=c,
size=size,
row0=row0,
col0=col0,
silent=True,
finalize=False,
NLgeom=NLgeom)
kG0 += self.flange.calc_kG0(c=c,
size=size,
row0=rowf,
col0=colf,
silent=True,
finalize=False,
NLgeom=NLgeom)
if finalize:
kG0 = finalize_symmetric_matrix(kG0)
self.kG0 = kG0
#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 calc_kM(self, silent=False, finalize=True):
msg('Calculating kM for assembly...', level=2, silent=silent)
size = self.get_size()
kM = 0
for p in self.panels:
if p.row_start is None or p.col_start is None:
raise ValueError('Panel attributes "row_start" and "col_start" must be defined!')
kM += p.calc_kM(row0=p.row_start, col0=p.col_start, size=size, silent=True, finalize=False)
if finalize:
kM = finalize_symmetric_matrix(kM)
self.kM = kM
msg('finished!', level=2, silent=silent)
return kM
def calc_k0(self, conn=None, c=None, silent=False, finalize=True, inc=1.):
"""Calculate the constitutive stiffness matrix of the assembly
Parameters
----------
conn : dict, optional
A connectivity dictionary. Optional if already defined for the
assembly.
c : array-like or None, optional
This must be the result of a static analysis, used to compute
non-linear terms based on the actual displacement field.
silent : bool, optional
A boolean to tell whether the log messages should be printed.
finalize : bool, optional
Asserts validity of output data and makes the output matrix
symmetric, should be ``False`` when assemblying.
inc : float, optional
Dummy argument needed for non-linear analyses.
"""
size = self.get_size()
if c is None:
msg('Calculating k0 for assembly...', level=2, silent=silent)
else:
check_c(c, size)
msg('Calculating kL for assembly...', level=2, silent=silent)
k0 = 0.
for p in self.panels:
if p.row_start is None or p.col_start is None:
raise ValueError(
'Panel attributes "row_start" and "col_start" must be defined!'
)
k0 += p.calc_k0(c=c,
row0=p.row_start,
col0=p.col_start,
size=size,
silent=True,
finalize=False)
if finalize:
k0 = finalize_symmetric_matrix(k0)
k0_conn = self.get_k0_conn(conn=conn)
k0 += self.k0_conn
self.k0 = k0
msg('finished!', level=2, silent=silent)
return k0
def calc_kT(self, c=None, silent=False, finalize=True, inc=None):
msg('Calculating kT for assembly...', level=2, silent=silent)
size = self.get_size()
kT = 0
#TODO use multiprocessing.Pool here
for p in self.panels:
if p.row_start is None or p.col_start is None:
raise ValueError('Panel attributes "row_start" and "col_start" must be defined!')
kT += p.calc_k0(c=c, size=size, row0=p.row_start, col0=p.col_start,
silent=True, finalize=False, inc=inc, NLgeom=True)
kT += p.calc_kG0(c=c, size=size, row0=p.row_start,
col0=p.col_start, silent=True, finalize=False, NLgeom=True)
if finalize:
kT = finalize_symmetric_matrix(kT)
k0_conn = self.get_k0_conn()
kT += k0_conn
self.kT = kT
msg('finished!', level=2, silent=silent)
return kT
def calc_k0(self, conn=None, c=None, silent=False, finalize=True, inc=1.):
"""Calculate the constitutive stiffness matrix of the assembly
Parameters
----------
conn : dict, optional
A connectivity dictionary. Optional if already defined for the
assembly.
c : array-like or None, optional
This must be the result of a static analysis, used to compute
non-linear terms based on the actual displacement field.
silent : bool, optional
A boolean to tell whether the log messages should be printed.
finalize : bool, optional
Asserts validity of output data and makes the output matrix
symmetric, should be ``False`` when assemblying.
inc : float, optional
Dummy argument needed for non-linear analyses.
"""
size = self.get_size()
if c is None:
msg('Calculating k0 for assembly...', level=2, silent=silent)
else:
check_c(c, size)
msg('Calculating kL for assembly...', level=2, silent=silent)
k0 = 0.
for p in self.panels:
if p.row_start is None or p.col_start is None:
raise ValueError('Panel attributes "row_start" and "col_start" must be defined!')
k0 += p.calc_k0(c=c, row0=p.row_start, col0=p.col_start, size=size,
silent=True, finalize=False)
if finalize:
k0 = finalize_symmetric_matrix(k0)
k0_conn = self.get_k0_conn(conn=conn)
k0 += self.k0_conn
self.k0 = k0
msg('finished!', level=2, silent=silent)
return k0
def calc_kM(self, silent=False, finalize=True):
msg('Calculating kM for assembly...', level=2, silent=silent)
size = self.get_size()
kM = 0
for p in self.panels:
if p.row_start is None or p.col_start is None:
raise ValueError(
'Panel attributes "row_start" and "col_start" must be defined!'
)
kM += p.calc_kM(row0=p.row_start,
col0=p.col_start,
size=size,
silent=True,
finalize=False)
if finalize:
kM = finalize_symmetric_matrix(kM)
self.kM = kM
msg('finished!', level=2, silent=silent)
return kM
def calc_kG0(self, c=None, silent=False, finalize=True):
"""Calculate the geometric stiffness matrix of the assembly
Parameters
----------
c : array-like or None, optional
This must be the result of a static analysis, used to compute
non-linear terms based on the actual displacement field.
silent : bool, optional
A boolean to tell whether the log messages should be printed.
finalize : bool, optional
Asserts validity of output data and makes the output matrix
symmetric, should be ``False`` when assemblying.
"""
size = self.get_size()
if c is None:
msg('Calculating kG0 for assembly...', level=2, silent=silent)
else:
check_c(c, size)
msg('Calculating kG for assembly...', level=2, silent=silent)
kG0 = 0.
for p in self.panels:
if p.row_start is None or p.col_start is None:
raise ValueError(
'Panel attributes "row_start" and "col_start" must be defined!'
)
kG0 += p.calc_kG0(c=c,
row0=p.row_start,
col0=p.col_start,
size=size,
silent=True,
finalize=False)
if finalize:
kG0 = finalize_symmetric_matrix(kG0)
self.kG0 = kG0
msg('finished!', level=2, silent=silent)
return kG0
def calc_kG0(self, size=None, row0=0, col0=0, silent=False, finalize=True,
c=None, NLgeom=False):
"""Calculate the linear geometric stiffness matrix
See :meth:`.Panel.calc_k0` for details on each parameter.
"""
self._rebuild()
if c is None:
msg('Calculating kG0... ', level=2, silent=silent)
else:
msg('Calculating kG... ', level=2, silent=silent)
# NOTE:
# - row0 and col0 define where the stiffener's base matrix starts
# - rowf and colf define where the stiffener's flange matrix starts
rowf = row0 + self.base.get_size()
colf = col0 + self.base.get_size()
kG0 = 0.
kG0 += self.base.calc_kG0(c=c, size=size, row0=row0, col0=col0, silent=True,
finalize=False, NLgeom=NLgeom)
kG0 += self.flange.calc_kG0(c=c, size=size, row0=rowf, col0=colf,
silent=True, finalize=False, NLgeom=NLgeom)
if finalize:
kG0 = finalize_symmetric_matrix(kG0)
self.kG0 = kG0
#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 calc_k0(self, size=None, row0=0, col0=0, silent=False, finalize=True):
"""Calculate the linear constitutive stiffness matrix
"""
self._rebuild()
msg('Calculating k0... ', level=2, silent=silent)
flangemod = panmodelDB.db[self.flange.model]['matrices']
bay = self.bay
a = bay.a
b = bay.b
m = bay.m
n = bay.n
k0 = 0.
if self.base is not None:
k0 += self.base.calc_k0(size=size,
row0=0,
col0=0,
silent=True,
finalize=False)
if self.flange is not None:
k0 += self.flange.calc_k0(size=size,
row0=row0,
col0=col0,
silent=True,
finalize=False)
# connectivity between stiffener'base and stiffener's flange
if self.base is None:
ktbf, krbf = calc_kt_kr(self.panel1, self.flange, 'ycte')
else:
ktbf, krbf = calc_kt_kr(self.base, self.flange, 'ycte')
mod = db['bladestiff2d_clt_donnell_bardell']['connections']
k0 += mod.fkCss(ktbf, krbf, self.ys, a, b, m, n, bay.u1tx,
bay.u1rx, bay.u2tx, bay.u2rx, bay.v1tx, bay.v1rx,
bay.v2tx, bay.v2rx, bay.w1tx, bay.w1rx, bay.w2tx,
bay.w2rx, bay.u1ty, bay.u1ry, bay.u2ty, bay.u2ry,
bay.v1ty, bay.v1ry, bay.v2ty, bay.v2ry, bay.w1ty,
bay.w1ry, bay.w2ty, bay.w2ry, size, 0, 0)
bf = self.flange.b
k0 += mod.fkCsf(
ktbf, krbf, self.ys, a, b, bf, m, n, self.flange.m,
self.flange.n, bay.u1tx, bay.u1rx, bay.u2tx, bay.u2rx,
bay.v1tx, bay.v1rx, bay.v2tx, bay.v2rx, bay.w1tx, bay.w1rx,
bay.w2tx, bay.w2rx, bay.u1ty, bay.u1ry, bay.u2ty, bay.u2ry,
bay.v1ty, bay.v1ry, bay.v2ty, bay.v2ry, bay.w1ty, bay.w1ry,
bay.w2ty, bay.w2ry, self.flange.u1tx, self.flange.u1rx,
self.flange.u2tx, self.flange.u2rx, self.flange.v1tx,
self.flange.v1rx, self.flange.v2tx, self.flange.v2rx,
self.flange.w1tx, self.flange.w1rx, self.flange.w2tx,
self.flange.w2rx, self.flange.u1ty, self.flange.u1ry,
self.flange.u2ty, self.flange.u2ry, self.flange.v1ty,
self.flange.v1ry, self.flange.v2ty, self.flange.v2ry,
self.flange.w1ty, self.flange.w1ry, self.flange.w2ty,
self.flange.w2ry, size, 0, col0)
k0 += mod.fkCff(
ktbf, krbf, a, bf, self.flange.m, self.flange.n,
self.flange.u1tx, self.flange.u1rx, self.flange.u2tx,
self.flange.u2rx, self.flange.v1tx, self.flange.v1rx,
self.flange.v2tx, self.flange.v2rx, self.flange.w1tx,
self.flange.w1rx, self.flange.w2tx, self.flange.w2rx,
self.flange.u1ty, self.flange.u1ry, self.flange.u2ty,
self.flange.u2ry, self.flange.v1ty, self.flange.v1ry,
self.flange.v2ty, self.flange.v2ry, self.flange.w1ty,
self.flange.w1ry, self.flange.w2ty, self.flange.w2ry, size,
row0, col0)
if finalize:
k0 = finalize_symmetric_matrix(k0)
self.k0 = k0
#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 calc_k0(self, size=None, row0=0, col0=0, silent=False, finalize=True):
"""Calculate the linear constitutive stiffness matrix
"""
self._rebuild()
msg('Calculating k0... ', level=2, silent=silent)
flangemod = panmodelDB.db[self.flange.model]['matrices']
bay = self.bay
a = bay.a
b = bay.b
m = bay.m
n = bay.n
k0 = 0.
if self.base is not None:
k0 += self.base.calc_k0(size=size, row0=0, col0=0, silent=True,
finalize=False)
if self.flange is not None:
k0 += self.flange.calc_k0(size=size, row0=row0, col0=col0,
silent=True, finalize=False)
# connectivity between stiffener'base and stiffener's flange
if self.base is None:
ktbf, krbf = calc_kt_kr(self.panel1, self.flange, 'ycte')
else:
ktbf, krbf = calc_kt_kr(self.base, self.flange, 'ycte')
mod = db['bladestiff2d_clt_donnell_bardell']['connections']
k0 += mod.fkCss(ktbf, krbf, self.ys, a, b, m, n,
bay.u1tx, bay.u1rx, bay.u2tx, bay.u2rx,
bay.v1tx, bay.v1rx, bay.v2tx, bay.v2rx,
bay.w1tx, bay.w1rx, bay.w2tx, bay.w2rx,
bay.u1ty, bay.u1ry, bay.u2ty, bay.u2ry,
bay.v1ty, bay.v1ry, bay.v2ty, bay.v2ry,
bay.w1ty, bay.w1ry, bay.w2ty, bay.w2ry,
size, 0, 0)
bf = self.flange.b
k0 += mod.fkCsf(ktbf, krbf, self.ys, a, b, bf, m, n, self.flange.m, self.flange.n,
bay.u1tx, bay.u1rx, bay.u2tx, bay.u2rx,
bay.v1tx, bay.v1rx, bay.v2tx, bay.v2rx,
bay.w1tx, bay.w1rx, bay.w2tx, bay.w2rx,
bay.u1ty, bay.u1ry, bay.u2ty, bay.u2ry,
bay.v1ty, bay.v1ry, bay.v2ty, bay.v2ry,
bay.w1ty, bay.w1ry, bay.w2ty, bay.w2ry,
self.flange.u1tx, self.flange.u1rx, self.flange.u2tx, self.flange.u2rx,
self.flange.v1tx, self.flange.v1rx, self.flange.v2tx, self.flange.v2rx,
self.flange.w1tx, self.flange.w1rx, self.flange.w2tx, self.flange.w2rx,
self.flange.u1ty, self.flange.u1ry, self.flange.u2ty, self.flange.u2ry,
self.flange.v1ty, self.flange.v1ry, self.flange.v2ty, self.flange.v2ry,
self.flange.w1ty, self.flange.w1ry, self.flange.w2ty, self.flange.w2ry,
size, 0, col0)
k0 += mod.fkCff(ktbf, krbf, a, bf, self.flange.m, self.flange.n,
self.flange.u1tx, self.flange.u1rx, self.flange.u2tx, self.flange.u2rx,
self.flange.v1tx, self.flange.v1rx, self.flange.v2tx, self.flange.v2rx,
self.flange.w1tx, self.flange.w1rx, self.flange.w2tx, self.flange.w2rx,
self.flange.u1ty, self.flange.u1ry, self.flange.u2ty, self.flange.u2ry,
self.flange.v1ty, self.flange.v1ry, self.flange.v2ty, self.flange.v2ry,
self.flange.w1ty, self.flange.w1ry, self.flange.w2ty, self.flange.w2ry,
size, row0, col0)
if finalize:
k0 = finalize_symmetric_matrix(k0)
self.k0 = k0
#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 calc_k0(self, size=None, row0=0, col0=0, silent=False, finalize=True):
"""Calculate the linear constitutive stiffness matrix
"""
self._rebuild()
msg('Calculating k0... ', level=2, silent=silent)
# NOTE
# row0 and col0 define where the stiffener's base matrix starts
# rowf and colf define where the stiffener's flange matrix starts
rowf = row0 + self.base.get_size()
colf = col0 + self.base.get_size()
k0 = 0.
k0 += self.base.calc_k0(size=size, row0=row0, col0=col0, silent=True, finalize=False)
k0 += self.flange.calc_k0(size=size, row0=rowf, col0=colf, silent=True, finalize=False)
# connectivity panel-base
conn = stiffmDB.db[self.model]['connections']
ktpb, krpb = calc_kt_kr(self.panel1, self.base, 'bot-top')
ktpb = min(1.e7, ktpb)
#TODO remove from Cython the capability to run with debonding defect
y1 = self.ys - self.base.b/2.
y2 = self.ys + self.base.b/2.
bay = self.bay
k0 += conn.fkCppy1y2(y1, y2,
ktpb, bay.a, bay.b, self.dpb, bay.m, bay.n,
bay.u1tx, bay.u1rx, bay.u2tx, bay.u2rx,
bay.v1tx, bay.v1rx, bay.v2tx, bay.v2rx,
bay.w1tx, bay.w1rx, bay.w2tx, bay.w2rx,
bay.u1ty, bay.u1ry, bay.u2ty, bay.u2ry,
bay.v1ty, bay.v1ry, bay.v2ty, bay.v2ry,
bay.w1ty, bay.w1ry, bay.w2ty, bay.w2ry,
size, 0, 0)
k0 += conn.fkCpby1y2(y1, y2,
ktpb, bay.a, bay.b, self.dpb,
bay.m, bay.n, self.base.m, self.base.n,
bay.u1tx, bay.u1rx, bay.u2tx, bay.u2rx,
bay.v1tx, bay.v1rx, bay.v2tx, bay.v2rx,
bay.w1tx, bay.w1rx, bay.w2tx, bay.w2rx,
bay.u1ty, bay.u1ry, bay.u2ty, bay.u2ry,
bay.v1ty, bay.v1ry, bay.v2ty, bay.v2ry,
bay.w1ty, bay.w1ry, bay.w2ty, bay.w2ry,
self.base.u1tx, self.base.u1rx, self.base.u2tx, self.base.u2rx,
self.base.v1tx, self.base.v1rx, self.base.v2tx, self.base.v2rx,
self.base.w1tx, self.base.w1rx, self.base.w2tx, self.base.w2rx,
self.base.u1ty, self.base.u1ry, self.base.u2ty, self.base.u2ry,
self.base.v1ty, self.base.v1ry, self.base.v2ty, self.base.v2ry,
self.base.w1ty, self.base.w1ry, self.base.w2ty, self.base.w2ry,
size, 0, col0)
k0 += conn.fkCbbpby1y2(y1, y2,
ktpb, bay.a, bay.b, self.base.m, self.base.n,
self.base.u1tx, self.base.u1rx, self.base.u2tx, self.base.u2rx,
self.base.v1tx, self.base.v1rx, self.base.v2tx, self.base.v2rx,
self.base.w1tx, self.base.w1rx, self.base.w2tx, self.base.w2rx,
self.base.u1ty, self.base.u1ry, self.base.u2ty, self.base.u2ry,
self.base.v1ty, self.base.v1ry, self.base.v2ty, self.base.v2ry,
self.base.w1ty, self.base.w1ry, self.base.w2ty, self.base.w2ry,
size, row0, col0)
# connectivity base-flange
ktbf, krbf = calc_kt_kr(self.base, self.flange, 'ycte')
ycte1 = (self.eta_conn_base + 1)/2. * self.base.b
ycte2 = (self.eta_conn_flange + 1)/2. * self.flange.b
k0 += fkCBFycte11(ktbf, krbf, self.base, ycte1, size, row0, col0)
k0 += fkCBFycte12(ktbf, krbf, self.base, self.flange, ycte1, ycte2, size, row0, colf)
k0 += fkCBFycte22(ktbf, krbf, self.base, self.flange, ycte2, size, rowf, colf)
if finalize:
k0 = finalize_symmetric_matrix(k0)
self.k0 = k0
#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 get_k0_conn(self, conn=None, finalize=True):
if conn is None:
if self.conn is None:
raise RuntimeError('No connectivity dictionary defined!')
conn = self.conn
if self.k0_conn is not None:
return self.k0_conn
size = self.get_size()
k0_conn = 0.
for connecti in conn:
p1 = connecti['p1']
p2 = connecti['p2']
if connecti['func'] == 'SSycte':
kt, kr = connections.calc_kt_kr(p1, p2, 'ycte')
k0_conn += connections.kCSSycte.fkCSSycte11(
kt, kr, p1, connecti['ycte1'],
size, p1.row_start, col0=p1.col_start)
k0_conn += connections.kCSSycte.fkCSSycte12(
kt, kr, p1, p2, connecti['ycte1'], connecti['ycte2'],
size, p1.row_start, col0=p2.col_start)
k0_conn += connections.kCSSycte.fkCSSycte22(
kt, kr, p1, p2, connecti['ycte2'],
size, p2.row_start, col0=p2.col_start)
elif connecti['func'] == 'SSxcte':
kt, kr = connections.calc_kt_kr(p1, p2, 'xcte')
k0_conn += connections.kCSSxcte.fkCSSxcte11(
kt, kr, p1, connecti['xcte1'],
size, p1.row_start, col0=p1.col_start)
k0_conn += connections.kCSSxcte.fkCSSxcte12(
kt, kr, p1, p2, connecti['xcte1'], connecti['xcte2'],
size, p1.row_start, col0=p2.col_start)
k0_conn += connections.kCSSxcte.fkCSSxcte22(
kt, kr, p1, p2, connecti['xcte2'],
size, p2.row_start, col0=p2.col_start)
elif connecti['func'] == 'SB':
kt, kr = connections.calc_kt_kr(p1, p2, 'bot-top')
dsb = sum(p1.plyts)/2. + sum(p2.plyts)/2.
k0_conn += connections.kCSB.fkCSB11(kt, dsb, p1,
size, p1.row_start, col0=p1.col_start)
k0_conn += connections.kCSB.fkCSB12(kt, dsb, p1, p2,
size, p1.row_start, col0=p2.col_start)
k0_conn += connections.kCSB.fkCSB22(kt, p1, p2,
size, p2.row_start, col0=p2.col_start)
elif connecti['func'] == 'BFycte':
kt, kr = connections.calc_kt_kr(p1, p2, 'ycte')
k0_conn += connections.kCBFycte.fkCBFycte11(
kt, kr, p1, connecti['ycte1'],
size, p1.row_start, col0=p1.col_start)
k0_conn += connections.kCBFycte.fkCBFycte12(
kt, kr, p1, p2, connecti['ycte1'], connecti['ycte2'],
size, p1.row_start, col0=p2.col_start)
k0_conn += connections.kCBFycte.fkCBFycte22(
kt, kr, p1, p2, connecti['ycte2'],
size, p2.row_start, col0=p2.col_start)
else:
raise
if finalize:
k0_conn = finalize_symmetric_matrix(k0_conn)
self.k0_conn = k0_conn
#NOTE memory cleanup
gc.collect()
return k0_conn
def get_k0_conn(self, conn=None, finalize=True):
if conn is None:
if self.conn is None:
raise RuntimeError('No connectivity dictionary defined!')
conn = self.conn
if self.k0_conn is not None:
return self.k0_conn
size = self.get_size()
k0_conn = 0.
for connecti in conn:
p1 = connecti['p1']
p2 = connecti['p2']
if connecti['func'] == 'SSycte':
kt, kr = connections.calc_kt_kr(p1, p2, 'ycte')
k0_conn += connections.kCSSycte.fkCSSycte11(kt,
kr,
p1,
connecti['ycte1'],
size,
p1.row_start,
col0=p1.col_start)
k0_conn += connections.kCSSycte.fkCSSycte12(kt,
kr,
p1,
p2,
connecti['ycte1'],
connecti['ycte2'],
size,
p1.row_start,
col0=p2.col_start)
k0_conn += connections.kCSSycte.fkCSSycte22(kt,
kr,
p1,
p2,
connecti['ycte2'],
size,
p2.row_start,
col0=p2.col_start)
elif connecti['func'] == 'SSxcte':
kt, kr = connections.calc_kt_kr(p1, p2, 'xcte')
k0_conn += connections.kCSSxcte.fkCSSxcte11(kt,
kr,
p1,
connecti['xcte1'],
size,
p1.row_start,
col0=p1.col_start)
k0_conn += connections.kCSSxcte.fkCSSxcte12(kt,
kr,
p1,
p2,
connecti['xcte1'],
connecti['xcte2'],
size,
p1.row_start,
col0=p2.col_start)
k0_conn += connections.kCSSxcte.fkCSSxcte22(kt,
kr,
p1,
p2,
connecti['xcte2'],
size,
p2.row_start,
col0=p2.col_start)
elif connecti['func'] == 'SB':
kt, kr = connections.calc_kt_kr(p1, p2, 'bot-top')
dsb = sum(p1.plyts) / 2. + sum(p2.plyts) / 2.
k0_conn += connections.kCSB.fkCSB11(kt,
dsb,
p1,
size,
p1.row_start,
col0=p1.col_start)
k0_conn += connections.kCSB.fkCSB12(kt,
dsb,
p1,
p2,
size,
p1.row_start,
col0=p2.col_start)
k0_conn += connections.kCSB.fkCSB22(kt,
p1,
p2,
size,
p2.row_start,
col0=p2.col_start)
elif connecti['func'] == 'BFycte':
kt, kr = connections.calc_kt_kr(p1, p2, 'ycte')
k0_conn += connections.kCBFycte.fkCBFycte11(kt,
kr,
p1,
connecti['ycte1'],
size,
p1.row_start,
col0=p1.col_start)
k0_conn += connections.kCBFycte.fkCBFycte12(kt,
kr,
p1,
p2,
connecti['ycte1'],
connecti['ycte2'],
size,
p1.row_start,
col0=p2.col_start)
k0_conn += connections.kCBFycte.fkCBFycte22(kt,
kr,
p1,
p2,
connecti['ycte2'],
size,
p2.row_start,
col0=p2.col_start)
else:
raise
if finalize:
k0_conn = finalize_symmetric_matrix(k0_conn)
self.k0_conn = k0_conn
#NOTE memory cleanup
gc.collect()
return k0_conn
def calc_k0(self, size=None, row0=0, col0=0, silent=False, finalize=True):
"""Calculate the linear constitutive stiffness matrix
"""
self._rebuild()
msg('Calculating k0... ', level=2, silent=silent)
# NOTE
# row0 and col0 define where the stiffener's base matrix starts
# rowf and colf define where the stiffener's flange matrix starts
rowf = row0 + self.base.get_size()
colf = col0 + self.base.get_size()
k0 = 0.
k0 += self.base.calc_k0(size=size,
row0=row0,
col0=col0,
silent=True,
finalize=False)
k0 += self.flange.calc_k0(size=size,
row0=rowf,
col0=colf,
silent=True,
finalize=False)
# connectivity panel-base
conn = stiffmDB.db[self.model]['connections']
ktpb, krpb = calc_kt_kr(self.panel1, self.base, 'bot-top')
ktpb = min(1.e7, ktpb)
#TODO remove from Cython the capability to run with debonding defect
y1 = self.ys - self.base.b / 2.
y2 = self.ys + self.base.b / 2.
bay = self.bay
k0 += conn.fkCppy1y2(y1, y2, ktpb, bay.a, bay.b, self.dpb, bay.m,
bay.n, bay.u1tx, bay.u1rx, bay.u2tx, bay.u2rx,
bay.v1tx, bay.v1rx, bay.v2tx, bay.v2rx, bay.w1tx,
bay.w1rx, bay.w2tx, bay.w2rx, bay.u1ty, bay.u1ry,
bay.u2ty, bay.u2ry, bay.v1ty, bay.v1ry, bay.v2ty,
bay.v2ry, bay.w1ty, bay.w1ry, bay.w2ty, bay.w2ry,
size, 0, 0)
k0 += conn.fkCpby1y2(
y1, y2, ktpb, bay.a, bay.b, self.dpb, bay.m, bay.n, self.base.m,
self.base.n, bay.u1tx, bay.u1rx, bay.u2tx, bay.u2rx, bay.v1tx,
bay.v1rx, bay.v2tx, bay.v2rx, bay.w1tx, bay.w1rx, bay.w2tx,
bay.w2rx, bay.u1ty, bay.u1ry, bay.u2ty, bay.u2ry, bay.v1ty,
bay.v1ry, bay.v2ty, bay.v2ry, bay.w1ty, bay.w1ry, bay.w2ty,
bay.w2ry, self.base.u1tx, self.base.u1rx, self.base.u2tx,
self.base.u2rx, self.base.v1tx, self.base.v1rx, self.base.v2tx,
self.base.v2rx, self.base.w1tx, self.base.w1rx, self.base.w2tx,
self.base.w2rx, self.base.u1ty, self.base.u1ry, self.base.u2ty,
self.base.u2ry, self.base.v1ty, self.base.v1ry, self.base.v2ty,
self.base.v2ry, self.base.w1ty, self.base.w1ry, self.base.w2ty,
self.base.w2ry, size, 0, col0)
k0 += conn.fkCbbpby1y2(y1, y2, ktpb, bay.a, bay.b, self.base.m,
self.base.n, self.base.u1tx, self.base.u1rx,
self.base.u2tx, self.base.u2rx, self.base.v1tx,
self.base.v1rx, self.base.v2tx, self.base.v2rx,
self.base.w1tx, self.base.w1rx, self.base.w2tx,
self.base.w2rx, self.base.u1ty, self.base.u1ry,
self.base.u2ty, self.base.u2ry, self.base.v1ty,
self.base.v1ry, self.base.v2ty, self.base.v2ry,
self.base.w1ty, self.base.w1ry, self.base.w2ty,
self.base.w2ry, size, row0, col0)
# connectivity base-flange
ktbf, krbf = calc_kt_kr(self.base, self.flange, 'ycte')
ycte1 = (self.eta_conn_base + 1) / 2. * self.base.b
ycte2 = (self.eta_conn_flange + 1) / 2. * self.flange.b
k0 += fkCBFycte11(ktbf, krbf, self.base, ycte1, size, row0, col0)
k0 += fkCBFycte12(ktbf, krbf, self.base, self.flange, ycte1, ycte2,
size, row0, colf)
k0 += fkCBFycte22(ktbf, krbf, self.base, self.flange, ycte2, size,
rowf, colf)
if finalize:
k0 = finalize_symmetric_matrix(k0)
self.k0 = k0
#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)
