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')
x1_g0 = integer_double_or_blank(card, 5, 'x1_g0', 0.0)
if isinstance(x1_g0, integer_types):
g0 = x1_g0
x = None
elif isinstance(x1_g0, float):
g0 = None
x = np.array([double_or_blank(card, 5, 'x1', 0.0),
double_or_blank(card, 6, 'x2', 0.0),
double_or_blank(card, 7, 'x3', 0.0)], dtype='float64')
if norm(x) == 0.0:
msg = 'G0 vector defining plane 1 is not defined.\n'
msg += 'G0 = %s\n' % g0
msg += 'X = %s\n' % x
raise RuntimeError(msg)
else:
raise ValueError('invalid x1Go=%r on CBEND' % x1_g0)
geom = integer(card, 8, 'geom')
assert len(card) == 9, 'len(CBEND card) = %i\ncard=%s' % (len(card), card)
return CBEND(eid, pid, ga, gb, g0, x, geom, comment=comment)
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(cls, card, comment='', sol=101):
csid = integer(card, 1, 'csid')
sids = []
tids = []
frictions = []
min_distances = []
max_distances = []
nfields = card.nfields
i = 2
j = 1
while i < nfields:
sids.append(integer(card, i, 'sid%s' % j))
tids.append(integer(card, i + 1, 'tid%s' % j))
frictions.append(double_or_blank(card, i + 2, 'fric%s' % j, 0.0))
if sol == 101:
min_distances.append(double_or_blank(card, i + 3, 'mind%s' % j, 0.0))
max_distances.append(double_or_blank(card, i + 4, 'maxd%s' % j, 0.0))
else:
min_distances.append(None)
max_distances.append(None)
i += 8
j += 1
return BCTSET(csid, sids, tids, frictions, min_distances,
max_distances, comment=comment,
sol=sol)
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(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 add_card(cls, card, comment=''):
pid = integer(card, 1, 'pid')
af = double_or_blank(card, 2, 'af')
d1 = double_or_blank(card, 3, 'd1')
d2 = double_or_blank(card, 4, 'd2', d1)
assert len(card) <= 5, 'len(PHBDY card) = %i' % len(card)
return PHBDY(pid, af, d1, d2, comment=comment)
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')
pid = integer(card, 2, 'pid')
Type = string(card, 3, 'Type')
#print("self.Type = %s" % self.Type)
# msg = 'CHBDYP Type=%r' % self.Type
#assert self.Type in ['POINT','LINE','ELCYL','FTUBE','TUBE'], msg
iViewFront = integer_or_blank(card, 4, 'iViewFront', 0)
iViewBack = integer_or_blank(card, 5, 'iViewBack', 0)
g1 = integer(card, 6, 'g1')
if Type != 'POINT':
g2 = integer(card, 7, 'g2')
else:
g2 = blank(card, 7, 'g2')
g0 = integer_or_blank(card, 8, 'g0', 0)
radMidFront = integer_or_blank(card, 9, 'radMidFront', 0)
radMidBack = integer_or_blank(card, 10, 'radMidBack', 0)
gmid = integer_or_blank(card, 11, 'gmid')
ce = integer_or_blank(card, 12, 'ce', 0)
e1 = double_or_blank(card, 13, 'e3')
e2 = double_or_blank(card, 14, 'e3')
e3 = double_or_blank(card, 15, 'e3')
assert len(card) <= 16, 'len(CHBDYP card) = %i\ncard=%s' % (len(card), card)
return CHBDYP(eid, pid, Type, g1, g2, g0=g0, gmid=gmid, ce=ce,
iViewFront=iViewFront, iViewBack=iViewBack,
radMidFront=radMidFront, radMidBack=radMidBack,
e1=e1, e2=e2, e3=e3, comment=comment)
def __init__(self, card=None, data=None, comment=''):
ThermalElement.__init__(self, card)
if comment:
self._comment = comment
if card:
#: Surface element ID
self.eid = integer(card, 1, 'eid')
#: PHBDY property entry identification numbers. (Integer > 0)
self.pid = integer(card, 2, 'pid')
assert self.pid > 0
self.Type = string(card, 3, 'Type')
#print("self.Type = %s" % self.Type)
# msg = 'CHBDYP Type=%r' % self.Type
#assert self.Type in ['POINT','LINE','ELCYL','FTUBE','TUBE'], msg
#: 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)
#: Grid point identification numbers of grids bounding the surface.
#: (Integer > 0)
self.g1 = integer(card, 6, 'g1')
#: Grid point identification numbers of grids bounding the surface.
#: (Integer > 0)
if self.Type != 'POINT':
self.g2 = integer(card, 7, 'g2')
else:
self.g2 = blank(card, 7, 'g2')
#: Orientation grid point. (Integer > 0; Default = 0)
self.g0 = integer_or_blank(card, 8, 'g0', 0)
#: RADM identification number for front face of surface element.
#: (Integer > 0)
self.radMidFront = integer_or_blank(card, 9, 'radMidFront', 0)
#: RADM identification number for back face of surface element.
#: (Integer > 0)
self.radMidBack = integer_or_blank(card, 10, 'radMidBack', 0)
#: Grid point identification number of a midside node if it is used
#: with the line type surface element.
self.gmid = integer_or_blank(card, 11, 'gmid')
#: Coordinate system for defining orientation vector.
#: (Integer > 0; Default = 0
self.ce = integer_or_blank(card, 12, 'ce', 0)
#: Components of the orientation vector in coordinate system CE.
#: The origin of the orientation vector is grid point G1.
#: (Real or blank)
self.e1 = double_or_blank(card, 13, 'e3')
self.e2 = double_or_blank(card, 14, 'e3')
self.e3 = double_or_blank(card, 15, 'e3')
assert len(card) <= 16, 'len(CHBDYP card) = %i' % len(card)
else:
raise NotImplementedError(data)
def set_E_G_nu(self, i, card):
r"""
\f[ G = \frac{E}{2 (1+\nu)} \f]
"""
E = double_or_blank(card, 2, 'E')
G = double_or_blank(card, 3, 'G')
nu = double_or_blank(card, 4, 'nu')
if G is None and E is None: # no E,G
raise RuntimeError('G=%s E=%s cannot both be None' % (G, E))
elif E is not None and G is not None and nu is not None:
pass
elif E is not None and nu is not None:
G = E / 2. / (1 + nu)
elif G is not None and nu is not None:
E = 2 * (1 + nu) * G
elif G is not None and E is not None:
nu = E / (2 * G) - 1.
elif G is None and nu is None:
G = 0.0
nu = 0.0
elif E is None and nu is None:
E = 0.0
nu = 0.0
else:
msg = 'G=%s E=%s nu=%s' % (G, E, nu)
raise RuntimeError(msg)
#self.model.log.debug('G = %s' % G)
self.E[i] = E
self.G[i] = G
self.nu[i] = nu
def add_card(cls, card, comment=''):
pid = integer(card, 1, 'pid')
mid = integer(card, 2, 'mid')
gamma = double_or_blank(card, 3, 'gamma', 0.5)
phi = double_or_blank(card, 4, 'gamma', 180.)
assert len(card) <= 5, 'len(PRAC3D card) = %i' % len(card)
return PRAC3D(pid, mid, gamma, phi, comment=comment)
def add_card(self, card, comment=''):
i = self.i
self.element_id[i] = integer(card, 1, 'eid')
self.property_id[i] = integer(card, 2, 'pid')
self.node_ids[i, :] = [
integer(card, 3, 'n1'),
integer(card, 4, 'n2'),
integer(card, 5, 'n3'),
integer(card, 6, 'n4')
]
theta_mcid = integer_double_or_blank(card, 7, 'theta_mcid', 0.0)
if isinstance(theta_mcid, float):
self.is_theta[i] = 1
self.theta[i] = theta_mcid
else:
self.is_theta[i] = 0
self.mcid[i] = theta_mcid
#self.thetaMcid =
#self.zOffset = double_or_blank(card, 7, 'zOffset', 0.0)
#blank(card, 8, 'blank')
#blank(card, 9, 'blank')
self.t_flag[i] = integer_or_blank(card, 10, 'TFlag', 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.i += 1
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_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 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 _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, 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(self, card, comment=''):
if comment:
self._comment = comment
pid = integer(card, 1, 'pid')
k = double_or_blank(card, 2, 'k', 0.0)
c = double_or_blank(card, 3, 'c', 0.0)
m = double_or_blank(card, 4, 'm', 0.0)
sa = double_or_blank(card, 6, 'sa', 0.0)
se = double_or_blank(card, 7, 'se', 0.0)
nfields = card.nfields
self.vars = []
istart = 9
while istart < nfields:
pname = string(card, istart, 'pname')
if pname == 'SHOCKA':
istart = self._read_shock(card, istart)
elif pname == 'SPRING':
self._read_spring(card, istart)
elif pname == 'DAMPER':
self._read_damper(card, istart)
elif pname == 'GENER':
self._read_gener(card, istart)
else:
break
istart += 8
self.pid = pid
self.k = k
self.c = c
self.m = m
self.sa = sa
self.se = se
def loadHESS_INV(self, nrows, card):
alphaOmega_default = None
LJ_default = None
if self.method == 'INV':
alphaOmega_default = 0.0
LJ_default = 1.0
for irow in range(nrows):
NEj = integer(card, 9 + 7 * irow + 5, 'NE%s' % str(irow))
NDJ_default = None
if self.method == 'INV':
NDJ_default = 3 * NEj
i = 9 + 8 * irow
self.alphaAjs.append(
double_or_blank(card, i, 'alphaA' + str(irow), alphaOmega_default))
self.omegaAjs.append(
double_or_blank(card, i + 1, 'omegaA' + str(irow), alphaOmega_default))
self.alphaBjs.append(
double_or_blank(card, i + 2, 'alphaB' + str(irow), alphaOmega_default))
self.omegaBjs.append(
double_or_blank(card, i + 3, 'omegaB' + str(irow), alphaOmega_default))
self.LJs.append(
double_or_blank(card, i + 4, 'LJ' + str(irow), LJ_default))
self.NEJs.append(
integer(card, i + 5, 'NEJ' + str(irow)))
self.NDJs.append(
integer_or_blank(card, i + 6, 'NDJ' + str(irow), NDJ_default))
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=''):
sid = integer(card, 1, 'sid')
f1 = double_or_blank(card, 2, 'f1', 0.0)
f2 = double_or_blank(card, 3, 'f2', 1.e20)
fspread = double_or_blank(card, 4, 'fspd', 0.1)
nfm = integer_or_blank(card, 5, 'nfm', 3)
assert len(card) <= 6, 'len(FREQ card) = %i\ncard=%s' % (len(card), card)
return FREQ4(sid, f1, f2, fspread, nfm, comment=comment)
def add_card(cls, card, comment=''):
sid = integer(card, 1, 'sid')
j = integer(card, 2, 'j')
k = integer(card, 3, 'k')
x = double_or_blank(card, 4, 'x', 0.0)
y = double_or_blank(card, 5, 'y', 0.0)
tid = integer_or_blank(card, 6, 'tid', 0)
assert len(card) <= 7, 'len(RANDPS card) = %i\ncard=%s' % (len(card), card)
return RANDPS(sid, j, k, x, y, tid, comment=comment)
def add_card(cls, card, comment=''):
pid = integer(card, 1, 'pid')
mid = integer(card, 2, 'mid')
t = double(card, 3, 't')
nsm = double_or_blank(card, 4, 'nsm', 0.0)
f1 = double_or_blank(card, 5, 'f1', 0.0)
f2 = double_or_blank(card, 6, 'f2', 0.0)
assert len(card) <= 7, 'len(PSHEAR card) = %i' % len(card)
return PSHEAR(pid, mid, t, nsm, f1, f2, comment=comment)
def __init__(self, card=None, data=None, comment=''):
if comment:
self._comment = comment
self.sid = integer(card, 1, 'sid')
self.f1 = double_or_blank(card, 2, 'f1', 0.0)
self.f2 = double_or_blank(card, 3, 'f2', 1.e20)
self.fspd = double_or_blank(card, 4, 'fspd', 0.1)
self.nfm = integer_or_blank(card, 5, 'nfm', 3)
assert len(card) <= 6, 'len(FREQ card) = %i' % len(card)
def add_card(cls, card, comment=''):
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' % len(card)
return PROD(pid, mid, A, j, c, nsm, comment=comment)
def add_card(cls, card, comment=''):
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 __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')
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, comment=''):
nlpci_id = integer(card, 1, 'nlpci_id')
Type = string_or_blank(card, 2, 'Type', 'CRIS')
minalr = double_or_blank(card, 3, 'minalr', 0.25)
maxalr = double_or_blank(card, 4, 'maxalr', 4.0)
scale = double_or_blank(card, 5, 'scale', 0.0)
blank(card, 6, 'blank')
desiter = integer_or_blank(card, 7, 'desiter', 12)
mxinc = integer_or_blank(card, 8, 'mxinc', 20)
return NLPCI(nlpci_id, Type, minalr, maxalr, scale, desiter, mxinc, comment=comment)
def add_card(cls, card, comment=''):
seid = integer(card, 1, 'seid')
superelement_type = string(card, 2, 'superelement_type')
rseid = integer_or_blank(card, 3, 'rseid', 0)
method = string_or_blank(card, 4, 'method', 'AUTO')
tol = double_or_blank(card, 5, 'tol', 1e-5)
loc = string_or_blank(card, 6, 'loc', 'YES')
unitno = integer_or_blank(card, 7, 'seid')
assert len(card) <= 8, f'len(SEBULK card) = {len(card):d}\ncard={card}'
return SEBULK(seid,
superelement_type,
rseid,
method=method,
tol=tol,
loc=loc,
unitno=unitno,
comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a RADM card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
nfields = card.nfields
radmid = integer(card, 1, 'radmid')
absorb = double_or_blank(card, 2, 'absorb')
emissivity = fields(double, card, 'emissivity', i=3, j=nfields)
return RADM(radmid, absorb, emissivity, comment=comment)
def add_card(self, card, comment=''):
i = self.i
self.element_id[i] = integer(card, 1, 'element_id')
self.caero[i] = integer(card, 2, 'caero')
self.box1[i] = integer(card, 3, 'box1')
self.box2[i] = integer(card, 4, 'box2')
self.setg[i] = integer(card, 5, 'setg')
self.dz[i] = double_or_blank(card, 6, 'dz', 0.0)
self.method[i] = string_or_blank(card, 7, 'method', 'IPS')
self.usage[i] = string_or_blank(card, 8, 'usage', 'BOTH')
self.nelements[i] = integer_or_blank(card, 9, 'nelements', 10)
self.melements[i] = integer_or_blank(card, 10, 'melements', 10)
assert self.nelements[i] > 0, 'nelements = %s' % self.nelements[i]
assert self.melements[i] > 0, 'melements = %s' % self.melements[i]
assert len(card) <= 11, 'len(SPLINE1 card) = %i\ncard=%s' % (len(card),
card)
self.i += 1
def add_card(self, card, comment=''):
i = self.i
sid = integer(card, 1, 'sid')
node = integer(card, 2, 'node')
component = integer(card, 3, 'component')
delay = double_or_blank(card, 4, 'delay')
assert component in [0, 1, 2, 3, 4, 5, 6], component
#assert len(card) <= 13, 'len(TLOAD2 card) = %i\ncard=%s' % (len(card), card)
self.sid[i] = sid
self.node_id[i] = node
self.component[i] = component
self.delay[i] = delay
self.i += 1
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(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=''):
sid = integer(card, 1, 'eid')
flag = string(card, 2, 'flag')
assert flag in [
'POINT', 'LINE', 'REV', 'AREA3', 'AREA4', 'AREA6', 'AREA8'
]
Q0 = double(card, 3, 'Q0')
af = double_or_blank(card, 4, 'af')
nnodes = cls.flag_to_nnodes[flag]
grids = []
for i in range(nnodes):
grid = integer(card, 5 + i, 'grid%i' % (i + 1))
grids.append(grid)
return QHBDY(sid, flag, Q0, af, grids, comment=comment)
def add_card(cls, card, comment=''):
sid = integer(card, 1, 'sid')
excite_id = integer(card, 2, 'excite_id')
delay = integer_or_blank(card, 3, 'delay', 0)
Type = integer_string_or_blank(card, 4, 'Type', 'LOAD')
T1 = double_or_blank(card, 5, 'T1', 0.0)
T2 = double_or_blank(card, 6, 'T2', T1)
frequency = double_or_blank(card, 7, 'frequency', 0.)
phase = double_or_blank(card, 8, 'phase', 0.)
c = double_or_blank(card, 9, 'c', 0.)
b = double_or_blank(card, 10, 'b', 0.)
us0 = double_or_blank(card, 11, 'us0', 0.)
vs0 = double_or_blank(card, 12, 'vs0', 0.)
if Type in [0, 'L', 'LO', 'LOA', 'LOAD']:
Type = 'LOAD'
elif Type in [1, 'D', 'DI', 'DIS', 'DISP']:
Type = 'DISP'
elif Type in [2, 'V', 'VE', 'VEL', 'VELO']:
Type = 'VELO'
elif Type in [3, 'A', 'AC', 'ACC', 'ACCE']:
Type = 'ACCE'
elif Type in [5, 6, 7, 12, 13]:
pass
else:
msg = 'invalid TLOAD2 type Type=%r' % Type
raise RuntimeError(msg)
assert len(card) <= 13, 'len(TLOAD2 card) = %i\ncard=%s' % (len(card),
card)
return TLOAD2(sid,
excite_id,
delay,
Type,
T1,
T2,
frequency,
phase,
c,
b,
us0,
vs0,
comment=comment)
def test_double_or_blank(self):
"""
value = double_or_blank(card, n, fieldname, default=None)
"""
# integer
card = BDFCard([1])
with self.assertRaises(SyntaxError):
double_or_blank(card, 0, 'field')
card = BDFCard(['2'])
with self.assertRaises(SyntaxError):
double_or_blank(card, 0, 'field')
self.check_double(double_or_blank)
# string
with self.assertRaises(SyntaxError):
double_or_blank(BDFCard(['a']), 0, 'field')
with self.assertRaises(SyntaxError):
double_or_blank(BDFCard(['1b']), 0, 'field')
# blank
self.check_blank(double_or_blank)
assert double_or_blank(BDFCard(['.']), 0, 'field') == 0.
def add_card(self, card, comment=''):
i = self.i
self.element_id[i] = integer(card, 1, 'element_id')
self.material_id[i] = integer(card, 2, 'material_id')
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')]
self.node_ids[i, :] = nids
#: theta
self.theta[i] = double_or_blank(card, 9, 'theta', 0.0)
assert len(card) <= 10, 'len(CTRIAX6 card) = %i\ncard=%s' % (len(card), card)
self.i += 1
def add_card(cls, card, comment=''):
"""
Adds a RBAR1 card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
eid = integer(card, 1, 'eid')
ga = integer(card, 2, 'ga')
gb = integer(card, 3, 'gb')
cb = components_or_blank(card, 4, 'cb')
alpha = double_or_blank(card, 5, 'alpha', 0.0)
assert len(card) <= 6, 'len(RBAR1 card) = %i\ncard=%s' % (len(card), card)
return RBAR1(eid, [ga, gb], cb, alpha=alpha, comment=comment)
def add_card(self, card, comment=''):
"""
Adds a CBUSH 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)
ga = integer(card, 3, 'ga')
gb = integer_or_blank(card, 4, 'gb')
#: 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')
x1_g0 = integer_double_or_blank(card, 5, 'x1_g0')
if isinstance(x1_g0, integer_types):
g0 = x1_g0
x = None
elif isinstance(x1_g0, float):
g0 = None
x1 = x1_g0
x2 = double_or_blank(card, 6, 'x2', 0.0)
x3 = double_or_blank(card, 7, 'x3', 0.0)
x = [x1, x2, x3]
if not isinstance(cid, integer_types):
assert max(x) != min(x), 'x=%s' % x
else:
g0 = None
x = [None, None, None]
#: Location of spring damper (0 <= s <= 1.0)
s = 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
ocid = integer_or_blank(card, 10, 'ocid', -1)
#: Components of spring-damper offset in the OCID coordinate system
#: if OCID > 0.
si = [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)
#return CBUSH(eid, pid, [ga, gb], x, g0, cid=cid, s=s, ocid=ocid, si=si, comment=comment)
return self.add(eid, pid, [ga, gb], x, g0, cid=cid, s=s, ocid=ocid, si=si, 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
"""
icard *= 2
#: Property ID
pid = integer(card, 1 + icard, 'pid')
mass = double_or_blank(card, 2 + icard, 'mass', 0.)
return PMASS(pid, mass, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a GUST card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
sid = integer(card, 1, 'sid')
dload = integer(card, 2, 'dload')
wg = double(card, 3, 'wg')
x0 = double(card, 4, 'x0')
V = double_or_blank(card, 5, 'V')
assert len(card) <= 6, 'len(GUST card) = %i\ncard=%s' % (len(card), card)
return GUST(sid, dload, wg, x0, V=V, comment=comment)
def add_card(cls, card, comment=''):
eid = integer(card, 1, 'eid')
pconvm = integer(card, 2, 'pconvm')
film_node = integer_or_blank(card, 3, 'film_node', 0)
cntmdot = integer_or_blank(card, 4, 'cntmdot', 0)
ta1 = integer(card, 5, 'ta1')
ta2 = integer_or_blank(card, 6, 'ta2', ta1)
mdot = double_or_blank(card, 7, 'mdot', 1.0)
assert len(card) <= 8, 'len(CONVM card) = %i\ncard=%s' % (len(card),
card)
return CONVM(eid,
pconvm,
film_node,
cntmdot,
ta1,
ta2,
mdot,
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(cls, card, beamor=None, comment=''):
"""
Adds a CBEAM card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
beamor : BEAMOR() or None
defines the defaults
comment : str; default=''
a comment for the card
"""
eid = integer(card, 1, 'eid')
pid_default = eid
x1_default, x2_default, x3_default = 0., 0., 0.
offt_default = 'GGG'
if beamor is not None:
if beamor.pid is not None:
pid_default = beamor.pid
if beamor.x is None:
x1_default = beamor.g0
x2_default = None
x3_default = None
else:
x1_default, x2_default, x3_default = beamor.x
offt_default = beamor.offt
pid = integer_or_blank(card, 2, 'pid', pid_default)
ga = integer(card, 3, 'ga')
gb = integer(card, 4, 'gb')
x, g0 = init_x_g0(card, eid, x1_default, x2_default, x3_default)
offt, bit = _init_offt_bit(card, eid, offt_default)# offt doesn't exist in NX nastran
pa = integer_or_blank(card, 9, 'pa', 0)
pb = integer_or_blank(card, 10, 'pb', 0)
wa = np.array([double_or_blank(card, 11, 'w1a', 0.0),
double_or_blank(card, 12, 'w2a', 0.0),
double_or_blank(card, 13, 'w3a', 0.0)], 'float64')
wb = np.array([double_or_blank(card, 14, 'w1b', 0.0),
double_or_blank(card, 15, 'w2b', 0.0),
double_or_blank(card, 16, 'w3b', 0.0)], 'float64')
sa = integer_or_blank(card, 17, 'sa', 0)
sb = integer_or_blank(card, 18, 'sb', 0)
assert len(card) <= 19, 'len(CBEAM card) = %i\ncard=%s' % (len(card), card)
return CBEAM(eid, pid, [ga, gb], x, g0, offt, bit,
pa=pa, pb=pb, wa=wa, wb=wb, sa=sa, sb=sb, 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(self, card, comment=None):
i = self.i
self._comments.append(comment)
#element_ids = {}
#for i in range(ncards):
#element_ids[i] = []
self.load_id[i] = integer(card, 1, 'load_id')
eid = integer(card, 2, 'element_id')
self.element_ids[i] = 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[i, :] = p
self.element_ids[i] = [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.element_ids[i] = list(unique(expand_thru([eid, 'THRU', eid2],
set_fields=False, sort_fields=False)))
#self.g1 = None
#self.g34 = None
else:
#: used for CPENTA, CHEXA
self.element_ids[i] = [eid]
#: used for solid element only
self.g1[i] = integer_or_blank(card, 7, 'g1', -1)
#: g3/g4 - different depending on CHEXA/CPENTA or CTETRA
self.g34[i] = integer_or_blank(card, 8, 'g34', -1)
#: Coordinate system identification number. See Remark 2.
#: (Integer >= 0;Default=0)
self.cid[i] = integer_or_blank(card, 9, 'cid', 0)
self.nvector[i, :] = [
double_or_blank(card, 10, 'N1'),
double_or_blank(card, 11, 'N2'),
double_or_blank(card, 12, 'N3'), ]
self.surf_or_line[i] = string_or_blank(card, 13, 'sorl', 'SURF')
self.line_load_dir[i] = string_or_blank(card, 14, 'ldir', 'NORM')
assert len(card) <= 15, 'len(PLOAD4 card) = %i\ncard=%s' % (len(card), card)
self.i += 1
def add_card(cls, card, comment=''):
"""
Adds a CBEAM 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)
ga = integer(card, 3, 'ga')
gb = integer(card, 4, 'gb')
x, g0 = init_x_g0(card, eid)
offt, bit = _init_offt_bit(card,
eid) # offt doesn't exist in NX nastran
pa = integer_or_blank(card, 9, 'pa', 0)
pb = integer_or_blank(card, 10, 'pb', 0)
wa = np.array([
double_or_blank(card, 11, 'w1a', 0.0),
double_or_blank(card, 12, 'w2a', 0.0),
double_or_blank(card, 13, 'w3a', 0.0)
], 'float64')
wb = np.array([
double_or_blank(card, 14, 'w1b', 0.0),
double_or_blank(card, 15, 'w2b', 0.0),
double_or_blank(card, 16, 'w3b', 0.0)
], 'float64')
sa = integer_or_blank(card, 17, 'sa', 0)
sb = integer_or_blank(card, 18, 'sb', 0)
assert len(card) <= 19, 'len(CBEAM card) = %i\ncard=%s' % (len(card),
card)
return CBEAM(eid,
pid, [ga, gb],
x,
g0,
offt,
bit,
pa=pa,
pb=pb,
wa=wa,
wb=wb,
sa=sa,
sb=sb,
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, comment=''):
"""
Adds a CMASS2 card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
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\ncard=%s' % (len(card), card)
return CMASS2(eid, mass, g1, c1, g2, c2, comment=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_card(cls, card, comment=''):
"""
Adds a BCRPARA card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
crid = integer(card, 1, 'crid')
surf = string_or_blank(card, 2, 'surf', 'TOP')
offset = double_or_blank(card, 3, 'offset', None)
Type = string_or_blank(card, 4, 'type', 'FLEX')
grid_point = integer_or_blank(card, 5, 'grid_point', 0)
return BCRPARA(crid, surf=surf, offset=offset, Type=Type,
grid_point=grid_point, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a MATS1 card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
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(cls, card, comment=''):
"""
Adds a CBAR 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)
ga = integer(card, 3, 'ga')
gb = integer(card, 4, 'gb')
x, g0 = cls._init_x_g0(card, eid)
# doesn't exist in NX nastran
offt = integer_string_or_blank(card, 8, 'offt', 'GGG')
#print('cls.offt = %r' % (cls.offt))
pa = integer_or_blank(card, 9, 'pa', 0)
pb = integer_or_blank(card, 10, 'pb', 0)
wa = np.array([
double_or_blank(card, 11, 'w1a', 0.0),
double_or_blank(card, 12, 'w2a', 0.0),
double_or_blank(card, 13, 'w3a', 0.0)
],
dtype='float64')
wb = np.array([
double_or_blank(card, 14, 'w1b', 0.0),
double_or_blank(card, 15, 'w2b', 0.0),
double_or_blank(card, 16, 'w3b', 0.0)
],
dtype='float64')
assert len(card) <= 17, 'len(CBAR card) = %i\ncard=%s' % (len(card),
card)
return CBAR(eid,
pid, [ga, gb],
x,
g0,
offt,
pa,
pb,
wa,
wb,
comment=comment)
def add_card(cls, card, comment=''):
"""
Adds an AERO card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
acsid = integer_or_blank(card, 1, 'acsid', 0)
velocity = double_or_blank(card, 2, 'velocity')
cref = double(card, 3, 'cRef')
rho_ref = double(card, 4, 'rho_ref')
sym_xz = integer_or_blank(card, 5, 'symXZ', 0)
sym_xy = integer_or_blank(card, 6, 'symXY', 0)
assert len(card) <= 7, 'len(AERO card) = %i\ncard=%s' % (len(card), card)
return AERO(velocity, cref, rho_ref, acsid=acsid, sym_xz=sym_xz, sym_xy=sym_xy,
comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a TF card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
sid = integer(card, 1, 'sid')
nid0 = integer(card, 2, 'nid0')
# component 0 means an SPOINT/EPOINT
c = components_or_blank(card, 3, 'components_0', 0)
b0 = double_or_blank(card, 4, 'b0', 0.)
b1 = double_or_blank(card, 5, 'b1', 0.)
b2 = double_or_blank(card, 6, 'b2', 0.)
nfields = len(card) - 9
nrows = nfields // 8
if nfields % 8 > 0:
nrows += 1
nids = []
components = []
a = []
for irow in range(nrows):
j = irow * 8 + 9
#ifield = irow + 1
nid = integer(card, j, 'grid_%i' % (irow + 1))
component = components_or_blank(card, j + 1,
'components_%i' % (irow + 1), 0)
a0 = double_or_blank(card, j + 2, 'a0_%i' % (irow + 1), 0.)
a1 = double_or_blank(card, j + 3, 'a1_%i' % (irow + 1), 0.)
a2 = double_or_blank(card, j + 4, 'a2_%i' % (irow + 1), 0.)
nids.append(nid)
components.append(component)
a.append([a0, a1, a2])
return TF(sid,
nid0,
c,
b0,
b1,
b2,
nids,
components,
a,
comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a BCONP card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
contact_id = integer(card, 1, 'contact_id')
slave = integer(card, 2, 'slave')
master = integer(card, 3, 'master')
sfac = double_or_blank(card, 5, 'sfac', 1.0)
fric_id = integer_or_blank(card, 6, 'fric_id')
ptype = integer_or_blank(card, 7, 'ptype', 1)
cid = integer_or_blank(card, 8, 'cid', 0)
return BCONP(contact_id, slave, master, sfac, fric_id, ptype, cid, comment=comment)
def add_card(cls, card, comment=''):
"""
Adds a TRIM card from ``BDF.add_card(...)``
Parameters
----------
card : BDFCard()
a BDFCard object
comment : str; default=''
a comment for the card
"""
sid = integer(card, 1, 'sid')
mach = double(card, 2, 'mach')
q = double(card, 3, 'q')
labels = []
uxs = []
label = string_or_blank(card, 4, 'label1')
if label:
ux = double(card, 5, 'ux1')
uxs.append(ux)
labels.append(label)
label = string_or_blank(card, 6, 'label2')
if label:
ux = double(card, 7, 'ux1')
uxs.append(ux)
labels.append(label)
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)
labels.append(label)
uxs.append(ux)
i += 2
n += 1
return TRIM(sid, mach, q, labels, uxs, aeqr, comment=comment)
