def repr_fields(self):
lid = set_blank_if_default(self.Lid(), -1e20)
uid = set_blank_if_default(self.Uid(), 1e20)
lowfq = set_blank_if_default(self.lowfq, 0.0)
highfq = set_blank_if_default(self.highfq, 1e20)
list_fields = ['DCONSTR', self.oid, self.Rid(), lid, uid, lowfq, highfq]
return list_fields
def repr_fields(self):
c0 = set_blank_if_default(self.c0, 0.)
cmult = set_blank_if_default(self.cmult, 1.)
list_fields = ['DLINK', self.oid, self.ddvid, c0, cmult]
for (idv, ci) in zip(self.IDv, self.Ci):
list_fields += [idv, ci]
return list_fields
def test_field_defaults(self):
self.assertEqual(set_blank_if_default(0.0, 0.0), None,
set_blank_if_default(0.0, 0.0))
self.assertEqual(set_blank_if_default(1.0, 0.0), 1.0,
set_blank_if_default(1.0, 0.0))
# None
self.assertEqual(set_default_if_blank(None, None), None,
set_default_if_blank(None, None))
# floats
self.assertEqual(set_default_if_blank(4.0, None), 4.0,
set_default_if_blank(4.0, None))
self.assertEqual(set_default_if_blank(None, 4.0), 4.0,
set_default_if_blank(None, 4.0))
# ints
self.assertEqual(set_default_if_blank(4, None), 4,
set_default_if_blank(4, None))
self.assertEqual(set_default_if_blank(None, 4), 4,
set_default_if_blank(None, 4))
# strings
self.assertEqual(set_default_if_blank('dummy', 'GGG'), 'dummy',
set_default_if_blank('dummy', 'GGG'))
self.assertEqual(set_default_if_blank(None, 'GGG'), 'GGG',
set_default_if_blank(None, 'GGG'))
def repr_fields(self):
nodes = self.node_ids
ge = set_blank_if_default(self.ge, 0.)
s = set_blank_if_default(self.s, 0.)
list_fields = ['CELAS2', self.eid, self.k, nodes[0], self.c1,
nodes[1], self.c2, ge, s]
return list_fields
def repr_fields(self):
j = set_blank_if_default(self.j, 0.0)
c = set_blank_if_default(self.c, 0.0)
nsm = set_blank_if_default(self.nsm, 0.0)
list_fields = [
'CONROD', self.eid] + self.node_ids + [self.Mid(), self.A, j, c, nsm]
return list_fields
def repr_fields(self):
film_node_id = set_blank_if_default(self.film_node_id, 0)
ta2 = set_blank_if_default(self.ta2, self.ta1)
mdot = set_blank_if_default(self.mdot, 1.0)
list_fields = ['CONVM', self.eid, self.pconvmID, film_node_id,
self.cntmdot, self.ta1, ta2, mdot]
return list_fields
def repr_fields(self):
nsm = set_blank_if_default(self.nsm, 0.)
gamma = set_blank_if_default(self.gamma, 0.5)
phi = set_blank_if_default(self.phi, 180.)
fields = ['PRAC2D', self.pid, self.Mid(), self.thick,
self.iPlane, nsm, gamma, phi]
return fields
def repr_fields(self):
xlb = set_blank_if_default(self.xlb, -1e20)
xub = set_blank_if_default(self.xub, 1e20)
delx = set_blank_if_default(self.delx, 1e20)
list_fields = ['DESVAR', self.oid, self.label, self.xinit, xlb,
xub, delx, self.ddval]
return list_fields
def write_card(self, bdf_file, size=8, element_ids=None):
if self.n:
if element_ids is None:
i = arange(self.n)
else:
i = searchsorted(self.element_id, self.element_id)
for (eid, pid, n, is_g0, g0, x, is_offt, offt, bit, pin, wa, wb, sa, sb) in zip(
self.element_id[i], self.property_id[i], self.node_ids[i],
self.is_g0[i], self.g0[i], self.x[i],
self.is_offt[i], self.offt[i], self.bit[i],
self.pin_flags[i], self.wa[i], self.wb[i], self.sa[i], self.sb[i]):
x1 = g0 if is_g0 else x[0]
x2 = 0 if is_g0 else x[1]
x3 = 0 if is_g0 else x[2]
offt_bit = offt if is_offt else bit
#print('is_offt=%s offt=%s bit=%s offt_bit=%s' % (is_offt, offt, bit, offt_bit))
pa = set_blank_if_default(pin[0], 0)
pb = set_blank_if_default(pin[1], 0)
w1a = set_blank_if_default(wa[0], 0.0)
w2a = set_blank_if_default(wa[1], 0.0)
w3a = set_blank_if_default(wa[2], 0.0)
w1b = set_blank_if_default(wb[0], 0.0)
w2b = set_blank_if_default(wb[1], 0.0)
w3b = set_blank_if_default(wb[2], 0.0)
sa = set_blank_if_default(sa, 0)
sb = set_blank_if_default(sb, 0)
card = ['CBEAM', eid, pid, n[0], n[1], x1, x2, x3, offt_bit,
pa, pb, w1a, w2a, w3a, w1b, w2b, w3b,
sa, sb]
bdf_file.write(print_card_8(card))
def repr_fields(self):
form = set_blank_if_default(self.form, 0)
flag = set_blank_if_default(self.flag, 0)
expr = set_blank_if_default(self.expr, 0.0)
exppi = set_blank_if_default(self.exppi, 0.0)
exppo = set_blank_if_default(self.exppo, 0.0)
list_fields = ["PCONVM", self.pconid, self.mid, form, flag, self.coef, expr, exppi, exppo]
return list_fields
def repr_fields(self):
mpMax = set_blank_if_default(self.mpMax, 1e20)
c0 = set_blank_if_default(self.c0, 0.)
list_fields = ['DVMREL1', self.oid, self.Type, self.Mid(),
self.mpName, self.mpMin, mpMax, c0, None]
for (dvid, coeff) in zip(self.dvids, self.coeffs):
list_fields.append(dvid)
list_fields.append(coeff)
return list_fields
def repr_fields(self):
#method = set_blank_if_default(self.method,1)
racc = set_blank_if_default(self.racc, 0.)
mb = set_blank_if_default(self.mb, 0)
idrf = set_blank_if_default(self.idrf, 0)
list_fields = ['RFORCE', self.sid, self.node_id, self.Cid(), self.scale,
self.r1, self.r2, self.r3, self.method, racc,
mb, idrf]
return list_fields
def get_offt_bit_defaults(self):
"""
offt doesn't exist in NX nastran
"""
if self.is_offt:
field8 = field8 = set_blank_if_default(self.offt, 'GGG')
else:
field8 = set_blank_if_default(self.bit, 0.0)
return field8
def repr_fields(self):
method = set_blank_if_default(self.method, 'MIN')
c1 = set_blank_if_default(self.c1, 100.)
c2 = set_blank_if_default(self.c2, 0.005)
list_fields = ['DRESP2', self.oid, self.label, self.DEquation(),
self.region, method, c1, c2, self.c3]
list_fields += self._pack_params()
return list_fields
def repr_fields(self):
xy = []
for xi, yi in zip(self.x, self.y):
xy.extend([xi, yi])
xaxis = set_blank_if_default(self.xaxis, 'LINEAR')
yaxis = set_blank_if_default(self.yaxis, 'LINEAR')
list_fields = ['TABRND1', self.tid, xaxis, yaxis, None, None,
None, None, None] + xy + ['ENDT']
return list_fields
def repr_fields(self):
iViewFront = set_blank_if_default(self.iViewFront, 0)
iViewBack = set_blank_if_default(self.iViewBack, 0)
radMidFront = set_blank_if_default(self.radMidFront, 0)
radMidBack = set_blank_if_default(self.radMidBack, 0)
list_fields = (['CHBDYG', self.eid, None, self.Type, iViewFront,
iViewBack, radMidFront, radMidBack, None, ] + self.node_ids)
return list_fields
def repr_fields(self):
form = set_blank_if_default(self.form, 0)
expf = set_blank_if_default(self.expf, 0.0)
ftype = set_blank_if_default(self.ftype, 0)
ce = set_blank_if_default(self.ce, 0)
list_fields = ['PCONV', self.pconid, self.mid, form, expf, ftype, self.tid,
None, None, self.chlen, self.gidin, ce, self.e1, self.e2,
self.e3]
return list_fields
def repr_fields(self):
#method = set_blank_if_default(self.method,'INV')
nep = set_blank_if_default(self.nep, 0)
ndp = set_blank_if_default(self.ndp, 3 * self.nep)
ndn = set_blank_if_default(self.ndn, 3 * self.nep)
norm = set_blank_if_default(self.norm, 'MAX')
list_fields = ['EIGB', self.sid, self.method, self.L1, self.L2, nep, ndp,
ndn, None, norm, self.G, self.C]
return list_fields
def repr_fields(self):
film_node = set_blank_if_default(self.film_node, 0)
cntrlnd = set_blank_if_default(self.cntrlnd, 0)
ta0 = self.ta[0]
ta = [ta0]
for tai in self.ta[1:]:
ta.append(set_blank_if_default(tai, ta0))
list_fields = ['CONV', self.eid, self.pconID, film_node, cntrlnd] + ta
return list_fields
def raw_method(self):
list_fields = []
if self.method in ['HESS', 'INV']:
for (alphaA, omegaA, alphaB, omegaB, Lj, NEj, NDj) in zip(
self.alphaAjs, self.omegaAjs, self.alphaBjs, self.omegaBjs,
self.LJs, self.NEJs, self.NDJs):
alphaA = set_blank_if_default(alphaA, 0.0)
omegaA = set_blank_if_default(omegaA, 0.0)
alphaB = set_blank_if_default(alphaB, 0.0)
omegaB = set_blank_if_default(omegaB, 0.0)
list_fields += [alphaA, omegaA, alphaB, omegaB, Lj, NEj, NDj, None]
elif self.method == 'CLAN':
assert len(self.alphaAjs) == len(self.omegaAjs)
assert len(self.alphaAjs) == len(self.mblkszs)
assert len(self.alphaAjs) == len(self.iblkszs)
assert len(self.alphaAjs) == len(self.ksteps)
assert len(self.alphaAjs) == len(self.NJIs)
for (alphaA, omegaA, mblksz, iblksz, kstep, Nj) in zip(
self.alphaAjs, self.omegaAjs, self.mblkszs, self.iblkszs,
self.ksteps, self.NJIs):
alphaA = set_blank_if_default(alphaA, 0.0)
omegaA = set_blank_if_default(omegaA, 0.0)
mblksz = set_blank_if_default(mblksz, 7)
iblksz = set_blank_if_default(iblksz, 2)
kstep = set_blank_if_default(kstep, 5)
list_fields += [alphaA, omegaA, mblksz, iblksz,
kstep, None, Nj, None]
else:
msg = 'invalid EIGC method...method=%r' % self.method
raise RuntimeError(msg)
return list_fields
def write_card(self, bdf_file, material_id=None, size=8, is_double=False):
if self.n:
if material_id is None:
i = np.arange(self.n)
else:
if isinstance(material_id, int):
material_id = [material_id]
i = np.searchsorted(self.material_id, material_id)
#print('imat1 = ', i)
#assert material_id is None, 'i=%i' % i
#self.model.log.debug"n = %s" % self.n)
#self.model.log.debug"mids MAT1 %s" % self.material_id)
Rho = ['' if rhoi == 0.0 else rhoi for rhoi in self.rho[i]]
A = ['' if ai == 0.0 else ai for ai in self.a[i]]
TRef = ['' if trefi == 0.0 else trefi for trefi in self.TRef[i]]
ge = ['' if gei == 0.0 else gei for gei in self.ge[i]]
St = ['' if st == 0.0 else st for st in self.St[i]]
Sc = ['' if sc == 0.0 else sc for sc in self.Sc[i]]
Ss = ['' if ss == 0.0 else ss for ss in self.Ss[i]]
if size == 8:
fmt_card = print_card_8
bdf_file.write('$MAT1 mid E G nu rho a TRef ge\n')
bdf_file.write('$ st sc ss mcsid\n')
else:
bdf_file.write('$MAT1* mid E G nu\n')
bdf_file.write('$* rho a TRef ge\n')
bdf_file.write('$* st sc ss mcsid\n')
if is_double:
fmt_card = print_card_double
else:
fmt_card = print_card_16
for (mid, E, G, nu, rho, a, TRef, ge, st, sc, ss, mcsid) in zip(
self.material_id[i], self.E[i], self.G[i], self.nu[i], Rho, A,
TRef, ge, St, Sc, Ss, self.mcsid[i]):
if mid in self._comments:
bdf_file.write(self._comments[mid])
#Gdefault = self.getG_default()
Gdefault = self._G_default(E, G, nu)
G = set_blank_if_default(G, Gdefault)
#rho = set_blank_if_default(rho, 0.)
#a = set_blank_if_default(a, 0.)
#TRef = set_blank_if_default(TRef, 0.)
#ge = set_blank_if_default(ge, 0.)
#st = set_blank_if_default(st, 0.)
#sc = set_blank_if_default(sc, 0.)
#ss = set_blank_if_default(ss, 0.)
mcsid = set_blank_if_default(mcsid, 0)
card = ['MAT1', mid, E, G, nu, rho, a, TRef, ge, st, sc, ss, mcsid]
bdf_file.write(fmt_card(card))
def repr_fields(self):
if self.g0 is not None:
x = [self.g0, None, None]
else:
x = self.x
ocid = set_blank_if_default(self.OCid(), -1)
s = set_blank_if_default(self.s, 0.5)
list_fields = (['CBUSH', self.eid, self.Pid(), self.Ga(), self.Gb()] +
x + [self.Cid(), s, ocid] + self.si)
return list_fields
def repr_fields(self):
twelveIt3 = set_blank_if_default(self.twelveIt3, 1.0)
tst = set_blank_if_default(self.tst, 0.833333)
nsm = set_blank_if_default(self.nsm, 0.0)
tOver2 = self.t / 2.
z1 = set_blank_if_default(self.z1, -tOver2)
z2 = set_blank_if_default(self.z2, tOver2)
list_fields = ['PSHELL', self.pid, self.Mid1(), self.t, self.Mid2(),
twelveIt3, self.Mid3(), tst, nsm, z1, z2, self.Mid4()]
return list_fields
def write_card(self, f, size=8, element_ids=None):
if self.n:
if element_ids is None:
i = arange(self.n)
else:
i = searchsorted(self.element_id, self.element_id)
for (eid, pid, n, is_g0, g0, x, offt, pin, wa, wb) in zip(
self.element_id[i], self.property_id[i], self.node_ids[i],
self.is_g0[i], self.g0[i], self.x[i],
self.offt[i],
self.pin_flags[i], self.wa[i], self.wb[i]):
pa = set_blank_if_default(pin[0], 0)
pb = set_blank_if_default(pin[1], 0)
w1a = set_blank_if_default(wa[0], 0.0)
w2a = set_blank_if_default(wa[1], 0.0)
w3a = set_blank_if_default(wa[2], 0.0)
w1b = set_blank_if_default(wb[0], 0.0)
w2b = set_blank_if_default(wb[1], 0.0)
w3b = set_blank_if_default(wb[2], 0.0)
x1 = g0 if is_g0 else x[0]
x2 = 0 if is_g0 else x[1]
x3 = 0 if is_g0 else x[2]
offt = set_string8_blank_if_default(offt, 'GGG')
card = ['CBAR', eid, pid, n[0], n[1], x1, x2, x3, offt,
pa, pb, w1a, w2a, w3a, w1b, w2b, w3b]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_card(self, bdf_file, size=8, property_id=None):
if self.n:
#print("PSOLID.property_id =", self.property_id)
for(pid, mid, cordm, integ, stress, isop, fctn) in zip(
self.property_id, self.material_id, self.cordm,
self.integ, self.stress, self.isop, self.fctn):
if pid in self._comments:
bdf_file.write(self._comments[pid])
cordm = set_blank_if_default(cordm, 0)
fctn = set_blank_if_default(fctn, 'SMECH')
card = ['PSOLID', pid, mid, cordm, integ,
stress, isop, fctn]
bdf_file.write(print_card_8(card))
def repr_fields(self):
u0 = set_blank_if_default(self.u0, 0.)
f0 = set_blank_if_default(self.f0, 0.)
ka = set_blank_if_default(self.ka, 1.e8)
kb = set_blank_if_default(self.kb, 1e-14 * self.ka)
kt = set_blank_if_default(self.kt, self.mu1 * self.ka)
mu1 = set_blank_if_default(self.mu1, 0.)
mu2 = set_blank_if_default(self.mu2, self.mu1)
tmax = set_blank_if_default(self.tmax, 0.)
mar = set_blank_if_default(self.mar, 100.)
trmin = set_blank_if_default(self.trmin, 0.001)
fields = ['PGAP', self.pid, u0, f0, ka, kb, kt, mu1, mu2,
tmax, mar, trmin]
return fields
def repr_fields(self):
"""
Gets the fields in their simplified form
Returns
-------
fields : List[int/float/str]
the fields that define the card
"""
cp = set_blank_if_default(self.Cp(), 0)
cd = set_blank_if_default(self.Cd(), 0)
seid = set_blank_if_default(self.SEid(), 0)
list_fields = ['GRID', self.nid, cp] + list(self.xyz) + [cd, self.ps,
seid]
return list_fields
def repr_fields(self):
"""
Gets the fields in their simplified form
:returns fields:
the fields that define the card
:type fields:
LIST
"""
cp = set_blank_if_default(self.Cp(), 0)
cd = set_blank_if_default(self.Cd(), 0)
ps = set_blank_if_default(self.ps, 0)
seid = set_blank_if_default(self.SEid(), 0)
list_fields = ['GRDSET', None, cp, None, None, None, cd, ps, seid]
return list_fields
def write_card(self, bdf_file, size=8, lids=None):
if self.n:
for (lid, nid, cid, scale_vel, r, method, scale_acc, mb, idrf) in zip(
self.load_id, self.node_id, self.coord_id, self.scale_vel,
self.r, self.scale_acc, self.mb, self.idrf):
#method = set_blank_if_default(method, 1)
scale_acc = set_blank_if_default(scale_acc, 0.)
mb = set_blank_if_default(mb, 0)
idrf = set_blank_if_default(idrf, 0)
card = ['RFORCE', lid, nid, cid, scale_vel,
r[0], r[1], r[2], method, scale_acc, mb, idrf]
if size == 8:
bdf_file.write(print_card_8(card))
else:
bdf_file.write(print_card_16(card))
def repr_fields(self):
list_fields = self.raw_fields()
list_fields2 = list_fields[0:4]
for field in list_fields[4:]:
val = set_blank_if_default(field, 0.)
list_fields2.append(val)
return list_fields2
def repr_fields(self):
ge = set_blank_if_default(self.ge, 0.)
s = set_blank_if_default(self.s, 0.)
list_fields = ['PELAS', self.pid, self.k, ge, s]
return list_fields
def repr_fields(self):
cntrlnd = set_blank_if_default(self.cntrlnd, 0)
eids = self.element_ids
eids.sort()
list_fields = ['QBDY3', self.sid, self.q0, cntrlnd] + collapse_thru_by(eids)
return list_fields
def repr_fields(self):
cr = set_blank_if_default(self.cr, 0.)
list_fields = ['PVISC', self.pid, self.ce, cr]
return list_fields
def write_card(self, bdf_file, size=8, material_id=None):
if self.n:
if material_id is None:
i = arange(self.n)
else:
i = searchsorted(self.material_id, material_id)
assert material_id is None
#card = ['$MAT1', 'mid', 'E', 'G', 'nu', 'rho', 'a', 'tref', 'ge']
#bdf_file.write(print_card_8(card))
#card = ['$', 'st', 'sc', 'ss', 'mcsid']
#bdf_file.write(print_card_8(card))
for (mid, e11, e22, nu12, g12, g1z, g2z, rho, a1, a2, tref,
Xt, Xc, Yt, Yc, S, ge, F12, strn) in zip(
self.material_id[i], self.e11[i], self.e22[i],
self.nu12[i], self.g12[i], self.g1z[i], self.g2z[i],
self.rho[i], self.a1[i], self.a2[i], self.tref[i],
self.Xt[i], self.Xc[i], self.Yt[i], self.Yc[i], self.S[i],
self.ge[i], self.F12[i], self.strn[i]):
if mid in self._comments:
bdf_file.write(self._comments[mid])
g12 = set_blank_if_default(g12, 0.)
g1z = set_blank_if_default(g1z, 1e8)
g2z = set_blank_if_default(g2z, 1e8)
rho = set_blank_if_default(rho, 0.0)
a1 = set_blank_if_default(a1, 0.0)
a2 = set_blank_if_default(a2, 0.0)
tref = set_blank_if_default(tref, 0.0)
Xt = set_blank_if_default(Xt, 0.)
Yt = set_blank_if_default(Yt, 0.)
Xc = set_blank_if_default(Xc, Xt)
Yc = set_blank_if_default(Yc, Yt)
S = set_blank_if_default(S, 0.0)
ge = set_blank_if_default(ge, 0.0)
F12 = set_blank_if_default(F12, 0.0)
strn = set_blank_if_default(strn, 0.0)
card = [
'MAT8', mid, e11, e22, nu12, g12, g1z, g2z, rho, a1, a2,
tref, Xt, Xc, Yt, Yc, S, ge, F12, strn
]
bdf_file.write(print_card_8(card))
def write_card(self, bdf_file, material_id=None, size=8, is_double=False):
if self.n:
if material_id is None:
i = np.arange(self.n)
else:
if isinstance(material_id, int):
material_id = [material_id]
i = np.searchsorted(self.material_id, material_id)
#print('imat1 = ', i)
#assert material_id is None, 'i=%i' % i
#self.model.log.debug"n = %s" % self.n)
#self.model.log.debug"mids MAT1 %s" % self.material_id)
Rho = ['' if rhoi == 0.0 else rhoi for rhoi in self.rho[i]]
A = ['' if ai == 0.0 else ai for ai in self.a[i]]
tref = ['' if trefi == 0.0 else trefi for trefi in self.tref[i]]
ge = ['' if gei == 0.0 else gei for gei in self.ge[i]]
St = ['' if st == 0.0 else st for st in self.St[i]]
Sc = ['' if sc == 0.0 else sc for sc in self.Sc[i]]
Ss = ['' if ss == 0.0 else ss for ss in self.Ss[i]]
if size == 8:
fmt_card = print_card_8
bdf_file.write(
'$MAT1 mid E G nu rho a tref ge\n'
)
bdf_file.write('$ st sc ss mcsid\n')
else:
bdf_file.write(
'$MAT1* mid E G nu\n'
)
bdf_file.write(
'$* rho a tref ge\n'
)
bdf_file.write(
'$* st sc ss mcsid\n'
)
if is_double:
fmt_card = print_card_double
else:
fmt_card = print_card_16
for (mid, E, G, nu, rho, a, tref, ge, st, sc, ss,
mcsid) in zip(self.material_id[i], self.E[i], self.G[i],
self.nu[i], Rho, A, TRef, ge, St, Sc, Ss,
self.mcsid[i]):
if mid in self._comments:
bdf_file.write(self._comments[mid])
#Gdefault = self.getG_default()
Gdefault = self._G_default(E, G, nu)
G = set_blank_if_default(G, Gdefault)
#rho = set_blank_if_default(rho, 0.)
#a = set_blank_if_default(a, 0.)
#tref = set_blank_if_default(tref, 0.)
#ge = set_blank_if_default(ge, 0.)
#st = set_blank_if_default(st, 0.)
#sc = set_blank_if_default(sc, 0.)
#ss = set_blank_if_default(ss, 0.)
mcsid = set_blank_if_default(mcsid, 0)
card = [
'MAT1', mid, E, G, nu, rho, a, tref, ge, st, sc, ss, mcsid
]
bdf_file.write(fmt_card(card))
def repr_fields(self):
t = set_blank_if_default(self.t, self.OD1 / 2.)
nsm = set_blank_if_default(self.nsm, 0.0)
OD2 = set_blank_if_default(self.OD2, self.OD1)
list_fields = ['PTUBE', self.pid, self.Mid(), self.OD1, t, nsm, OD2]
return list_fields
def repr_fields(self):
j = set_blank_if_default(self.j, 0.0)
c = set_blank_if_default(self.c, 0.0)
nsm = set_blank_if_default(self.nsm, 0.0)
list_fields = ['PROD', self.pid, self.Mid(), self.A, j, c, nsm]
return list_fields
def repr_fields(self):
method = set_blank_if_default(self.method, 'LAN')
norm = set_blank_if_default(self.norm, 'MASS')
list_fields = ['EIGR', self.sid, method, self.f1, self.f2, self.ne,
self.nd, None, None, norm, self.G, self.C]
return list_fields
def raw_fields(self):
stress_strain = set_blank_if_default(self.stress_strain, 'GRID')
fields = ['PLSOLID', self.pid, self.Mid(), stress_strain]
return fields
def repr_fields(self):
alpha = set_blank_if_default(self.alpha, 0.)
list_fields = ['RBE2', self.eid, self.Gn(), self.cm
] + self.Gmi_node_ids + [alpha]
return list_fields
def repr_fields(self):
theta_mcid = set_blank_if_default(self.theta_mcid, 0.0)
nodeIDs = self.node_ids
list_fields = ['CTRIAX', self.eid, self.Pid()] + nodeIDs + [theta_mcid]
return list_fields
def repr_fields(self):
alpha = set_blank_if_default(self.alpha, 0.0)
list_fields = ['RBAR1', self.eid, self.Ga(), self.Gb(), self.cb, alpha]
return list_fields
def repr_fields(self):
mass = set_blank_if_default(self.mass, 0.)
fields = ['CMASS2', self.eid, mass, self.G1(), self.c1,
self.G2(), self.c2]
return fields
def set_string16_blank_if_default(value, default):
"""helper method for writing BDFs"""
val = set_blank_if_default(value, default)
if val is None:
return ' '
return '%16s' % val
def repr_fields(self):
gamma = set_blank_if_default(self.gamma, 0.5)
phi = set_blank_if_default(self.phi, 180.)
fields = ['PRAC3D', self.pid, self.Mid(), gamma, phi]
return fields
