class PROD(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/PROPERTY/PROD')
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
data = np.empty(len(card_ids), dtype=cls.table_def.dtype)
pid = data['PID']
mid = data['MID']
a = data['A']
j = data['J']
c = data['C']
nsm = data['NSM']
i = -1
for card_id in card_ids:
i += 1
card = cards[card_id]
pid[i] = card.pid
mid[i] = card.mid
a[i] = card.A
j[i] = card.j
c[i] = card.c
nsm[i] = card.nsm
result = {'IDENTITY': data}
return result
class TABLED2(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/TABLE/TABLED2/IDENTITY', rename={'XY_POS': 'POS', 'XY_LEN': 'LEN'})
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
xy = {'IDENTITY': {'X': [], 'Y': []}}
result = {'IDENTITY': {'ID': [], 'X1': [], 'POS': [], 'LEN': [], 'DOMAIN_ID': []},
'XY': xy,
'_subtables': ['XY']}
x = xy['IDENTITY']['X']
y = xy['IDENTITY']['Y']
identity = result['IDENTITY']
id_ = identity['ID']
x1 = identity['X1']
pos = identity['POS']
len_ = identity['LEN']
_pos = 0
for card_id in card_ids:
card = cards[card_id]
id_.append(card.tid)
x1.append(card.x1)
pos.append(_pos)
_len = len(card.x)
len_.append(_len)
_pos += _len
x.extend(list(card.x))
y.extend(list(card.y))
return result
class TABDMP1(CardTable):
table_def = TableDef.create(TABDMP1_SPEC, rename={'DAMP_POS': 'POS', 'DAMP_LEN': 'LEN'})
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
damp = {'IDENTITY': {'F': [], 'G': []}}
result = {'IDENTITY': {'ID': [], 'TYPE': [], 'POS': [], 'LEN': [], 'DOMAIN_ID': []},
'DAMP': damp,
'_subtables': ['DAMP']}
f = damp['IDENTITY']['F']
g = damp['IDENTITY']['G']
identity = result['IDENTITY']
id_ = identity['ID']
type_ = identity['TYPE']
pos = identity['POS']
len_ = identity['LEN']
_pos = 0
for card_id in card_ids:
card = cards[card_id]
id_.append(card.tid)
type_.append(card.Type)
pos.append(_pos)
_len = len(card.x)
len_.append(_len)
f += list(card.x)
g += list(card.y)
return result
class PELAS(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/PROPERTY/PELAS')
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
data = np.empty(len(card_ids), dtype=cls.table_def.dtype)
pid = data['PID']
k = data['K']
ge = data['GE']
s = data['S']
i = -1
for card_id in card_ids:
i += 1
card = cards[card_id]
pid[i] = card.pid
k[i] = card.k
ge[i] = card.ge
s[i] = card.s
result = {'IDENTITY': data}
return result
class FREQ1(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/DYNAMIC/FREQ1')
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
result = {'IDENTITY': {'SID': [], 'F1': [], 'DF': [], 'NDF': [], 'DOMAIN_ID': []}}
identity = result['IDENTITY']
sid = identity['SID']
f1 = identity['F1']
df = identity['DF']
ndf = identity['NDF']
for card_id in card_ids:
card_list = cards[card_id]
for card in card_list:
sid.append(card.sid)
f1.append(card.f1)
df.append(card.df)
ndf.append(card.ndf)
return result
class SPC(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/CONSTRAINT/SPC')
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
result = {
'IDENTITY': {
'SID': [],
'G': [],
'C': [],
'D': [],
'DOMAIN_ID': []
},
}
identity = result['IDENTITY']
sid = identity['SID']
g = identity['G']
c = identity['C']
d = identity['D']
for card_id in card_ids:
card_list = sorted(cards[card_id], key=lambda x: x.conid)
for card in card_list:
sid += [card.conid] * len(card.gids)
g += card.gids
c += card.components
d += card.enforced
return result
class PSHEAR(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/PROPERTY/PSHEAR')
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
data = np.empty(len(card_ids), dtype=cls.table_def.dtype)
pid = data['PID']
mid = data['MID']
t = data['T']
nsm = data['NSM']
f1 = data['F1']
f2 = data['F2']
i = -1
for card_id in card_ids:
i += 1
card = cards[card_id]
pid[i] = card.pid
mid[i] = card.mid
t[i] = card.t
nsm[i] = card.nsm
f1[i] = card.f1
f2[i] = card.f2
result = {'IDENTITY': data}
return result
class PBAR(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/PROPERTY/PBAR')
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
data = np.empty(len(card_ids), dtype=cls.table_def.dtype)
pid = data['PID']
mid = data['MID']
a = data['A']
i1 = data['I1']
i2 = data['I2']
j = data['J']
nsm = data['NSM']
data['FE'] = DataHelper.default_double # blank field
c1 = data['C1']
c2 = data['C2']
d1 = data['D1']
d2 = data['D2']
e1 = data['E1']
e2 = data['E2']
f1 = data['F1']
f2 = data['F2']
k1 = data['K1']
k2 = data['K2']
i12 = data['I12']
i = -1
for card_id in card_ids:
i += 1
card = cards[card_id]
pid[i] = card.pid
mid[i] = card.mid
a[i] = card.A
i1[i] = card.i1
i2[i] = card.i2
j[i] = card.j
nsm[i] = card.nsm
c1[i] = card.c1
c2[i] = card.c2
d1[i] = card.d1
d2[i] = card.d2
e1[i] = card.e1
e2[i] = card.e2
f1[i] = card.f1
f2[i] = card.f2
k1[i] = card.k1
k2[i] = card.k2
i12[i] = card.i12
result = {'IDENTITY': data}
return result
class MAT8(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/MATERIAL/MAT8')
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
data = np.empty(len(card_ids), dtype=cls.table_def.dtype)
mid = data['MID']
e1 = data['E1']
e2 = data['E2']
nu12 = data['NU12']
g1z = data['G1Z']
g2z = data['G2Z']
rho = data['RHO']
a1 = data['A1']
a2 = data['A2']
tref = data['TREF']
xt = data['XT']
xc = data['XC']
yt = data['YT']
yc = data['YC']
s = data['S']
ge = data['GE']
f12 = data['F12']
strn = data['STRN']
i = -1
for card_id in card_ids:
i += 1
card = cards[card_id]
mid[i] = card.mid
e1[i] = card.e11
e2[i] = card.e22
nu12[i] = card.nu12
g1z[i] = card.g1z
g2z[i] = card.g2z
rho[i] = card.rho
a1[i] = card.a1
a2[i] = card.a2
tref[i] = card.tref
xt[i] = card.Xt
xc[i] = card.Xc
yt[i] = card.Yt
yc[i] = card.Yc
s[i] = card.S
ge[i] = card.ge
f12[i] = card.F12
strn[i] = card.strn
result = {'IDENTITY': data}
return result
class PBARL(CardTable):
table_def = TableDef.create(PBARL_SPEC)
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
info = {'IDENTITY': {'VALUE': []}}
result = {
'IDENTITY': {
'PID': [],
'MID': [],
'GROUP': [],
'TYPE': [],
'NSM': [],
'INFO_POS': [],
'INFO_LEN': [],
'DOMAIN_ID': []
},
'INFO': info,
'_subtables': ['INFO']
}
identity = result['IDENTITY']
value = info['IDENTITY']['VALUE']
pid = identity['PID']
mid = identity['MID']
group = identity['GROUP']
type_ = identity['TYPE']
nsm = identity['NSM']
info_pos = identity['INFO_POS']
info_len = identity['INFO_LEN']
_pos = 0
for card_id in card_ids:
card = cards[card_id]
pid.append(card.pid)
mid.append(card.mid)
group.append(card.group)
type_.append(card.beam_type)
nsm.append(card.nsm)
info_pos.append(_pos)
_info_len = len(card.dim)
info_len.append(_info_len)
_pos += _info_len
value += list(card.dim)
return result
class SPC1_G(CardTable):
card_id = 'SPC1'
table_def = TableDef.create(
'/NASTRAN/INPUT/CONSTRAINT/SPC1/SPC1_G/IDENTITY')
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
g = {'IDENTITY': {'ID': []}}
result = {
'IDENTITY': {
'SID': [],
'C': [],
'G_POS': [],
'G_LEN': [],
'DOMAIN_ID': []
},
'G': g,
'_subtables': ['G']
}
identity = result['IDENTITY']
sid = identity['SID']
c = identity['C']
g_pos = identity['G_POS']
g_len = identity['G_LEN']
id = g['IDENTITY']['ID']
_pos = 0
for card_id in card_ids:
card_list = sorted(cards[card_id], key=lambda x: x.conid)
for card in card_list:
nids = []
for nid in card.node_ids:
if nid is None:
continue
nids.append(nid)
sid.append(card.conid)
c.append(card.components)
g_pos.append(_pos)
_g_len = len(nids)
_pos += _g_len
g_len.append(_g_len)
id += nids
return result
class PBUSH(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/PROPERTY/PBUSH')
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
data = np.empty(len(card_ids), dtype=cls.table_def.dtype)
pid = data['PID']
k = data['K']
b = data['B']
ge = data['GE']
sa = data['SA']
st = data['ST']
ea = data['EA']
et = data['ET']
m = data['M']
def _get_value(obj, attr, default):
try:
return getattr(obj, attr)
except AttributeError:
return default
def _get_list(obj, attr, default):
lst = list(getattr(obj, attr))
if len(lst) == 0:
return [default] * 6
return lst
i = -1
for card_id in card_ids:
i += 1
card = cards[card_id]
pid[i] = card.pid
k[i] = _get_list(card, 'Ki', DataHelper.default_double)
b[i] = _get_list(card, 'Bi', DataHelper.default_double)
ge[i] = _get_list(card, 'GEi', DataHelper.default_double)
sa[i] = _get_value(card, 'sa', DataHelper.default_double)
st[i] = _get_value(card, 'st', DataHelper.default_double)
ea[i] = _get_value(card, 'ea', DataHelper.default_double)
et[i] = _get_value(card, 'et', DataHelper.default_double)
m[i] = _get_value(card, 'm', DataHelper.default_double)
result = {'IDENTITY': data}
return result
class PSHELL(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/PROPERTY/PSHELL')
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
data = np.empty(len(card_ids), dtype=cls.table_def.dtype)
pid = data['PID']
mid1 = data['MID1']
t = data['T']
mid2 = data['MID2']
bk = data['BK']
mid3 = data['MID3']
ts = data['TS']
nsm = data['NSM']
z1 = data['Z1']
z2 = data['Z2']
mid4 = data['MID4']
def _get_mid(val, default):
if val is None:
val = default
return val
i = -1
for card_id in card_ids:
i += 1
card = cards[card_id]
pid[i] = card.pid
mid1[i] = card.mid1
t[i] = card.t
mid2[i] = _get_mid(card.mid2, DataHelper.default_int)
bk[i] = card.twelveIt3
mid3[i] = _get_mid(card.mid3, DataHelper.default_int)
ts[i] = card.tst
nsm[i] = card.nsm
z1[i] = card.z1
z2[i] = card.z2
mid4[i] = _get_mid(card.mid4, DataHelper.default_int)
result = {'IDENTITY': data}
return result
class LOAD(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/LOAD/LOAD/IDENTITY')
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
sfactors = {'IDENTITY': {'SI': [], 'LI': []}}
data = {
'IDENTITY': {
'SID': [],
'S': [],
'SFACTORS_POS': [],
'SFACTORS_LEN': []
},
'SFACTORS': sfactors,
'_subtables': ['SFACTORS']
}
identity = data['IDENTITY']
sid = identity['SID']
s = identity['S']
pos = identity['SFACTORS_POS']
_len = identity['SFACTORS_LEN']
sfactors = sfactors['IDENTITY']
si = sfactors['SI']
li = sfactors['LI']
_pos = 0
for card_id in card_ids:
card_list = sorted(cards[card_id], key=lambda x: x.sid)
for card in card_list:
sid.append(card.sid)
s.append(card.scale)
pos.append(_pos)
data_len = len(card.scale_factors)
_pos += data_len
_len.append(data_len)
si += list(card.scale_factors)
li += list(card.load_ids)
return data
class DLOAD(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/LOAD/DLOAD/IDENTITY')
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
sl = {'IDENTITY': {'SI': [], 'LI': []}}
result = {
'IDENTITY': {
'SID': [],
'S': [],
'SL_LEN': [],
'SL_POS': [],
'DOMAIN_ID': []
},
'SL': sl,
'_subtables': ['SL']
}
si = sl['IDENTITY']['SI']
li = sl['IDENTITY']['LI']
identity = result['IDENTITY']
sid = identity['SID']
s = identity['S']
sl_len = identity['SL_LEN']
sl_pos = identity['SL_POS']
_pos = 0
for card_id in card_ids:
card_list = cards[card_id]
for card in card_list:
sid.append(card.sid)
s.append(card.scale)
sl_pos.append(_pos)
_len = len(card.scale_factors)
sl_len.append(_len)
_pos += _len
si += card.scale_factors
li += card.load_ids
return result
class MAT1(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/MATERIAL/MAT1')
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
data = np.empty(len(card_ids), dtype=cls.table_def.dtype)
mid = data['MID']
e = data['E']
g = data['G']
nu = data['NU']
rho = data['RHO']
a = data['A']
tref = data['TREF']
ge = data['GE']
st = data['ST']
sc = data['SC']
ss = data['SS']
mcsid = data['MCSID']
i = -1
for card_id in card_ids:
i += 1
card = cards[card_id]
mid[i] = card.mid
e[i] = card.e
g[i] = card.g
nu[i] = card.nu
rho[i] = card.rho
a[i] = card.a
tref[i] = card.tref
ge[i] = card.ge
st[i] = card.St
sc[i] = card.Sc
ss[i] = card.Ss
mcsid[i] = card.mcsid
result = {'IDENTITY': data}
return result
class TABLED1(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/TABLE/TABLED1/IDENTITY', rename={'XY_POS': 'POS', 'XY_LEN': 'LEN'})
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
xy = {'IDENTITY': {'X': [], 'Y': []}}
result = {'IDENTITY': {'ID': [], 'CODEX': [], 'CODEY': [], 'POS': [], 'LEN': [], 'DOMAIN_ID': []},
'XY': xy,
'_subtables': ['XY']}
x = xy['IDENTITY']['X']
y = xy['IDENTITY']['Y']
identity = result['IDENTITY']
id_ = identity['ID']
codex = identity['CODEX']
codey = identity['CODEY']
pos = identity['POS']
len_ = identity['LEN']
# TODO: TABLED1 confirm codes are correct
_xy_code = {'LINEAR': 1, 'LOG': 2, '': 1, None: 1}
_pos = 0
for card_id in card_ids:
card = cards[card_id]
id_.append(card.tid)
codex.append(_xy_code[card.xaxis])
codey.append(_xy_code[card.yaxis])
pos.append(_pos)
_len = len(card.x)
len_.append(_len)
_pos += _len
x.extend(list(card.x))
y.extend(list(card.y))
return result
class MAT4(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/MATERIAL/MAT4')
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
data = np.empty(len(card_ids), dtype=cls.table_def.dtype)
mid = data['MID']
k = data['K']
cp = data['CP']
rho = data['RHO']
h = data['H']
mu = data['MU']
hgen = data['HGEN']
refenth = data['REFENTH']
tch = data['TCH']
tdelta = data['TDELTA']
qlat = data['QLAT']
i = -1
for card_id in card_ids:
i += 1
card = cards[card_id]
mid[i] = card.mid
k[i] = card.k
cp[i] = card.cp
rho[i] = card.rho
h[i] = card.H
mu[i] = card.mu
hgen[i] = card.hgen
refenth[i] = card.ref_enthalpy
tch[i] = card.tch
tdelta[i] = card.tdelta
qlat[i] = card.qlat
result = {'IDENTITY': data}
return result
class SPCADD(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/CONSTRAINT/SPCADD/IDENTITY')
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
s = {'IDENTITY': {'S': []}}
result = {
'IDENTITY': {
'SID': [],
'S_POS': [],
'S_LEN': [],
'DOMAIN_ID': []
},
'S': s,
'_subtables': ['S']
}
identity = result['IDENTITY']
sid = identity['SID']
s_pos = identity['S_POS']
s_len = identity['S_LEN']
s = s['IDENTITY']['S']
_pos = 0
for card_id in card_ids:
card_list = sorted(cards[card_id], key=lambda x: x.conid)
for card in card_list:
sid.append(card.conid)
s_pos.append(_pos)
_s_len = len(card.sets)
s_len.append(_s_len)
s += card.sets
return result
class FORCE(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/LOAD/FORCE')
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
result = {
'IDENTITY': {
'SID': [],
'G': [],
'CID': [],
'F': [],
'N': [],
'DOMAIN_ID': []
}
}
identity = result['IDENTITY']
sid = identity['SID']
g = identity['G']
cid = identity['CID']
f = identity['F']
n = identity['N']
for card_id in card_ids:
card_list = sorted(cards[card_id], key=lambda x: x.node)
for card in card_list:
sid.append(card.sid)
g.append(card.node)
cid.append(card.cid)
f.append(card.mag)
n.append(card.xyz)
identity['N'] = np.array(n)
return result
class NSM1(CardTable):
"""
<group name="NSM1">
<dataset name="IDENTITY">
<field name="SID" type="integer"/>
<field name="TYPE" type="character" size="8"/>
<field name="PROP" type="character" size="8" description="Name of nonstructural mass entry: NSM1 or NSML1"/>
<field name="VALUE" type="double"/>
<field name="ALL" type="integer"/>
<field name="LIST_POS" type="integer"/>
<field name="LIST_LEN" type="integer"/>
<field name="THRU_POS" type="integer"/>
<field name="THRU_LEN" type="integer"/>
<field name="THRUBY_POS" type="integer"/>
<field name="THRUBY_LEN" type="integer"/>
<field name="DOMAIN_ID" type="integer"/>
</dataset>
<dataset name="IDLIST">
<field name="ID" type="integer"/>
</dataset>
<dataset name="THRU">
<field name="ID1" type="integer"/>
<field name="ID2" type="integer"/>
</dataset>
<dataset name="THRU_BY">
<field name="ID1" type="integer"/>
<field name="ID2" type="integer"/>
<field name="N" type="integer"/>
</dataset>
</group>
"""
table_def = TableDef.create('/NASTRAN/INPUT/PROPERTY/NSM1/IDENTITY',
rename={
'IDLIST_POS': 'LIST_POS',
'IDLIST_LEN': 'LIST_LEN',
'THRU_BY_POS': 'THRUBY_POS',
'THRU_BY_LEN': 'THRUBY_LEN'
})
class PBCOMP(CardTable):
"""
<group name="PBCOMP">
<dataset name="IDENTITY">
<field name="PID" type="integer"/>
<field name="MID" type="integer"/>
<field name="A" type="double"/>
<field name="I1" type="double"/>
<field name="I2" type="double"/>
<field name="I12" type="double"/>
<field name="J" type="double"/>
<field name="NSM" type="double"/>
<field name="K1" type="double"/>
<field name="K2" type="double"/>
<field name="M1" type="double"/>
<field name="M2" type="double"/>
<field name="N1" type="double"/>
<field name="N2" type="double"/>
<field name="NSECT" type="integer"/>
<field name="POS" type="integer"/>
<field name="LEN" type="integer"/>
<field name="DOMAIN_ID" type="integer"/>
</dataset>
<dataset name="SECTION">
<field name="Y" type="double"/>
<field name="Z" type="double"/>
<field name="C" type="double"/>
<field name="MID" type="integer"/>
</dataset>
</group>
"""
table_def = TableDef.create('/NASTRAN/INPUT/PROPERTY/PBCOMP/IDENTITY',
rename={
'SECTION_POS': 'POS',
'SECTION_LEN': 'LEN'
})
class PCOMPG(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/PROPERTY/PCOMPG/IDENTITY')
@classmethod
def from_bdf(cls, cards):
_ft = {
None: DataHelper.default_int,
'': DataHelper.default_int,
'HILL': 1,
'HOFF': 2,
'TSAI': 3,
'STRN': 4
}
# TODO: check that sout is correct
_convert_sout = {'YES': 1, 'NO': 0}
ply = {
'IDENTITY': {
'GPLYID': [],
'MID': [],
'THICK': [],
'THETA': [],
'SOUT': [],
'MIDMTX': [],
'VF': [],
'VV': [],
'CTEMP': [],
'MOIST': [],
'CRIT': [],
'NFTI': [],
'FTI': []
}
}
result = {
'IDENTITY': {
'PID': [],
'NPLIES': [],
'Z0': [],
'NSM': [],
'SB': [],
'FT': [],
'TREF': [],
'GE': [],
'MICRO': [],
'PLY_POS': [],
'PLY_LEN': [],
'DOMAIN_ID': []
},
'PLY': ply,
'_subtables': ['PLY']
}
identity = result['IDENTITY']
pid = identity['PID']
nplies = identity['NPLIES']
z0 = identity['Z0']
nsm = identity['NSM']
sb = identity['SB']
ft = identity['FT']
tref = identity['TREF']
ge = identity['GE']
micro = identity['MICRO']
ply_pos = identity['PLY_POS']
ply_len = identity['PLY_LEN']
ply = ply['IDENTITY']
gplyid = ply['GPLYID']
mid = ply['MID']
thick = ply['THICK']
theta = ply['THETA']
sout = ply['SOUT']
midmtx = ply['MIDMTX']
vf = ply['VF']
vv = ply['VV']
ctemp = ply['CTEMP']
moist = ply['MOIST']
crit = ply['CRIT']
nfti = ply['NFTI']
fti = ply['FTI']
card_ids = sorted(iterkeys(cards))
_pos = 0
for card_id in card_ids:
card = cards[card_id]
pid.append(card.pid)
n = len(card.thicknesses)
nplies.append(n)
z0.append(card.z0)
nsm.append(card.nsm)
sb.append(card.sb)
ft.append(_ft[card.ft])
tref.append(card.tref)
ge.append(card.ge)
micro.append(DataHelper.unknown_str)
ply_pos.append(_pos)
ply_len.append(n)
_pos += n
gplyid += list(card.global_ply_ids)
mid += list(card.mids)
thick += list(card.thicknesses)
theta += list(card.thetas)
sout += [_convert_sout[_] for _ in card.souts]
midmtx += [DataHelper.unknown_int] * n
vf += [DataHelper.unknown_double] * n
vv += [DataHelper.unknown_double] * n
ctemp += [DataHelper.unknown_double] * n
moist += [DataHelper.unknown_double] * n
crit += [DataHelper.unknown_str] * n
nfti += [DataHelper.unknown_int] * n
fti += [DataHelper.unknown_str] * n
return result
class PCOMPF(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/PROPERTY/PCOMPF/IDENTITY',
rename={
'IDLIST_POS': 'LIST_POS',
'IDLIST_LEN': 'LIST_LEN'
})
class PCOMP(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/PROPERTY/PCOMP/IDENTITY')
@classmethod
def from_bdf(cls, cards):
_ft = {
None: DataHelper.default_int,
'': DataHelper.default_int,
'HILL': 1,
'HOFF': 2,
'TSAI': 3,
'STRN': 4
}
# TODO: check that sout is correct
_convert_sout = {'YES': 1, 'NO': 0}
ply = {'IDENTITY': {'MID': [], 'T': [], 'THETA': [], 'SOUT': []}}
data = {
'IDENTITY': {
'PID': [],
'NPLIES': [],
'Z0': [],
'NSM': [],
'SB': [],
'FT': [],
'TREF': [],
'GE': [],
'PLY_POS': [],
'PLY_LEN': []
},
'PLY': ply,
'_subtables': ['PLY']
}
identity = data['IDENTITY']
pid = identity['PID']
nplies = identity['NPLIES']
z0 = identity['Z0']
nsm = identity['NSM']
sb = identity['SB']
ft = identity['FT']
tref = identity['TREF']
ge = identity['GE']
ply_pos = identity['PLY_POS']
ply_len = identity['PLY_LEN']
ply = ply['IDENTITY']
mid = ply['MID']
t = ply['T']
theta = ply['THETA']
sout = ply['SOUT']
card_ids = sorted(iterkeys(cards))
_ply_pos = 0
for card_id in card_ids:
card = cards[card_id]
_plies = len(card.material_ids)
pid.append(card.pid)
nplies.append(_plies)
z0.append(round(card.z0, 15))
nsm.append(card.nsm)
sb.append(card.sb)
ft.append(_ft[card.ft])
tref.append(card.tref)
ge.append(card.ge)
ply_pos.append(_ply_pos)
ply_len.append(_plies)
_ply_pos += _plies
mid.extend(list(card.material_ids))
t.extend(list(card.thicknesses))
theta.extend(card.thetas)
sout.extend([_convert_sout.get(_, 0) for _ in card.souts])
return data
class PCOHE(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/PROPERTY/PCOHE')
class PBUSHT(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/PROPERTY/PBUSHT')
class PBEMN1(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/PROPERTY/PBEMN1')
class PBEAML(CardTable):
table_def = TableDef.create(
'/NASTRAN/INPUT/PROPERTY/PBEAML/IDENTITY',
subtables=[
TableDef.create(
'/NASTRAN/INPUT/PROPERTY/PBEAML/SECTION',
subtables=[
TableDef.create('/NASTRAN/INPUT/PROPERTY/PBEAML/DIMS')
])
])
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
dims = {'IDENTITY': {'DIM': []}}
section = {
'IDENTITY': {
'SO': [],
'RDIST': [],
'DIMS_POS': [],
'DIMS_LEN': [],
'NSM': []
},
'DIMS': dims,
'_subtables': ['DIMS']
}
result = {
'IDENTITY': {
'PID': [],
'MID': [],
'GROUP': [],
'TYPE': [],
'SECTION_POS': [],
'SECTION_LEN': [],
'DOMAIN_ID': []
},
'SECTION': section,
'_subtables': ['SECTION']
}
section = section['IDENTITY']
identity = result['IDENTITY']
dim = dims['IDENTITY']['DIM']
so = section['SO']
rdist = section['RDIST']
dims_pos = section['DIMS_POS']
dims_len = section['DIMS_LEN']
nsm = section['NSM']
pid = identity['PID']
mid = identity['MID']
group = identity['GROUP']
type_ = identity['TYPE']
section_pos = identity['SECTION_POS']
section_len = identity['SECTION_LEN']
# TODO: PBEAML - verify so is correct
_so = {
'': DataHelper.default_double,
None: DataHelper.default_double,
'NO': 0.,
'YES': 1.,
'YESA': 2.
}
_section_pos = 0
_dims_pos = 0
for card_id in card_ids:
card = cards[card_id]
pid.append(card.pid)
mid.append(card.mid)
group.append(card.group)
type_.append(card.beam_type)
_section_len = len(card.so)
section_pos.append(_section_pos)
section_len.append(_section_len)
so += [_so[_s] for _s in card.so]
rdist += list(card.xxb)
nsm += list(card.nsm)
for _dim in card.dim:
_dim_len = len(_dim)
dims_pos.append(_dims_pos)
_dims_pos += _dim_len
dims_len.append(_dim_len)
dim += list(_dim)
return result
class PBEAM(CardTable):
table_def = TableDef.create('/NASTRAN/INPUT/PROPERTY/PBEAM')
@classmethod
def from_bdf(cls, cards):
card_ids = sorted(cards.keys())
data = np.empty(len(card_ids), dtype=cls.table_def.dtype)
pid = data['PID']
mid = data['MID']
nsegs = data['NSEGS']
data['CCF'][:] = DataHelper.unknown_int
data['CWELD'][:] = DataHelper.unknown_int
######################
so = data['SO']
xxb = data['XXB']
a = data['A']
i1 = data['I1']
i2 = data['I2']
i12 = data['I12']
j = data['J']
nsm = data['NSM']
c1 = data['C1']
c2 = data['C2']
d1 = data['D1']
d2 = data['D2']
e1 = data['E1']
e2 = data['E2']
f1 = data['F1']
f2 = data['F2']
######################
k1 = data['K1']
k2 = data['K2']
s1 = data['S1']
s2 = data['S2']
nsia = data['NSIA']
nsib = data['NSIB']
cwa = data['CWA']
cwb = data['CWB']
m1a = data['M1A']
m2a = data['M2A']
m1b = data['M1B']
m2b = data['M2B']
n1a = data['N1A']
n2a = data['N2A']
n1b = data['N1B']
n2b = data['N2B']
# TODO: PBEAM - verify so is correct
_so = {
'': DataHelper.default_double,
None: DataHelper.default_double,
'NO': 0.,
'YES': 1.,
'YESA': 2.
}
# TODO: The first and last stations (xxb = 0.0, 1.0 are in slots 0 and 10).
# Intermediate slots are 0.0 if they are not defined and nonzero
# if the data is meaningful. The data coming from the PBEAM/PBEAML
# is sorted, but only uses as many fields as is necessary to fully
# define the card.
#
# TODO: PBEAM: verify that above comment has been implemented correctly regarding resizing of data
i = -1
for card_id in card_ids:
i += 1
card = cards[card_id]
pid[i] = card.pid
mid[i] = card.mid
nsegs[i] = len(card.so)
so[i] = _resize([_so[_] for _ in card.so], 11)
xxb[i] = _resize(card.xxb, 11)
a[i] = _resize(card.A, 11)
i1[i] = _resize(card.i1, 11)
i2[i] = _resize(card.i2, 11)
i12[i] = _resize(card.i12, 11)
j[i] = _resize(card.j, 11)
nsm[i] = _resize(card.nsm, 11)
c1[i] = _resize(card.c1, 11)
c2[i] = _resize(card.c2, 11)
d1[i] = _resize(card.d1, 11)
d2[i] = _resize(card.d2, 11)
e1[i] = _resize(card.e1, 11)
e2[i] = _resize(card.e2, 11)
f1[i] = _resize(card.f1, 11)
f2[i] = _resize(card.f2, 11)
k1[i] = card.k1
k2[i] = card.k2
s1[i] = card.s1
s2[i] = card.s2
nsia[i] = card.nsia
nsib[i] = card.nsib
cwa[i] = card.cwa
cwb[i] = card.cwb
m1a[i] = card.m1a
m2a[i] = card.m2a
m1b[i] = card.m1b
m2b[i] = card.m2b
n1a[i] = card.n1a
n2a[i] = card.n2a
n1b[i] = card.n1b
n2b[i] = card.n2b
result = {'IDENTITY': data}
return result
