def __init__(self, card=None, data=None, comment=""):
LineDamper.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.eid = integer(card, 1, "eid")
#: Value of the scalar damper (Real)
self.b = double(card, 2, "b")
nids = [integer_or_blank(card, 3, "n1", 0), integer_or_blank(card, 5, "n2", 0)]
#: component number
self.c1 = integer_or_blank(card, 4, "c1", 0)
self.c2 = integer_or_blank(card, 6, "c2", 0)
assert len(card) <= 7, "len(CDAMP2 card) = %i" % len(card)
else:
self.eid = data[0]
self.b = data[1]
nids = [data[2], data[4]]
self.c1 = data[3]
self.c2 = data[5]
# CDAMP2 do not have to be unique
self.prepare_node_ids(nids, allow_empty_nodes=True)
assert len(self.nodes) == 2
msg = "on\n%s\n is invalid validComponents=[0,1,2,3,4,5,6]" % str(self)
assert self.c1 in [0, 1, 2, 3, 4, 5, 6], "c1=%r %s" % (self.c1, msg)
assert self.c2 in [0, 1, 2, 3, 4, 5, 6], "c2=%r %s" % (self.c2, msg)
def __init__(self, card=None, data=None, comment=""):
LineDamper.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.eid = integer(card, 1, "eid")
self.pid = integer(card, 2, "pid")
nids = [integer_or_blank(card, 3, "g1", 0), integer_or_blank(card, 5, "g2", 0)]
#: component number
self.c1 = integer_or_blank(card, 4, "c1", 0)
self.c2 = integer_or_blank(card, 6, "c2", 0)
assert len(card) <= 7, "len(CDAMP1 card) = %i" % len(card)
else:
self.eid = data[0]
self.pid = data[1]
nids = [data[2], data[4]]
self.c1 = data[3]
self.c2 = data[5]
self.prepare_node_ids(nids, allow_empty_nodes=True)
assert len(self.nodes) == 2
msg = "on\n%s\n is invalid validComponents=[0,1,2,3,4,5,6]" % str(self)
assert self.c1 in [0, 1, 2, 3, 4, 5, 6], "c1=|%s| %s" % (self.c1, msg)
assert self.c2 in [0, 1, 2, 3, 4, 5, 6], "c2=|%s| %s" % (self.c2, msg)
def test_integer_or_blank(self):
"""
value = integer_or_blank(card, n, fieldname)
"""
# integer
self.check_integer(integer_or_blank)
# float
with self.assertRaises(SyntaxError):
integer_or_blank(BDFCard([1.0]), 0, "field")
with self.assertRaises(SyntaxError):
integer_or_blank(BDFCard(["1."]), 0, "field")
# string
with self.assertRaises(SyntaxError):
integer_or_blank(BDFCard(["a"]), 0, "field")
with self.assertRaises(SyntaxError):
integer_or_blank(BDFCard(["1b"]), 0, "field")
# blank
self.assertEqual("a", integer_or_blank(BDFCard([""]), 0, "field", "a"))
self.assertEqual("b", integer_or_blank(BDFCard([None]), 0, "field", "b"))
card = [1, "2", "3.", "C", None, ""]
exact = [1, 2, SyntaxError, SyntaxError, None, None]
default = [None, None, None, None, None, None]
self.run_function_default(integer_or_blank, card, exact, default)
def __init__(self, card=None, data=None, comment=''):
LineElement.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.eid = integer(card, 1, 'eid')
self.pid = integer_or_blank(card, 2, 'pid', self.eid)
self.ga = integer(card, 3, 'ga')
self.gb = integer(card, 4, 'gb')
self.gc = integer(card, 5, 'gc')
self.initX_G0(card)
self.wa = array([double_or_blank(card, 9, 'w1a', 0.0),
double_or_blank(card, 10, 'w2a', 0.0),
double_or_blank(card, 11, 'w3a', 0.0)], dtype='float64')
self.wb = array([double_or_blank(card, 12, 'w1b', 0.0),
double_or_blank(card, 13, 'w2b', 0.0),
double_or_blank(card, 14, 'w3b', 0.0)], dtype='float64')
self.wc = array([double_or_blank(card, 15, 'w1c', 0.0),
double_or_blank(card, 16, 'w2c', 0.0),
double_or_blank(card, 17, 'w3c', 0.0)], dtype='float64')
self.tw = array([double_or_blank(card, 18, 0., 'twa'),
double_or_blank(card, 19, 0., 'twb'),
double_or_blank(card, 20, 0., 'twc')], dtype='float64')
self.s = array([integer_or_blank(card, 21, 'sa'),
integer_or_blank(card, 22, 'sb'),
integer_or_blank(card, 23, 'sc')], dtype='float64')
assert len(card) <= 24, 'len(CBEAM3 card) = %i' % len(card)
else:
raise NotImplementedError(data)
def __init__(self, card=None, data=None, comment=''):
SpringElement.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.eid = integer(card, 1, 'eid')
#: property ID
self.pid = integer_or_blank(card, 2, 'pid', self.eid)
nids = [integer(card, 3, 'g1'), integer_or_blank(card, 5, 'g2', 0)]
#: component number
self.c1 = integer_or_blank(card, 4, 'c1', 0)
self.c2 = integer_or_blank(card, 6, 'c2', 0)
assert len(card) <= 7, 'len(CELAS1 card) = %i' % len(card)
else:
self.eid = data[0]
self.pid = data[1]
nids = [data[2], data[3]]
self.c1 = data[4]
self.c2 = data[5]
msg = 'on\n%s\n is invalid validComponents=[0,1,2,3,4,5,6]' % str(self)
assert self.c1 in [0, 1, 2, 3, 4, 5, 6], 'c1=|%s| %s' % (self.c1, msg)
assert self.c2 in [0, 1, 2, 3, 4, 5, 6], 'c2=|%s| %s' % (self.c2, msg)
self.prepareNodeIDs(nids, allowEmptyNodes=True)
assert len(self.nodes) == 2
def __init__(self, card=None, data=None, comment=''):
Property.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Property ID
self.pid = integer(card, 1, 'pid')
#: Material ID
self.mid1 = integer_or_blank(card, 2, 'mid1', 0)
self.t1 = double_or_blank(card, 3, 't1')
self.mid2 = integer_or_blank(card, 4, 'mid2', 0)
if self.mid2 > 0:
self.i = double(card, 5, 'i')
assert self.i > 0.0
else:
self.i = blank(card, 5, 'i')
self.mid3 = integer(card, 6, 0)
if self.mid3 > 0:
self.t2 = double(card, 7, 't3')
assert self.t2 > 0.0
else:
self.t2 = blank(card, 7, 't3')
self.nsm = double(card, 8, 'nsm')
self.z1 = double(card, 9, 'z1')
self.z2 = double(card, 10, 'z2')
self.phi = fields(double, card, 'phi', i=11, j=len(card))
else:
raise NotImplementedError(data)
def __init__(self, card=None, data=None, comment=''):
if comment:
self._comment = comment
if card:
self.name = string(card, 1, 'name')
#zero
#: 4-Lower Triangular; 5=Upper Triangular; 6=Symmetric; 8=Identity (m=nRows, n=m)
self.ifo = integer(card, 3, 'ifo')
#: 1-Real, Single Precision; 2=Real,Double Precision; 3=Complex, Single; 4=Complex, Double
self.tin = integer(card, 4, 'tin')
#: 0-Set by cell precision
self.tout = integer_or_blank(card, 5, 'tout', 0)
self.polar = integer_or_blank(card, 6, 'polar')
if self.ifo == 9:
self.ncol = integer(card, 8, 'ncol')
else:
self.ncol = blank(card, 8, 'ncol')
else:
raise NotImplementedError(data)
self.GCj = []
self.GCi = []
self.Real = []
if self.isComplex():
self.Complex = []
def getShockA(self, card, iStart):
self.shockType = string_or_blank(card, iStart + 1, 'shockType')
self.shockCVT = double(card, iStart + 2, 'shockCVT')
self.shockCVC = double_or_blank(card, iStart + 3, 'shockCVC')
self.shockExpVT = double_or_blank(card, iStart + 4, 'shockExpVT', 1.0)
self.shockExpVC = double_or_blank(card, iStart + 5, 'shockExpVC',
self.shockExpVT)
if self.shockType == 'TABLE':
pass
# self.shockIDTS = integer(card, iStart + 6, 'shockIDTS')
# self.shockIDETS = blank(card, iStart + 9, 'shockIDETS')
# self.shockIDECS = blank(card, iStart + 10, 'shockIDECS')
# self.shockIDETSD = blank(card, iStart + 11, 'shockIDETSD')
# self.shockIDECSD = blank(card, iStart + 12, 'shockIDECSD')
elif self.shockType == 'EQUAT':
self.shockIDTS = blank(card, iStart + 6, 'shockIDTS')
self.shockIDETS = integer(card, iStart + 9, 'shockIDETS')
self.shockIDECS = integer_or_blank(card, iStart + 10, 'shockIDECS',
self.shockIDETS)
self.shockIDETSD = integer(card, iStart + 11, 'shockIDETSD')
self.shockIDECSD = integer_or_blank(card, iStart + 11,
'shockIDECSD',
self.shockIDETSD)
else:
raise RuntimeError('Invalid shockType=|%s| on card\n%s' %
(self.shockType, card))
iStart += 8
return iStart
def __init__(self, card=None, data=None, comment=''):
SpringElement.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.eid = integer(card, 1, 'eid')
#: property ID
self.pid = integer_or_blank(card, 2, 'pid', self.eid)
nids = [integer(card, 3, 'g1'), integer_or_blank(card, 5, 'g2', 0)]
#: component number
self.c1 = integer_or_blank(card, 4, 'c1', 0)
self.c2 = integer_or_blank(card, 6, 'c2', 0)
assert len(card) <= 7, 'len(CELAS1 card) = %i' % len(card)
else:
self.eid = data[0]
self.pid = data[1]
nids = [data[2], data[3]]
self.c1 = data[4]
self.c2 = data[5]
msg = 'on\n%s\n is invalid validComponents=[0,1,2,3,4,5,6]' % str(self)
assert self.c1 in [0, 1, 2, 3, 4, 5, 6], 'c1=|%s| %s' % (self.c1, msg)
assert self.c2 in [0, 1, 2, 3, 4, 5, 6], 'c2=|%s| %s' % (self.c2, msg)
self.prepareNodeIDs(nids, allowEmptyNodes=True)
assert len(self.nodes) == 2
def __init__(self, card=None, data=None, comment=''):
if comment:
self._comment = comment
if card:
#: Set identification number
self.sid = integer(card, 1, 'sid')
#: Coordinate system identification number.
self.cid = integer_or_blank(card, 2, 'cid', 0)
#: scale factor
self.scale = double(card, 3, 'scale')
#: Acceleration vector components measured in coordinate system CID
self.N = array([double_or_blank(card, 4, 'N1', 0.0),
double_or_blank(card, 5, 'N2', 0.0),
double_or_blank(card, 6, 'N3', 0.0)])
#: Indicates whether the CID coordinate system is defined in the
#: main Bulk Data Section (MB = -1) or the partitioned superelement
#: Bulk Data Section (MB = 0). Coordinate systems referenced in the
#: main Bulk Data Section are considered stationary with respect to
#: the assembly basic coordinate system. See Remark 10.
#: (Integer; Default = 0)
self.mb = integer_or_blank(card, 7, 'mb', 0)
assert len(card) <= 8, 'len(GRAV card) = %i' % len(card)
else:
self.sid = data[0]
self.cid = data[1]
self.a = data[2]
self.N = array(data[3:6])
self.mb = data[6]
self.scale = 1.
assert len(data) == 7
assert not allclose(max(abs(self.N)), 0.), ('GRAV N is a zero vector, '
'N=%s' % (str(self.N)))
def add(self, card, comment=''):
i = self.i
self.element_id[i] = integer(card, 1, 'element_id')
self.property_id[i] = integer(card, 2, 'property_id')
self.coord_id[i] = integer_or_blank(card, 3, 'cp', 0)
self.nspan[i] = integer_or_blank(card, 4, 'nspan', 0)
self.nchord[i] = integer_or_blank(card, 5, 'nchord', 0)
#if self.nspan==0:
self.lspan[i] = integer_or_blank(card, 6, 'lspan', 0)
#if self.nchord==0:
self.lchord[i] = integer_or_blank(card, 7, 'lchord', 0)
self.igid[i] = integer(card, 8, 'igid')
self.p1[i, :] = [
double_or_blank(card, 9, 'x1', 0.0),
double_or_blank(card, 10, 'y1', 0.0),
double_or_blank(card, 11, 'z1', 0.0)
]
self.x12[i] = double_or_blank(card, 12, 'x12', 0.)
self.p4[i, :] = [
double_or_blank(card, 13, 'x4', 0.0),
double_or_blank(card, 14, 'y4', 0.0),
double_or_blank(card, 15, 'z4', 0.0)
]
self.x43[i] = double_or_blank(card, 16, 'x43', 0.)
assert len(card) <= 17, 'len(CAERO1 card) = %i' % len(card)
self.i += 1
def __init__(self, card=None, data=None, comment=''):
if comment:
self._comment = comment
if card:
self.name = string(card, 1, 'name')
#zero
#: 4-Lower Triangular; 5=Upper Triangular; 6=Symmetric; 8=Identity (m=nRows, n=m)
self.ifo = integer(card, 3, 'ifo')
#: 1-Real, Single Precision; 2=Real,Double Precision; 3=Complex, Single; 4=Complex, Double
self.tin = integer(card, 4, 'tin')
#: 0-Set by cell precision
self.tout = integer_or_blank(card, 5, 'tout', 0)
#: Input format of Ai, Bi. (Integer=blank or 0 indicates real, imaginary format;
#: Integer > 0 indicates amplitude, phase format.)
self.polar = integer_or_blank(card, 6, 'polar', 0)
if self.ifo in [6, 9]:
self.ncol = integer(card, 8, 'ncol')
else: # technically right, but nulling this will fix bad decks
self.ncol = None
#self.ncol = blank(card, 8, 'ncol')
else:
raise NotImplementedError(data)
self.GCj = []
self.GCi = []
self.Real = []
if self.isComplex():
self.Complex = []
def add(self, card, comment=''):
i = self.i
self.element_id[i] = integer(card, 1, 'element_id')
self.property_id[i] = integer(card, 2, 'property_id')
self.node_ids[i] = [
integer(card, 3, 'node_id1'),
integer(card, 4, 'node_id2'),
integer(card, 5, 'node_id3'),
integer_or_blank(card, 6, 'node_id4', 0),
integer_or_blank(card, 7, 'node_id5', 0),
integer_or_blank(card, 8, 'node_id6', 0)
]
#self.thetaMcid[i] = integer_double_or_blank(card, 9, 'thetaMcid', 0.0)
self.offset[i] = double_or_blank(card, 10, 'zOffset', 0.0)
self.thickness[i] = [
double_or_blank(card, 11, 'T1', 1.0),
double_or_blank(card, 12, 'T2', 1.0),
double_or_blank(card, 13, 'T3', 1.0),
]
self.t_flag[i] = integer_or_blank(card, 14, 'TFlag', 0)
assert len(card) <= 15, 'len(CTRIA6 card) = %i' % len(card)
self.i += 1
def __init__(self, card=None, data=None, comment=''):
LineElement.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.eid = integer(card, 1, 'eid')
self.pid = integer(card, 2, 'pid', self.eid)
self.ga = integer(card, 3, 'ga')
self.gb = integer(card, 4, 'gb')
self.gc = integer(card, 5, 'gc')
self.initX_G0(card)
self.w1a = double_or_blank(card, 9, 'w1a', 0.0)
self.w2a = double_or_blank(card, 10, 'w2a', 0.0)
self.w3a = double_or_blank(card, 11, 'w3a', 0.0)
self.w1b = double_or_blank(card, 12, 'w1b', 0.0)
self.w2b = double_or_blank(card, 13, 'w2b', 0.0)
self.w3b = double_or_blank(card, 14, 'w3b', 0.0)
self.w1c = double_or_blank(card, 15, 'w1c', 0.0)
self.w2c = double_or_blank(card, 16, 'w2c', 0.0)
self.w3c = double_or_blank(card, 17, 'w3c', 0.0)
self.twa = double_or_blank(card, 18, 0., 'twa')
self.twb = double_or_blank(card, 19, 0., 'twb')
self.twc = double_or_blank(card, 20, 0., 'twc')
self.sa = integer_or_blank(card, 21, 'sa')
self.sb = integer_or_blank(card, 22, 'sb')
self.sc = integer_or_blank(card, 23, 'sc')
assert len(card) <= 24, 'len(CBEAM3 card) = %i' % len(card)
else:
raise NotImplementedError(data)
def __init__(self, card=None, data=None, comment=''):
if comment:
self._comment = comment
if card:
self.name = string(card, 1, 'name')
#zero
#: 4-Lower Triangular; 5=Upper Triangular; 6=Symmetric; 8=Identity (m=nRows, n=m)
self.ifo = integer(card, 3, 'ifo')
#: 1-Real, Single Precision; 2=Real,Double Precision; 3=Complex, Single; 4=Complex, Double
self.tin = integer(card, 4, 'tin')
#: 0-Set by cell precision
self.tout = integer_or_blank(card, 5, 'tout', 0)
self.polar = integer_or_blank(card, 6, 'polar')
if self.ifo == 9:
self.ncol = integer(card, 8, 'ncol')
else:
self.ncol = blank(card, 8, 'ncol')
else:
raise NotImplementedError(data)
self.GCj = []
self.GCi = []
self.Real = []
if self.isComplex():
self.Complex = []
def add(self, card, comment=''):
i = self.i
self.element_id[i] = integer(card, 1, 'element_id')
self.property_id[i] = integer(card, 2, 'property_id')
self.node_ids[i, :] = [
integer(card, 3, 'n1'),
integer(card, 4, 'n2'),
integer(card, 5, 'n3'),
integer(card, 6, 'n4'),
integer_or_blank(card, 7, 'n5', 0),
integer_or_blank(card, 8, 'n6', 0),
integer_or_blank(card, 9, 'n7', 0),
integer_or_blank(card, 10, 'n8', 0)]
self.thickness[i, :] = [
double_or_blank(card, 11, 'T1', 1.0),
double_or_blank(card, 12, 'T2', 1.0),
double_or_blank(card, 13, 'T3', 1.0),
double_or_blank(card, 14, 'T4', 1.0), ]
#self.thetaMcid[i] = integer_double_or_blank(card, 15, 'thetaMcid', 0.0)
self.zoffset[i] = double_or_blank(card, 16, 'zOffset', 0.0)
self.t_flag[i] = integer_or_blank(card, 17, 'TFlag', 0)
self.i += 1
def __init__(self, card=None, data=None, comment=''):
"""
Creates the GRID card
:param self:
the GRID object pointer
:param card:
a BDFCard object
:type card:
BDFCard
:param data:
a list with the GRID fields defined in OP2 format
:type data:
LIST
:param comment:
a comment for the card
:type comment:
string
"""
if comment:
self._comment = comment
Node.__init__(self, card, data)
if card:
#: Node ID
self.nid = integer(card, 1, 'nid')
#: Grid point coordinate system
self.cp = integer_or_blank(card, 2, 'cp', 0)
#: node location in local frame
self.xyz = array([
double_or_blank(card, 3, 'x1', 0.),
double_or_blank(card, 4, 'x2', 0.),
double_or_blank(card, 5, 'x3', 0.)], dtype='float64')
#: Analysis coordinate system
self.cd = integer_or_blank(card, 6, 'cd', 0)
#: SPC constraint
self.ps = str(integer_or_blank(card, 7, 'ps', ''))
#: Superelement ID
self.seid = integer_or_blank(card, 8, 'seid', 0)
assert len(card) <= 9, 'len(GRID card) = %i' % len(card)
else:
self.nid = data[0]
self.cp = data[1]
self.xyz = array(data[2:5])
self.cd = data[5]
self.ps = data[6]
self.seid = data[7]
if self.ps == 0:
self.ps = ''
assert len(self.xyz) == 3
assert self.nid > 0, 'nid=%s' % (self.nid)
assert self.cp >= 0, 'cp=%s' % (self.cp)
assert self.cd >= -1, 'cd=%s' % (self.cd)
assert self.seid >= 0, 'seid=%s' % (self.seid)
def add(self, card, comment=''):
i = self.i
self.element_id[i] = integer(card, 1, 'element_id')
self.property_id[i] = integer(card, 2, 'property_id')
self.coord_id[i] = integer_or_blank(card, 3, 'cp', 0)
self.nspan[i] = integer_or_blank(card, 4, 'nspan', 0)
self.nchord[i] = integer_or_blank(card, 5, 'nchord', 0)
#if self.nspan==0:
self.lspan[i] = integer_or_blank(card, 6, 'lspan', 0)
#if self.nchord==0:
self.lchord[i] = integer_or_blank(card, 7, 'lchord', 0)
self.igid[i] = integer(card, 8, 'igid')
self.p1[i, :] = [double_or_blank(card, 9, 'x1', 0.0),
double_or_blank(card, 10, 'y1', 0.0),
double_or_blank(card, 11, 'z1', 0.0)]
self.x12[i] = double_or_blank(card, 12, 'x12', 0.)
self.p4[i, :] = [double_or_blank(card, 13, 'x4', 0.0),
double_or_blank(card, 14, 'y4', 0.0),
double_or_blank(card, 15, 'z4', 0.0)]
self.x43[i] = double_or_blank(card, 16, 'x43', 0.)
assert len(card) <= 17, 'len(CAERO1 card) = %i' % len(card)
self.i += 1
def __init__(self, card=None, data=None, comment=''):
Property.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Property ID
self.pid = integer(card, 1, 'pid')
#: diameter of the fastener
self.d = double(card, 2, 'd')
assert self.d > 0
#: Specifies the element stiffness coordinate system
self.mcid = integer_or_blank(card, 3, 'mcid', -1)
assert self.mcid >= -1
self.mflag = integer_or_blank(card, 4, 'mflag', 0) # 0-absolute 1-relative
assert self.mflag in [0, 1]
#: stiffness values in directions 1-3
self.kt1 = double(card, 5, 'kt1')
self.kt2 = double(card, 6, 'kt2')
self.kt3 = double(card, 7, 'kt3')
#: Rotational stiffness values in directions 1-3
self.kr1 = double_or_blank(card, 8, 'kr1', 0.0)
self.kr2 = double_or_blank(card, 9, 'kr2', 0.0)
self.kr3 = double_or_blank(card, 10, 'kr3', 0.0)
#: Lumped mass of fastener
self.mass = double_or_blank(card, 11, 'mass', 0.0)
#: Structural damping
self.ge = double_or_blank(card, 12, 'ge', 0.0)
assert len(card) <= 13, 'len(PFAST card) = %i' % len(card)
else:
raise NotImplementedError(data)
def add(self, card, comment=''):
self._comment = comment
self.n = 1
self.cp = integer_or_blank(card, 2, 'cp', 0)
self.cd = integer_or_blank(card, 6, 'cd', 0)
self.ps = integer_or_blank(card, 7, 'ps', -1)
self.seid = integer_or_blank(card, 8, 'seid', 0)
def add(self, card, comment=''):
cp0 = self.model.grdset.cp
cd0 = self.model.grdset.cd
ps0 = self.model.grdset.ps
seid0 = self.model.grdset.seid
i = self.i
#: Node ID
self.node_id[i] = integer(card, 1, 'nid')
#: Grid point coordinate system
self.cp[i] = integer_or_blank(card, 2, 'cp', cp0)
x = double_or_blank(card, 3, 'x1', 0.)
y = double_or_blank(card, 4, 'x2', 0.)
z = double_or_blank(card, 5, 'x3', 0.)
#: node location in local frame
self.xyz[i] = [x, y, z]
#: Analysis coordinate system
self.cd[i] = integer_or_blank(card, 6, 'cd', cd0)
#: SPC constraint
self.ps[i] = integer_or_blank(card, 7, 'ps', ps0)
#: Superelement ID
self.seid[i] = integer_or_blank(card, 8, 'seid', seid0)
self.i += 1
def __init__(self, card=None, data=None, comment=''):
LineDamper.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.eid = integer(card, 1, 'eid')
self.pid = integer(card, 2, 'pid')
nids = [integer_or_blank(card, 3, 'g1', 0),
integer_or_blank(card, 5, 'g2', 0)]
#: component number
self.c1 = integer_or_blank(card, 4, 'c1', 0)
self.c2 = integer_or_blank(card, 6, 'c2', 0)
assert len(card) <= 7, 'len(CDAMP1 card) = %i' % len(card)
else:
self.eid = data[0]
self.pid = data[1]
nids = [data[2], data[4]]
self.c1 = data[3]
self.c2 = data[5]
self.prepare_node_ids(nids, allow_empty_nodes=True)
assert len(self.nodes) == 2
msg = 'on\n%s\n is invalid validComponents=[0,1,2,3,4,5,6]' % str(self)
assert self.c1 in [0, 1, 2, 3, 4, 5, 6], 'c1=|%s| %s' % (self.c1, msg)
assert self.c2 in [0, 1, 2, 3, 4, 5, 6], 'c2=|%s| %s' % (self.c2, msg)
def __init__(self, card=None, data=None, comment=''):
Property.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Property ID
self.pid = integer(card, 1, 'pid')
#: diameter of the fastener
self.d = double(card, 2, 'd')
assert self.d > 0
#: Specifies the element stiffness coordinate system
self.mcid = integer_or_blank(card, 3, 'mcid', -1)
assert self.mcid >= -1
self.mflag = integer_or_blank(card, 4, 'mflag',
0) # 0-absolute 1-relative
assert self.mflag in [0, 1]
#: stiffness values in directions 1-3
self.kt1 = double(card, 5, 'kt1')
self.kt2 = double(card, 6, 'kt2')
self.kt3 = double(card, 7, 'kt3')
#: Rotational stiffness values in directions 1-3
self.kr1 = double_or_blank(card, 8, 'kr1', 0.0)
self.kr2 = double_or_blank(card, 9, 'kr2', 0.0)
self.kr3 = double_or_blank(card, 10, 'kr3', 0.0)
#: Lumped mass of fastener
self.mass = double_or_blank(card, 11, 'mass', 0.0)
#: Structural damping
self.ge = double_or_blank(card, 12, 'ge', 0.0)
assert len(card) <= 13, 'len(PFAST card) = %i' % len(card)
else:
raise NotImplementedError(data)
def __init__(self, card=None, data=None, comment=''):
TriShell.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Element ID
self.eid = integer(card, 1, 'eid')
#: Material ID
self.mid = integer(card, 2, 'mid')
nids = [
integer(card, 3, 'n1'),
integer_or_blank(card, 4, 'n2'),
integer(card, 5, 'n3'),
integer_or_blank(card, 6, 'n4'),
integer(card, 7, 'n5'),
integer_or_blank(card, 8, 'n6')
]
#: theta
self.theta = double_or_blank(card, 9, 'theta', 0.0)
assert len(card) <= 10, 'len(CTRIAX6 card) = %i' % len(card)
else:
raise NotImplementedError(data)
self.prepareNodeIDs(nids, allowEmptyNodes=True)
assert len(nids) == 6, 'error on CTRIAX6'
def __init__(self, card=None, data=None, comment=''):
LineDamper.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.eid = integer(card, 1, 'eid')
#: Value of the scalar damper (Real)
self.b = double(card, 2, 'b')
nids = [
integer_or_blank(card, 3, 'n1', 0),
integer_or_blank(card, 5, 'n2', 0)
]
#: component number
self.c1 = integer_or_blank(card, 4, 'c1', 0)
self.c2 = integer_or_blank(card, 6, 'c2', 0)
assert len(card) <= 7, 'len(CDAMP2 card) = %i' % len(card)
else:
self.eid = data[0]
self.b = data[1]
nids = [data[2], data[4]]
self.c1 = data[3]
self.c2 = data[5]
self.prepareNodeIDs(nids, allowEmptyNodes=True)
assert len(self.nodes) == 2
msg = 'on\n%s\n is invalid validComponents=[0,1,2,3,4,5,6]' % str(self)
assert self.c1 in [0, 1, 2, 3, 4, 5, 6], 'c1=|%s| %s' % (self.c1, msg)
assert self.c2 in [0, 1, 2, 3, 4, 5, 6], 'c2=|%s| %s' % (self.c2, msg)
def __init__(self, card=None, data=None, comment=""):
ThermalElement.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Surface element ID number for a side of an
#: element. (0 < Integer < 100,000,000)
self.eid = integer(card, 1, "eid")
#: A heat conduction element identification
self.eid2 = integer(card, 2, "eid2")
#: A consistent element side identification number
#: (1 < Integer < 6)
self.side = integer(card, 3, "side")
assert 0 < self.side < 7
#: A VIEW entry identification number for the front face
self.iViewFront = integer_or_blank(card, 4, "iViewFront", 0)
#: A VIEW entry identification number for the back face
self.iViewBack = integer_or_blank(card, 5, "iViewBack", 0)
#: RADM identification number for front face of surface element
#: (Integer > 0)
self.radMidFront = integer_or_blank(card, 6, "radMidFront", 0)
#: RADM identification number for back face of surface element
#: (Integer > 0)
self.radMidBack = integer_or_blank(card, 7, "radMidBack", 0)
assert len(card) <= 8, "len(CHBDYE card) = %i" % len(card)
else:
raise NotImplementedError(data)
self.grids = []
def test_integer_or_blank(self):
"""
value = integer_or_blank(card, n, fieldname)
"""
# integer
self.check_integer(integer_or_blank)
# float
with self.assertRaises(SyntaxError):
integer_or_blank(BDFCard([1.] ), 0, 'field')
with self.assertRaises(SyntaxError):
integer_or_blank(BDFCard(['1.']), 0, 'field')
# string
with self.assertRaises(SyntaxError):
integer_or_blank(BDFCard(['a'] ), 0, 'field')
with self.assertRaises(SyntaxError):
integer_or_blank(BDFCard(['1b']), 0, 'field')
# blank
self.assertEqual('a', integer_or_blank(BDFCard([''] ), 0, 'field', 'a'))
self.assertEqual('b', integer_or_blank(BDFCard([None] ), 0, 'field', 'b'))
card = [1, '2', '3.', 'C', None, '']
exact = [1, 2, SyntaxError, SyntaxError, None, None]
default = [None, None, None, None, None, None]
self.run_function_default(integer_or_blank, card, exact, default)
def __init__(self, card=None, data=None, comment=''):
TabularLoad.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.sid = integer(card, 1, 'sid')
self.exciteID = integer(card, 2, 'exciteID')
self.delay = integer_double_or_blank(card, 3, 'delay', 0)
self.dphase = integer_double_or_blank(card, 4, 'dphase')
self.tb = integer_or_blank(card, 5, 'tb', 0)
self.tp = integer_or_blank(card, 6, 'tp', 0)
self.Type = integer_string_or_blank(card, 7, 'Type', 'LOAD')
if self.Type in [0, 'L', 'LO', 'LOA', 'LOAD']:
self.Type = 'LOAD'
elif self.Type in [1, 'D', 'DI', 'DIS', 'DISP']:
self.Type = 'DISP'
elif self.Type in [2, 'V', 'VE', 'VEL', 'VELO']:
self.Type = 'VELO'
elif self.Type in [3, 'A', 'AC', 'ACC', 'ACCE']:
self.Type = 'ACCE'
else:
msg = 'invalid RLOAD2 type Type=|%s|' % self.Type
raise RuntimeError(msg)
assert len(card) <= 8, 'len(RLOAD2 card) = %i' % len(card)
else:
raise NotImplementedError(data)
def __init__(self, card=None, data=None, comment=''):
ThermalElement.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Surface element ID number for a side of an
#: element. (0 < Integer < 100,000,000)
self.eid = integer(card, 1, 'eid')
#: A heat conduction element identification
self.eid2 = integer(card, 2, 'eid2')
#: A consistent element side identification number
#: (1 < Integer < 6)
self.side = integer(card, 3, 'side')
assert 0 < self.side < 7
#: A VIEW entry identification number for the front face
self.iViewFront = integer_or_blank(card, 4, 'iViewFront', 0)
#: A VIEW entry identification number for the back face
self.iViewBack = integer_or_blank(card, 5, 'iViewBack', 0)
#: RADM identification number for front face of surface element
#: (Integer > 0)
self.radMidFront = integer_or_blank(card, 6, 'radMidFront', 0)
#: RADM identification number for back face of surface element
#: (Integer > 0)
self.radMidBack = integer_or_blank(card, 7, 'radMidBack', 0)
assert len(card) <= 8, 'len(CHBDYE card) = %i' % len(card)
else:
raise NotImplementedError(data)
self.grids = []
def __init__(self, card=None, data=None, comment=''):
TabularLoad.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.sid = integer(card, 1, 'sid')
self.exciteID = integer(card, 2, 'exciteID')
self.delay = integer_double_or_blank(card, 3, 'delay')
self.dphase = integer_double_or_blank(card, 4, 'dphase')
self.tb = integer_or_blank(card, 5, 'tb', 0)
self.tp = integer_or_blank(card, 6, 'tp', 0)
self.Type = string_or_blank(card, 7, 'Type', 'LOAD')
if self.Type in [0, 'L', 'LO', 'LOA', 'LOAD']:
self.Type = 'LOAD'
elif self.Type in [1, 'D', 'DI', 'DIS', 'DISP']:
self.Type = 'DISP'
elif self.Type in [2, 'V', 'VE', 'VEL', 'VELO']:
self.Type = 'VELO'
elif self.Type in [3, 'A', 'AC', 'ACC', 'ACCE']:
self.Type = 'ACCE'
else:
msg = 'invalid RLOAD2 type Type=|%s|' % self.Type
raise RuntimeError(msg)
assert len(card) <= 8, 'len(RLOAD2 card) = %i' % len(card)
else:
raise NotImplementedError(data)
def __init__(self, card=None, data=None, comment=''):
if comment:
self._comment = comment
if card:
self.name = string(card, 1, 'name')
#zero
#: 4-Lower Triangular; 5=Upper Triangular; 6=Symmetric; 8=Identity (m=nRows, n=m)
self.ifo = integer(card, 3, 'ifo')
#: 1-Real, Single Precision; 2=Real,Double Precision; 3=Complex, Single; 4=Complex, Double
self.tin = integer(card, 4, 'tin')
#: 0-Set by cell precision
self.tout = integer_or_blank(card, 5, 'tout', 0)
#: Input format of Ai, Bi. (Integer=blank or 0 indicates real, imaginary format;
#: Integer > 0 indicates amplitude, phase format.)
self.polar = integer_or_blank(card, 6, 'polar', 0)
if self.ifo in [6, 9]:
self.ncol = integer(card, 8, 'ncol')
else: # technically right, but nulling this will fix bad decks
self.ncol = None
#self.ncol = blank(card, 8, 'ncol')
else:
raise NotImplementedError(data)
self.GCj = []
self.GCi = []
self.Real = []
if self.is_complex():
self.Complex = []
def getShockA(self, card, iStart):
self.shockType = string_or_blank(card, iStart + 1, 'shockType')
self.shockCVT = double(card, iStart + 2, 'shockCVT')
self.shockCVC = double_or_blank(card, iStart + 3, 'shockCVC')
self.shockExpVT = double_or_blank(card, iStart + 4, 'shockExpVT', 1.0)
self.shockExpVC = double_or_blank(card, iStart + 5,
'shockExpVC', self.shockExpVT)
if self.shockType == 'TABLE':
pass
# self.shockIDTS = integer(card, iStart + 6, 'shockIDTS')
# self.shockIDETS = blank(card, iStart + 9, 'shockIDETS')
# self.shockIDECS = blank(card, iStart + 10, 'shockIDECS')
# self.shockIDETSD = blank(card, iStart + 11, 'shockIDETSD')
# self.shockIDECSD = blank(card, iStart + 12, 'shockIDECSD')
elif self.shockType == 'EQUAT':
self.shockIDTS = blank(card, iStart + 6, 'shockIDTS')
self.shockIDETS = integer(card, iStart + 9, 'shockIDETS')
self.shockIDECS = integer_or_blank(card, iStart + 10,
'shockIDECS', self.shockIDETS)
self.shockIDETSD = integer(card, iStart + 11, 'shockIDETSD')
self.shockIDECSD = integer_or_blank(card, iStart + 11,
'shockIDECSD', self.shockIDETSD)
else:
raise RuntimeError('Invalid shockType=|%s| on card\n%s' %(self.shockType, card))
iStart += 8
return iStart
def __init__(self, card=None, data=None, comment=''):
Property.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Property ID
self.pid = integer(card, 1, 'pid')
#: Material ID
self.mid1 = integer_or_blank(card, 2, 'mid1', 0)
self.t1 = double_or_blank(card, 3, 't1')
self.mid2 = integer_or_blank(card, 4, 'mid2', 0)
if self.mid2 > 0:
self.i = double(card, 5, 'i')
assert self.i > 0.0
else:
self.i = blank(card, 5, 'i')
self.mid3 = integer(card, 6, 0)
if self.mid3 > 0:
self.t2 = double(card, 7, 't3')
assert self.t2 > 0.0
else:
self.t2 = blank(card, 7, 't3')
self.nsm = double(card, 8, 'nsm')
self.z1 = double(card, 9, 'z1')
self.z2 = double(card, 10, 'z2')
self.phi = fields(double, card, 'phi', i=11, j=len(card))
else:
raise NotImplementedError(data)
def __init__(self, card=None, data=None, comment=''):
if comment:
self._comment = comment
if card:
self.sid = integer(card, 1, 'sid')
self.eid = integer(card, 2, 'eid')
p1 = double_or_blank(card, 3, 'p1', 0.0)
p = [p1,
double_or_blank(card, 4, 'p2', p1),
double_or_blank(card, 5, 'p3', p1),
double_or_blank(card, 6, 'p4', p1)]
self.pressures = p
self.eids = [self.eid]
if (integer_string_or_blank(card, 7, 'g1/THRU') == 'THRU' and
integer_or_blank(card, 8, 'eid2')): # plates
eid2 = integer(card, 8, 'eid2')
if eid2:
self.eids = expand_thru([self.eid, 'THRU', eid2])
self.g1 = None
self.g34 = None
else:
#: used for CPENTA, CHEXA
self.eids = [self.eid]
#: used for solid element only
self.g1 = integer_or_blank(card, 7, 'g1')
#: g3/g4 - different depending on CHEXA/CPENTA or CTETRA
self.g34 = integer_or_blank(card, 8, 'g34')
#: Coordinate system identification number. See Remark 2.
#: (Integer >= 0;Default=0)
self.cid = integer_or_blank(card, 9, 'cid', 0)
#print "PLOAD4 cid = ",self.cid
self.NVector = array([double_or_blank(card, 10, 'N1', 0.0),
double_or_blank(card, 11, 'N2', 0.0),
double_or_blank(card, 12, 'N3', 0.0)])
self.sorl = string_or_blank(card, 13, 'sorl', 'SURF')
self.ldir = string_or_blank(card, 14, 'ldir', 'NORM')
assert len(card) <= 15, 'len(PLOAD4 card) = %i' % len(card)
else:
#print "PLOAD4 = ",data
self.sid = data[0]
self.eid = data[1]
self.pressures = data[2]
self.g1 = data[3]
self.g34 = data[4]
self.cid = data[5]
self.NVector = data[6]
self.sorl = data[7]
#self.ldir = data[8]
#assert len(data)==8
self.g1 = self.g1
self.g34 = self.g34
self.eids = [self.eid]
def add(self, card, comment=''):
i = self.i
eid = integer(card, 1, 'element_id')
self.element_id[i] = eid
self.property_id[i] = integer_or_blank(card, 2, 'property_id', eid)
self.node_ids[i] = [integer(card, 3, 'GA'), integer(card, 4, 'GB')]
#---------------------------------------------------------
# x / g0
field5 = integer_double_or_blank(card, 5, 'x1_g0')
if isinstance(field5, int):
self.is_g0[i] = True
self.g0[i] = field5
elif isinstance(field5, float):
self.is_g0[i] = False
x = array([
field5,
double_or_blank(card, 6, 'x2', x2_default),
double_or_blank(card, 7, 'x3', x3_default)
],
dtype='float64')
self.x[i, :] = x
if norm(x) == 0.0:
msg = 'G0 vector defining plane 1 is not defined on %s %s.\n' % (
self.type, eid)
msg += 'G0 = %s\n' % field5
msg += 'X = %s\n' % x
msg += '%s' % card
raise RuntimeError(msg)
#else:
#msg = ('field5 on %s (G0/X1) is the wrong type...eid=%s field5=%s '
#'type=%s' % (self.type, eid, field5, type(field5)))
#raise RuntimeError(msg)
#---------------------------------------------------------
#: Element coordinate system identification. A 0 means the basic
#: coordinate system. If CID is blank, then the element coordinate
#: system is determined from GO or Xi.
#: (default=blank=element-based)
cid = integer_or_blank(card, 8, 'cid')
if cid is not None:
self.cid[i] = cid
#: Location of spring damper (0 <= s <= 1.0)
self.s[i] = double_or_blank(card, 9, 's', 0.5)
#: Coordinate system identification of spring-damper offset. See
#: Remark 9. (Integer > -1; Default = -1, which means the offset
#: point lies on the line between GA and GB
self.ocid[i] = integer_or_blank(card, 10, 'ocid', -1)
#: Components of spring-damper offset in the OCID coordinate system
#: if OCID > 0.
self.si[i, :] = [
double_or_blank(card, 11, 's1'),
double_or_blank(card, 12, 's2'),
double_or_blank(card, 13, 's3')
]
assert len(card) <= 14, 'len(CBUSH card) = %i' % len(card)
self.i += 1
def add(self, card, comment=''):
i = self.i
self.element_id[i] = integer(card, 1, 'eid')
self.property_id[i] = integer_or_blank(card, 2, 'pid', self.element_id[i])
self.node_ids[i, :] = [integer(card, 3, 'n1'),
integer(card, 5, 'n2')]
self.components[i, :] = [integer_or_blank(card, 4, 'c1', 0),
integer_or_blank(card, 6, 'c2', 0)]
assert len(card) <= 7, 'len(CELAS1 card) = %i' % len(card)
self.i += 1
def __init__(self, card=None, data=None, comment=''):
SolidElement.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Element ID
self.eid = integer(card, 1, 'eid')
#: Property ID
self.pid = integer(card, 2, 'pid')
nids = [
integer(card, 3, 'nid1'),
integer(card, 4, 'nid2'),
integer(card, 5, 'nid3'),
integer(card, 6, 'nid4'),
integer(card, 7, 'nid5'),
integer(card, 8, 'nid6'),
integer_or_blank(card, 9, 'nid7'),
integer_or_blank(card, 10, 'nid8'),
integer_or_blank(card, 11, 'nid9'),
integer_or_blank(card, 12, 'nid10'),
integer_or_blank(card, 13, 'nid11'),
integer_or_blank(card, 14, 'nid12'),
integer_or_blank(card, 15, 'nid13'),
integer_or_blank(card, 16, 'nid14'),
integer_or_blank(card, 17, 'nid15'),
]
assert len(card) <= 18, 'len(CPENTA15 card) = %i' % len(card)
else:
self.eid = data[0]
self.pid = data[1]
nids = [d if d > 0 else None for d in data[2:]]
assert len(data) == 17, 'len(data)=%s data=%s' % (len(data), data)
self.prepare_node_ids(nids, allow_empty_nodes=True)
assert len(self.nodes) <= 15
def __init__(self, card=None, data=None, comment=''):
SolidElement.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Element ID
self.eid = integer(card, 1, 'eid')
#: Property ID
self.pid = integer(card, 2, 'pid')
nids = [
integer(card, 3, 'nid1'),
integer(card, 4, 'nid2'),
integer(card, 5, 'nid3'),
integer(card, 6, 'nid4'),
integer(card, 7, 'nid5'),
integer(card, 8, 'nid6'),
integer_or_blank(card, 9, 'nid7'),
integer_or_blank(card, 10, 'nid8'),
integer_or_blank(card, 11, 'nid9'),
integer_or_blank(card, 12, 'nid10'),
integer_or_blank(card, 13, 'nid11'),
integer_or_blank(card, 14, 'nid12'),
integer_or_blank(card, 15, 'nid13'),
integer_or_blank(card, 16, 'nid14'),
integer_or_blank(card, 17, 'nid15'),
]
assert len(card) <= 18, 'len(CPENTA15 card) = %i' % len(card)
else:
self.eid = data[0]
self.pid = data[1]
nids = [d if d > 0 else None for d in data[2:]]
assert len(data) == 17, 'len(data)=%s data=%s' % (len(data), data)
self.prepareNodeIDs(nids, allowEmptyNodes=True)
assert len(self.nodes) <= 15
def __init__(self, card=None, data=None, comment=''):
ShellProperty.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Property ID
self.pid = integer(card, 1, 'pid')
self.mid1 = integer_or_blank(card, 2, 'mid1')
#: thickness
self.t = double_or_blank(card, 3, 't')
#: Material identification number for bending
#: -1 for plane strin
self.mid2 = integer_or_blank(card, 4, 'mid2')
#: Scales the moment of interia of the element based on the
#: moment of interia for a plate
#:
#: ..math:: I = \frac{12I}{t^3} I_{plate}
self.twelveIt3 = double_or_blank(card, 5, '12*I/t^3', 1.0) # poor name
self.mid3 = integer_or_blank(card, 6, 'mid3')
self.tst = double_or_blank(card, 7, 'ts/t', 0.833333)
#: Non-structural Mass
self.nsm = double_or_blank(card, 8, 'nsm', 0.0)
if self.t is not None:
tOver2 = self.t / 2.
self.z1 = double_or_blank(card, 9, 'z1', -tOver2)
self.z2 = double_or_blank(card, 10, 'z2', tOver2)
else:
self.z1 = double_or_blank(card, 9, 'z1')
self.z2 = double_or_blank(card, 10, 'z2')
self.mid4 = integer_or_blank(card, 11, 'mid4')
#if self.mid2 is None:
# assert self.mid3 is None
#else: # mid2 is defined
# #print "self.mid2 = ",self.mid2
# assert self.mid2 >= -1
# #assert self.mid3 > 0
#if self.mid is not None and self.mid2 is not None:
# assert self.mid4==None
assert len(card) <= 12, 'len(PSHELL card) = %i' % len(card)
else:
self.pid = data[0]
self.mid1 = data[1]
self.t = data[2]
self.mid2 = data[3]
self.twelveIt3 = data[4]
self.mid3 = data[5]
self.tst = data[6]
self.nsm = data[7]
self.z1 = data[8]
self.z2 = data[9]
self.mid4 = data[10]
def add(self, card, comment=''):
print('add...')
i = self.i
#comment = self._comments[i]
eid = integer(card, 1, 'element_id')
if comment:
self._comments[eid] = comment
#: Element ID
self.element_id[i] = eid
#: Property ID
self.property_id[i] = integer(card, 2, 'property_id')
#: Node IDs
nids = array([
integer(card, 3, 'node_id_1'),
integer(card, 4, 'node_id_2'),
integer(card, 5, 'node_id_3'),
integer(card, 6, 'node_id_4'),
integer(card, 7, 'node_id_5'),
integer(card, 8, 'node_id_6'),
integer_or_blank(card, 9, 'node_id_7', 0),
integer_or_blank(card, 10, 'node_id_8', 0),
integer_or_blank(card, 11, 'node_id_9', 0),
integer_or_blank(card, 12, 'node_id_10', 0),
integer_or_blank(card, 13, 'node_id_11', 0),
integer_or_blank(card, 14, 'node_id_12', 0),
integer_or_blank(card, 15, 'node_id_13', 0),
integer_or_blank(card, 16, 'node_id_14', 0),
integer_or_blank(card, 17, 'node_id_15', 0),
], dtype='int32')
self.node_ids[i, :] = nids
assert len(card) <= 17, 'len(CPENTA15 card) = %i' % len(card)
self.i += 1
def __init__(self, card=None, data=None, comment=''):
QuadShell.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Element ID
self.eid = integer(card, 1, 'eid')
#: Property ID
self.pid = integer(card, 2, 'pid')
nids = [
integer_or_blank(card, 3, 'n1'),
integer_or_blank(card, 4, 'n2'),
integer_or_blank(card, 5, 'n3'),
integer_or_blank(card, 6, 'n4'),
integer_or_blank(card, 7, 'n5'),
integer_or_blank(card, 8, 'n6'),
integer_or_blank(card, 9, 'n7'),
integer_or_blank(card, 10, 'n8'),
integer_or_blank(card, 11, 'n9')
]
assert len(card) <= 12, 'len(CQUADX card) = %i' % len(card)
else:
raise NotImplementedError(data)
self.prepareNodeIDs(nids, allowEmptyNodes=True)
assert len(self.nodes) == 9
def __init__(self, card=None, data=None, comment=''):
ShellProperty.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Property ID
self.pid = integer(card, 1, 'pid')
self.mid1 = integer_or_blank(card, 2, 'mid1')
#: thickness
self.t = double(card, 3, 't')
#: Material identification number for bending
self.mid2 = integer_or_blank(card, 4, 'mid2')
#: Scales the moment of interia of the element based on the
#: moment of interia for a plate
#:
#: ..math:: I = \frac{12I}{t^3} I_{plate}
self.twelveIt3 = double_or_blank(card, 5, '12*I/t^3',
1.0) # poor name
self.mid3 = integer_or_blank(card, 6, 'mid3')
self.tst = double_or_blank(card, 7, 'ts/t', 0.833333)
#: Non-structural Mass
self.nsm = double_or_blank(card, 8, 'nsm', 0.0)
tOver2 = self.t / 2.
self.z1 = double_or_blank(card, 9, 'z1', -tOver2)
self.z2 = double_or_blank(card, 10, 'z2', tOver2)
self.mid4 = integer_or_blank(card, 11, 'mid4')
#if self.mid2 is None:
# assert self.mid3 is None
#else: # mid2 is defined
# #print "self.mid2 = ",self.mid2
# assert self.mid2 >= -1
# #assert self.mid3 > 0
#if self.mid is not None and self.mid2 is not None:
# assert self.mid4==None
assert len(card) <= 12, 'len(PSHELL card) = %i' % len(card)
else:
self.pid = data[0]
self.mid1 = data[1]
self.t = data[2]
self.mid2 = data[3]
self.twelveIt3 = data[4]
self.mid3 = data[5]
self.tst = data[6]
self.nsm = data[7]
self.z1 = data[8]
self.z2 = data[9]
self.mid4 = data[10]
#maxMid = max(self.mid1,self.mid2,self.mid3,self.mid4)
assert self.t > 0.0, ('the thickness must be defined on the PSHELL'
' card (Ti field not supported)')
def add(self, card, comment=''):
print('add...')
i = self.i
#comment = self._comments[i]
eid = integer(card, 1, 'element_id')
#if comment:
#self._comments[eid] = comment
#: Element ID
self.element_id[i] = eid
#: Property ID
self.property_id[i] = integer(card, 2, 'property_id')
#: Node IDs
nids = array([
integer(card, 3, 'node_id_1'),
integer(card, 4, 'node_id_2'),
integer(card, 5, 'node_id_3'),
integer(card, 6, 'node_id_4'),
integer(card, 7, 'node_id_5'),
integer(card, 8, 'node_id_6'),
integer_or_blank(card, 9, 'node_id_7', 0),
integer_or_blank(card, 10, 'node_id_8', 0),
integer_or_blank(card, 11, 'node_id_9', 0),
integer_or_blank(card, 12, 'node_id_10', 0),
integer_or_blank(card, 13, 'node_id_11', 0),
integer_or_blank(card, 14, 'node_id_12', 0),
integer_or_blank(card, 15, 'node_id_13', 0),
integer_or_blank(card, 16, 'node_id_14', 0),
integer_or_blank(card, 17, 'node_id_15', 0),
],
dtype='int32')
self.node_ids[i, :] = nids
assert len(card) <= 17, 'len(CPENTA15 card) = %i' % len(card)
self.i += 1
def __init__(self, card=None, data=None, comment=''):
if comment:
self._comment = comment
self.nlpci_id = integer(card, 1, 'nlpci_id')
self.Type = string_or_blank(card, 2, 'Type', 'CRIS')
self.minalr = double_or_blank(card, 3, 'minalr', 0.25)
self.maxalr = double_or_blank(card, 4, 'maxalr', 4.0)
self.scale = double_or_blank(card, 5, 'scale', 0.0)
blank(card, 6, 'blank')
self.desiter = integer_or_blank(card, 7, 'desiter', 12)
self.mxinc = integer_or_blank(card, 8, 'mxinc', 20)
def getGener(self, card, iStart):
self.generIDT = integer(card, iStart + 2, 'generIDT')
self.generIDC = integer_or_blank(card, iStart + 3, 'generIDC',
self.generIDT)
self.generIDTDU = integer(card, iStart + 4, 'generIDTDU')
self.generIDCDU = integer_or_blank(card, iStart + 5, 'generIDCDU',
self.generIDTDU)
self.generIDTDV = integer(card, iStart + 6, 'generIDTDV')
self.generIDCDV = integer_or_blank(card, iStart + 7, 'generIDCDV',
self.generIDTDV)
self.vars.append('GENER')
def add(self, card=None, comment=''):
if comment:
self._comment = comment
i = self.i
#: Identification number of a MAT1, MAT2, or MAT9 entry.
self.material_id[i] = integer(card, 1, 'mid')
#: Identification number of a TABLES1 or TABLEST entry. If H is
#: given, then this field must be blank.
self.table_id[i] = integer_or_blank(card, 2, 'tid', 0)
#: Type of material nonlinearity. ('NLELAST' for nonlinear elastic
#: or 'PLASTIC' for elastoplastic.)
self.Type[i] = string(card, 3, 'Type')
if self.Type[i] == 'NLELAST':
self.h[i] = blank(card, 4, 'h')
self.hr[i] = blank(card, 6, 'hr')
self.yf[i] = blank(card, 5, 'yf')
self.limit1[i] = blank(card, 7, 'yf')
self.limit2[i] = blank(card, 8, 'yf')
else:
#: Work hardening slope (slope of stress versus plastic strain) in
#: units of stress. For elastic-perfectly plastic cases, H=0.0.
#: For more than a single slope in the plastic range, the
#: stress-strain data must be supplied on a TABLES1 entry
#: referenced by TID, and this field must be blank
h = double_or_blank(card, 4, 'H')
self.h[i] = h
if h is None:
self.hflag[i] = False
else:
self.hflag[i] = True
#: Yield function criterion, selected by one of the following
#: values (1) Von Mises (2) Tresca (3) Mohr-Coulomb
#: (4) Drucker-Prager
self.yf[i] = integer_or_blank(card, 5, 'yf', 1)
#: Hardening Rule, selected by one of the following values
#: (Integer): (1) Isotropic (Default) (2) Kinematic
#: (3) Combined isotropic and kinematic hardening
self.hr[i] = integer_or_blank(card, 6, 'hr', 1)
#: Initial yield point
self.limit1[i] = double(card, 7, 'limit1')
if self.yf[i] == 3 or self.yf[i] == 4:
#: Internal friction angle, measured in degrees, for the
#: Mohr-Coulomb and Drucker-Prager yield criteria
self.limit2[i] = double(card, 8, 'limit2')
else:
#self.limit2[i] = blank(card, 8, 'limit2')
#self.limit2[i] = None
pass
assert len(card) <= 9, 'len(MATS1 card) = %i' % len(card)
self.i += 1
def add(self, card=None, comment=''):
if comment:
self._comment = comment
i = self.i
#: Identification number of a MAT1, MAT2, or MAT9 entry.
self.material_id[i] = integer(card, 1, 'mid')
#: Identification number of a TABLES1 or TABLEST entry. If H is
#: given, then this field must be blank.
self.table_id[i] = integer_or_blank(card, 2, 'tid')
#: Type of material nonlinearity. ('NLELAST' for nonlinear elastic
#: or 'PLASTIC' for elastoplastic.)
self.Type[i] = string(card, 3, 'Type')
if self.Type[i] == 'NLELAST':
self.h[i] = blank(card, 4, 'h')
self.hr[i] = blank(card, 6, 'hr')
self.yf[i] = blank(card, 5, 'yf')
self.limit1[i] = blank(card, 7, 'yf')
self.limit2[i] = blank(card, 8, 'yf')
else:
#: Work hardening slope (slope of stress versus plastic strain) in
#: units of stress. For elastic-perfectly plastic cases, H=0.0.
#: For more than a single slope in the plastic range, the
#: stress-strain data must be supplied on a TABLES1 entry
#: referenced by TID, and this field must be blank
h = double_or_blank(card, 4, 'H')
self.h[i] = h
if h is None:
self.hflag[i] = False
else:
self.hflag[i] = True
#: Yield function criterion, selected by one of the following
#: values (1) Von Mises (2) Tresca (3) Mohr-Coulomb
#: (4) Drucker-Prager
self.yf[i] = integer_or_blank(card, 5, 'yf', 1)
#: Hardening Rule, selected by one of the following values
#: (Integer): (1) Isotropic (Default) (2) Kinematic
#: (3) Combined isotropic and kinematic hardening
self.hr[i] = integer_or_blank(card, 6, 'hr', 1)
#: Initial yield point
self.limit1[i] = double(card, 7, 'limit1')
if self.yf[i] == 3 or self.yf[i] == 4:
#: Internal friction angle, measured in degrees, for the
#: Mohr-Coulomb and Drucker-Prager yield criteria
self.limit2[i] = double(card, 8, 'limit2')
else:
#self.limit2[i] = blank(card, 8, 'limit2')
#self.limit2[i] = None
pass
assert len(card) <= 9, 'len(MATS1 card) = %i' % len(card)
self.i += 1
def getGener(self, card, iStart):
self.generIDT = integer(card, iStart + 2, 'generIDT')
self.generIDC = integer_or_blank(card, iStart + 3,
'generIDC', self.generIDT)
self.generIDTDU = integer(card, iStart + 4, 'generIDTDU')
self.generIDCDU = integer_or_blank(card, iStart + 5,
'generIDCDU', self.generIDTDU)
self.generIDTDV = integer(card, iStart + 6, 'generIDTDV')
self.generIDCDV = integer_or_blank(card, iStart + 7,
'generIDCDV', self.generIDTDV)
self.vars.append('GENER')
def add(self, card, comment=''):
i = self.i
self.element_id[i] = integer(card, 1, 'eid')
self.property_id[i] = integer_or_blank(card, 2, 'pid',
self.element_id[i])
self.node_ids[i, :] = [integer(card, 3, 'n1'), integer(card, 5, 'n2')]
self.components[i, :] = [
integer_or_blank(card, 4, 'c1', 0),
integer_or_blank(card, 6, 'c2', 0)
]
assert len(card) <= 7, 'len(CELAS1 card) = %i' % len(card)
self.i += 1
def add(self, card, comment=None):
i = self.i
self.element_id[i] = integer(card, 1, 'eid')
self.K[i] = double(card, 2, 'k')
self.node_ids[i, :] = [integer(card, 3, 'G1'),
integer_or_blank(card, 5, 'G2')]
self.components[i, :] = [integer_or_blank(card, 4, 'C1', 0),
integer_or_blank(card, 6, 'C2', 0)]
self.ge[i] = double_or_blank(card, 7, 'ge', 0.)
self.s[i] = double_or_blank(card, 8, 's', 0.)
assert len(card) <= 9, 'len(CELAS2 card) = %i' % len(card) + str(card)
self.i += 1
def __init__(self, card=None, data=None, sol=None, comment=''):
Method.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Set identification number. (Unique Integer > 0)
self.sid = integer(card, 1, 'sid')
#: For vibration analysis: frequency range of interest. For
#: buckling analysis: eigenvalue range of interest. See Remark 4.
#: (Real or blank, -5 10e16 <= V1 < V2 <= 5.10e16)
self.v1 = double_or_blank(card, 2, 'v1')
self.v2 = double_or_blank(card, 3, 'v2')
#: Number of roots desired
self.nd = integer_or_blank(card, 4, 'nd')
#: Diagnostic level. (0 < Integer < 4; Default = 0)
self.msglvl = integer_or_blank(card, 5, 'msglvl', 0)
#: Number of vectors in block or set. Default is machine dependent
self.maxset = integer_or_blank(card, 6, 'maxset')
#: Estimate of the first flexible mode natural frequency
#: (Real or blank)
self.shfscl = double_or_blank(card, 7, 'shfscl')
#: Method for normalizing eigenvectors (Character: 'MASS' or 'MAX')
self.norm = string_or_blank(card, 8, 'norm')
optionValues = [interpret_value(field) for field in card[9:] ]
self.options = []
self.values = []
#print "optionValues = ",optionValues
for optionValue in optionValues:
#print "optionValue = ",optionValue
(option, value) = optionValue.split('=')
self.options.append(option)
self.values.append(value)
#: Method for normalizing eigenvectors
if sol in [103, 115, 146]:
# normal modes,cyclic normal modes, flutter
self.norm = string_or_blank(card, 8, 'norm', 'MASS')
elif sol in [105, 110, 111, 116]:
# buckling, modal complex eigenvalues,
# modal frequency response,cyclic buckling
self.norm = string_or_blank(card, 8, 'norm', 'MAX')
else:
self.norm = string_or_blank(card, 8, 'norm')
#assert len(card) <= 9, 'len(EIGRL card) = %i' % len(card)
assert len(card) <= 10, 'len(EIGRL card) = %i' % len(card)
#msg = 'norm=%s sol=%s' % (self.norm, sol)
#assert self.norm in ['MASS', 'MAX'],msg
#assert card.nFields()<9,'card = %s' %(card.fields(0))
else:
raise NotImplementedError('EIGRL')
def add(self, card, comment=None):
i = self.i
self.element_id[i] = integer(card, 1, 'eid')
self.K[i] = double(card, 2, 'k')
self.node_ids[i, :] = [integer(card, 3, 'G1'),
integer(card, 5, 'G2')]
self.components[i, :] = [integer_or_blank(card, 4, 'C1', 0),
integer_or_blank(card, 6, 'C2', 0)]
self.ge[i] = double_or_blank(card, 7, 'ge', 0.)
self.s[i] = double_or_blank(card, 8, 's', 0.)
assert len(card) <= 9, 'len(CELAS4 card) = %i' % len(card) + str(card)
self.i += 1
def __init__(self, card=None, data=None, sol=None, comment=''):
Method.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Set identification number. (Unique Integer > 0)
self.sid = integer(card, 1, 'sid')
#: For vibration analysis: frequency range of interest. For
#: buckling analysis: eigenvalue range of interest. See Remark 4.
#: (Real or blank, -5 10e16 <= V1 < V2 <= 5.10e16)
self.v1 = double_or_blank(card, 2, 'v1')
self.v2 = double_or_blank(card, 3, 'v2')
#: Number of roots desired
self.nd = integer_or_blank(card, 4, 'nd')
#: Diagnostic level. (0 < Integer < 4; Default = 0)
self.msglvl = integer_or_blank(card, 5, 'msglvl', 0)
#: Number of vectors in block or set. Default is machine dependent
self.maxset = integer_or_blank(card, 6, 'maxset')
#: Estimate of the first flexible mode natural frequency
#: (Real or blank)
self.shfscl = double_or_blank(card, 7, 'shfscl')
#: Method for normalizing eigenvectors (Character: 'MASS' or 'MAX')
self.norm = string_or_blank(card, 8, 'norm')
optionValues = card[9:]
self.options = []
self.values = []
#print "optionValues = ",optionValues
for optionValue in optionValues:
#print "optionValue = ",optionValue
(option, value) = optionValue.split('=')
self.options.append(option)
self.values.append(value)
#: Method for normalizing eigenvectors
if sol in [103, 115, 146]:
# normal modes,cyclic normal modes, flutter
self.norm = string_or_blank(card, 8, 'norm', 'MASS')
elif sol in [105, 110, 111, 116]:
# buckling, modal complex eigenvalues,
# modal frequency response,cyclic buckling
self.norm = string_or_blank(card, 8, 'norm', 'MAX')
else:
self.norm = string_or_blank(card, 8, 'norm')
#assert len(card) <= 9, 'len(EIGRL card) = %i' % len(card)
assert len(card) <= 10, 'len(EIGRL card) = %i' % len(card)
#msg = 'norm=%s sol=%s' % (self.norm, sol)
#assert self.norm in ['MASS', 'MAX'],msg
#assert card.nFields()<9,'card = %s' %(card.fields(0))
else:
raise NotImplementedError('EIGRL')
def __init__(self, card=None, data=None, comment=''):
Method.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: Set identification number. (Unique Integer > 0)
self.sid = integer(card, 1, 'sid')
#: Method of eigenvalue extraction. (Character: 'INV' for inverse
#: power method or 'SINV' for enhanced inverse power method.)
self.method = string_or_blank(card, 2, 'method', 'LAN')
assert self.method in [
'LAN', 'AHOU', 'INV', 'SINV', 'GIV', 'MGIV', 'HOU', 'MHOU',
'AGIV'
], 'method=%s' % self.method
#: Frequency range of interest
self.f1 = double_or_blank(card, 3, 'f1')
self.f2 = double_or_blank(card, 4, 'f2')
#: Estimate of number of roots in range (Required for
#: METHOD = 'INV'). Not used by 'SINV' method.
self.ne = integer_or_blank(card, 5, 'ne')
#: Desired number of roots (default=600 for SINV 3*ne for INV)
if self.method in ['SINV']:
self.nd = integer_or_blank(card, 6, 'nd', 600)
if self.method in ['INV']:
self.nd = integer_or_blank(card, 6, 'nd', 3 * self.ne)
elif self.method in ['GIV', 'MGIV', 'HOU', 'MHOU']:
self.nd = integer_or_blank(card, 6, 'nd', 0)
else:
self.nd = integer(card, 6, 'nd')
#: Method for normalizing eigenvectors. ('MAX' or 'POINT';
#: Default='MAX')
self.norm = string_or_blank(card, 9, 'norm', 'MASS')
assert self.norm in ['POINT', 'MASS', 'MAX']
if self.method == 'POINT':
#: Grid or scalar point identification number. Required only if
#: NORM='POINT'. (Integer>0)
self.G = integer(card, 10, 'G')
#: Component number. Required only if NORM='POINT' and G is a
#: geometric grid point. (1<Integer<6)
self.C = components(card, 11, 'C')
else:
self.G = blank(card, 10, 'G')
self.C = blank(card, 11, 'C')
assert len(card) <= 12, 'len(EIGR card) = %i' % len(card)
else:
raise NotImplementedError('EIGR')
