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))