def test_sebset(self):
"""checks the SEBSET/SEBSET1 cards"""
model = BDF(debug=False)
seid = 42
bset1a = SEBSET1(seid, [1, 'THRU', 10], 4, comment='bset1')
bset1b = SEBSET1.add_card(BDFCard(['SEBSET1', seid, 5, 1, 2, 3, 4, 5, 6, 7, 8, 10, 9]),
comment='sebset1')
bset1a.write_card()
bset1b.write_card()
model._add_sebset_object(bset1a)
model._add_sebset_object(bset1b)
#| BSET1 | C | ID1 | THRU | ID2 | | | | |
sebseta = SEBSET(seid, [1, 2, 3, 4, 5], [5, 4, 3, 2, 1], comment='sebset')
sebsetb = SEBSET.add_card(BDFCard(['SEBSET', seid,
1, 2, 3, 4, 5,
5, 4, 3, 2, 1]), comment='sebset')
assert len(sebseta.components) == 5, sebseta.components
model._add_sebset_object(sebseta)
model._add_sebset_object(sebsetb)
nids = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for nid in nids:
model.add_grid(nid, [float(nid), 0., 0.])
sebseta.validate()
sebsetb.validate()
sebseta.write_card()
sebsetb.write_card()
save_load_deck(model, run_save_load_hdf5=True)
def test_cset(self):
"""checks the CSET/CSET1 cards"""
model = BDF(debug=False)
cset1a = CSET1([1, 'THRU', 10], 4, comment='cset')
cset1b = CSET1.add_card(BDFCard(['CSET1', 5, 1, 2, 3, 4, 5, 6, 7, 8, 10, 9]),
comment='cset1')
cset1a.write_card()
cset1b.write_card()
model._add_cset_object(cset1a)
model._add_cset_object(cset1b)
#| ASET1 | C | ID1 | THRU | ID2 | | | | |
cseta = CSET([1, 2, 3, 4, 5], [5, 4, 3, 2, 1], comment='cset')
csetb = CSET.add_card(BDFCard(['CSET',
1, 2, 3, 4, 5,
5, 4, 3, 2, 1]), comment='cset')
model._add_cset_object(cseta)
model._add_cset_object(csetb)
model.add_cset([1, 2, 3], '42', comment='cset')
model.add_cset1([1, 2, 3], [1, 2, 3], comment='cset1')
nids = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for nid in nids:
model.add_grid(nid, [float(nid), 0., 0.])
cseta.validate()
csetb.validate()
cseta.write_card()
csetb.write_card()
save_load_deck(model, run_save_load_hdf5=True)
def test_integer_or_blank(self):
"""
value = integer_or_blank(card, n, fieldname)
"""
# integer
self.check_integer(integer_or_blank)
# float
with self.assertRaises(SyntaxError):
integer_or_blank(BDFCard([1.]), 0, 'field')
with self.assertRaises(SyntaxError):
integer_or_blank(BDFCard(['1.']), 0, 'field')
#with self.assertRaises(SyntaxError):
#integer(BDFCard(['cat']), 0, 'field')
# string
with self.assertRaises(SyntaxError):
integer_or_blank(BDFCard(['a']), 0, 'field')
with self.assertRaises(SyntaxError):
integer_or_blank(BDFCard(['1b']), 0, 'field')
self.check_blank(integer_or_blank)
with self.assertRaises(SyntaxError):
integer_or_blank(BDFCard(['1+2']), 0, 'field')
card = [1, '2', '3.', 'C', None, '']
exact = [1, 2, SyntaxError, SyntaxError, None, None]
default = [None, None, None, None, None, None]
self.run_function_default(integer_or_blank, card, exact, default)
def test_integer_double_string_or_blank(self):
"""tests the integer_double_string_or_blank function"""
# out of range
self.assertEqual(
None, integer_double_string_or_blank(BDFCard([1.]), 1, 'field'))
#with self.assertRaises(SyntaxError):
#print(integer_double_string_or_blank(BDFCard(['1b']), 0, 'field'))
# integer
self.check_integer(integer_double_string_or_blank)
# float
self.check_double(integer_double_string_or_blank)
# string
self.assertEqual(
'LOAD',
integer_double_string_or_blank(BDFCard(['load']), 0, 'field'))
self.assertEqual(
'MN-MM',
integer_double_string_or_blank(BDFCard(['MN-MM']), 0, 'field'))
#self.assertEqual(-1, integer_double_string_or_blank(BDFCard(['-1']), 0, 'field'))
self.assertEqual(
1000, integer_double_string_or_blank(BDFCard([1000]), 0, 'field'))
self.assertEqual(
'CAT',
integer_double_string_or_blank(BDFCard([100]), 1, 'field', 'CAT'))
def test_integer_double_or_blank(self):
"""
value = double_or_blank(card, n, fieldname, default=None)
"""
# integer
self.check_integer(integer_double_or_blank)
# float
self.check_double(integer_double_or_blank)
self.assertEqual(1.e-9,
integer_double_or_blank(BDFCard(['1-9']), 0, 'field'))
self.assertEqual(1.e+9,
integer_double_or_blank(BDFCard(['1+9']), 0, 'field'))
# error - string
with self.assertRaises(SyntaxError):
integer_double_or_blank(BDFCard(['C']), 0, 'field')
with self.assertRaises(SyntaxError):
integer_double_or_blank(BDFCard(['1C']), 0, 'field')
with self.assertRaises(SyntaxError):
integer_double_or_blank(BDFCard(['C1']), 0, 'field')
# blank
double_or_blank(BDFCard([' ']), 0, 'field')
double_or_blank(BDFCard([None]), 0, 'field')
self.assertEqual(1.e-9, double_or_blank(BDFCard(['1-9']), 0, 'field'))
self.assertEqual(1.e+9, double_or_blank(BDFCard(['1+9']), 0, 'field'))
self.assertEqual(
1000, integer_double_or_blank(BDFCard(['1000']), 0, 'field'))
def test_qset(self):
"""checks the QSET/QSET1 cards"""
model = BDF(debug=False)
qset1a = QSET1([1, 'THRU', 10], 4, comment='qset')
qset1b = QSET1.add_card(BDFCard(
['QSET1', 5, 1, 2, 3, 4, 5, 6, 7, 8, 10, 9]),
comment='qset1')
model._add_qset_object(qset1a)
model._add_qset_object(qset1b)
qset1a.write_card()
qset1b.write_card()
#| ASET1 | C | ID1 | THRU | ID2 | | | | |
qseta = QSET([1, 2, 3, 4, 5], [5, 4, 3, 2, 1], comment='qset')
qsetb = QSET.add_card(BDFCard(['QSET', 1, 2, 3, 4, 5, 5, 4, 3, 2, 1]),
comment='qset')
model._add_qset_object(qseta)
model._add_qset_object(qsetb)
nids = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for nid in nids:
model.add_grid(nid, [float(nid), 0., 0.])
qseta.validate()
qsetb.validate()
qseta.write_card()
qsetb.write_card()
save_load_deck(model)
def test_secset(self):
"""checks the SECSET/SECSET1 cards"""
model = BDF(debug=False)
seid = 171
secset1a = SECSET1(seid, [1, 'THRU', 10], 4, comment='cset')
secset1b = SECSET1.add_card(BDFCard(
['SECSET1', seid, 5, 1, 2, 3, 4, 5, 6, 7, 8, 10, 9]),
comment='secset1')
secset1a.write_card()
secset1b.write_card()
model._add_secset_object(secset1a)
model._add_secset_object(secset1b)
#| ASET1 | C | ID1 | THRU | ID2 | | | | |
secseta = SECSET(seid, [1, 2, 3, 4, 5], [5, 4, 3, 2, 1],
comment='secset')
secsetb = SECSET.add_card(BDFCard(
['SECSET', seid, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1]),
comment='secset')
model._add_secset_object(secseta)
model._add_secset_object(secsetb)
model.add_secset(seid, [1, 2, 3], '42', comment='secset')
model.add_secset1(seid, [1, 2, 3], [1, 2, 3], comment='secset1')
nids = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
for nid in nids:
model.add_grid(nid, [float(nid), 0., 0.])
secseta.validate()
secsetb.validate()
secseta.write_card()
secsetb.write_card()
save_load_deck(model)
def check_blank(self, method):
"""common blank checks"""
assert method(BDFCard([' ']), 0, 'field') is None
assert method(BDFCard([None]), 0, 'field') is None
#assert method(BDFCard(['.']), 0, 'field') == 0.
self.assertEqual('a', method(BDFCard(['']), 0, 'field', 'a'))
self.assertEqual('b', method(BDFCard([None]), 0, 'field', 'b'))
def test_integer_or_double(self):
# out of range
with self.assertRaises(SyntaxError):
integer_or_double(BDFCard([1.]), 1, 'field')
self.assertEqual(1.e-9, integer_or_double(BDFCard(['1-9']), 0,
'field'))
self.assertEqual(1.e+9, integer_or_double(BDFCard(['1+9']), 0,
'field'))
def test_double_or_string(self):
"""tests the double_or_string function"""
# out of range
with self.assertRaises(SyntaxError):
double_or_string(BDFCard([1.]), 1, 'field')
self.assertEqual(1.e-9, double_or_string(BDFCard(['1-9']), 0, 'field'))
self.assertEqual(1.e+9, double_or_string(BDFCard(['1+9']), 0, 'field'))
self.check_double(double_or_string)
self.check_string(double_or_string, check_dash=False)
def test_blank(self):
"""
value = integer(card, n, fieldname)
"""
# integer
with self.assertRaises(SyntaxError):
blank(BDFCard([1]), 0, 'field')
with self.assertRaises(SyntaxError):
blank(BDFCard(['1']), 0, 'field')
# float
with self.assertRaises(SyntaxError):
blank(BDFCard([1.]), 0, 'field')
with self.assertRaises(SyntaxError):
blank(BDFCard(['1.']), 0, 'field')
# string
with self.assertRaises(SyntaxError):
blank(BDFCard(['a']), 0, 'field')
with self.assertRaises(SyntaxError):
blank(BDFCard(['1b']), 0, 'field')
# blank
val = blank(BDFCard(['']), 0, 'field')
self.assertEqual(val, None)
val = blank(BDFCard([None]), 0, 'field')
self.assertEqual(val, None)
val = blank(BDFCard([None]), 0, 'field', 'default')
self.assertEqual(val, 'default')
def test_double(self):
"""
value = double(card, n, fieldname)
"""
# out of range
with self.assertRaises(SyntaxError):
double(BDFCard([1.]), 1, 'field')
# integer
with self.assertRaises(SyntaxError):
double(BDFCard([1]), 0, 'field')
with self.assertRaises(SyntaxError):
double(BDFCard(['1']), 0, 'field')
self.assertEqual(1.e-9, double(BDFCard(['1-9']), 0, 'field'))
self.assertEqual(1.e+9, double(BDFCard(['1+9']), 0, 'field'))
# float
self.check_double(double)
# string
with self.assertRaises(SyntaxError):
double(BDFCard(['a']), 0, 'field')
with self.assertRaises(SyntaxError):
double(BDFCard(['1b']), 0, 'field')
# blank
with self.assertRaises(SyntaxError):
double(BDFCard(['']), 0, 'field')
with self.assertRaises(SyntaxError):
double(BDFCard([None]), 0, 'field')
card = [1.0, '2.0', '3.', 'C', None, '']
exact = [1.0, 2.0, 3.0, SyntaxError, SyntaxError, SyntaxError]
self.run_function(double, card, exact)
def check_integer(self, method):
"""common integer checks"""
self.assertEqual(1, method(BDFCard([1]), 0, 'field'))
self.assertEqual(2, method(BDFCard(['2']), 0, 'field'))
self.assertEqual(-1, method(BDFCard(['-1']), 0, 'field'))
#if check_space:
with self.assertRaises(SyntaxError):
method(BDFCard(['1 3']), 0, 'field')
with self.assertRaises(SyntaxError):
method(BDFCard(['-1 3']), 0, 'field')
def test_string(self):
"""
value = string(card, n, fieldname)
"""
# integer
with self.assertRaises(SyntaxError):
string(BDFCard([1]), 0, 'field')
with self.assertRaises(SyntaxError):
string(BDFCard(['1']), 0, 'field')
# float
with self.assertRaises(SyntaxError):
string(BDFCard([1.]), 0, 'field')
with self.assertRaises(SyntaxError):
string(BDFCard(['1.']), 0, 'field')
# string
self.assertEqual('A', string(BDFCard(['a']), 0, 'field'))
self.assertEqual('1B', string(BDFCard(['1b']), 0, 'field'))
# blank
with self.assertRaises(SyntaxError):
string(BDFCard(['']), 0, 'field')
with self.assertRaises(SyntaxError):
string(BDFCard([None]), 0, 'field')
card = ['a', 'b1', '3.', 'C', None, '', 'frog']
exact = ['A', 'B1', SyntaxError, 'C', SyntaxError, SyntaxError, 'FROG']
self.run_function(string, card, exact)
def test_bset(self):
"""checks the BSET/BSET1 cards"""
bset1a = BSET1(4, [1, 'THRU', 10])
bset1b = BSET1.add_card(
BDFCard(['BSET1', 5, 1, 2, 3, 4, 5, 6, 7, 8, 10, 9]))
bset1a.write_card()
bset1b.write_card()
#| ASET1 | C | ID1 | THRU | ID2 | | | | |
bseta = BSET([1, 2, 3, 4, 5], [5, 4, 3, 2, 1])
bsetb = BSET.add_card(BDFCard(['BSET', 1, 2, 3, 4, 5, 5, 4, 3, 2, 1]))
bseta.validate()
bsetb.validate()
bseta.write_card()
bsetb.write_card()
def test_qset(self):
"""checks the QSET/QSET1 cards"""
qset1a = QSET1(4, [1, 'THRU', 10])
qset1b = QSET1.add_card(
BDFCard(['QSET1', 5, 1, 2, 3, 4, 5, 6, 7, 8, 10, 9]))
qset1a.write_card()
qset1b.write_card()
#| ASET1 | C | ID1 | THRU | ID2 | | | | |
qseta = QSET([1, 2, 3, 4, 5], [5, 4, 3, 2, 1])
qsetb = QSET.add_card(BDFCard(['QSET', 1, 2, 3, 4, 5, 5, 4, 3, 2, 1]))
qseta.validate()
qsetb.validate()
qseta.write_card()
qsetb.write_card()
def _test_cset(self):
"""checks the CSET/CSET1 cards"""
cset1a = CSET1(4, [1, 'THRU', 10])
cset1b = CSET1.add_card(
BDFCard(['CSET1', 5, 1, 2, 3, 4, 5, 6, 7, 8, 10, 9]))
cset1a.write_card()
cset1b.write_card()
#| ASET1 | C | ID1 | THRU | ID2 | | | | |
cseta = CSET([1, 2, 3, 4, 5], [5, 4, 3, 2, 1])
csetb = CSET.add_card(BDFCard(['CSET', 1, 2, 3, 4, 5, 5, 4, 3, 2, 1]))
cseta.validate()
csetb.validate()
cseta.write_card()
csetb.write_card()
def test_set1_03(self):
"""checks the SET1 card"""
sid = 10
ids = [1, 2, 3, 4, 5]
set1a = SET1(sid, ids, is_skin=False, comment='set1')
set1b = SET1.add_card(BDFCard(['SET1', sid] + ids))
set1a.write_card()
def test_omit(self):
"""checks the OMIT/OMIT1 cards"""
model = BDF(debug=False)
omit1a = OMIT1([1, 'THRU', 10], 4, comment='omit1')
self.assertEqual(omit1a.components, 4)
omit1b = OMIT1.add_card(BDFCard(
['OMIT1', 5, 1, 2, 3, 4, 5, 6, 7, 8, 10, 9]),
comment='omit1')
model._add_omit_object(omit1a)
model._add_omit_object(omit1b)
omit1a.validate()
omit1b.validate()
omit1a.write_card()
omit1b.write_card()
#| OMIT1 | C | ID1 | THRU | ID2 | | | | |
#omita = OMIT([1, 2, 3, 4, 5], [5, 4, 3, 2, 1])
#omitb = OMIT.add_card(BDFCard(['OMIT',
#1, 2, 3, 4, 5,
#5, 4, 3, 2, 1]))
#omita.validate()
#omitb.validate()
#omita.write_card()
#omitb.write_card()
save_load_deck(model)
def run_function(self, f, card, exact):
"""
Helper function
Parameters
----------
f : function
integer_or_blank
card : List[varies]
a series of values to add
exacts : List[float]
list of results
"""
assert len(card) == len(
exact), 'len(card)=%s len(exact)=%s' % (len(card), len(exact))
i = 0
fieldname = 'f'
bdf_card = BDFCard(card)
for i, exacti in enumerate(exact):
if exacti == SyntaxError:
with self.assertRaises(SyntaxError):
msg = 'field=%r exact=%r' % (bdf_card.field(i), exacti)
#print msg
f(bdf_card, i, fieldname)
else:
value = f(bdf_card, i, fieldname)
self.assertEqual(value, exacti)
i += 1
def run_function_default(self, f, card, exact, default):
"""
Helper function
Parameters
----------
f : function
integer_or_blank
card : List[varies]
a series of values to add
exacts : List[float]
list of results
default : List[float]
list of default values
"""
fieldname = 'f'
assert len(card) == len(
exact), 'len(card)=%s len(exact)=%s' % (len(card), len(exact))
assert len(card) == len(default), 'len(card)=%s len(default)=%s' % (
len(card), len(default))
i = 0
bdf_card = BDFCard(card)
for i, exacti in enumerate(exact):
defaulti = default[i]
if exacti == SyntaxError:
with self.assertRaises(exacti):
#msg = 'field=%r exact=%r default=%r' % (bdf_card.field(i), exacti, defaulti)
#print(msg)
f(bdf_card, i, fieldname, defaulti)
else:
value = f(bdf_card, i, fieldname, defaulti)
self.assertEqual(value, exacti)
i += 1
def test_integer_double_or_string(self):
"""tests the integer_double_or_string function"""
# out of range
with self.assertRaises(SyntaxError):
integer_double_or_string(BDFCard([1.]), 1, 'field')
with self.assertRaises(SyntaxError):
integer_double_or_string(BDFCard(['1b']), 0, 'field')
# integer
self.check_integer(integer_double_or_string)
# float
self.check_double(integer_double_or_string)
# string
self.assertEqual(
'LOAD', integer_double_or_string(BDFCard(['load']), 0, 'field'))
def test_set3_01(self):
"""checks the SET3 card"""
sid = 10
ids = [1, 2, 3, 4, 5]
desc = 'ELEM'
set3a = SET3(sid, desc, ids, comment='')
set3b = SET3.add_card(BDFCard(['SET3', sid, desc] + ids))
set3a.write_card()
def test_integer_double_or_string(self):
# out of range
with self.assertRaises(SyntaxError):
integer_or_double(BDFCard([1.]), 1, 'field')
# integer
self.check_integer(integer_double_or_string)
# float
self.check_double(integer_double_or_string)
# string
self.assertEqual(
'LOAD', integer_double_or_string(BDFCard(['load']), 0, 'field'))
self.assertEqual(
'MN-MM',
integer_double_string_or_blank(BDFCard(['MN-MM']), 0, 'field'))
def test_modal_components(self):
"""modal components """
card = BDFCard(['42'])
with self.assertRaises(SyntaxError):
modal_components(card, 0, 'field')
self.assertEqual(modal_components(BDFCard(['-1']), 0, 'field'), -1)
self.assertEqual(modal_components(BDFCard(['0']), 0, 'field'), 0)
self.assertEqual(modal_components(BDFCard(['1']), 0, 'field'), 1)
self.assertEqual(modal_components(BDFCard(['2']), 0, 'field'), 2)
self.assertEqual(modal_components(BDFCard(['3']), 0, 'field'), 3)
self.assertEqual(modal_components(BDFCard(['4']), 0, 'field'), 4)
self.assertEqual(modal_components(BDFCard(['5']), 0, 'field'), 5)
self.assertEqual(modal_components(BDFCard(['6']), 0, 'field'), 6)
with self.assertRaises(SyntaxError):
self.assertEqual(modal_components(BDFCard(['7']), 0, 'field'), 7)
def add_card(cls, card_lines, comment=''):
card = BDFCard(to_fields([card_lines[0]], 'GMSURF'))
surf_id = integer(card, 1, 'surf_id')
group = string(card, 2, 'group')
cid_in = integer_or_blank(card, 3, 'cid_in', 0)
cid_bc = integer_or_blank(card, 4, 'cid_bc', 0)
data = card_lines[1:]
return GMSURF(surf_id, group, data, cid_in=cid_in, cid_bc=cid_bc, comment=comment)
def test_integer_string_or_blank(self):
"""tests the integer_string_or_blank function"""
# integer
self.check_integer(integer_string_or_blank)
# float
#print type(integer_string_or_blank(BDFCard(['4.0']), 0, 'field'))
with self.assertRaises(SyntaxError):
integer_string_or_blank(BDFCard([3.0]), 0, 'field')
with self.assertRaises(SyntaxError):
integer_string_or_blank(BDFCard(['4.0']), 0, 'field')
with self.assertRaises(SyntaxError):
integer_string_or_blank(BDFCard(['5.']), 0, 'field')
with self.assertRaises(SyntaxError):
integer_string_or_blank(BDFCard(['1b']), 0, 'field')
# string
self.assertEqual(
'LOAD', integer_string_or_blank(BDFCard(['load']), 0, 'field'))
self.assertEqual(1000,
integer_string_or_blank(BDFCard([1000]), 0, 'field'))
self.assertEqual(-1,
integer_string_or_blank(BDFCard(['-1']), 0, 'field'))
# blank
self.check_blank(integer_string_or_blank)
def test_integer(self):
"""
value = integer(card, n, fieldname)
"""
# integer
self.check_integer(integer)
# out of range
with self.assertRaises(SyntaxError):
integer(BDFCard([1.]), 1, 'field')
# float
with self.assertRaises(SyntaxError):
integer(BDFCard([1.]), 0, 'field')
with self.assertRaises(SyntaxError):
integer(BDFCard(['1.']), 0, 'field')
# string
with self.assertRaises(SyntaxError):
integer(BDFCard(['a']), 0, 'field')
with self.assertRaises(SyntaxError):
integer(BDFCard(['1b']), 0, 'field')
# blank
with self.assertRaises(SyntaxError):
integer(BDFCard(['']), 0, 'field')
with self.assertRaises(SyntaxError):
integer(BDFCard([None]), 0, 'field')
card = [1, '2', '3.', 'C', None, '']
exact = [1, 2, SyntaxError, SyntaxError, SyntaxError, SyntaxError]
self.run_function(integer, card, exact)
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_integer_or_string(self):
# out of range
with self.assertRaises(SyntaxError):
integer_or_string(BDFCard([1.]), 1, 'field')
self.assertEqual(1000, integer_or_string(BDFCard([1000]), 0, 'field'))
self.assertEqual(-1, integer_or_string(BDFCard(['-1']), 0, 'field'))
self.assertEqual(1000, integer_or_string(BDFCard(['1000']), 0, 'field'))
self.assertEqual('CAT', integer_or_string(BDFCard(['cat']), 0, 'field'))
self.assertEqual('CAT', integer_or_string(BDFCard([' cat ']), 0, 'field'))
with self.assertRaises(SyntaxError):
integer_or_string(BDFCard(['1b']), 0, 'field')
with self.assertRaises(SyntaxError):
integer_or_string(BDFCard(['1+2']), 0, 'field')
