def add_card(cls, card, comment=''):
pid = integer(card, 1, 'pid')
tkid = integer_or_blank(card, 2, 'tkid', 0)
tgeid = integer_or_blank(card, 3, 'tgeid', 0)
tknid = integer_or_blank(card, 4, 'tknid', 0)
assert len(card) <= 5, 'len(PELAST card) = %i' % len(card)
return PELAST(pid, tkid, tgeid, tknid, comment=comment)
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 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 add_card(cls, card, comment=''):
mid = integer(card, 1, 'mid')
tid = integer_or_blank(card, 2, 'tid')
Type = string(card, 3, 'Type')
if Type not in ['NLELAST', 'PLASTIC']:
raise ValueError('MATS1 Type must be [NLELAST, PLASTIC]; Type=%r' % Type)
if Type == 'NLELAST':
# should we even read these?
h = None
hr = None
yf = None
limit1 = None
limit2 = None
#h = blank(card, 4, 'h')
#hr = blank(card, 6, 'hr')
#yf = blank(card, 5, 'yf')
#limit1 = blank(card, 7, 'yf')
#limit2 = blank(card, 8, 'yf')
else:
h = double_or_blank(card, 4, 'H')
yf = integer_or_blank(card, 5, 'yf', 1)
hr = integer_or_blank(card, 6, 'hr', 1)
limit1 = double(card, 7, 'limit1')
if yf in [3, 4]:
limit2 = double(card, 8, 'limit2')
else:
#limit2 = blank(card, 8, 'limit2')
limit2 = None
assert len(card) <= 9, 'len(MATS1 card) = %i\ncard=%s' % (len(card), card)
return MATS1(mid, tid, Type, h, hr, yf, limit1, limit2, comment=comment)
def __init__(self, card=None, data=None, comment=''):
ThermalElement.__init__(self, card)
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 add_card(cls, card, comment=''):
eid = integer(card, 1, 'eid')
pid = integer_or_blank(card, 2, 'pid', eid)
nids = [integer_or_blank(card, 3, 'n1', 0),
integer_or_blank(card, 4, 'n2', 0)]
assert len(card) <= 5, 'len(CVISC card) = %i\ncard=%s' % (len(card), card)
return CVISC(eid, pid, nids, comment=comment)
def __init__(self, card, comment=''):
ThermalElement.__init__(self, card)
if comment:
self._comment = comment
#: Surface element ID
self.eid = integer(card, 1, 'eid')
# no field 2
#: Surface type
self.Type = string(card, 3, 'Type')
assert self.Type in ['REV', 'AREA3', 'AREA4', 'AREA6', 'AREA8']
#: 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, 8, '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)
# no field 8
#: Grid point IDs of grids bounding the surface (Integer > 0)
self.nodes = []
n = 1
for i in range(9, len(card)):
grid = integer_or_blank(card, i, 'grid%i' % n)
if grid is not None:
self.nodes.append(grid)
assert len(self.nodes) > 0, 'card=%s' % card
def add_card(cls, card, comment=''):
eid = integer(card, 1, 'eid')
pid = integer(card, 2, 'pid')
nids = [integer_or_blank(card, 3, 'n1', 0),
integer_or_blank(card, 4, 'n2', 0)]
assert len(card) <= 5, 'len(CDAMP5 card) = %i' % len(card)
return CDAMP5(eid, pid, nids, comment=comment)
def add_card(cls, card, comment=''):
name = string(card, 1, 'name')
#zero
#: 4-Lower Triangular; 5=Upper Triangular; 6=Symmetric; 8=Identity (m=nRows, n=m)
ifo = integer(card, 3, 'ifo')
#: 1-Real, Single Precision; 2=Real,Double Precision;
# 3=Complex, Single; 4=Complex, Double
tin = integer(card, 4, 'tin')
#: 0-Set by cell precision
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.)
polar = integer_or_blank(card, 6, 'polar', 0)
if ifo == 1: # square
ncols = integer_or_blank(card, 8, 'ifo=%s; ncol' % (ifo))
elif ifo == 6: # symmetric
ncols = integer_or_blank(card, 8, 'ifo=%s; ncol' % (ifo))
elif ifo in [2, 9]: # rectangular
ncols = integer(card, 8, 'ifo=%s; ncol' % (ifo))
else:
# technically right, but nulling this will fix bad decks
#self.ncols = blank(card, 8, 'ifo=%s; ncol' % self.ifo)
raise NotImplementedError('ifo=%s is not supported' % ifo)
GCj = []
GCi = []
Real = []
Complex = []
return cls(name, ifo, tin, tout, polar, ncols,
GCj, GCi, Real, Complex, comment=comment)
def add_card(cls, card, comment=''):
eid = integer(card, 1, 'eid')
pid = integer_or_blank(card, 2, 'pid', eid)
s1 = integer_or_blank(card, 3, 's1')
s2 = integer_or_blank(card, 4, 's2')
assert len(card) <= 5, 'len(CMASS3 card) = %i' % len(card)
return CMASS3(eid, pid, s1, s2, comment=comment)
def build(self):
cards = self._cards
ncards = len(cards)
self.n = ncards
if ncards:
float_fmt = self.model.float_fmt
self.nid = zeros(ncards, 'int32')
self.temp = zeros(ncards, float_fmt)
for i, card in enumerate(cards):
#: Node ID
self.nid[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)
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\ncard=%s' % (len(card), card)
self.i += 1
def add_card(cls, card, comment=''):
pid = integer(card, 1, 'pid')
mid1 = integer_or_blank(card, 2, 'mid1')
t = double_or_blank(card, 3, 't')
mid2 = integer_or_blank(card, 4, 'mid2')
twelveIt3 = double_or_blank(card, 5, '12*I/t^3', 1.0) # poor name
mid3 = integer_or_blank(card, 6, 'mid3')
tst = double_or_blank(card, 7, 'ts/t', 0.833333)
nsm = double_or_blank(card, 8, 'nsm', 0.0)
if t is not None:
t_over_2 = t / 2.
z1 = double_or_blank(card, 9, 'z1', -t_over_2)
z2 = double_or_blank(card, 10, 'z2', t_over_2)
else:
z1 = double_or_blank(card, 9, 'z1')
z2 = double_or_blank(card, 10, 'z2')
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.mid1 is not None and self.mid2 is not None:
# assert self.mid4 == None
assert len(card) <= 12, 'len(PSHELL card) = %i' % len(card)
return PSHELL(pid, mid1, t, mid2, twelveIt3,
mid3, tst, nsm,
z1, z2, mid4, comment=comment)
def add_card(cls, card, comment=''):
eid = integer(card, 1, 'eid')
k = double(card, 2, 'k')
s1 = integer_or_blank(card, 3, 's1', 0)
s2 = integer_or_blank(card, 4, 's2', 0)
assert len(card) <= 5, 'len(CELAS4 card) = %i\ncard=%s' % (len(card), card)
return CELAS4(eid, k, s1, s2, comment=comment)
def add_card(self, card, comment=''):
pid = integer(card, 1, 'property_id')
if comment:
self.set_comment(pid, comment)
i = self.i
self.property_id[i] = pid
self.thickness[i] = double(card, 3, 'thickness')
self.twelveIt3[i] = double_or_blank(card, 5, '12*I/t^3', 1.0)
self.tst[i] = double_or_blank(card, 7, 'ts/t', 0.833333)
self.nsm[i] = double_or_blank(card, 8, 'nsm', 0.0)
t_over_2 = self.thickness[i] / 2.
self.z1[i] = double_or_blank(card, 9, 'z1', -t_over_2)
self.z2[i] = double_or_blank(card, 10, 'z2', t_over_2)
self.material_ids[i, :] = [
integer(card, 2, 'material_id'),
integer_or_blank(card, 4, 'material_id2', -1),
integer_or_blank(card, 6, 'material_id3', -1),
integer_or_blank(card, 11, 'material_id4', -1)
]
#self.model.log.debug(self.material_ids[i, :])
#ii = np.array([i])
#file_obj = StringIO()
#file_obj.write('<PSHELL object> n=%s\n' % self.n)
#self.write_card_by_index(file_obj, i=ii)
#print(file_obj.getvalue())
assert len(card) <= 12, 'len(PSHELL card) = %i\ncard=%s' % (len(card), card)
self.i += 1
def add_card(cls, card, comment=''):
eid = integer(card, 1, 'eid')
pid = integer_or_blank(card, 2, 'pid', eid)
ga = integer(card, 3, 'ga')
gb = integer(card, 4, 'gb')
gc = integer(card, 5, 'gc')
x, g0 = cls._init_x_g0(card, eid)
wa = np.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')
wb = np.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')
wc = np.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')
tw = np.array([double_or_blank(card, 18, 0., 'twa'),
double_or_blank(card, 19, 0., 'twb'),
double_or_blank(card, 20, 0., 'twc')], dtype='float64')
s = np.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\ncard=%s' % (len(card), card)
return CBEAM3(eid, pid, ga, gb, gc, x, g0,
wa, wb, wc, tw, s, comment='')
def add_card(cls, card, comment=''):
#: Property ID
pid = integer(card, 1, 'pid')
#: Material ID
mid1 = integer_or_blank(card, 2, 'mid1', 0)
t1 = double_or_blank(card, 3, 't1')
mid2 = integer_or_blank(card, 4, 'mid2', 0)
if mid2 > 0:
i = double(card, 5, 'i')
assert i > 0.0
else:
i = blank(card, 5, 'i')
mid3 = integer(card, 6, 0)
if mid3 > 0:
t2 = double(card, 7, 't3')
assert t2 > 0.0
else:
t2 = blank(card, 7, 't3')
nsm = double(card, 8, 'nsm')
z1 = double(card, 9, 'z1')
z2 = double(card, 10, 'z2')
j = 1
phi = []
for i in range(11, len(card)):
phii = double(card, i, 'phi' % j)
phi.append(phii)
j += 1
return PCONEAX(pid, mid1, t1, mid2, i, mid3, t2, nsm, z1, z2, phi,
comment=comment)
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 _read_shock(self, card, istart):
"""
F(u, v) = Cv * S(u) * sign(v) * |v|^ev
"""
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)
#def DEquation(self):
#if isinstance(self.dequation, int):
#return self.dequation
#return self.dequation.equation_id
else:
raise RuntimeError('Invalid shockType=%r on card\n%s' %(self.shockType, card))
istart += 8
return istart
def add_card(cls, card, comment=''):
sid = integer(card, 1, 'sid')
method = string_or_blank(card, 2, 'method', 'LAN')
f1 = double_or_blank(card, 3, 'f1')
f2 = double_or_blank(card, 4, 'f2')
ne = integer_or_blank(card, 5, 'ne')
if method not in cls.allowed_methods:
msg = 'method=%s; allowed_methods=[%s]' % (
method, ', '.join(cls.allowed_methods))
raise ValueError(msg)
if method == 'SINV':
nd = integer_or_blank(card, 6, 'nd', 600)
if method == 'INV':
nd = integer_or_blank(card, 6, 'nd', 3 * ne)
elif method in ['GIV', 'MGIV', 'HOU', 'MHOU']:
nd = integer_or_blank(card, 6, 'nd', 0)
else:
nd = integer(card, 6, 'nd')
norm = string_or_blank(card, 9, 'norm', 'MASS')
if method == 'POINT':
G = integer(card, 10, 'G')
C = components(card, 11, 'C')
else:
G = blank(card, 10, 'G')
C = blank(card, 11, 'C')
assert len(card) <= 12, 'len(EIGR card) = %i\ncard=%s' % (len(card), card)
return EIGR(sid, method, f1, f2, ne, nd, norm, G, C, comment=comment)
def add_card(self, card, comment=''):
i = self.i
self.element_id[i] = integer(card, 1, 'element_id')
self.property_id[i] = integer(card, 2, 'property_id')
print(card)
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.theta_mcid[i] = integer_double_or_blank(card, 15, 'theta_mcid', 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 add_card(cls, card, comment=''):
eid = integer(card, 1, 'eid')
pid = integer_or_blank(card, 2, 'pid', eid)
s1 = integer_or_blank(card, 3, 's1', 0)
s2 = integer_or_blank(card, 4, 's2', 0)
assert len(card) <= 5, 'len(CELAS3 card) = %i\ncard=%s' % (len(card), card)
return CELAS3(eid, pid, s1, s2, comment=comment)
def add_card(cls, card, comment=''):
eid = integer(card, 1, 'eid')
pid = integer_or_blank(card, 2, 'pid', eid)
nids = [integer(card, 3, 'g1'), integer_or_blank(card, 5, 'g2', 0)]
c1 = integer_or_blank(card, 4, 'c1', 0)
c2 = integer_or_blank(card, 6, 'c2', 0)
assert len(card) <= 7, 'len(CELAS1 card) = %i\ncard=%s' % (len(card), card)
return CELAS1(eid, pid, nids, c1, c2, comment=comment)
def add_card(cls, card, comment=''):
eid = integer(card, 1, 'eid')
pid = integer_or_blank(card, 2, 'pid', eid)
ga = integer(card, 3, 'ga')
gb = integer_or_blank(card, 4, 'gb')
cid = integer_or_blank(card, 5, 'cid')
assert len(card) <= 6, 'len(CBUSH1D card) = %i\ncard=%s' % (len(card), card)
return CBUSH1D(eid, pid, ga, gb, cid, comment=comment)
def add_card(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\ncard=%s" % (len(card), card)
self.i += 1
def add_card(cls, card, comment=''):
eid = integer(card, 1, 'eid')
pid = integer_or_blank(card, 2, 'pid', eid)
g1 = integer_or_blank(card, 3, 'g1')
c1 = integer_or_blank(card, 4, 'c1')
g2 = integer_or_blank(card, 5, 'g2')
c2 = integer_or_blank(card, 6, 'c2')
assert len(card) <= 7, 'len(CMASS1 card) = %i' % len(card)
return CMASS1(eid, pid, g1, c1, g2, c2, comment=comment)
def add_card(cls, card, comment=''):
eid = integer(card, 1, 'eid')
mass = double_or_blank(card, 2, 'mass', 0.)
g1 = integer_or_blank(card, 3, 'g1')
c1 = integer_or_blank(card, 4, 'c1')
g2 = integer_or_blank(card, 5, 'g2')
c2 = integer_or_blank(card, 6, 'c2')
assert len(card) <= 7, 'len(CMASS2 card) = %i' % len(card)
return CMASS2(eid, mass, g1, c1, g2, c2, comment=comment)
def add_card(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, integer_types):
self.is_g0[i] = True
self.g0[i] = field5
elif isinstance(field5, float):
self.is_g0[i] = False
# TODO: why is this custom?
x2_default = 0.0
x3_default = 0.0
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 (-1), then the element coordinate
#: system is determined from GO or Xi.
#: (default=blank=element-based)
cid = integer_or_blank(card, 8, 'cid', -1)
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\ncard=%s' % (len(card), 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')
option_values = [interpret_value(field) for field in card[9:]]
self.options = []
self.values = []
for option_value in option_values:
try:
(option, value) = option_value.split('=')
except AttributeError:
msg = 'parsing EIGRL card incorrectly; option_values=%s\ncard=%s' % (
option_values, card)
raise RuntimeError(msg)
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_card(cls, card, comment=''):
eid = integer(card, 1, 'eid')
b = double(card, 2, 'b')
nids = [integer_or_blank(card, 3, 'n1', 0),
integer_or_blank(card, 5, 'n2', 0)]
c1 = integer_or_blank(card, 4, 'c1', 0)
c2 = integer_or_blank(card, 6, 'c2', 0)
assert len(card) <= 7, 'len(CDAMP2 card) = %i\ncard=%s' % (len(card), card)
return CDAMP2(eid, b, nids, c1, c2, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a CDAMP2 card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
eid = integer(card, 1, 'eid')
b = double(card, 2, 'b')
nids = [
integer_or_blank(card, 3, 'n1', 0),
integer_or_blank(card, 5, 'n2', 0)
]
c1 = integer_or_blank(card, 4, 'c1', 0)
c2 = integer_or_blank(card, 6, 'c2', 0)
assert len(card) <= 7, 'len(CDAMP2 card) = %i\ncard=%s' % (len(card),
card)
return CDAMP2(eid, b, nids, c1, c2, comment=comment)
def add_card(cls, card, comment=''):
seid = integer(card, 1, 'seid')
psid = integer_or_blank(card, 2, 'psid', 0)
nodes = []
i = 1
nfields = len(card)
for ifield in range(3, nfields):
nid = integer_string_or_blank(card, ifield, 'nid_%i' % i)
if nid:
i += 1
nodes.append(nid)
assert len(card) >= 3, f'len(CSUPER card) = {len(card):d}\ncard={card}'
return CSUPER(seid, psid, nodes, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a CTRAX3 card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
eid = integer(card, 1, 'eid')
pid = integer(card, 2, 'pid')
nids = [
integer_or_blank(card, 3, 'n1'),
integer_or_blank(card, 4, 'n2'),
integer_or_blank(card, 5, 'n3'),
]
theta = integer_double_or_blank(card, 6, 'theta', 0.0)
assert len(card) <= 7, 'len(CTRAX3 card) = %i\ncard=%s' % (len(card), card)
return CTRAX3(eid, pid, nids, theta=theta, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a QVECT card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
sid = integer(card, 1, 'sid')
q0 = double(card, 2, 'q0')
t_source = double_or_blank(card, 3, 't_source')
ce = integer_or_blank(card, 4, 'ce', 0)
vector_tableds = [
integer_double_or_blank(card, 5, 'e1_tabled1', 0.0),
integer_double_or_blank(card, 6, 'e2_tabled2', 0.0),
integer_double_or_blank(card, 7, 'e3_tabled3', 0.0),
]
control_id = integer_or_blank(card, 8, 'control_id', 0)
i = 1
eids = []
for ifield in range(9, len(card)):
eid = integer_or_string(card, ifield, 'eid_%i' % i)
eids.append(eid)
assert eid != 0, card
i += 1
elements = expand_thru_by(eids)
return QVECT(sid,
q0,
elements,
t_source=t_source,
ce=ce,
vector_tableds=vector_tableds,
control_id=control_id,
comment=comment)
def _read_spring(card, istart):
"""
F(u) = Ft(u)
"""
spring_type = string_or_blank(card, istart + 1, 'springType')
spring_idt = integer(card, istart + 2, 'springIDT')
if spring_type == 'TABLE':
spring_idc = blank(card, istart + 3, 'springIDC')
spring_idtdu = blank(card, istart + 4, 'springIDTDU')
spring_idcdu = blank(card, istart + 5, 'springIDCDU')
elif spring_type == 'EQUAT':
spring_idc = integer_or_blank(card, istart + 3, 'springIDC',
spring_idt)
spring_idtdu = integer(card, istart + 4, 'springIDTDU')
spring_idcdu = integer_or_blank(card, istart + 5, 'springIDCDU',
spring_idtdu)
else:
msg = 'Invalid springType=%r on card\n%s' % (spring_type, card)
raise RuntimeError(msg)
return spring_type, spring_idt, spring_idc, spring_idtdu, spring_idcdu
def add_card(cls, card, comment=''):
seid_a = integer(card, 1, 'seid_a')
seid_b = integer(card, 2, 'seid_b')
tol = double_or_blank(card, 3, 'tol', 1e-5)
loc = string_or_blank(card, 4, 'loc', 'YES')
fields = card[9:]
if len(fields) < 2:
assert len(card) >= 9, f'len(SECONCT card) = {len(card):d}\ncard={card}'
assert len(fields) % 2 == 0, 'card=%s\nfields=%s' % (card, fields)
if 'THRU' in fields:
raise NotImplementedError(fields)
#start_a = integer(card, 9, 'start_a')
#thru_a = string(card, 10, 'thru_a')
#end_a = integer(card, 11, 'end_a')
#start_b = integer(card, 12, 'start_b')
#thru_b = string(card, 13, 'thru_b')
#end_b = integer(card, 14, 'end_b')
#assert thru_a == 'THRU', thru_a
#assert thru_b == 'THRU', thru_b
#nodes_a = list(range(start_a+1, end_a+1))
#nodes_b = list(range(start_b+1, end_b+1))
#print(nodes_a)
else:
nodes_a = []
nodes_b = []
inode = 1
for ifield in range(0, len(fields), 2):
node_a = integer_or_blank(card, 9+ifield, 'node_a%i' % inode)
node_b = integer_or_blank(card, 9+ifield+1, 'node_b%i' % inode)
if node_a is None and node_b is None:
continue
assert node_a is not None, fields
assert node_b is not None, fields
nodes_a.append(node_a)
nodes_b.append(node_b)
inode += 1
return SECONCT(seid_a, seid_b, tol, loc, nodes_a, nodes_b, comment=comment)
def __init__(self, card, data, comment):
"""
Defines the CORD2x class
:param card: a BDFCard object
:param data: a list analogous to the card
"""
self.is_resolved = False
Coord.__init__(self, card, data, comment)
if card:
#: coordinate system ID
self.cid = integer(card, 1, 'cid')
#: reference coordinate system ID
self.rid = integer_or_blank(card, 2, 'rid', 0)
#: origin in a point relative to the rid coordinate system
self.e1 = array([double_or_blank(card, 3, 'e1x', 0.0),
double_or_blank(card, 4, 'e1y', 0.0),
double_or_blank(card, 5, 'e1z', 0.0)],
dtype='float64')
#: z-axis in a point relative to the rid coordinate system
self.e2 = array([double_or_blank(card, 6, 'e2x', 0.0),
double_or_blank(card, 7, 'e2y', 0.0),
double_or_blank(card, 8, 'e2z', 0.0)],
dtype='float64')
#: a point on the xz-plane relative to the rid coordinate system
self.e3 = array([double_or_blank(card, 9, 'e3x', 0.0),
double_or_blank(card, 10, 'e3y', 0.0),
double_or_blank(card, 11, 'e3z', 0.0)],
dtype='float64')
else:
self.cid = data[0]
self.rid = data[1]
self.e1 = array(data[2:5], dtype='float64')
self.e2 = array(data[5:8], dtype='float64')
self.e3 = array(data[8:11], dtype='float64')
assert len(data) == 11, 'data = %s' % (data)
assert len(self.e1) == 3, self.e1
assert len(self.e2) == 3, self.e2
assert len(self.e3) == 3, self.e3
#: the global axes
self.i = None
self.j = None
self.k = None
if self.rid == 0:
self.is_resolved = True
self.setup()
def add_card(self, card, comment=''):
i = self.i
if comment:
self.set_comment(mid, comment)
self.material_id[i] = integer(card, 1, 'material_id')
self.model.log.debug('add MATHP.material_id = %s' % self.material_id)
a10 = double_or_blank(card, 2, 'a10', 0.)
a01 = double_or_blank(card, 3, 'a01', 0.)
self.a10[i] = a10
self.a01[i] = a01
self.d1[i] = double_or_blank(card, 4, 'd1', (a10 + a01) * 1000)
self.rho[i] = double_or_blank(card, 5, 'rho', 0.)
self.av[i] = double_or_blank(card, 6, 'av', 0.)
self.tref[i] = double_or_blank(card, 7, 'tref', 0.)
self.ge[i] = double_or_blank(card, 8, 'ge', 0.)
self.na[i] = integer_or_blank(card, 10, 'na', 1)
self.nd[i] = integer_or_blank(card, 11, 'nd', 1)
self.a20[i] = double_or_blank(card, 17, 'a20', 0.)
self.a11[i] = double_or_blank(card, 18, 'a11', 0.)
self.a02[i] = double_or_blank(card, 19, 'a02', 0.)
self.d2[i] = double_or_blank(card, 20, 'd2', 0.)
self.a30[i] = double_or_blank(card, 25, 'a30', 0.)
self.a21[i] = double_or_blank(card, 26, 'a21', 0.)
self.a12[i] = double_or_blank(card, 27, 'a12', 0.)
self.a03[i] = double_or_blank(card, 28, 'a03', 0.)
self.d3[i] = double_or_blank(card, 29, 'd3', 0.)
self.a40[i] = double_or_blank(card, 33, 'a40', 0.)
self.a31[i] = double_or_blank(card, 34, 'a31', 0.)
self.a22[i] = double_or_blank(card, 35, 'a22', 0.)
self.a13[i] = double_or_blank(card, 36, 'a13', 0.)
self.a04[i] = double_or_blank(card, 37, 'a04', 0.)
self.d4[i] = double_or_blank(card, 38, 'd4', 0.)
self.a50[i] = double_or_blank(card, 41, 'a50', 0.)
self.a41[i] = double_or_blank(card, 42, 'a41', 0.)
self.a32[i] = double_or_blank(card, 43, 'a32', 0.)
self.a23[i] = double_or_blank(card, 44, 'a23', 0.)
self.a14[i] = double_or_blank(card, 45, 'a14', 0.)
self.a05[i] = double_or_blank(card, 46, 'a05', 0.)
self.d5[i] = double_or_blank(card, 47, 'd5', 0.)
self.tab1[i] = integer_or_blank(card, 49, 'tab1', 0)
self.tab2[i] = integer_or_blank(card, 50, 'tab2', 0)
self.tab3[i] = integer_or_blank(card, 51, 'tab3', 0)
self.tab4[i] = integer_or_blank(card, 52, 'tab4', 0)
self.tabd[i] = integer_or_blank(card, 56, 'tabd', 0)
assert len(card) <= 57, 'len(MATHP card) = %i\ncard=%s' % (len(card),
card)
self.i += 1
def add_card(cls, card, comment=''):
"""
Adds a CFAST card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
eid = integer(card, 1, 'eid')
pid = integer_or_blank(card, 2, 'pid', eid)
Type = string(card, 3, 'Type')
ida = integer(card, 4, 'ida')
idb = integer(card, 5, 'idb')
gs = integer_or_blank(card, 6, 'gs')
ga = integer_or_blank(card, 7, 'ga')
gb = integer_or_blank(card, 8, 'gb')
xs = double_or_blank(card, 9, 'xs')
ys = double_or_blank(card, 10, 'ys')
zs = double_or_blank(card, 11, 'zs')
assert len(card) <= 12, 'len(CFAST card) = %i\ncard=%s' % (len(card),
card)
#if self.Type=='PROP': # PSHELL/PCOMP ida & idb
return CFAST(eid,
pid,
Type,
ida,
idb,
gs=gs,
ga=ga,
gb=gb,
xs=xs,
ys=ys,
zs=zs,
comment=comment)
def _load_hess_inv(nrows, method, card):
"""loads inverse power"""
alpha_omega_default = None
LJ_default = None
if method == 'INV':
alpha_omega_default = 0.0
LJ_default = 1.0
alphaAjs = []
alphaBjs = []
omegaAjs = []
omegaBjs = []
#mblkszs = []
#iblkszs = []
#ksteps = []
LJs = []
NEJs = []
NDJs = []
for irow in range(nrows):
NEj = integer_or_blank(card, 9 + 7 * irow + 5, 'NE%s' % str(irow), 0)
NDJ_default = None
if method == 'INV':
NDJ_default = 3 * NEj
i = 9 + 8 * irow
alphaAjs.append(
double_or_blank(card, i, 'alphaA' + str(irow), alpha_omega_default))
omegaAjs.append(
double_or_blank(card, i + 1, 'omegaA' + str(irow), alpha_omega_default))
alphaBjs.append(
double_or_blank(card, i + 2, 'alphaB' + str(irow), alpha_omega_default))
omegaBjs.append(
double_or_blank(card, i + 3, 'omegaB' + str(irow), alpha_omega_default))
LJs.append(
double_or_blank(card, i + 4, 'LJ' + str(irow), LJ_default))
NEJs.append(NEj)
NDJs.append(integer_or_blank(card, i + 6, 'NDJ' + str(irow), NDJ_default))
return alphaAjs, omegaAjs, alphaBjs, omegaBjs, LJs, NEJs, NDJs
def add_card(cls, card, comment=''):
"""
Adds a SESET card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
seid = integer_or_blank(card, 1, 'seid', 0)
ids = fields(integer_or_string, card, 'ID', i=2, j=len(card))
return SESET(seid, ids, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a CDAMP1 card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
eid = integer(card, 1, 'eid')
pid = integer_or_blank(card, 2, 'pid', eid)
nids = [
integer_or_blank(card, 3, 'g1', 0),
integer_or_blank(card, 5, 'g2', 0)
]
#: component number
c1 = integer_or_blank(card, 4, 'c1', 0)
c2 = integer_or_blank(card, 6, 'c2', 0)
assert len(card) <= 7, f'len(CDAMP1 card) = {len(card):d}\ncard={card}'
return CDAMP1(eid, pid, nids, c1, c2, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a DMIG,UACCEL card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
tin = integer(card, 4, 'tin')
ncol = integer_or_blank(card, 8, 'ncol')
return DMIG_UACCEL(tin, ncol, load_sequences={}, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a LSEQ card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
sid = integer(card, 1, 'sid')
excite_id = integer(card, 2, 'excite_id')
load_id = integer_or_blank(card, 3, 'lid')
temp_id = integer_or_blank(card, 4, 'tid')
if load_id is None and temp_id is None:
msg = 'LSEQ load_id/temp_id must not be None; load_id=%s temp_id=%s' % (
load_id, temp_id)
raise RuntimeError(msg)
assert len(card) <= 5, 'len(LSEQ card) = %i\ncard=%s' % (len(card),
card)
return LSEQ(sid, excite_id, load_id, tid=temp_id, comment=comment)
def add_card(cls, card, comment=''):
"""
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str
a comment for the card
"""
#: Grid point coordinate system
blank(card, 1, 'blank')
cp = integer_or_blank(card, 2, 'cp', 0)
blank(card, 3, 'blank')
blank(card, 4, 'blank')
blank(card, 5, 'blank')
cd = integer_or_blank(card, 6, 'cd', 0)
ps = str(integer_or_blank(card, 7, 'ps', ''))
seid = integer_or_blank(card, 8, 'seid', 0)
assert len(card) <= 9, 'len(GRDSET card) = %i\ncard=%s' % (len(card),
card)
return GRDSET(cp, cd, ps, seid, comment=comment)
def add_card(self, card, comment=''):
self.model.log.debug(' adding CTUBE')
i = self.i
eid = integer(card, 1, 'element_id')
#if comment:
#self.set_comment(eid, comment)
self.element_id[i] = integer(card, 1, 'element_id')
self.property_id[i] = integer_or_blank(card, 2, 'property_id',
self.element_id[i])
self.node_ids[i] = [integer(card, 3, 'n1'), integer(card, 4, 'n2')]
assert len(card) == 5, 'len(CTUBE card) = %i\ncard=%s' % (len(card),
card)
self.i += 1
def add_card(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.theta_mcid[i] = integer_double_or_blank(card, 9, 'theta_mcid', 0.0)
self.zoffset[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\ncard=%s' % (len(card), card)
self.i += 1
def _load_clan(nrows, card):
"""loads complex Lanczos"""
alphaAjs = []
omegaAjs = []
mblkszs = []
iblkszs = []
ksteps = []
NJIs = []
for irow in range(nrows):
#NDJ_default = None
i = 9 + 8 * irow
alphaAjs.append(double_or_blank(card, i, 'alpha' + str(irow), 0.0))
omegaAjs.append(
double_or_blank(card, i + 1, 'omega' + str(irow), 0.0))
mblkszs.append(
double_or_blank(card, i + 2, 'mblock' + str(irow), 7))
iblkszs.append(
integer_or_blank(card, i + 3, 'iblksz' + str(irow), 2))
ksteps.append(integer_or_blank(card, i + 4, 'kstep' + str(irow),
5))
NJIs.append(integer(card, i + 6, 'NJI' + str(irow)))
return alphaAjs, omegaAjs, mblkszs, iblkszs, ksteps, NJIs
def add_card(cls, card, comment=''):
sid = integer(card, 1, 'sid')
qvol = double(card, 2, 'qvol')
control_point = integer_or_blank(card, 3, 'control_id', 0)
i = 1
eids = []
for ifield in range(4, len(card)):
eid = integer_or_string(card, ifield, 'eid_%i' % i)
eids.append(eid)
i += 1
elements = expand_thru_by(eids)
return QVOL(sid, qvol, control_point, elements, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a CELAS2 card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
eid = integer(card, 1, 'eid')
k = double(card, 2, 'k')
nids = [
integer_or_blank(card, 3, 'g1', 0),
integer_or_blank(card, 5, 'g2', 0)
]
c1 = integer_or_blank(card, 4, 'c1', 0)
c2 = integer_or_blank(card, 6, 'c2', 0)
ge = double_or_blank(card, 7, 'ge', 0.)
s = double_or_blank(card, 8, 's', 0.)
assert len(card) <= 9, f'len(CELAS2 card) = {len(card):d}\ncard={card}'
return CELAS2(eid, k, nids, c1, c2, ge, s, comment=comment)
def add_card(self, card, nPDAMP=0, comment=''):
self.n = 1
#if comment:
# self.comment = comment
noffset = nPDAMP * 5
# 2 PDAMP properties can be defined on 1 PDAMP card
# these are split into 2 separate cards
pid = integer_or_blank(card, 1 + noffset, 'pid')
if pid is not None:
self._property_id.append(pid)
self._B.append(double(card, 2 + noffset, 'b'))
self._ge.append(double_or_blank(card, 3 + noffset, 'ge', 0.))
self._s.append(double_or_blank(card, 4 + noffset, 's', 0.))
def add_card(cls, card, comment=''):
"""
Adds a RFORCE1 card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
sid = integer(card, 1, 'sid')
nid = integer_or_blank(card, 2, 'nid', 0)
cid = integer_or_blank(card, 3, 'cid', 0)
scale = double_or_blank(card, 4, 'scale', 1.)
r123 = [
double_or_blank(card, 5, 'r1', 1.),
double_or_blank(card, 6, 'r2', 0.),
double_or_blank(card, 7, 'r3', 0.),
]
method = integer_or_blank(card, 8, 'method', 1)
racc = double_or_blank(card, 9, 'racc', 0.)
mb = integer_or_blank(card, 10, 'mb', 0)
group_id = integer_or_blank(card, 11, 'group_id', 0)
assert len(card) <= 12, 'len(RFORCE1 card) = %i\ncard=%s' % (len(card),
card)
return RFORCE1(sid,
nid,
scale,
cid=cid,
r123=r123,
racc=racc,
mb=mb,
group_id=group_id,
method=method,
comment=comment)
def add_card(cls, card, comment=''):
eid = integer(card, 1, 'eid')
pconid = integer(card, 2, 'pconid')
film_node = integer_or_blank(card, 3, 'film_node', 0)
cntrlnd = integer_or_blank(card, 4, 'cntrlnd', 0)
ta1 = integer(card, 5, 'TA1')
assert ta1 > 0, ta1
ta2 = integer_or_blank(card, 6, 'ta2', ta1)
ta3 = integer_or_blank(card, 7, 'ta3', ta1)
ta4 = integer_or_blank(card, 8, 'ta4', ta1)
ta5 = integer_or_blank(card, 9, 'ta5', ta1)
ta6 = integer_or_blank(card, 10, 'ta6', ta1)
ta7 = integer_or_blank(card, 11, 'ta7', ta1)
ta8 = integer_or_blank(card, 12, 'ta8', ta1)
ta = [ta1, ta2, ta3, ta4, ta5, ta6, ta7, ta8]
assert len(card) <= 13, 'len(CONV card) = %i\ncard=%s' % (len(card),
card)
return CONV(eid, pconid, film_node, cntrlnd, ta, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a PDAMPT card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
pid = integer(card, 1, 'pid')
tbid = integer_or_blank(card, 2, 'tbid', 0)
assert len(card) <= 3, 'len(PDAMPT card) = %i\ncard=%s' % (len(card), card)
return PDAMPT(pid, tbid, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a RFORCE card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
sid = integer(card, 1, 'sid')
nid = integer_or_blank(card, 2, 'nid', 0)
cid = integer_or_blank(card, 3, 'cid', 0)
scale = double_or_blank(card, 4, 'scale', 1.)
r1 = double_or_blank(card, 5, 'r1', 0.)
r2 = double_or_blank(card, 6, 'r2', 0.)
r3 = double_or_blank(card, 7, 'r3', 0.)
method = integer_or_blank(card, 8, 'method', 1)
racc = double_or_blank(card, 9, 'racc', 0.)
mb = integer_or_blank(card, 10, 'mb', 0)
idrf = integer_or_blank(card, 11, 'idrf', 0)
assert len(card) <= 12, 'len(RFORCE card) = %i\ncard=%s' % (len(card),
card)
return RFORCE(sid,
nid,
cid,
scale,
r1,
r2,
r3,
method,
racc,
mb,
idrf,
comment=comment)
def add_card(self, card, comment):
i = self.i
self.load_id[i] = integer(card, 1, 'sid')
self.node_id[i] = integer(card, 2, 'node')
self.coord_id[i] = integer_or_blank(card, 3, 'cid', 0)
self.mag[i] = double(card, 4, 'mag')
xyz = [
double_or_blank(card, 5, 'X1', 0.0),
double_or_blank(card, 6, 'X2', 0.0),
double_or_blank(card, 7, 'X3', 0.0)
]
self.xyz[i] = xyz
assert len(card) <= 8, 'len(FORCE card) = %i\ncard=%s' % (len(card),
card)
self.i += 1
def add_card(cls, card, comment=''):
"""
Adds a VIEW card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
iview = integer(card, 1, 'iview')
icavity = integer(card, 2, 'icavity')
shade = string_or_blank(card, 3, 'shade', default='BOTH')
nbeta = integer_or_blank(card, 4, 'nbeta', default=1)
ngamma = integer_or_blank(card, 5, 'ngamma', default=1)
dislin = double_or_blank(card, 6, 'dislin', default=0.0)
return VIEW(iview,
icavity,
shade=shade,
nbeta=nbeta,
ngamma=ngamma,
dislin=dislin,
comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a TABLES1 card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
table_id = integer(card, 1, 'tid')
Type = integer_or_blank(card, 2, 'Type', 1)
x, y = read_table(card, table_id, 'TABLES1')
return TABLES1(table_id, x, y, Type=Type, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a RADLST card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
icavity = integer(card, 1, 'icavity')
matrix_type = integer_or_blank(card, 2, 'matrix_type', 1)
eids = fields(integer, card, 'eid', i=3, j=card.nfields)
return RADLST(icavity, eids, matrix_type=matrix_type, comment=comment)
def get_spc_constraint(card, i):
"""parses an SPC/SPCD card"""
if i == 0:
constraint_id = integer(card, 1, 'sid')
node_id = integer(card, 2, 'G1')
dofs = components_or_blank(card, 3, 'C1', 0)
enforced_motion = double_or_blank(card, 4, 'D1', 0.0)
elif i == 1:
constraint_id = integer(card, 1, 'sid')
node_id = integer_or_blank(card, 5, 'G2')
dofs = components_or_blank(card, 6, 'C2', 0)
enforced_motion = double_or_blank(card, 7, 'D2', 0.0)
else:
raise RuntimeError('i =', i)
return constraint_id, node_id, dofs, enforced_motion
