def test_cord2r_1(self):
grid = ['GRID 20143 7 -9.31-4 .11841 .028296']
coord = [
'CORD2R 7 1.135 .089237 -.0676 .135 .089237 -.0676',
' 1.135 .089237 .9324'
]
model = BDF(debug=False)
card = model._process_card(grid)
model.add_card(card, card[0])
card = model._process_card(coord)
model.add_card(card, card[0])
model.cross_reference()
g = model.Node(20143)
#print(g.Position(debug=False))
# by running it through Patran...
#GRID 20143 1.1067 .207647 -.068531
diff = g.Position() - array([1.106704, .207647, -0.068531])
msg = 'diff=%s' % diff
assert allclose(diff, 0.), msg
coord = model.Coord(7)
coord.T()
self.assertTrue(array_equal(coord.T(), coord.beta_n(2)))
def test_gap_01(self):
"""tests a CGAP/PGAP"""
log = get_logger(level='warning')
model = BDF(log=log)
lines = [
'CGAP 899 90 21 99 0. 1. 0. 0'
]
card = model._process_card(lines)
card = BDFCard(card)
cgap = CGAP.add_card(card, comment='cgap')
node_ids = cgap.node_ids
assert node_ids == [21, 99], node_ids
self.assertEqual(cgap.eid, 899)
self.assertEqual(cgap.Pid(), 90)
cgap.write_card(size=8)
cgap.raw_fields()
lines = ['PGAP 90 1.E+5']
card = model._process_card(lines)
card = BDFCard(card)
pgap = PGAP.add_card(card, comment='pgap')
pgap.write_card(size=8)
pgap.write_card(size=16)
self.assertEqual(pgap.Pid(), 90)
pgap.raw_fields()
def test_cord2r_02(self):
grid = ['GRID 20143 7 -9.31-4 .11841 .028296']
coord = [
'CORD2R 7 1.135 .089237 -.0676 .135 .089237 -.0676',
' 1.135 .089237 .9324'
]
model = BDF(debug=False)
card = model._process_card(grid)
model.add_card(card, card[0])
card = model._process_card(coord)
model.add_card(card, card[0])
model.cross_reference()
coord = model.Coord(7)
#print(coord.origin)
#print(coord.i, coord.j, coord.k)
node = model.Node(20143)
xyzp1 = Position(node.xyz, node.cp, model)
xyzp2 = Position(node.xyz, node.cp_ref, model)
xyz = node.get_position()
assert np.array_equal(xyz, xyzp1)
assert np.array_equal(xyz, xyzp2)
xyz_same = PositionWRT([1., 2., 3.], 100, 100, model)
assert np.array_equal(xyz_same, [1., 2., 3.])
xyz_wrt_p1 = PositionWRT(node.xyz, node.cp, 0, model)
xyz_wrt_p2 = PositionWRT(node.xyz, node.cp_ref, 0, model)
xyz_wrt = node.get_position_wrt(model, 0)
assert np.array_equal(xyz, xyz_wrt_p1)
assert np.array_equal(xyz, xyz_wrt_p2)
assert np.array_equal(xyz, xyz_wrt)
# by running it through Patran...
#GRID 20143 1.1067 .207647 -.068531
expected = array([1.106704, .207647, -0.068531])
diff = xyz - expected
msg = '\nexpected=%s \nactual =%s \ndiff =%s' % (expected, xyz, diff)
assert allclose(diff, 0.), msg
coord = model.Coord(7)
coord.beta_n(1)
coord.beta_n(2)
coord.beta_n(3)
coord.beta_n(6)
with self.assertRaises(AttributeError):
self.assertTrue(array_equal(coord.T(), coord.beta_n(2)))
#with self.assertRaises(NotImplementedError):
#self.assertTrue(array_equal(coord.T(), coord.beta_n(2)))
model2 = BDF(debug=False)
cid = 7
origin = [1.135, .089237, -.0676]
zaxis = [.135, .089237, -.0676]
xzplane = [1.135, .089237, .9324]
coord2 = model2.add_cord2r(cid, origin, zaxis, xzplane, rid=0, comment='cord2r')
coord2.comment = ''
assert coord == coord2, 'coord:\n%r\ncoord2:\n%r' % (str(coord), str(coord2))
def test_gap_01(self):
"""tests a CGAP/PGAP"""
log = get_logger(level='warning')
model = BDF(log=log)
lines = [
'CGAP 899 90 21 99 0. 1. 0. 0'
]
card = model._process_card(lines)
card = BDFCard(card)
cgap = CGAP.add_card(card, comment='cgap')
node_ids = cgap.node_ids
assert node_ids == [21, 99], node_ids
self.assertEqual(cgap.eid, 899)
self.assertEqual(cgap.Pid(), 90)
cgap.write_card(size=8)
cgap.raw_fields()
model.elements[899] = cgap
lines = ['PGAP 90 1.E+5']
card = model._process_card(lines)
card = BDFCard(card)
pgap = PGAP.add_card(card, comment='pgap')
pgap.write_card(size=8)
pgap.write_card(size=16)
self.assertEqual(pgap.Pid(), 90)
pgap.raw_fields()
model.properties[90] = pgap
model.add_grid(3, [-1., 0., 0.])
model.add_grid(21, [0., 0., 0.])
model.add_grid(99, [1., 0., 0.])
eid = 100
pid = 90
nids = [21, 99]
x = None
g0 = 3
cid = None
cgap = model.add_cgap(eid, pid, nids, x, g0, cid, comment='cgap')
node_ids = cgap.node_ids
assert node_ids == [21, 99], node_ids
self.assertEqual(cgap.eid, 100)
self.assertEqual(cgap.Pid(), 90)
cgap.write_card(size=8)
cgap.raw_fields()
model.cross_reference()
save_load_deck(model)
def test_cord1s_01(self):
lines = ['cord1s,2,1,4,3']
model = BDF(debug=False)
card = model._process_card(lines)
cardi = BDFCard(card)
size = 8
card = CORD1S.add_card(cardi)
self.assertEqual(card.Cid(), 2)
self.assertEqual(card.Rid(), 0)
card.write_card(size, 'dummy')
card.raw_fields()
model = BDF(debug=False)
cid = 2
grid1, grid2, grid3 = 1, 4, 3
coord = model.add_cord1s(cid, grid1, grid2, grid3, comment='cord1c')
coord.comment = ''
assert coord == card, 'card:\n%r\ncoord:\n%r' % (str(coord), str(card))
model.add_grid(1, [0., 0., 0.])
model.add_grid(3, [0., 0., 1.])
model.add_grid(4, [1., 0., 1.])
coord.cross_reference(model)
unused_cord2s = coord.to_cord2x(model, rid=0)
def test_cpenta_01(self):
"""tests a cpenta15"""
lines = [
'CPENTA,85,22,201,202,203,205,206,207,+PN2',
'+PN2,209,210,217, , , ,213,214,', ',218'
]
bdf = BDF(debug=False)
card = bdf._process_card(lines)
card = BDFCard(card)
solid = CPENTA15.add_card(card, comment='cpenta15')
solid.write_card(size=8, is_double=False)
solid.write_card(size=16, is_double=False)
solid.raw_fields()
node_ids = solid.node_ids
assert node_ids == [
201, 202, 203, 205, 206, 207, 209, 210, 217, None, None, None, 213,
214, 218
], node_ids
nids = [
201, 202, 203, 205, 206, 207, 209, 210, 217, None, None, None, 213,
214, 218
]
CPENTA15.add_card(card, comment='spike')
eid = 85
pid = 22
bdf.add_cpenta(eid, pid, nids, comment='spike')
def test_cbush_01(self):
"""tests a CBUSH"""
log = get_logger(level='warning')
model = BDF(log=log)
lines = ['cbush,101,102,1,,,,,0']
card = model._process_card(lines)
card = BDFCard(card)
size = 8
elem = CBUSH.add_card(card)
self.assertEqual(elem.eid, 101)
self.assertEqual(elem.Pid(), 102)
elem.write_card(size, 'dummy')
elem.raw_fields()
pid = 101
k_tables = [201]
b_tables = [202]
ge_tables = [203]
kn_tables = [204]
model.add_pbusht(pid,
k_tables,
b_tables,
ge_tables,
kn_tables,
comment='pbusht')
save_load_deck(model)
def test_cord1s_01(self):
lines = ['cord1s,2,1,4,3']
model = BDF(debug=False)
card = model._process_card(lines)
cardi = BDFCard(card)
size = 8
card = CORD1S.add_card(cardi)
self.assertEqual(card.Cid(), 2)
self.assertEqual(card.Rid(), 0)
card.write_card(size, 'dummy')
card.raw_fields()
model = BDF(debug=False)
model.set_error_storage(nparse_errors=0, stop_on_parsing_error=True,
nxref_errors=0, stop_on_xref_error=True)
cid = 2
grid1, grid2, grid3 = 1, 4, 3
coord = model.add_cord1s(cid, grid1, grid2, grid3, comment='cord1c')
coord.comment = ''
assert coord == card, 'card:\n%r\ncoord:\n%r' % (str(coord), str(card))
make_tri(model)
coord.cross_reference(model)
model2 = deepcopy(model)
model2.cross_reference()
save_load_deck(model2, run_renumber=False)
unused_cord2s = coord.to_cord2x(model, rid=0)
model.pop_parse_errors()
model.pop_xref_errors()
model.coords[cid] = coord
model.cross_reference()
save_load_deck(model, run_renumber=False)
def test_dmig_06(self):
lines = ['DMIG ENFORCE 0 1 1 0']
model = BDF(debug=False)
card = model._process_card(lines)
card_obj = BDFCard(card)
size = 8
dmi = DMIG.add_card(card_obj)
dmi.write_card(size, 'dummy')
def test_dmi_01(self):
"""tests a DMI card"""
lines = ['DMI,Q,0,6,1,0,,4,4']
model = BDF(debug=False)
card = model._process_card(lines)
card_obj = BDFCard(card)
size = 8
dmi = DMI.add_card(card_obj)
dmi.write_card(size, 'dummy')
def test_support1_01(self):
lines = ['SUPORT1, 1, 126']
bdf = BDF(debug=False)
card = bdf._process_card(lines)
cardi = BDFCard(card)
size = 8
con = SUPORT1.add_card(cardi)
con.write_card(size, 'dummy')
con.raw_fields()
def test_support1_01(self):
lines = ['SUPORT1, 1, 126']
model = BDF(debug=False)
card = model._process_card(lines)
cardi = BDFCard(card)
size = 8
con = SUPORT1.add_card(cardi)
con.write_card(size, 'dummy')
con.raw_fields()
save_load_deck(model)
def test_pbar_1(self):
"""tests the PBAR BDF add"""
area = 0.0
i11 = 4.9e-2
i22 = 5.5e-2
i12 = 6.6e-2
j = 7.7e-2
nsm = 1.0
fields = [
u'PBAR',
1510998,
1520998,
area,
i11,
i22,
j,
nsm,
None,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
None,
None,
i12,
]
card = print_card_8(fields)
#print(card)
card = print_card_8(fields)
lines = card.split('\n')
model = BDF(debug=False)
card = model._process_card(lines)
cardi = BDFCard(card)
pbar = PBAR.add_card(cardi)
pbar.raw_fields()
self.assertEqual(pbar.A, area)
self.assertEqual(pbar.i1, i11)
self.assertEqual(pbar.i2, i22)
self.assertEqual(pbar.i12, i12)
self.assertEqual(pbar.j, j)
self.assertEqual(pbar.k1, None)
self.assertEqual(pbar.k2, None)
self.assertEqual(pbar.nsm, nsm)
assert np.allclose(pbar.Area(), area)
assert np.allclose(pbar.I11(), i11)
assert np.allclose(pbar.I22(), i22)
assert np.allclose(pbar.I12(), i12)
assert np.allclose(pbar.J(), j)
assert np.allclose(pbar.Nsm(), nsm)
def test_cord2_rcs_03(self):
"""
all points are located at <30,40,50>
"""
model = BDF(debug=False)
cards = [
[
'CORD2S* 2 0 0. 0.',
'* 0. 0. 0. 1.* ',
'* 1. 0. 1.',
],
[
#'$ Femap with NX Nastran Coordinate System 30 : rectangular in spherical',
'CORD2R* 30 2 14. 30.',
'* 70. 13.431863852 32.1458443949 75.2107442927* ',
'* 14.4583462334 33.4569982885 68.2297989286',
],
[
#'$ Femap with NX Nastran Coordinate System 31 : cylindrical in spherical',
'CORD2C* 31 2 3. 42.',
'* -173. 2.86526881213 45.5425615252 159.180363517* ',
'* 3.65222385965 29.2536614627 -178.631312271',
],
[
#'$ Femap with NX Nastran Coordinate System 32 : spherical in spherical',
'CORD2S* 32 2 22. 14.',
'* 85. 22.1243073983 11.9537753718 77.9978191005* ',
'* 21.0997242967 13.1806120497 88.4824763008',
],
[
'GRID* 30 30 40.7437952957 -23.6254877994',
'* -33.09784854 0',
],
[
'GRID* 31 31 62.9378078196 15.9774797923',
'* 31.0484428362 0',
],
[
'GRID* 32 32 53.8270847449 95.8215692632',
'* 159.097767463 0',
],
]
for lines in cards:
card = model._process_card(lines)
model.add_card(card, card[0])
model.cross_reference()
for nid in model.nodes:
a = array([30., 40., 50.])
b = model.Node(nid).Position()
self.assertTrue(
allclose(array([30., 40., 50.]),
model.Node(nid).Position()), str(a - b))
def test_cord2_rcs_02(self):
"""
all points are located at <30,40,50>
"""
model = BDF(debug=False)
cards = [
[
'CORD2C* 1 0 0. 0.',
'* 0. 0. 0. 1.* ',
'* 1. 0. 1.',
],
[
#'$ Femap with NX Nastran Coordinate System 20 : rectangular defined in cylindrical',
'CORD2R* 20 1 7. 20.',
'* -6. 7.07106781187 28.1301023542 -6.* ',
'* 7.70710678119 20. -5.29289321881',
],
[
#'$ Femap with NX Nastran Coordinate System 21 : cylindrical defined in cylindrical',
'CORD2C* 21 1 15. -30.',
'* 12. 14.6565766735 -30.3177805524 12.9355733712* ',
'* 14.6234241583 -26.4257323272 11.9304419665',
],
[
#'$ Femap with NX Nastran Coordinate System 22 : spherical defined in cylindrical',
'CORD2S* 22 1 5. -75.',
'* 20. 5.66032384035 -82.9319986389 19.8502545865* ',
'* 4.88876051026 -73.8006653677 19.0116094889',
],
[
'GRID* 20 20 64.2559135157 -14.9400459772',
'* 27.3271005317 0',
],
[
'GRID* 21 21 52.8328862418 -28.8729017195',
'* 34.615939507 0',
],
[
'GRID* 22 22 61.1042111232 158.773483595',
'* -167.4951724 0',
],
]
for lines in cards:
card = model._process_card(lines)
model.add_card(card, card[0])
model.cross_reference()
for nid in model.nodes:
a = array([30., 40., 50.])
b = model.Node(nid).Position()
self.assertTrue(
allclose(array([30., 40., 50.]),
model.Node(nid).Position()), str(a - b))
def test_cbush_01(self):
"""tests a CBUSH"""
model = BDF(debug=False)
lines = ['cbush,101,102,1,,,,,0']
card = model._process_card(lines)
card = BDFCard(card)
size = 8
elem = CBUSH.add_card(card)
self.assertEqual(elem.eid, 101)
self.assertEqual(elem.Pid(), 102)
elem.write_card(size, 'dummy')
elem.raw_fields()
def test_cord1r_01(self):
"""simple CORD1R input/output test"""
lines = ['cord1r,2,1,4,3']
model = BDF(debug=False)
card = model._process_card(lines)
card = BDFCard(card)
size = 8
coord = CORD1R.add_card(card)
self.assertEqual(coord.Cid(), 2)
self.assertEqual(coord.Rid(), 0)
coord.write_card(size, 'dummy')
coord.raw_fields()
def test_pelas_01(self):
"""tests PELAS"""
lines = ['pelas, 201, 1.e+5']
model = BDF(debug=False)
card = model._process_card(lines)
card = BDFCard(card)
size = 8
elem = PELAS.add_card(card)
elem.write_card(size, 'dummy')
elem.raw_fields()
self.assertEqual(elem.Pid(), 201)
self.assertEqual(elem.K(), 1e5)
def test_set1_01(self):
bdf = BDF(debug=False)
lines = ['SET1, 1100, 100, 101']
card = bdf._process_card(lines)
card = BDFCard(card)
size = 8
card = SET1.add_card(card)
card.write_card(size, 'dummy')
card.raw_fields()
card2 = SET1(1100, [100, 101], is_skin=False, comment='')
card2.write_card(size, 'dummy')
def test_cord2c_01(self):
"""simple CORD2R/CORD2C input/output test"""
lines = [
'CORD2C* 3 0 0. 0.',
'* 0. 0. 0. 1.*',
'* 1. 0. 1.'
]
model = BDF(debug=False)
card = model._process_card(lines)
cardi = BDFCard(card)
cord2c = CORD2C.add_card(cardi)
model._add_coord_object(cord2c)
lines = [
'CORD2R 4 3 10. 0. 5. 10. 90. 5.',
' 10. 0. 6.'
]
card = model._process_card(lines)
cardi = BDFCard(card)
cord2r = CORD2R.add_card(cardi)
model._add_coord_object(cord2r)
model.cross_reference()
cord2r_b = model.Coord(3)
self.assertEqual(cord2r_b.Cid(), 3)
self.assertEqual(cord2r_b.Rid(), 0)
cord2r_c = model.Coord(4)
self.assertEqual(cord2r_c.Cid(), 4)
self.assertEqual(cord2r_c.Rid(), 3)
self.assertTrue(allclose(cord2r_c.i, array([0., 0., 1.])))
delta = cord2r_c.j - array([1., 1., 0.]) / 2**0.5
self.assertTrue(allclose(cord2r_c.j,
array([1., 1., 0.]) / 2**0.5), str(delta))
delta = cord2r_c.k - array([-1., 1., 0.]) / 2**0.5
self.assertTrue(allclose(cord2r_c.k,
array([-1., 1., 0.]) / 2**0.5), str(delta))
def test_cbush_01(self):
"""tests a CBUSH"""
log = get_logger(level='warning')
model = BDF(log=log)
lines = ['cbush,101,102,1,,,,,0']
card = model._process_card(lines)
card = BDFCard(card)
size = 8
elem = CBUSH.add_card(card)
self.assertEqual(elem.eid, 101)
self.assertEqual(elem.Pid(), 102)
elem.write_card(size, 'dummy')
elem.raw_fields()
def test_cord2c_01(self):
lines = [
'CORD2C* 3 0 0. 0.',
'* 0. 0. 0. 1.*',
'* 1. 0. 1.'
]
model = BDF(debug=False)
card = model._process_card(lines)
card = BDFCard(card)
card = CORD2C(card)
model._add_coord_object(card)
lines = [
'CORD2R 4 3 10. 0. 5. 10. 90. 5.',
' 10. 0. 6.'
]
card = model._process_card(lines)
card = BDFCard(card)
card = CORD2R(card)
model._add_coord_object(card)
model.cross_reference()
cord2r = model.Coord(3)
self.assertEqual(cord2r.Cid(), 3)
self.assertEqual(cord2r.Rid(), 0)
cord2r = model.Coord(4)
self.assertEqual(cord2r.Cid(), 4)
self.assertEqual(cord2r.Rid(), 3)
self.assertTrue(allclose(cord2r.i, array([0., 0., 1.])))
delta = cord2r.j - array([1., 1., 0.]) / 2**0.5
self.assertTrue(allclose(cord2r.j,
array([1., 1., 0.]) / 2**0.5), str(delta))
delta = cord2r.k - array([-1., 1., 0.]) / 2**0.5
self.assertTrue(allclose(cord2r.k,
array([-1., 1., 0.]) / 2**0.5), str(delta))
def test_cdamp1_01(self):
"""tests a CDAMP1"""
model = BDF(debug=False)
lines = ['CDAMP1, 2001, 20, 1001, 1']
card = model._process_card(lines)
card = BDFCard(card)
size = 8
elem = CDAMP1.add_card(card)
self.assertEqual(elem.eid, 2001)
self.assertEqual(elem.Pid(), 20)
node_ids = elem.node_ids
assert node_ids == [1001, None], node_ids
elem.write_card(size, 'dummy')
elem.raw_fields()
def test_cord2_rcs_01(self):
"""
all points are located at <30,40,50>
"""
model = BDF(debug=False)
cards = [
[
#'$ Femap with NX Nastran Coordinate System 10 : rectangular defined in a rectangular',
'CORD2R* 10 0 10. 5.',
'* 3. 10.3420201433 4.53015368961 3.81379768136* ',
'* 10.7198463104 5.68767171433 3.09449287122',
],
[
#'$ Femap with NX Nastran Coordinate System 11 : cylindrical defined in rectangular',
'CORD2C* 11 0 7. 3.',
'* 9. 7.64278760969 2.73799736977 9.71984631039* ',
'* 7.75440650673 3.37968226211 8.46454486422',
],
[
#'$ Femap with NX Nastran Coordinate System 12 : spherical defined in rectangular',
'CORD2S* 12 0 12. 8.',
'* 5. 12.6427876097 7.86697777844 5.75440650673* ',
'* 12.6634139482 8.58906867688 4.53861076379',
],
[
'GRID* 10 10 42.9066011565 34.2422137135',
'* 28.6442730262 0',
],
[
'GRID* 11 11 48.8014631871 78.8394787869',
'* 34.6037164304 0',
],
[
'GRID* 12 12 58.0775343829 44.7276544324',
'* 75.7955331161 0',
],
]
for lines in cards:
card = model._process_card(lines)
model.add_card(card, card[0])
model.cross_reference()
for nid in model.nodes:
a = array([30., 40., 50.])
b = model.Node(nid).get_position()
self.assertTrue(
allclose(array([30., 40., 50.]),
model.Node(nid).get_position()), str(a - b))
def test_mat8_01(self): # should fail...
"""tests MAT8"""
#lines = [ # fails???
# 'MAT8* 4700007 1675.47 1675.47 .33 * LHIG',
# '* LHIG28.2 210000. 78000. * LHIH',
# '* LHIH1.32-5 1.32-5 75. 1.943 * LHII',
# '* LHII1.943 1.943 1.943 3.35',
#]
lines = [ # fails
'MAT8* 4700010 2.83+6 1.14+6 .55 * LHIJ',
'* LHIJ717000. 285194. 285194. * LHIK',
'* LHIK9.17-6 2.606-5 70. * LHIL',
'* LHIL',
]
lines_expected = [
'MAT8* 4700010 2830000. 1140000. .55',
'* 717000. 285194. 285194.',
'* .00000917 .00002606 70.',
'*',
]
log = get_logger(level='warning')
model = BDF(log=log)
card = model._process_card(lines)
#print(print_card_8(card))
cardi = BDFCard(card)
card2 = MAT8.add_card(cardi)
fields = card2.raw_fields()
msg = print_card_8(fields)
size = 16
msg = card2.write_card(size, 'dummy')
lines_actual = msg.rstrip().split('\n')
msg = '\n%s\n\n%s' % ('\n'.join(lines_expected), msg)
msg += 'nlines_actual=%i nlines_expected=%i' % (len(lines_actual),
len(lines_expected))
#print(msg)
self.assertEqual(len(lines_actual), len(lines_expected), msg)
for actual, expected in zip(lines_actual, lines_expected):
msg = 'actual = %r\n' % actual
msg += 'expected = %r' % expected
self.assertEqual(actual, expected, msg)
def test_cord1c_01(self):
lines = ['cord1c,2,1,4,3']
model = BDF(debug=False)
card = model._process_card(lines)
cardi = BDFCard(card)
size = 8
card = CORD1C.add_card(cardi)
self.assertEqual(card.Cid(), 2)
self.assertEqual(card.Rid(), 0)
card.write_card(size, 'dummy')
card.raw_fields()
model = BDF()
cid = 2
grid1, grid2, grid3 = 1, 4, 3
coord = model.add_cord1c(cid, grid1, grid2, grid3, comment='cord1c')
coord.comment = ''
assert coord == card, 'card:\n%r\ncoord:\n%r' % (str(coord), str(card))
def test_set2_01(self):
"""checks the SET2 card"""
bdf = BDF(debug=False)
lines = ['SET2, 110, 10, -0.1, 1.1, -0.1, 1.1']
card = bdf._process_card(lines)
card = BDFCard(card)
size = 8
card = SET2.add_card(card)
card.write_card(size, 'dummy')
card.raw_fields()
card2 = SET2(110, 10, -0.1, 1.1, -0.1, 1.1, comment='')
card2.write_card(size, 'dummy')
card2.raw_fields()
card3 = bdf.add_set2(110, 10, -0.1, 1.1, -0.1, 1.1)
card3.write_card(size, 'dummy')
card3.raw_fields()
def test_cdamp1_01(self):
"""tests a CDAMP1"""
log = get_logger(level='warning')
model = BDF(log=log)
lines = ['CDAMP1, 2001, 20, 1001, 1']
card = model._process_card(lines)
card = BDFCard(card)
size = 8
elem = CDAMP1.add_card(card)
self.assertEqual(elem.eid, 2001)
self.assertEqual(elem.Pid(), 20)
node_ids = elem.node_ids
assert node_ids == [1001, None], node_ids
elem.write_card(size, 'dummy')
elem.raw_fields()
pid = 1
tbid = 2
model.add_pdampt(pid, tbid, comment='pdampt')
save_load_deck(model)
def test_damper_01(self):
"""tests PDAMP"""
lines = ['pdamp, 201, 1.e+5']
log = get_logger(level='warning')
model = BDF(log=log)
card = model._process_card(lines)
card = BDFCard(card)
size = 8
elem = PDAMP.add_card(card)
elem.write_card(size, 'dummy')
elem.raw_fields()
self.assertEqual(elem.Pid(), 201)
self.assertEqual(elem.B(), 1e5)
fields = ['pelas', 201, 1.e+5, None, None, 202, 2.e+5]
card_name = fields[0]
model.add_card(fields, card_name, comment='', is_list=True,
has_none=True)
assert len(model.properties) == 2, model.properties
save_load_deck(model)
def test_mat11_01(self):
"""tests MAT11"""
log = get_logger(level='warning')
model = BDF(log=log)
lines = [
'MAT11 1 1.+75000000. 700000. .1 .13 .267000000.+',
'+ 9000000.3000000. .1 1.-5 7.-6 8.-6 50.',
]
lines_expected = [
'MAT11 1 1.+75000000. 700000. .1 .13 .267000000.',
' 9000000.3000000. .1 .00001 .000007 .000008 50.'
]
card = model._process_card(lines)
cardi = BDFCard(card)
mat = MAT11.add_card(cardi)
fields = mat.raw_fields()
msg = print_card_8(fields)
#f = StringIO.StringIO()
size = 8
msg = mat.write_card(size, 'dummy')
#msg = f.getvalue()
#print(msg)
lines_actual = msg.rstrip().split('\n')
msg = '\n%s\n\n%s' % ('\n'.join(lines_expected), msg)
msg += 'nlines_actual=%i nlines_expected=%i' % (len(lines_actual),
len(lines_expected))
#print(msg)
self.assertEqual(len(lines_actual), len(lines_expected), msg)
for actual, expected in zip(lines_actual, lines_expected):
msg = '\nactual = %r\n' % actual
msg += 'expected = %r' % expected
self.assertEqual(actual, expected, msg)
save_load_deck(model,
xref='standard',
punch=True,
run_remove_unused=False)
