def write_bdf(self, f, size=8, is_double=False):
if self.n:
card = ['GRDSET', None, self.cp, None, None, None, self.cd, self.seid]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8):
for comp, nodes in iteritems(self.components):
card = ['SPC1', self.constraint_id, comp] + list(nodes)
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, size=8, is_double=False):
card = self.reprFields()
if size == 8:
return self.comment() + print_card_8(card)
elif is_double:
return self.comment() + print_card_double(card)
return self.comment() + print_card_16(card)
def write_bdf(self, size=8, is_double=False):
card = self.reprFields()
if size == 8:
return self.comment() + print_card_8(card)
elif is_double:
return self.comment() + print_card_double(card)
return self.comment() + print_card_16(card)
def write_bdf(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_bdf(self, f, size=8):
card = ['NLPCI', self.nlpci_id, self.Type, self.minalr,
self.maxalr, self.scale, None, self.desiter, self.mxinc]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8):
card = ['SPCADD', self.spc_id] + self.spc_ids
#print "card = ", card
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size, is_double, coord_id=None):
assert size in [8, 16], size
assert is_double in [True, False], is_double
if self.n:
#if coord_id is None:
i = arange(self.n)
#else:
#assert len(unique(coord_id))==len(coord_id), unique(coord_id)
#i = searchsorted(self.coord_id, coord_id)
if size == 8:
for cid, coord in iteritems(self.coords):
if cid > 0:
list_fields = [coord.type, cid, coord.rid] + list(coord.e1) + list(coord.e2) + list(coord.e3)
f.write(print_card_8(list_fields))
else:
if is_double:
for cid, coord in iteritems(self.coords):
if cid > 0:
list_fields = [coord.type, cid, coord.rid] + list(coord.e1) + list(coord.e2) + list(coord.e3)
f.write(print_card_16(list_fields))
else:
for cid, coord in iteritems(self.coords):
if cid > 0:
list_fields = [coord.type, cid, coord.rid] + list(coord.e1) + list(coord.e2) + list(coord.e3)
f.write(print_card_double(list_fields))
def write_bdf(self, f, size=8, property_id=None):
#print('PBARL.n = %s' % self.n)
if self.n:
if property_id is None:
i = arange(self.n)
else:
i = searchsorted(self.property_id, property_id)
#print('i = %s' % i)
#cid = [cid if cid != 0 else '' for cid in self.coord_id]
#group = set_blank_if_default(self.group, 'MSCBMLO')
#list_fields = ['PBARL', self.pid, self.Mid(), group, self.Type, None,
#None, None, None] + self.dim + [self.nsm]
#self.model.log.debug('*pbarl write pids=%s' % self.property_id)
for (j, pid, mid, group, Type, nsm) in zip(count(), self.property_id[i], self.material_id[i],
self.group[i], self.Type[i], self.nsm[i]):
dim = self.dim[j]
sgroup = set_blank_if_default(group, 'MSCBMLO')
list_fields = ['PBARL', pid, mid, group, Type, None,
None, None, None] + dim + [nsm]
if size == 8:
f.write(print_card_8(list_fields))
else:
f.write(print_card_16(list_fields))
def write_bdf(self, f, size=8):
for comp, nodes in iteritems(self.components):
card = ['SPC1', self.constraint_id, comp] + list(nodes)
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(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_bdf(self, f, size=8, property_id=None):
#print('PBARL.n = %s' % self.n)
if self.n:
if property_id is None:
i = arange(self.n)
else:
i = searchsorted(self.property_id, property_id)
#print('i = %s' % i)
#cid = [cid if cid != 0 else '' for cid in self.coord_id]
#group = set_blank_if_default(self.group, 'MSCBMLO')
#list_fields = ['PBARL', self.pid, self.Mid(), group, self.Type, None,
#None, None, None] + self.dim + [self.nsm]
#self.model.log.debug('*pbarl write pids=%s' % self.property_id)
for (j, pid, mid, group, Type,
nsm) in zip(count(), self.property_id[i], self.material_id[i],
self.group[i], self.Type[i], self.nsm[i]):
dim = self.dim[j]
sgroup = set_blank_if_default(group, 'MSCBMLO')
list_fields = [
'PBARL', pid, mid, group, Type, None, None, None, None
] + dim + [nsm]
if size == 8:
f.write(print_card_8(list_fields))
else:
f.write(print_card_16(list_fields))
def write_bdf(self, f, size=8, material_id=None):
if size == 8:
for mid, table_id, Type, h, hflag, yf, hr, limit1, limit2 in zip(
self.material_id, self.table_id, self.Type, self.h,
self.hflag, self.yf, self.hr, self.limit1, self.limit2):
if not hflag:
h = None
if limit2 is None:
card = ['MATS1', mid, table_id, Type, h, yf, hr, limit1]
else:
card = [
'MATS1', mid, table_id, Type, h, yf, hr, limit1, limit2
]
f.write(print_card_8(card))
else:
for mid, table_id, Type, h, hflag, yf, hr, limit1, limit2 in zip(
self.material_id, self.table_id, self.Type, self.h,
self.hflag, self.yf, self.hr, self.limit1, self.limit2):
if not hflag:
h = None
if limit2 is None:
card = ['MATS1', mid, table_id, Type, h, yf, hr, limit1]
else:
card = [
'MATS1', mid, table_id, Type, h, yf, hr, limit1, limit2
]
f.write(print_card_16(card))
def write_bdf(self, f, size=8, is_double=False):
#..todo:: collapse the IDs
if self.n:
card = ['EPOINT'] + list(self.epoint)
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8):
card = [
'NLPCI', self.nlpci_id, self.Type, self.minalr, self.maxalr,
self.scale, None, self.desiter, self.mxinc
]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8):
if self.n:
n = 0
for lid, t in zip(self.load_id, self.temperature_default):
card = ['TEMPD', lid, t]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8):
if self.n:
n = 0
for lid, t in zip(self.load_id, self.temperature_default):
card = ['TEMPD', lid, t]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8, is_double=False):
if self.n:
f.write('$POINTAX\n')
for (nid, rid, phi) in zip(self.point_id, self.ring_id, self.phi):
card = ['POINTAX', rid, phi]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8, lids=None):
if self.n:
for (lid, nid, cid, mag, xyz) in zip(
self.load_id, self.node_id, self.coord_id, self.mag, self.xyz):
card = ['MOMENT', lid, nid, cid, mag, xyz[0], xyz[1], xyz[2] ]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8, lids=None):
if self.n:
for (lid, cid, scale, N, mb) in zip(
self.load_id, self.coord_id, self.scale, self.N, self.mb):
card = ['GRAV', lid, cid, scale, N[0], N[1], n[2], mb]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8):
if self.n:
for constraint in self.constraints:
card = ['MPC', self.constraint_id]
for (G, C, A) in constraint:
card += [G, C, A]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8):
if self.n:
for constraint in self.constraints:
card = ['MPC', self.constraint_id]
for (G, C, A) in constraint:
card += [G, C, A]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8):
if self.n:
for dof, node_ids in sorted(iteritems(self.components)):
card = ['SPC', self.constraint_id]
for node_id in node_ids:
card += [node_id, dof, 0.0]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8):
if self.n:
for dof, node_ids in sorted(iteritems(self.components)):
card = ['SPC', self.constraint_id]
for node_id in node_ids:
card += [node_id, dof, 0.0]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8, is_double=False, load_id=None):
if load_id is None:
load_id = self.load_id
load_id = asarray(load_id)
list_fields = ['LOAD', self.load_id, self.scale]
for (scaleFactor, lid) in zip(self.scale_factors, self.load_ids):
list_fields += [scaleFactor, lid]
if size == 8:
f.write(print_card_8(list_fields))
else:
f.write(print_card_16(list_fields))
def write_bdf(self, f, size=8, is_double=False, load_id=None):
if load_id is None:
load_id = self.load_id
load_id = asarray(load_id)
list_fields = ['LOAD', self.load_id, self.scale]
for (scaleFactor, lid) in zip(self.scale_factors, self.load_ids):
list_fields += [scaleFactor, lid]
if size == 8:
f.write(print_card_8(list_fields))
else:
f.write(print_card_16(list_fields))
def write_bdf(self, f, size=8, load_ids=None):
if self.n:
i = self.get_index(load_ids)
for (lid, eid, p, n,
theta) in zip(self.load_id[i], self.element_id[i], self.p[i],
self.node_ids[i], self.theta[i]):
card = ['PLOADX1', lid, eid, p[0], p[1], n[0], n[1], theta]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8, lids=None):
if self.n:
for (lid, nid, cid, mag, xyz) in zip(self.load_id, self.node_id,
self.coord_id, self.mag,
self.xyz):
card = ['FORCE1', lid, nid, cid, mag, xyz[0], xyz[1], xyz[2]]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8, element_id=None):
if self.n:
if element_id is None:
i = arange(self.n)
for (eid, n12, mid, A, J, c, nsm) in zip(
self.element_id, self.node_ids, self.material_id, self.A, self.J,
self.c, self.nsm):
card = ['CONROD', eid, n12[0], n12[1], mid, A, J, c, nsm ]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8, eids=None):
if self.n:
if eids is None:
i = arange(self.n)
else:
i = searchsorted(self.element_id, self.eid)
for (eid, pid, n, c) in zip(self.element_id[i], self.property_id[i], self.node_ids[i], self.components[i]):
card = ['CELAS1', eid, pid, n[0], n[1], c[0], c[1] ]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8, is_double=False, load_id=None):
if self.n:
if load_id is None:
for (lid, nid, cid, mag, xyz) in zip(
self.load_id, self.node_id, self.coord_id, self.mag, self.xyz):
card = ['FORCE', lid, nid, cid, mag, xyz[0], xyz[1], xyz[2] ]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
else:
for lid in unique(load_id):
i = where(self.load_id == lid)[0]
for (lid, nid, cid, mag, xyz) in zip(
self.load_id[i], self.node_id[i], self.coord_id[i], self.mag[i], self.xyz[i]):
card = ['FORCE', lid, nid, cid, mag, xyz[0], xyz[1], xyz[2] ]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8, property_id=None):
if self.n:
if property_id is None:
i = arange(self.n)
else:
i = property_id
for (pid, k, ge, s) in zip(self.property_id[i], self.K[i], self.ge[i], self.s[i]):
card = ['PELAS', pid, k, ge, s]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8, element_id=None):
if self.n:
if element_id is None:
i = arange(self.n)
for (eid, n12, mid, A, J, c,
nsm) in zip(self.element_id, self.node_ids, self.material_id,
self.A, self.J, self.c, self.nsm):
card = ['CONROD', eid, n12[0], n12[1], mid, A, J, c, nsm]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def cart3d_to_nastran_filename(cart3d_filename,
bdf_filename,
log=None,
debug=False):
"""
Converts a Cart3D file to STL format.
:param cart3d_filename: path to the input Cart3D file
:param bdf_filename: path to the output BDF file
:param log: a logger object (or None)
:param debug: True/False (used if log is not defined)
"""
cart3d = Cart3DReader(log=log, debug=debug)
(nodes, elements, regions, loads) = cart3d.read_cart3d(cart3d_filename)
#bdf = BDF()
#bdf.nodes = cart3d.nodes
#bdf.elements = cart3d.elements
#bdf.write_bdf(bdf_filename)
#return
f = open(bdf_filename, 'wb')
f.write('CEND\n')
f.write('BEGIN BULK\n')
f.write('$Nodes\n')
i = 0
nid = 1
cid = 0
for node in nodes:
card = print_card_16(['GRID', nid, cid] + list(node))
f.write(card)
eid = 1
f.write('$Elements\n')
for (n1, n2, n3), pid in zip(elements, regions):
card = print_card_8(['CTRIA3', eid, pid, n1, n2, n3])
f.write(card)
eid += 1
t = 0.1
E = 1e7
nu = 0.3
f.write('$Properties\n')
for pid in unique(regions):
mid = pid
card = print_card_8(['PSHELL', pid, mid, t])
f.write(card)
card = print_card_8(['MAT1', mid, E, None, nu])
f.write(card)
f.write('ENDDATA\n')
f.close()
def test_card_double(self):
card = print_card_double(['GRID', 1, None, 120.322,-4.82872,1.13362])
card_expected = 'GRID* 1 1.2032200000D+02-4.828720000D+00\n'
card_expected += '* 1.1336200000D+00\n'
self.assertEqual(card, card_expected)
#card = print_card_double(['CHEXA', 1, 2, 2, 3, 4, 1, 8, 5,
#6, 7])
#card_expected = ''
#card_expected += 'CHEXA* 1 2 2 3\n'
#card_expected +='* 4 1 8 5\n'
#card_expected +='* 6 7\n'
#card_expected += '* 1.1336200000D+00\n'
#card = print_card_double(['CTETRA',6437,1,14533,5598,1577,9976,42364,5599,42365,42363,30022,12904])
#card_expected = ''
#card_expected += 'CTETRA* 6437 1 14533 5598\n'
#card_expected += '* 1577 9976 42364 5599\n'
#card_expected += '* 42365 42363 30022 12904\n'
#card_expected += '* \n'
#card_expected +='CTETRA* 6437 1 14533 5598\n'
#card_expected +='* 1577 9976 42364 5599\n'
#card_expected +='* 42365 42363 30022 12904\n'
#card_expected +='* \n'
#self.assertEqual(card, card_expected)
#=============================
# mid E1 E2 nu12 G12 G1z G2z rho
card = print_card_8(['MAT8', 6, 1.7e+7, 1.7e+7, .98, 340000., 180000., 180000., .0001712,
# a1 a2 TRef
None, 71.33])
card_expected = ''
card_expected += 'MAT8 6 1.7+7 1.7+7 .98 340000. 180000. 180000..0001712\n'
card_expected += ' 71.33\n'
self.assertEqual(card, card_expected)
card = print_card_16(['MAT8', 6, 1.7e+7, 1.7e+7, .98, 340000., 180000., 180000., .0001712,
# a1 a2 TRef
None, 71.33])
card_expected = ''
card_expected += 'MAT8* 6 17000000. 17000000. .98\n'
card_expected += '* 340000. 180000. 180000. .0001712\n'
card_expected += '* 71.33\n'
card_expected += '*\n'
# bad
self.assertEqual(card, card_expected)
def write_bdf(self, f, size=8, element_id=None):
if self.n:
if element_id is None:
i = arange(self.n)
else:
assert len(unique(element_id))==len(element_id), unique(element_id)
i = searchsorted(self.element_id, element_id)
for (eid, pid, n) in zip(self.element_id[i], self.property_id[i], self.node_ids[i]):
card = ['CSHEAR', eid, pid, n[0], n[1], n[2], n[3]]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8, load_ids=None):
if self.n:
if load_ids is None:
i = arange(self.n)
else:
i = searchsorted(load_ids, self.load_id)
for (load_id, element_id, p) in zip(self.load_id[i],
self.element_id[i], self.p[i]):
card = ['PLOAD2', load_id, element_id, p]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8, is_double=True, element_id=None):
assert size in [8, 16], size
assert is_double in [True, False], is_double
if self.n:
if element_id is None:
i = arange(self.n)
else:
#assert len(unique(element_id))==len(element_id), unique(element_id)
i = searchsorted(self.element_id, element_id)
#print('i = %s' % i)
Cid = [cid if cid != 0 else '' for cid in self.coord_id[i]]
Nspan = [nspan if nspan != 0 else '' for nspan in self.nspan[i]]
Nchord = [
nchord if nchord != 0 else '' for nchord in self.nchord[i]
]
Igid = self.igid[i]
Lspan = [lspan if lspan != 0. else '' for lspan in self.lspan[i]]
Lchord = [
lchord if lchord != 0. else '' for lchord in self.lchord[i]
]
for (eid, pid, cid, nspan, nchord, lspan, lchord, igid, p1, x12,
p4, x43) in zip(self.element_id[i], self.property_id[i], Cid,
Nspan, Nchord, Lspan, Lchord, Igid,
self.p1[i, :], self.x12[i], self.p4[i, :],
self.x43[i]):
card = [
'CAERO1',
eid,
pid,
cid,
nspan,
nchord,
lspan,
lchord,
igid,
p1[0],
p1[1],
p1[2],
x12,
p4[0],
p4[1],
p4[2],
x43,
]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8, load_ids=None):
if self.n:
if load_ids is None:
i = arange(self.n)
else:
i = searchsorted(load_ids, self.load_id)
for (load_id, element_id, Type, scale, x1, p1, x2, p2) in zip(self.load_id[i], self.element_id[i],
self.Type[i], self.scale[i], self.x1[i], self.p1[i], self.x2[i], self.p2[i]):
card = ['PLOAD1', load_id, element_id, Type, scale, x1, p1, x2, p2 ]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8, load_ids=None):
if self.n:
if load_ids is None:
i = arange(self.n)
else:
i = searchsorted(load_ids, self.load_id)
n3 = ['' if n3i == 0 else n3i for n3i in self.node_ids[i, 3]]
for (load_id, p, n, n3i) in zip(self.load_id[i], self.pressure[i],self.node_ids[i, :2], n3):
card = ['PLOAD', load_id, p, n[0], n[1], n[2], n3i ]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def print_card(fields, size=8):
"""
Prints a nastran-style card with 8 or 16-character width fields
:param fields: all the fields in the BDF card (no blanks)
:param size: the width of a field (size=8 or 16)
:returns card: string representation of the card in small/large field format
"""
if size == 8:
return print_card_8(fields)
elif size == 16:
return print_card_16(fields)
else:
msg = 'fields = %s\nsize = %s' % (fields, size)
raise ValueError(msg)
def write_bdf(self, f, size=8, load_ids=None):
if self.n:
if load_ids is None:
i = arange(self.n)
else:
i = searchsorted(load_ids, self.load_id)
n3 = ['' if n3i == 0 else n3i for n3i in self.node_ids[i, 3]]
for (load_id, p, n, n3i) in zip(self.load_id[i], self.pressure[i],
self.node_ids[i, :2], n3):
card = ['PLOAD', load_id, p, n[0], n[1], n[2], n3i]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def print_card(fields, size=8):
"""
Prints a nastran-style card with 8 or 16-character width fields
:param fields: all the fields in the BDF card (no blanks)
:param size: the width of a field (size=8 or 16)
:returns card: string representation of the card in small/large field format
"""
if size == 8:
return print_card_8(fields)
elif size == 16:
return print_card_16(fields)
else:
msg = 'fields = %s\nsize = %s' % (fields, size)
raise ValueError(msg)
def write_bdf(self, f, size=8, eids=None):
if self.n:
if eids is None:
i = arange(self.n)
else:
i = searchsorted(self.element_id, self.eid)
for (eid, pid, n, c) in zip(self.element_id[i],
self.property_id[i], self.node_ids[i],
self.components[i]):
card = ['CELAS1', eid, pid, n[0], n[1], c[0], c[1]]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8):
if self.n:
t0 = self.model.tempd.cp
seid0 = self.model.grdset.seid
Cp = [cpi if cpi != cp0 else '' for cpi in self.cp]
Cd = [cdi if cdi != cd0 else '' for cdi in self.cd]
Ps = [psi if psi != ps0 else '' for psi in self.ps]
Seid = [seidi if seidi != seid0 else '' for seidi in self.seid]
for (nid, cp, xyz, cd, ps, seid) in zip(self.nid, Cp, self.xyz, Cd, Ps, Seid):
card = ['TEMP', nid, cp, xyz[0], xyz[1], xyz[2], cd, ps, seid]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def cart3d_to_nastran_filename(cart3d_filename, bdf_filename, log=None, debug=False):
"""
Converts a Cart3D file to STL format.
:param cart3d_filename: path to the input Cart3D file
:param bdf_filename: path to the output BDF file
:param log: a logger object (or None)
:param debug: True/False (used if log is not defined)
"""
cart3d = Cart3DReader(log=log, debug=debug)
(nodes, elements, regions, loads) = cart3d.read_cart3d(cart3d_filename)
#bdf = BDF()
#bdf.nodes = cart3d.nodes
#bdf.elements = cart3d.elements
#bdf.write_bdf(bdf_filename)
#return
f = open(bdf_filename, 'wb')
f.write('CEND\n')
f.write('BEGIN BULK\n')
f.write('$Nodes\n')
i = 0
nid = 1
cid = 0
for node in nodes:
card = print_card_16(['GRID', nid, cid] + list(node))
f.write(card)
eid = 1
f.write('$Elements\n')
for (n1, n2, n3), pid in zip(elements, regions):
card = print_card_8(['CTRIA3', eid, pid, n1, n2, n3])
f.write(card)
eid += 1
t = 0.1
E = 1e7
nu = 0.3
f.write('$Properties\n')
for pid in unique(regions):
mid = pid
card = print_card_8(['PSHELL', pid, mid, t])
f.write(card)
card = print_card_8(['MAT1', mid, E, None, nu])
f.write(card)
f.write('ENDDATA\n')
f.close()
def print_card(fields, size=8):
"""
Prints a nastran-style card with 8 or 16-character width fields
:param fields: all the fields in the BDF card (no blanks)
:param size: the width of a field (size=8 or 16)
.. warning:: 8 or 16 is required, but 16 is not checked for
"""
if size == 8:
return print_card_8(fields)
elif size == 16:
return print_card_16(fields)
else:
msg = 'fields = %s\nsize = %s' % (fields, size)
raise ValueError(msg)
def write_bdf(self, f, 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:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8):
if self.n:
t0 = self.model.tempd.cp
seid0 = self.model.grdset.seid
Cp = [cpi if cpi != cp0 else '' for cpi in self.cp]
Cd = [cdi if cdi != cd0 else '' for cdi in self.cd]
Ps = [psi if psi != ps0 else '' for psi in self.ps]
Seid = [seidi if seidi != seid0 else '' for seidi in self.seid]
for (nid, cp, xyz, cd, ps, seid) in zip(self.nid, Cp, self.xyz, Cd,
Ps, Seid):
card = ['TEMP', nid, cp, xyz[0], xyz[1], xyz[2], cd, ps, seid]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8, element_id=None):
if self.n:
if element_id is None:
i = arange(self.n)
else:
i = searchsorted(self.element_id, element_id)
Cid = [cid if cid != 0 else '' for cid in self.coord_id[i]]
for (eid, nid, cid, m) in zip(self.element_id[i], self.node_id[i], Cid, self.mass_matrix):
card = ['CONM1', eid, nid, cid, m[0, 0], m[1, 0], m[1, 1],
m[2, 0], m[2, 1], m[2, 2], m[3, 0], m[3, 1], m[3, 2],
m[3, 3], m[4, 0], m[4, 1], m[4, 2], m[4, 3], m[4, 4],
m[5, 0], m[5, 1], m[5, 2], m[5, 3], m[5, 4], m[5, 5]]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8, element_id=None):
if self.n:
i = self.get_index_by_element_id(element_id)
Theta = [theta if theta != 0.0 else '' for theta in self.theta[i]]
N0 = [n if n != 0 else '' for n in self.node_ids[i, 0]]
N1 = [n if n != 0 else '' for n in self.node_ids[i, 1]]
N2 = [n if n != 0 else '' for n in self.node_ids[i, 2]]
N3 = [n if n != 0 else '' for n in self.node_ids[i, 3]]
N4 = [n if n != 0 else '' for n in self.node_ids[i, 4]]
N5 = [n if n != 0 else '' for n in self.node_ids[i, 5]]
for (eid, mid, n0, n1, n2, n3, n4, n5, theta) in zip(self.element_id[i], self.material_id[i],
N0, N1, N2, N3, N4, N5, Theta):
card = ['CTRIAX6', eid, mid, n0, n1, n2, n3, n4, n5, theta]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8, is_double=False, element_id=None):
if self.n:
#print('eid %s' % element_id)
if element_id is None:
i = arange(self.n)
else:
i = searchsorted(self.element_id, element_id)
if isinstance(i, int) or isinstance(i, int64):
i = array([i])
#print('i =', i, type(i))
for (eid, pid, n) in zip(self.element_id[i], self.property_id[i], self.node_ids[i]):
card = ['CROD', eid, pid, n[0], n[1] ]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
def write_bdf(self, f, size=8, eids=None):
if self.n:
if eids is None:
i = arange(self.n)
else:
i = searchsorted(self.element_id, self.eid)
N0 = self.node_ids[i, 0]
N1 = self.node_ids[i, 1]
C0 = self.components[i, 0]
C1 = self.components[i, 1]
for (eid, k, n0, n1, c0, c1, ge, s) in zip(self.element_id[i],
self.K[i], N0, N1, C0, C1, self.ge[i], self.s[i]):
card = ['CELAS4', eid, k, n0, c0, n1, c1, ge, s ]
if size == 8:
f.write(print_card_8(card))
else:
f.write(print_card_16(card))
