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