def add_card(cls, card, comment=''):
sid = integer(card, 1, 'sid')
f1 = double(card, 2, 'f1') # default=0.0 ?
f2 = double(card, 3, 'f2')
ndf = integer_or_blank(card, 4, 'nf', 1)
assert len(card) <= 5, 'len(FREQ2 card) = %i\ncard=%s' % (len(card), card)
return FREQ2(sid, f1, f2, ndf, comment=comment)
def __init__(self, card=None, data=None, comment=''):
Table.__init__(self, card, data)
if comment:
self._comment = comment
if card:
self.tid = integer(card, 1, 'tid')
self.x1 = double(card, 2, 'x1')
self.x2 = double(card, 3, 'x2')
assert self.x2 != 0.0
nfields = len(card) - 1
nterms = (nfields - 9) // 2
if nterms < 0:
raise SyntaxError('%r card is too short' % self.type)
xy = []
for i in range(nterms):
n = 9 + i * 2
if card.field(n) == 'ENDT':
break
x = double_or_string(card, n, 'x' + str(i + 1))
y = double_or_string(card, n + 1, 'y' + str(i + 1))
if x == 'SKIP' or y == 'SKIP':
continue
xy += [x, y]
string(card, nfields, 'ENDT')
is_data = False
else:
self.tid = data[0]
self.x1 = data[1]
self.x2 = data[2]
xy = data[3:]
is_data = True
self.parse_fields(xy, nrepeated=2, is_data=is_data)
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 add_card(self, card, comment=''):
assert self.n > 0, self.n
i = self.i
load_id = integer(card, 1, 'load_id')
tbar = double(card, 3, 'Tbar')
tprime = double(card, 4, 'Tprime')
t1 = double_or_blank(card, 5, 'T1')
t2 = double_or_blank(card, 6, 'T2')
self.load_id[i] = load_id
self.element_id[i] = integer(card, 2, 'element_id')
self.tbar[i] = tbar
self.tprime[i] = tprime
self.temp[i, 0] = t1
self.temp[i, 1] = t2
self.i += 1
if len(card) >= 7:
# i must be < self.n
eids = expand_thru(card[9:])
for eid in eids:
self.load_id[i] = load_id
assert isinstance(eid, int), eid
self.element_id[i] = eid
self.tbar[i] = tbar
self.tprime[i] = tprime
self.temp[i, 0] = t1
self.temp[i, 1] = t2
self.i += 1
assert self.i <= self.n
assert len(card) <= 7, '%s; n=%s' % (card, len(card))
#assert len(card) <= 7, len(card)
self.eids = None
def add_card(self, card, comment=''):
i = self.i
mid = integer(card, 1, 'mid')
if comment:
self.set_comment(mid, comment)
self.material_id[i] = mid
self.e11[i] = double(card, 2, 'E11') #: .. todo:: is this the correct default
self.e22[i] = double(card, 3, 'E22') #: .. todo:: is this the correct default
self.nu12[i] = double_or_blank(card, 4, 'nu12', 0.0)
self.g12[i] = double_or_blank(card, 5, 'g12', 0.0)
self.g1z[i] = double_or_blank(card, 6, 'g1z', 1e8)
self.g2z[i] = double_or_blank(card, 7, 'g2z', 1e8)
self.rho[i] = double_or_blank(card, 8, 'rho', 0.0)
self.a1[i] = double_or_blank(card, 9, 'a1', 0.0)
self.a2[i] = double_or_blank(card, 10, 'a2', 0.0)
self.TRef[i] = double_or_blank(card, 11, 'TRef', 0.0)
self.Xt[i] = double_or_blank(card, 12, 'Xt', 0.0)
self.Xc[i] = double_or_blank(card, 13, 'Xc', self.Xt[i])
self.Yt[i] = double_or_blank(card, 14, 'Yt', 0.0)
self.Yc[i] = double_or_blank(card, 15, 'Yc', self.Yt[i])
self.S[i] = double_or_blank(card, 16, 'S', 0.0)
self.ge[i] = double_or_blank(card, 17, 'ge', 0.0)
self.F12[i] = double_or_blank(card, 18, 'F12', 0.0)
self.strn[i] = double_or_blank(card, 19, 'strn', 0.0)
assert len(card) <= 20, 'len(MAT8 card) = %i\ncard=%s' % (len(card), card)
self.i += 1
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')
#: Coordinates of point in complex plane. (Real)
self.alpha1 = double(card, 2, 'alpha1')
#: Coordinates of point in complex plane. (Real)
self.omega1 = double(card, 3, 'omega1')
#: Multiplicity of complex root at pole defined by point at ALPHAi
#: and OMEGAi
self.m1 = integer(card, 4, 'm1')
#: Coordinates of point in complex plane. (Real)
self.alpha2 = double(card, 5, 'alpha2')
#: Coordinates of point in complex plane. (Real)
self.omega2 = double(card, 6, 'omega2')
#: Multiplicity of complex root at pole defined by point at ALPHAi
#: and OMEGAi
self.m2 = integer(card, 7, 'm2')
assert len(card) == 8, 'len(EIGP card) = %i' % len(card)
else:
raise NotImplementedError('EIGP')
def add_card(cls, card, comment=''):
sid = integer(card, 1, 'sid')
excite_id = integer(card, 2, 'excite_id') # DAREA, FBALOAD, SLOAD
delay = integer_double_or_blank(card, 3, 'delay', 0) # DELAY, FBADLAY
dphase = integer_double_or_blank(card, 4, 'dphase', 0) # DPHASE, FBAPHAS
power = integer_double_or_blank(card, 5, 'power/tp/rp', 0) # TABLEDi/power
rho = double(card, 6, 'rho')
b = double(card, 7, 'bulk modulus')
assert len(card) <= 8, 'len(ACSRCE card) = %i\n%s' % (len(card), card)
return ACSRCE(sid, excite_id, delay, dphase, power, rho, b, comment=comment)
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\ncard=%s' % (len(card), card)
self.i += 1
def add_card(cls, card, comment=''):
sid = integer(card, 1, 'sid')
alpha1 = double(card, 2, 'alpha1')
omega1 = double(card, 3, 'omega1')
m1 = integer(card, 4, 'm1')
alpha2 = double(card, 5, 'alpha2')
omega2 = double(card, 6, 'omega2')
m2 = integer(card, 7, 'm2')
assert len(card) == 8, 'len(EIGP card) = %i\ncard=%s' % (len(card), card)
return EIGP(sid, alpha1, omega1, m1, alpha2, omega2, m2, comment=comment)
def __init__(self, card=None, data=None, comment=''):
if comment:
self._comment = comment
self.sid = integer(card, 1, 'sid')
f1 = double(card, 2, 'f1') # default=0.0 ?
f2 = double(card, 3, 'f2')
nf = integer_or_blank(card, 4, 'nf', 1)
assert len(card) <= 5, 'len(FREQ2 card) = %i' % len(card)
d = 1. / nf * log(f2 / f1)
self.freqs = []
for i in range(nf):
self.freqs.append(f1 * exp(i * d)) # 0 based index
self.clean_freqs()
def add_card(cls, card, comment=''):
sid = integer(card, 1, 'sid')
scale = double(card, 2, 'scale')
scale_factors = []
load_ids = []
# alternating of scale factor & load set ID
nloads = len(card) - 3
assert nloads % 2 == 0
for i in range(nloads // 2):
n = 2 * i + 3
scale_factors.append(double(card, n, 'scale_factor'))
load_ids.append(integer(card, n + 1, 'load_id'))
return cls(sid, scale, scale_factors, load_ids, comment=comment)
def __init__(self, card=None, data=None, comment=''):
ThermalBC.__init__(self, card, data)
if comment:
self._comment = comment
if card:
#: NODAMB Ambient point for radiation exchange. (Integer > 0)
self.nodamb = integer(card, 1, 'nodamb')
assert self.nodamb > 0
#: Radiation view factor between the face and the ambient point.
#: (Real > 0.0)
self.famb = double(card, 2, 'famb')
assert self.famb > 0.0
#: Control point for thermal flux load. (Integer > 0; Default = 0)
self.cntrlnd = integer_or_blank(card, 3, 'cntrlnd', 0)
assert self.cntrlnd >= 0
nfields = card.nfields
eids = fields(integer_or_string, card, 'eid', i=4, j=nfields)
#: CHBDYi element identification number
self.eids = expand_thru_by(eids)
else:
raise NotImplementedError(data)
min_eid = min(self.eids)
if min_eid < 1:
msg = 'min(eids)=%i' % min_eid
raise ValueError(msg)
def build(self):
"""
:param cards: the list of MOMENT cards
"""
cards = self._cards
ncards = len(cards)
self.n = ncards
if ncards:
float_fmt = self.model.float
#: Property ID
self.load_id = zeros(ncards, 'int32')
self.node_id = zeros(ncards, 'int32')
self.coord_id = zeros(ncards, 'int32')
self.mag = zeros(ncards, float_fmt)
self.xyz = zeros((ncards, 3), float_fmt)
for i, card in enumerate(cards):
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(MOMENT card) = %i\ncard=%s' % (len(card), card)
i = self.load_id.argsort()
self.load_id = self.load_id[i]
self.node_id = self.node_id[i]
self.coord_id = self.coord_id[i]
self.mag = self.mag[i]
self.xyz = self.xyz[i]
self._cards = []
self._comments = []
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(cls, card, icard=0, comment=''):
nfields = len(card) - 1
assert nfields % 2 == 0, 'card=%s' % card
i = 2 * icard
sid = integer(card, i + 1, 'sid')
temperature = double(card, i + 2, 'temp')
return TEMPD(sid, temperature, comment=comment)
def add_card(cls, card, icard=0, comment=''):
noffset = icard * 5
pid = integer(card, 1 + noffset, 'pid')
k = double(card, 2 + noffset, 'k')
ge = double_or_blank(card, 3 + noffset, 'ge', 0.)
s = double_or_blank(card, 4 + noffset, 's', 0.)
return PELAS(pid, k, ge, s, comment=comment)
def add_card(cls, card, comment=''):
conid = integer(card, 1, 'conid')
gids = []
constraints = []
enforced = []
fields = card.fields(0)
nfields = len(fields)
i = 1
for ifield in range(2, nfields, 8):
grid = integer(card, ifield, 'G%i' % i)
component = components_or_blank(card, ifield + 1, 'constraint%i' % i, 0) # scalar point
if i == 1:
enforcedi = double(card, ifield + 2, 'enforced%i' % i)
if enforcedi == 0.0:
raise RuntimeError('enforced1 must be nonzero; enforcedi=%r' % enforcedi)
else:
enforcedi = double_or_blank(card, ifield + 2, 'enforced%i' % i, 0.0)
gids.append(grid)
constraints.append(component)
enforced.append(enforcedi)
i += 1
if ifield + 4 > nfields and i != 2:
# if G2 is empty (it's ifield+4 because nfields is length based and not loop friendly)
break
grid = integer(card, ifield + 3, 'G%i' % i)
component = components_or_blank(card, ifield + 4, 'constraint%i' % i, 0) # scalar point
enforcedi = double_or_blank(card, ifield + 5, 'enforced%i' % i)
gids.append(grid)
constraints.append(component)
enforced.append(enforcedi)
i += 1
return MPC(conid, gids, constraints, enforced, 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, icard=0, comment=''):
noffset = 3 * icard
sid = integer(card, 1, 'sid')
p = integer(card, 2 + noffset, 'p')
c = components_or_blank(card, 3 + noffset, 'c', 0)
scale = double(card, 4 + noffset, 'scale')
return DAREA(sid, p, c, scale, comment=comment)
def __init__(self, card, comment=''):
self.pid = integer(card, 1, 'property_id')
self.sets = []
self.Types = []
self.gammas = []
self._cps = []
#self.set = integer(card, 2, 'set_id')
#self.Type = string(card, 3, 'Type')
#if self.Type not in ['NEWTON','PRANDTL-MEYER', 'CP']:
# raise RuntimeError('Type=%r' % Type)
#self.gamma = double_or_blank(card, 4, 'gamma', 1.4)
i = 2
while i < len(card):
self.sets.append(integer(card, i, 'set_id'))
Type = string(card, i+1, 'Type')
self.Types.append(Type)
#if self.Type not in ['NEWTON','PRANDTL-MEYER', 'CP']:
#raise RuntimeError('Type=%r' % Type)
self.gammas.append(double_or_blank(card, i+2, 'gamma', 1.4))
_cp = None
if Type == 'CP':
_cp = double(card, i+3, 'Cp')
elif Type == 'NEWTON':
_cp = double_or_blank(card, i+3, 'Cp_nominal', 2.0)
self._cps.append(_cp)
i += 7
def add_tempd(self, card, comment):
assert (len(card) - 1) % 2 == 0, card
for i in range(1, len(card), 2):
temp_id = integer(card, i, 'temp_id')
temperature = double(card, i+1, 'temperature')
self._objs[temp_id].add_default(temp_id, temperature, comment)
self.model.log.debug('TEMPs keys=%s' % self._objs.keys())
def add_card(cls, card, comment=''):
conid = integer(card, 1, 'conid')
rid = integer(card, 2, 'rid')
hid = integer(card, 3, 'hid')
c = components(card, 4, 'c')
d = double(card, 5, 'd')
return SPCAX(conid, rid, hid, c, d, comment=comment)
def add_card(cls, card, icard=0, comment=''):
noffset = 2 * icard
sid = integer(card, 1, 'sid')
Type = string(card, 2, 'Type')
id = integer(card, 3 + noffset, 'id')
value = double(card, 4 + noffset, 'value')
return NSM(sid, Type, id, value, comment=comment)
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')
f1 = double_or_blank(card, 2, 'f1', 0.0)
df = double(card, 3, 'df')
ndf = integer_or_blank(card, 4, 'ndf', 1)
assert len(card) <= 5, 'len(FREQ card) = %i\ncard=%s' % (len(card), card)
return FREQ1(sid, f1, df, ndf, 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.mag[i] = double(card, 4, 'mag')
n1234 = [
integer(card, 4, 'g1'),
integer(card, 5, 'g2'),
integer(card, 6, 'g3'),
integer(card, 7, 'g4'),
]
self.grids = n1234
#self.xyz[i] = xyz
mag = double(card, 3, 'mag')
assert len(card) <= 8, 'len(MOMENT2 card) = %i\ncard=%s' % (len(card), card)
self.i += 1
def parse(self, card, icard=0, comment=''):
noffset = 3 * icard
sid = integer(card, 1, 'sid')
node = integer(card, 2 + noffset, 'node_p')
component = int(components_or_blank(card, 3 + noffset, 'c', 0))
scale = double(card, 4 + noffset, 'scale')
data = (sid, node, component, scale)
return data, comment
def check_double(self, method):
# float
method(BDFCard([3.0]), 0, 'field')
method(BDFCard(['4.0']), 0, 'field')
method(BDFCard(['5.']), 0, 'field')
self.assertEqual(1.0, double(BDFCard([1.]), 0, 'field'))
self.assertEqual(1.0, double(BDFCard(['1.']), 0, 'field'))
self.assertEqual(-9.31e-4, double(BDFCard(['-9.31-4']), 0, 'field'))
# float
val = method(BDFCard([1.]), 0, 'field')
self.assertEqual(1., val)
val = method(BDFCard(['1.']), 0, 'field')
self.assertEqual(1., val)
val = method(BDFCard(['1-3']), 0, 'field')
self.assertEqual(1.e-3, val)
def add_card(cls, card, comment=''):
sid = integer(card, 1, 'sid')
Q0 = double(card, 2, 'Q0')
cntrlnd = integer_or_blank(card, 3, 'cntrlnd', 0)
nfields = card.nfields
eids = fields(integer_or_string, card, 'eid', i=4, j=nfields)
return QBDY3(sid, Q0, cntrlnd, eids, comment=comment)
def add_card(self, card, comment=""):
#: Trim set identification number. (Integer > 0)
self.trim_id = integer(card, 1, "trim_id")
#: Mach number. (Real > 0.0 and != 1.0)
self.mach = double(card, 2, "mach")
assert self.mach >= 0.0, "mach = %r" % self.mach
assert self.mach != 1.0, "mach = %r" % self.mach
#: Dynamic pressure. (Real > 0.0)
self.q = double(card, 3, "q")
assert self.q > 0.0, "q=%s" % self.q
#: The label identifying aerodynamic trim variables defined on an
#: AESTAT or AESURF entry.
self.labels = []
#: The magnitude of the aerodynamic extra point degree-of-freedom.
#: (Real)
self.uxs = []
label = string_or_blank(card, 4, "label1")
if label:
ux = double(card, 5, "ux1")
self.uxs.append(ux)
self.labels.append(label)
label = string_or_blank(card, 6, "label2")
if label:
ux = double(card, 7, "ux1")
self.uxs.append(ux)
self.labels.append(label)
#: Flag to request a rigid trim analysis (Real > 0.0 and < 1.0;
#: Default = 1.0. A value of 0.0 provides a rigid trim analysis,
#: not supported
self.aeqr = double_or_blank(card, 8, "aeqr", 1.0)
i = 9
n = 3
while i < len(card):
label = string(card, i, "label%i" % n)
ux = double(card, i + 1, "ux%i" % n)
self.labels.append(label)
self.uxs.append(ux)
i += 2
def add_card(cls, card, comment=''):
"""
Adds a PDAMP5 card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
pid = integer(card, 1, 'pid')
mid = integer(card, 2, 'mid')
b = double(card, 3, 'b')
assert len(card) == 4, 'len(PDAMP5 card) = %i\ncard=%s' % (len(card),
card)
return PDAMP5(pid, mid, b, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a CELAS4 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')
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(cls, card, icard=0, comment=''):
"""
Adds a PMASS card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
icard : int; default=0
the index of the card that's being parsed
comment : str; default=''
a comment for the card
"""
pid = integer(card, 1 + 4 * icard, 'pid')
ce = double(card, 2 + 4 * icard, 'ce')
cr = double_or_blank(card, 3 + 4 * icard, 'cr', 0.)
return PVISC(pid, ce, cr, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a PCONEAX card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
#: 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_or_blank(card, 6, 'mid3', 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 icard in range(11, len(card)):
phii = double(card, icard, 'phi%i' % icard)
phi.append(phii)
j += 1
return PCONEAX(pid,
mid1,
t1,
mid2,
i,
mid3,
t2,
nsm,
z1,
z2,
phi,
comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a QBDY3 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')
cntrlnd = integer_or_blank(card, 3, 'cntrlnd', 0)
nfields = card.nfields
eids = fields(integer_or_string, card, 'eid', i=4, j=nfields)
return QBDY3(sid, q0, cntrlnd, eids, comment=comment)
def add_card(cls, card, icard=0, comment=''):
"""
Adds a PDAMP card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
icard : int; default=0
the index of the card that's being parsed
comment : str; default=''
a comment for the card
"""
noffset = icard * 2
pid = integer(card, 1 + noffset, 'pid')
b = double(card, 2 + noffset, 'b')
return PDAMP(pid, b, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a RADBC card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
nodamb = integer(card, 1, 'nodamb')
famb = double(card, 2, 'famb')
cntrlnd = integer_or_blank(card, 3, 'cntrlnd', 0)
nfields = card.nfields
eids = fields(integer_or_string, card, 'eid', i=4, j=nfields)
return RADBC(nodamb, famb, cntrlnd, eids, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a SPCAX card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
conid = integer(card, 1, 'conid')
rid = integer(card, 2, 'rid')
hid = integer(card, 3, 'hid')
c = parse_components(card, 4, 'c')
d = double(card, 5, 'd')
return SPCAX(conid, rid, hid, c, d, comment=comment)
def add_card(self, card, comment=''):
self.model.log.debug(' adding CONROD')
i = self.i
eid = integer(card, 1, 'element_id')
self.element_id[i] = eid
self.node_ids[i] = [
integer(card, 2, 'node_1'),
integer(card, 3, 'node_2')
]
self.material_id[i] = integer(card, 4, 'material_id')
self.A[i] = double(card, 5, 'Area')
self.J[i] = double_or_blank(card, 6, 'J', 0.0)
self.c[i] = double_or_blank(card, 7, 'c', 0.0)
self.nsm[i] = double_or_blank(card, 8, 'non_structural_mass', 0.0)
assert len(card) <= 9, 'len(CONROD card) = %i\ncard=%s' % (len(card),
card)
self.i += 1
def add_card(cls, card, comment=''):
pid = integer(card, 1, 'pid')
mid = integer(card, 2, 'mid')
thick = double(card, 3, 'thick')
iplane = integer(card, 4, 'iplane')
nsm = double_or_blank(card, 5, 'nsm', 0.)
gamma = double_or_blank(card, 6, 'gamma', 0.5)
phi = double_or_blank(card, 7, 'phi', 180.)
assert len(card) <= 8, 'len(PRAC2D card) = %i\ncard=%s' % (len(card),
card)
return PRAC2D(pid,
mid,
thick,
iplane,
nsm,
gamma,
phi,
comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a RINGAX card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
nid = integer(card, 1, 'nid')
ringax = integer(card, 2, 'ringax')
phi = double(card, 3, 'phi')
assert len(card) <= 4, 'len(POINTAX card) = %i\ncard=%s' % (len(card),
card)
return POINTAX(nid, ringax, phi, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a FREQ1 card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
sid = integer(card, 1, 'sid')
f1 = double_or_blank(card, 2, 'f1', 0.0)
df = double(card, 3, 'df')
ndf = integer_or_blank(card, 4, 'ndf', 1)
assert len(card) <= 5, 'len(FREQ card) = %i\ncard=%s' % (len(card),
card)
return FREQ1(sid, f1, df, ndf, comment=comment)
def add_card(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', 0)
]
print(integer_or_blank(card, 6, 'C2', 0))
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\ncard=%s' % (
len(card), card) + str(card)
self.i += 1
def _read_shock(card, istart):
"""
F(u, v) = Cv * S(u) * sign(v) * |v|^ev
"""
shock_type = string_or_blank(card, istart + 1, 'shockType')
shock_cvt = double(card, istart + 2, 'shockCVT')
shock_cvc = double_or_blank(card, istart + 3, 'shockCVC')
shock_exp_vt = double_or_blank(card, istart + 4, 'shockExpVT', 1.0)
shock_exp_vc = double_or_blank(card, istart + 5,
'shockExpVC', shock_exp_vt)
if shock_type == 'TABLE':
shock_idts = None
shock_idets = None
shock_idecs = None
shock_idetsd = None
shock_idecsd = None
# shock_idts = integer(card, istart + 6, 'shockIDTS')
# shock_idets = blank(card, istart + 9, 'shockIDETS')
# shock_idecs = blank(card, istart + 10, 'shockIDECS')
# shock_idetsd = blank(card, istart + 11, 'shockIDETSD')
# shock_idecsd = blank(card, istart + 12, 'shockIDECSD')
elif shock_type == 'EQUAT':
shock_idts = blank(card, istart + 6, 'shockIDTS')
shock_idets = integer(card, istart + 9, 'shockIDETS')
shock_idecs = integer_or_blank(card, istart + 10,
'shockIDECS', shock_idets)
shock_idetsd = integer(card, istart + 11, 'shockIDETSD')
shock_idecsd = integer_or_blank(card, istart + 11,
'shockIDECSD', shock_idetsd)
#def DEquation(self):
#if isinstance(self.dequation, int):
#return self.dequation
#return self.dequation.equation_id
else:
msg = 'Invalid shockType=%r on card\n%s' % (shock_type, card)
raise RuntimeError(msg)
out = (
shock_type, shock_cvt, shock_cvc, shock_exp_vt, shock_exp_vc,
shock_idts, shock_idets, shock_idecs, shock_idetsd, shock_idecsd
)
istart += 8
return istart, out
def build(self):
cards = self._cards
ncards = len(cards)
self.n = ncards
if ncards:
float_fmt = self.model.float_fmt
#: Property ID
self.load_id = zeros(ncards, 'int32')
#: Element ID
self.element_id = zeros(ncards, 'int32')
# Surface traction at grid point GA. (Real)
self.p = zeros((ncards, 2), float_fmt)
#: Corner grid points. GA and GB are any two adjacent corner grid points of the
#: element. (Integer > 0)
self.node_ids = zeros((ncards, 2), 'int32')
#: Angle between surface traction and inward normal to the line segment.
#: (Real Default = 0.0)
self.theta = zeros(ncards, float_fmt)
for i, card in enumerate(cards):
self.load_id[i] = integer(card, 1, 'load_id')
self.element_id[i] = integer(card, 2, 'element_id')
pa = double(card, 3, 'pa')
pb = double_or_blank(card, 4, 'pb', pa)
self.p[i, :] = [pa, pb]
self.node_ids[i, :] = [
integer(card, 5, 'ga'),
integer(card, 6, 'gb')
]
self.theta[i] = double_or_blank(card, 7, 'theta', 0.)
assert len(card) <= 8, 'len(PLOADX1 card) = %i\ncard=%s' % (
len(card), card)
i = self.load_id.argsort()
self.load_id = self.load_id[i]
self.element_id = self.element_id[i]
self.node_ids = self.node_ids[i, :]
self.p = self.p[i, :]
self.theta = self.theta[i]
self._cards = []
self._comments = []
def add_card(cls, card, comment=''):
"""
Adds a CONROD card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
eid = integer(card, 1, 'eid')
nids = [integer(card, 2, 'n1'), integer(card, 3, 'n2')]
mid = integer(card, 4, 'mid')
A = double(card, 5, 'A')
j = double_or_blank(card, 6, 'j', 0.0)
c = double_or_blank(card, 7, 'c', 0.0)
nsm = double_or_blank(card, 8, 'nsm', 0.0)
return CONROD(eid, mid, nids, A, j, c, nsm, comment=comment)
def add_card(cls, card, icard=0, comment=''):
"""
Adds a RINGAX card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
ioffset = 2 * icard
j = icard + 1
ringfl = integer(card, 1+ioffset, 'ringfl_%i' % j)
xa = double(card, 2+ioffset, 'xa_%i' % j)
xb = double_or_blank(card, 3+ioffset, 'xa_%i' % j)
assert len(card) <= 9, 'len(RINGFL card) = %i\ncard=%s' % (len(card), card)
return RINGFL(ringfl, xa, xb, comment=comment)
def add_card(cls, card, icard=0, comment=''):
"""
Adds a TEMPD card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
icard : int; default=0
sid to be parsed
comment : str; default=''
a comment for the card
"""
nfields = len(card) - 1
assert nfields % 2 == 0, 'card=%s' % card
i = 2 * icard
sid = integer(card, i + 1, 'sid')
temperature = double(card, i + 2, 'temp')
return TEMPD(sid, temperature, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a PROD card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
pid = integer(card, 1, 'pid')
mid = integer(card, 2, 'mid')
A = double(card, 3, 'A')
j = double_or_blank(card, 4, 'J', 0.0)
c = double_or_blank(card, 5, 'c', 0.0)
nsm = double_or_blank(card, 6, 'nsm', 0.0)
assert len(card) <= 7, 'len(PROD card) = %i\ncard=%s' % (len(card), card)
return PROD(pid, mid, A, j, c, nsm, comment=comment)
def add_card(cls, card, icard=0, comment=''):
"""
Adds an NSM card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
icard : int; default=0
the index of the card that's being parsed
comment : str; default=''
a comment for the card
"""
noffset = 2 * icard
sid = integer(card, 1, 'sid')
nsm_type = string(card, 2, 'Type')
pid_eid = integer(card, 3 + noffset, 'pid/eid')
value = double(card, 4 + noffset, 'value')
return cls(sid, nsm_type, pid_eid, value, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a PTUBE card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
pid = integer(card, 1, 'pid')
mid = integer(card, 2, 'mid')
OD1 = double(card, 3, 'OD1')
t = double_or_blank(card, 4, 't', OD1/2.)
nsm = double_or_blank(card, 5, 'nsm', 0.0)
OD2 = double_or_blank(card, 6, 'OD2', OD1)
assert len(card) <= 7, 'len(PTUBE card) = %i\ncard=%s' % (len(card), card)
return PTUBE(pid, mid, OD1, t, nsm, OD2, 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=''):
"""
Adds a DIVERG card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
sid = integer(card, 1, 'sid')
nroots = integer(card, 2, 'nroot')
j = 1
machs = []
for i in range(3, len(card)):
mach = double(card, i, 'Mach_%i' % j)
machs.append(mach)
j += 1
return DIVERG(sid, nroots, machs, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a QBDY1 card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
sid = integer(card, 1, 'sid')
qflux = double(card, 2, 'qflux')
eids = []
j = 1
for i in range(3, len(card)):
eid = integer_or_string(card, i, 'eid%i' % j)
eids.append(eid)
j += 1
return QBDY1(sid, qflux, eids, comment=comment)
def add_card(cls, card, comment=''):
pconid = integer(card, 1, 'pconid')
mid = integer(card, 2, 'mid')
form = integer_or_blank(card, 3, 'form', 0)
flag = integer_or_blank(card, 4, 'flag', 0)
coef = double(card, 5, 'coef')
expr = double_or_blank(card, 6, 'expr', 0.0)
exppi = double_or_blank(card, 7, 'exppi', 0.0)
exppo = double_or_blank(card, 8, 'exppo', 0.0)
assert len(card) <= 9, 'len(PCONVM card) = %i\ncard=%s' % (len(card),
card)
return PCONVM(pconid,
mid,
form,
flag,
coef,
expr,
exppi,
exppo,
comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a PRESAX card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
sid = integer(card, 1, 'sid')
pressure = double(card, 2, 'pressure')
rid1 = integer(card, 3, 'rid1')
rid2 = integer(card, 4, 'rid2')
phi1 = double_or_blank(card, 5, 'phi1', 0.)
phi2 = double_or_blank(card, 6, 'phi2', 360.)
assert len(card) == 7, 'len(PRESAX card) = %i\ncard=%s' % (len(card),
card)
return PRESAX(sid, pressure, rid1, rid2, phi1, phi2, comment=comment)
def add_card(cls, card, icard=0, comment=''):
"""
Adds a PELAS card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
icard : int; default=0
the index of the PELAS card that's being parsed
must be 0 or 1
comment : str; default=''
a comment for the card
"""
noffset = icard * 4
pid = integer(card, 1 + noffset, 'pid')
k = double(card, 2 + noffset, 'k')
ge = double_or_blank(card, 3 + noffset, 'ge', 0.)
s = double_or_blank(card, 4 + noffset, 's', 0.)
return PELAS(pid, k, ge, s, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a PRAC2D card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
pid = integer(card, 1, 'pid')
mid = integer(card, 2, 'mid')
thick = double(card, 3, 'thick')
iplane = integer(card, 4, 'iplane')
nsm = double_or_blank(card, 5, 'nsm', 0.)
gamma = double_or_blank(card, 6, 'gamma', 0.5)
phi = double_or_blank(card, 7, 'phi', 180.)
assert len(card) <= 8, 'len(PRAC2D card) = %i\ncard=%s' % (len(card), card)
return PRAC2D(pid, mid, thick, iplane, nsm, gamma, phi,
comment=comment)
def add_card(cls, card, comment=''):
tid = integer(card, 1, 'tid')
x1 = double(card, 2, 'x1')
nfields = len(card) - 1
nterms = (nfields - 9) // 2
if nterms < 0:
raise SyntaxError('%r card is too short' % cls.type)
xy = []
for i in range(nterms):
n = 9 + i * 2
if card.field(n) == 'ENDT':
break
x = double_or_string(card, n, 'x' + str(i + 1))
y = double_or_string(card, n + 1, 'y' + str(i + 1))
if x == 'SKIP' or y == 'SKIP':
continue
xy.append([x, y])
string(card, nfields, 'ENDT')
x, y = make_xy(tid, 'TABLEM2', xy)
return TABLEM2(tid, x1, x, y, comment=comment)
def add_card(self, 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, 'len(CELAS2 card) = %i\ncard=%s' % (len(card), card)
self.add(eid, k, nids, [c1, c2], ge, s, comment=comment)
