def test_groundcheck_3(self): lines = [ 'GROUNDCHECK(SET=ALL)=YES', 'SUBCASE 1', ' DISPLACEMENT = ALL', ] lines_expected = [ 'GROUNDCHECK(SET=ALL) = YES', 'SUBCASE 1', ' DISPLACEMENT = ALL', 'BEGIN BULK', ] deck = CaseControlDeck(lines) deck_msg = '%s' % deck #print('%s' % deck_msg) deck_lines = deck_msg.split('\n') compare_lines(self, deck_lines, lines_expected, has_endline=False) lines = [ 'GROUNDCHECK(PRINT, THRESH=0.01, DATAREC=NO, SET=ALL)=YES', 'SUBCASE 1', ' DISPLACEMENT = ALL', ] lines_expected = [ 'GROUNDCHECK(PRINT, THRESH=0.01, DATAREC=NO, SET=ALL) = YES', 'SUBCASE 1', ' DISPLACEMENT = ALL', 'BEGIN BULK', ] deck = CaseControlDeck(lines) deck_msg = '%s' % deck #print('%s' % deck_msg) deck_lines = deck_msg.split('\n') compare_lines(self, deck_lines, lines_expected, has_endline=False)
def test_case_control_set(self): """tests adding SETs""" deck = CaseControlDeck([], log=None) subcase = deck.create_new_subcase(1) subcase.params['SET 42'] = [[1, 2, 3, 4, 5], 42, 'SET-type'] set_str = write_set(41, [1, 2, 3]).rstrip() set_str2 = set_str.split('=', 1)[1] assert set_str2 == ' 1, 2, 3', set_str2 subcase.add('SET 52', set_str2, 52, 'SET-type') subcase.add_set_from_values(100, [1, 2, 10])
def test_case_control_05(self): lines = [ 'SUBCASE 1', ' ACCELERATION(PLOT,PRINT,PHASE) = ALL', ' DISPLACEMENT(PLOT,PRINT,PHASE) = ALL', ' DLOAD = 32', ' M2GG = 111', ' SET 88 = 5, 6, 7, 8, 9, 10 THRU 55 EXCEPT 15, 16, 77, 78, 79, ' '100 THRU 300', ' SET 99 = 1 THRU 10', ' SET 105 = 1.009, 10.2, 13.4, 14.0, 15.0', ' SET 111 = MAAX1,MAAX2', ' SET 1001 = 101/T1, 501/T3, 991/R3', #' SET = ALL', ' SET 20 = ALL', ' SPC = 42', ' TSTEPNL = 22', ' VELOCITY(PLOT,PRINT,PHASE) = ALL', 'BEGIN BULK', ] deck = CaseControlDeck(lines) deck.create_new_subcase(2) deck.add_parameter_to_local_subcase(2, 'SET 2 = 11,12,13,14,15,16,17,18,' '19,20,21,22,23,24,25,26,' '1000000000000000000000000000000000000000000000000000000,33') deck_msg = '%s' % deck #print('%r' % deck_lines) deck_lines = deck_msg.split('\n') lines_expected = [ 'SUBCASE 1', #' SET = ALL', ' SET 20 = ALL', ' SET 88 = 77, 78, 79, 5 THRU 14, 17 THRU 55, 100 THRU 300', ' SET 99 = 1 THRU 10', ' SET 105 = 1.009, 10.2, 13.4, 14.0, 15.0', ' SET 111 = MAAX1, MAAX2', ' SET 1001 = 101/T1, 501/T3, 991/R3', ' ACCELERATION(PLOT,PRINT,PHASE) = ALL', ' DISPLACEMENT(PLOT,PRINT,PHASE) = ALL', ' DLOAD = 32', ' M2GG = 111', ' SPC = 42', ' TSTEPNL = 22', ' VELOCITY(PLOT,PRINT,PHASE) = ALL', 'SUBCASE 2', ' SET 2 = 33,', ' 1000000000000000000000000000000000000000000000000000000,', ' 11 THRU 26', ] compare_lines(self, deck_lines, lines_expected, has_endline=False)
def test_subcase_equals(self): lines = [ 'SET 100 = 100', 'DISP = 100', 'SUBCASE 1', ' SPC = 1', ' LOAD = 1', 'SUBCASE= 2', ' SPC = 2', ' LOAD = 2', ' DISP = ALL', 'SUBCASE =3', ' SET 100 = 100, 101', ' SPC = 3', ' LOAD = 3', ' DISP = 100', 'SUBCASE=4', ' SPC = 3', ' LOAD = 3', ' DISP = 100', ] deck = CaseControlDeck(lines) unused_default = deck.subcases[0] unused_sc3 = deck.subcases[3] unused_sc4 = deck.subcases[4] #------------------------------------- lines = [ 'DISP = 100', 'SUBCASEBAD', ' SPC = 3', ' LOAD = 3', ' DISP = 100', ] with self.assertRaises(SyntaxError): deck = CaseControlDeck(lines) #------------------------------------- lines = [ 'DISP = 100', 'SUBCASE BAD', ' SPC = 3', ' LOAD = 3', ' DISP = 100', ] with self.assertRaises(ValueError): deck = CaseControlDeck(lines)
def test_case_control_11(self): """ this test checks that subcase 3 uses its local definition of set 100 and subcase 4 uses the default definition """ lines = [ 'SET 100 = 100', 'DISP = 100', 'SUBCASE 1', ' SPC = 1', ' LOAD = 1', 'SUBCASE 2', ' SPC = 2', ' LOAD = 2', ' DISP = ALL', 'SUBCASE 3', ' SET 100 = 100, 101', ' SPC = 3', ' LOAD = 3', ' DISP = 100', 'SUBCASE 4', ' SPC = 3', ' LOAD = 3', ' DISP = 100', ] deck = CaseControlDeck(lines) default = deck.subcases[0] sc3 = deck.subcases[3] sc4 = deck.subcases[4] assert default.params['SET 100'] == [[100], 100, 'SET-type'] assert sc3.params['SET 100'] == [[100, 101], 100, 'SET-type'] assert sc4.params['SET 100'] == [[100], 100, 'SET-type']
def test_groundcheck_2(self): lines = [ 'GROUNDCHECK(PRINT,SET=(G,N,N+AUTOSPC,F,A),THRESH=1e-2,DATAREC=NO,FAKE)=YES', 'SUBCASE 1', ' DISPLACEMENT = ALL', ] with self.assertRaises(KeyError): unused_deck = CaseControlDeck(lines)
def test_weightcheck(self): weightchecks = [ 'WEIGHTCHECK=YES', 'WEIGHTCHECK(GRID=12,SET=(G,N,A),MASS)=YES', ] for weightcheck in weightchecks: deck = CaseControlDeck([weightcheck]) str(deck)
def test_groundcheck(self): groundchecks = [ 'groundcheck=YES', 'groundcheck(set=(g),datarec=yes,rthresh=.8)=yes', ] for groundcheck in groundchecks: deck = CaseControlDeck([groundcheck]) str(deck)
def test_case_control_04(self): seti = 'SET 88 = 5, 6, 7, 8, 9, 10 THRU 55 EXCEPT 15, 16, 77, 78, 79, 100 THRU 300' lines = [] deck = CaseControlDeck(lines) deck.create_new_subcase(2) deck.add_parameter_to_local_subcase(2, seti) values, set_id = deck.get_subcase_parameter(2, 'SET 88') check = [ (7, True), (13, True), (15, False), (16, False), (55, True), (77, True), (99, False), (150, True), ] for value, exists in check: if exists: assert value in values, 'value=%s should be in values=%s' % ( value, values) else: assert value not in values, 'value=%s should NOT be in values=%s' % ( value, values) unused_msg = write_set(set_id, values) singles, doubles = collapse_thru_packs(values) assert singles == [77, 78, 79], singles assert doubles == [[5, 'THRU', 14], [17, 'THRU', 55], [100, 'THRU', 300]], doubles
def test_case_control_06(self): lines_expected = [ 'ACCELERATION(PLOT,PRINT,PHASE) = ALL', 'DISPLACEMENT(PLOT,PRINT,PHASE) = ALL', 'BEGIN BULK', ] deck = CaseControlDeck(lines_expected) deck_msg = '%s' % deck deck_lines = deck_msg.split('\n') compare_lines(self, deck_lines, lines_expected, has_endline=False)
def test_case_control_04(self): seti = 'SET 88 = 5, 6, 7, 8, 9, 10 THRU 55 EXCEPT 15, 16, 77, 78, 79, 100 THRU 300' lines = [] deck = CaseControlDeck(lines) deck.create_new_subcase(2) deck.add_parameter_to_local_subcase(2, seti) values, options = deck.get_subcase_parameter(2, 'SET 88') check = [ (7, True), (13, True), (15, False), (16, False), (55, True), (77, True), (99, False), (150, True), ] for value, exists in check: if exists: assert value in values, 'value=%s should be in values=%s' % (value, values) else: assert value not in values, 'value=%s should NOT be in values=%s' % (value, values) msg = write_set(values, options) singles, doubles = collapse_thru_packs(values) assert singles == [77, 78, 79], singles assert doubles == [[5, 'THRU', 14], [17, 'THRU', 55], [100, 'THRU', 300]], doubles
def test_case_control_07(self): lines = [ 'TITLE= VIBRATION OF A BEAM.', 'dsaprt=(end=sens)', 'ECHO = UNSORT', 'OLOAD = ALL', 'DISP = ALL', 'DESSUB = 2', 'METHOD = 1', 'ANALYSIS = MODES', 'DESOBJ = 1', 'SUBCASE 1', 'DESSUB = 1', ' SUPER 1', 'SUBCASE 2', 'BEGIN BULK', ] lines_expected = [ 'ANALYSIS = MODES', 'DESOBJ = 1', 'DESSUB = 2', 'DISPLACEMENT = ALL', 'dsaprt=(end=sens)', 'ECHO = UNSORT', 'METHOD = 1', 'OLOAD = ALL', 'TITLE = VIBRATION OF A BEAM.', 'SUBCASE 1', ' SUPER 1', ' DESSUB = 1', 'SUBCASE 2', ' ANALYSIS = MODES', ' DESOBJ = 1', ' DESSUB = 2', ' DISPLACEMENT = ALL', ' dsaprt=(end=sens)', ' ECHO = UNSORT', ' METHOD = 1', ' OLOAD = ALL', ' TITLE = VIBRATION OF A BEAM.', 'BEGIN BULK', ] deck = CaseControlDeck(lines) deck_msg = '%s' % deck #print('%s' % deck_msg) deck_lines = deck_msg.split('\n') #print "--------" #print deck_msg compare_lines(self, deck_lines, lines_expected, has_endline=False)
def test_sets(self): lines = [ 'SET 1 = 1,2, 21,THRU,25, 31,THRU,37', 'SET 11 = 11, 12, 121 THRU 125, 131 THRU 137', ] lines_expected = [ 'SET 1 = 1, 2, 21 THRU 25, 31 THRU 37', 'SET 11 = 11, 12, 121 THRU 125, 131 THRU 137', 'BEGIN BULK', ] deck = CaseControlDeck(lines) deck_msg = '%s' % deck #print('%s' % deck_msg) deck_lines = deck_msg.split('\n') compare_lines(self, deck_lines, lines_expected, has_endline=False)
def test_case_control_11(self): lines = [ 'GROUNDCHECK(PRINT,', 'THRESH=1e-2,DATAREC=NO)=YES', 'SUBCASE 1', ' DISPLACEMENT = ALL', ] lines_expected = [ 'GROUNDCHECK(PRINT,THRESH=1e-2,DATAREC=NO) = YES', 'SUBCASE 1', ' DISPLACEMENT = ALL', ] deck = CaseControlDeck(lines) deck_msg = '%s' % deck #print('%s' % deck_msg) deck_lines = deck_msg.split('\n') compare_lines(self, deck_lines, lines_expected, has_endline=False)
def setup_case_control(model, extra_case_lines=None): lines = [ 'STRESS(PLOT,PRINT) = ALL', 'STRAIN(PLOT,PRINT) = ALL', 'FORCE(PLOT,PRINT) = ALL', 'DISP(PLOT,PRINT) = ALL', 'GPFORCE(PLOT,PRINT) = ALL', 'SPCFORCE(PLOT,PRINT) = ALL', 'SUBCASE 1', ' LOAD = 2', ' SPC = 3', ] if extra_case_lines is not None: lines += extra_case_lines cc = CaseControlDeck(lines, log=model.log) model.sol = 101 model.case_control_deck = cc
def test_case_control_09(self): lines = [ 'GROUNDCHECK(PRINT,SET=(G,N,N+AUTOSPC,F,A),', 'DATAREC=NO)=YES', 'SUBCASE 1', ' DISPLACEMENT = ALL', ] lines_expected = [ 'GROUNDCHECK(PRINT, SET=(G,N,N+AUTOSPC,F,A), DATAREC=NO) = YES', 'SUBCASE 1', ' DISPLACEMENT = ALL', ] deck = CaseControlDeck(lines) deck_msg = '%s' % deck #print('%s' % deck_msg) deck_lines = deck_msg.split('\n') compare_lines(self, deck_lines, lines_expected, has_endline=False)
def test_case_control_05(self): lines = [ 'SUBCASE 1', ' ACCELERATION(PLOT,PRINT,PHASE) = ALL', ' DISPLACEMENT(PLOT,PRINT,PHASE) = ALL', ' DLOAD = 32', ' M2GG = 111', ' SET 88 = 5, 6, 7, 8, 9, 10 THRU 55 EXCEPT 15, 16, 77, 78, 79, ' '100 THRU 300', ' SET 99 = 1 THRU 10', ' SET 105 = 1.009, 10.2, 13.4, 14.0, 15.0', ' SET 111 = MAAX1,MAAX2', ' SET 1001 = 101/T1, 501/T3, 991/R3', #' SET = ALL', ' SET 20 = ALL', ' SPC = 42', ' TSTEPNL = 22', ' VELOCITY(PLOT,PRINT,PHASE) = ALL', 'BEGIN BULK', ] deck = CaseControlDeck(lines) deck.create_new_subcase(2) deck.add_parameter_to_local_subcase( 2, 'SET 2 = 11,12,13,14,15,16,17,18,' '19,20,21,22,23,24,25,26,' '1000000000000000000000000000000000000000000000000000000,33') deck_msg = '%s' % deck #print('%r' % deck_lines) deck_lines = deck_msg.split('\n') lines_expected = [ 'SUBCASE 1', #' SET = ALL', ' SET 20 = ALL', ' SET 88 = 77, 78, 79, 5 THRU 14, 17 THRU 55, 100 THRU 300', ' SET 99 = 1 THRU 10', ' SET 105 = 1.009, 10.2, 13.4, 14.0, 15.0', ' SET 111 = MAAX1, MAAX2', ' SET 1001 = 101/T1, 501/T3, 991/R3', ' ACCELERATION(PLOT,PRINT,PHASE) = ALL', ' DISPLACEMENT(PLOT,PRINT,PHASE) = ALL', ' DLOAD = 32', ' M2GG = 111', ' SPC = 42', ' TSTEPNL = 22', ' VELOCITY(PLOT,PRINT,PHASE) = ALL', 'SUBCASE 2', ' SET 2 = 33,', ' 1000000000000000000000000000000000000000000000000000000,', ' 11 THRU 26', ] compare_lines(self, deck_lines, lines_expected, has_endline=False)
def __init__(self): #: a dictionary that maps an integer of the subcaseName to the #: subcase_id self.iSubcaseNameMap = {} self.subtitles = defaultdict(list) self.case_control_deck = CaseControlDeck([], log=self.log) self.labels = {} self.expected_times = {} self.make_geom = False #: BDF Title self.title = None self.page_num = 1 self.iSubcases = [] self.__objects_vector_init__() self.__objects_init__() self.__objects_common_init__()
def test_case_control_01(self): lines = ['SPC=2', 'MPC =3', 'STRESS= ALL', 'DISPLACEMENT(PLOT,PUNCH) = 8', ] deck = CaseControlDeck(lines) deck.write_begin_bulk = False self.assertTrue(deck.has_parameter(0, 'SPC')) self.assertTrue(deck.has_parameter(0, 'sPC')) self.assertFalse(deck.has_parameter(0, 'JUNK')) #print("get_subcase_parameter(MPC) 3 = ", deck.get_subcase_parameter(0, 'MPC')) deck.add_parameter_to_global_subcase('GPFORCE = 7') deck.create_new_subcase(1) deck.create_new_subcase(2) deck.add_parameter_to_local_subcase(1, 'STRAIN = 7') out = deck.get_subcase_parameter(0, 'GPFORCE') deck.add_parameter_to_local_subcase(1, 'ANALYSIS = SAERO') deck.add_parameter_to_local_subcase(2, 'ANALYSIS = STATIC') out = deck.get_subcase_parameter(2, 'ANALYSIS') deck.add_parameter_to_local_subcase(1, 'SET 1 = 100') deck.add_parameter_to_local_subcase(1, 'SET 2 = 200') lines_expected = [ 'DISPLACEMENT(PLOT,PUNCH) = 8', 'GPFORCE = 7', 'MPC = 3', 'SPC = 2', 'STRESS = ALL', 'SUBCASE 1', ' SET 1 = 100', ' SET 2 = 200', ' ANALYSIS = SAERO', ' STRAIN = 7', 'SUBCASE 2', ' ANALYSIS = STATIC',] deck_string = '%s' % deck deck_lines = deck_string.strip().splitlines() msg = '\n' + '\n'.join(deck_lines) self.assertEqual(lines_expected, deck_lines, msg=msg) compare_lines(self, deck_lines, lines_expected, has_endline=False)
def test_case_control_01(self): lines = [ 'SPC=2', 'MPC =3', 'STRESS= ALL', 'DISPLACEMENT(PLOT,PUNCH) = 8', ] deck = CaseControlDeck(lines) deck.write_begin_bulk = False self.assertTrue(deck.has_parameter(0, 'SPC')) self.assertTrue(deck.has_parameter(0, 'sPC')) self.assertFalse(deck.has_parameter(0, 'JUNK')) #print("get_subcase_parameter(MPC) 3 = ", deck.get_subcase_parameter(0, 'MPC')) deck.add_parameter_to_global_subcase('GPFORCE = 7') deck.create_new_subcase(1) deck.create_new_subcase(2) deck.add_parameter_to_local_subcase(1, 'STRAIN = 7') unused_out = deck.get_subcase_parameter(0, 'GPFORCE') deck.add_parameter_to_local_subcase(1, 'ANALYSIS = SAERO') deck.add_parameter_to_local_subcase(2, 'ANALYSIS = STATIC') unused_out = deck.get_subcase_parameter(2, 'ANALYSIS') deck.add_parameter_to_local_subcase(1, 'SET 1 = 100') deck.add_parameter_to_local_subcase(1, 'SET 2 = 200') lines_expected = [ 'DISPLACEMENT(PLOT,PUNCH) = 8', 'GPFORCE = 7', 'MPC = 3', 'SPC = 2', 'STRESS = ALL', 'SUBCASE 1', ' SET 1 = 100', ' SET 2 = 200', ' ANALYSIS = SAERO', ' STRAIN = 7', 'SUBCASE 2', ' ANALYSIS = STATIC', ] deck_string = '%s' % deck deck_lines = deck_string.strip().splitlines() msg = '\n' + '\n'.join(deck_lines) self.assertEqual(lines_expected, deck_lines, msg=msg) compare_lines(self, deck_lines, lines_expected, has_endline=False)
def bdf_merge(bdf_filenames, bdf_filename_out=None, renumber=True, encoding=None, size=8, is_double=False, cards_to_skip=None, log=None, skip_case_control_deck=False): """ Merges multiple BDF into one file Parameters ---------- bdf_filenames : List[str] list of bdf filenames bdf_filename_out : str / None the output bdf filename (default=None; None -> no writing) renumber : bool should the bdf be renumbered (default=True) encoding : str the unicode encoding (default=None; system default) size : int; {8, 16}; default=8 the bdf write precision is_double : bool; default=False the field precision to write cards_to_skip : List[str]; (default=None -> don't skip any cards) There are edge cases (e.g. FLUTTER analysis) where things can break due to uncross-referenced cards. You need to disable entire classes of cards in that case (e.g. all aero cards). skip_case_control_deck : bool, optional, default : False If true, don't consider the case control deck while merging. Returns ------- model : BDF Merged model. mappers_all : List[mapper] mapper : Dict[bdf_attribute] : old_id_to_new_id_dict List of mapper dictionaries of original ids to merged bdf_attribute : str a BDF attribute (e.g., 'nodes', 'elements') old_id_to_new_id_dict : dict[id_old] : id_new a sub dictionary that is used to map the node/element/etc. ids mapper = { 'elements' : eid_map, 'nodes' : nid_map, 'coords' : cid_map, ... } Supports nodes: GRID coords: CORDx elements: CQUAD4, CTRIA3, CTETRA, CPENTA, CHEXA, CELASx, CBAR, CBEAM CONM1, CONM2, CMASS properties: PSHELL, PCOMP, PSOLID, PMASS materials: MAT1, MAT8 .. todo:: doesn't support SPOINTs/EPOINTs .. warning:: still very preliminary """ if not isinstance(bdf_filenames, (list, tuple)): raise TypeError('bdf_filenames is not a list/tuple...%s' % str(bdf_filenames)) if not len(bdf_filenames) > 1: raise RuntimeError("You can't merge one BDF...bdf_filenames=%s" % str(bdf_filenames)) for bdf_filename in bdf_filenames: if not isinstance(bdf_filename, (string_types, BDF, StringIO)): raise TypeError('bdf_filenames is not a string/BDF...%s' % bdf_filename) #bdf_filenames = [bdf_filenames] #starting_id_dict_default = { #'cid' : max(model.coords.keys()), #'nid' : max(model.nodes.keys()), #'eid' : max([ #max(model.elements.keys()), #max(model.masses.keys()), #]), #'pid' : max([ #max(model.properties.keys()), #max(model.properties_mass.keys()), #]), #'mid' : max(model.material_ids), #} bdf_filename0 = bdf_filenames[0] if isinstance(bdf_filename0, BDF): model = bdf_filename0 else: model = BDF(debug=False, log=log) model.disable_cards(cards_to_skip) model.read_bdf(bdf_filename0, encoding=encoding, validate=False) if skip_case_control_deck: model.case_control_deck = CaseControlDeck([], log=None) model.log.info('primary=%s' % bdf_filename0) _mapper_0 = _get_mapper_0(model) # mapper for first model data_members = [ 'coords', 'nodes', 'elements', 'masses', 'properties', 'properties_mass', 'materials', 'sets', 'rigid_elements', 'mpcs', 'caeros', 'splines', ] mappers = [] for bdf_filename in bdf_filenames[1:]: starting_id_dict = get_renumber_starting_ids_from_model(model) #for param, val in sorted(starting_id_dict.items()): #print(' %-3s %s' % (param, val)) model.log.info('secondary=%s' % bdf_filename) if isinstance(bdf_filename, BDF): model2_renumber = bdf_filename else: model2_renumber = BDF(debug=False, log=log) model2_renumber.disable_cards(cards_to_skip) model2_renumber.read_bdf(bdf_filename) _apply_scalar_cards(model, model2_renumber) bdf_dump = StringIO() # 'bdf_merge_temp.bdf' _, mapperi = bdf_renumber(model2_renumber, bdf_dump, starting_id_dict=starting_id_dict, size=size, is_double=is_double, cards_to_skip=cards_to_skip) bdf_dump.seek(0) mappers.append(mapperi) model2 = BDF(debug=False, log=log) model2.disable_cards(cards_to_skip) model2.read_bdf(bdf_dump) #model.log.info('model2.node_ids = %s' % np.array(model2.node_ids)) for data_member in data_members: data1 = getattr(model, data_member) data2 = getattr(model2, data_member) if isinstance(data1, dict): #model.log.info(' working on %s' % (data_member)) for key, value in data2.items(): if data_member in 'coords' and key == 0: continue if isinstance(value, list): assert key not in data1, key data1[key] = value else: assert key not in data1, key data1[key] = value #print(' %s' % key) else: raise NotImplementedError(type(data1)) #if bdf_filenames_out: #model.write_bdf(bdf_filenames_out, size=size) mapper_renumber = None if renumber: model.log.info('final renumber...') starting_id_dict = { 'cid': 1, 'nid': 1, 'eid': 1, 'pid': 1, 'mid': 1, } _, mapper_renumber = bdf_renumber(model, bdf_filename_out, starting_id_dict=starting_id_dict, size=size, is_double=is_double, cards_to_skip=cards_to_skip) bdf_filename_temp = StringIO() model.write_bdf(bdf_filename_temp, size=size, is_double=False, interspersed=False, enddata=None, close=False) bdf_filename_temp.seek(0) model = read_bdf(bdf_filename_temp, validate=False, xref=model._xref, punch=False, log=model.log, debug=True, mode=model._nastran_format) elif bdf_filename_out: model.write_bdf(out_filename=bdf_filename_out, encoding=None, size=size, is_double=is_double, interspersed=True, enddata=None) mappers_final = _assemble_mapper(mappers, _mapper_0, data_members, mapper_renumber=mapper_renumber) return model, mappers_final
def load_case_control(geom_model: BDF, hdf5_case_control): names = hdf5_case_control.dtype.names names = list(names) names.remove('SID') lines = [] cc = CaseControlDeck(lines, log=None) log = cc.log sids = hdf5_case_control['SID'] log.info(f'subcases = {sids}') for sid in sids: subcase = cc.create_new_subcase(sid) cc.subcases[sid] = subcase integer_mapped_names = { 'NOHARMON': ('HARMONICS', 1), 'SPCSET': ('SPC', 0), 'MPCSET': ('MPC', 0), 'TIC': ('IC', 0), 'ESLSET': ('LOAD', 0), 'DYMLDSET': ('DLOAD', 0), 'TFSET': ('TFL', 0), 'FLUTTER': ('FLUTTER', 0), 'RANDOM': ('RANDOM', 0), 'GUST': ('GUST', 0), 'LOADSET': ('LOADSET', 0), 'CLOAD': ('CLOAD', 0), 'APRESS': ('APRESS', 0), 'TRIM': ('TRIM', 0), 'FLDBNDY': ('MFLUID', 0), 'DIVERG': ('DIVERG', 0), 'DESOBJ': ('DESOBJ', 0), 'DESSUB': ('DESSUB', 0), 'BCID': ('BC', 0), 'REESET': ('METHOD(STRUCTURE)', 0), 'ELDSET': ('DEFORM', 0), 'THLDSET': ('TEMP(LOAD)', 0), 'THMATSET': ('TEMP(MAT)', 0), # or TEMP(INIT) ??? 'FEQRESET': ('FREQUENCY', 0), 'TSTEPTRN': ('TSTEP', 0), 'AXSYMSET': ('AXISYMMETRIC', 0), 'DAMPTBL': ('SDAMP(STRUCT)', 0), 'NONPARAM': ('NLPARM', 0), 'LOADSET': ('LOADSET', 0), 'MODLIST': ('OMODES', 0), 'REESETF': ('METHOD(FLUID)', 0), 'NMODES': ('NMODES', 0), 'ADAPT': ('ADAPT', 0), 'SUBSPAN': ('SUBSPAN', 0), 'DESGLB': ('DESGLB', 0), 'SUPORT1': ('SUPORT1', 0), 'STATSUBB': ('STATSUB(BUCKLE)', 0), 'STATSUBP': ('STATSUB(PRELOAD)', 0), 'AUXMODEL': ('AUXMODEL', 0), 'NSMID': ('NSM', 0), 'NONLINLD': ('NONLINEAR', 0), 'CYCLIC': ('DSYM', 0), 'DYNRED': ('DYNRED', 0), 'CEESET': ('CMETHOD', 0), 'AECSSSET': ('CSSCHD', 0), 'TEMPMAT': ('TEMP(MAT)', 0), 'RGYRO': ('RGYRO', 0), # superelements 'SEMG': ('SEMG', -1), 'SEKR': ('SEKR', -1), 'SELG': ('SELG', -1), 'SELR': ('SELR', -1), #'SEID' : ('SEID', -1), 'SEMR': ('SEMR', -1), 'SEDV': ('SEDV', -1), 'SERE': ('SERE', -1), 'SEEXCLUDE': ('SEEX', 0), 'SEEXCLUDE': ('SEEX', 0), } stress_mapped_names = [ # media = plot; print; punch # format = real; real/imag; magnitude/phase # rout - random output # RANDBIT: Random analysis request bit pattern (DISP,VELO,etc.) ('DISPLACEMENT', 'DPLPTSET', 'DPLMEDIA', 'DPLFMT'), # ROUTDISP ('OLOAD', 'LDSPTSET', 'LDSMEDIA', 'LDSFMT'), # ROUTLOAD ('VELOCITY', 'VELPTSET', 'VELMEDIA', 'VELFMT'), # ROUTVELO ('ACCEL', 'ACCPTSET', 'ACCMEDIA', 'ACCFMT'), # ROUTACCE ('MPCFORCE', 'MPCFSET', 'MPCMEDIA', 'MPCFFMT'), # ROUTMSCF ('SPCFORCE', 'FOCPTSET', 'FOCMEDIA', 'FOCFMT'), # ROUTSPCF ('FORCE', 'FCEPTSET', 'FCEMEDIA', 'FCEFMT'), # ROUTFORC ('STRESS', 'STSPTSET', 'STSMEDIA', 'STSFMT'), # ROUTSTRS, VONMISES-done ('STRAIN', 'STNSET', 'STNMEDIA', 'STNFMT'), # ROUTSTRN #'GPQSTRS', # CQUAD4 corner stress output - done #'GPQFORC', # CQUAD4 corner force output - done #'GPQSTRN', # CQUAD4 corner strain output - done ('SDISP', 'SSDSET', 'SSDMEDIA', 'SSDFMT'), ('SVELO', 'SSVSET', 'SSVMEDIA', 'SSVFMT'), ('SACCE', 'SSASET', 'SSAMEDIA', 'SSAFMT'), ('GPFORCE', 'GPFSET', 'GPFMEDIA', 'GPFFMT'), ('ESE', 'ESESET', 'ESEMEDIA', 'ESEFMT'), ('AEROF', 'ARFPTSET', 'ARFMEDIA', 'ARFFMT'), ('SVECTOR', 'SVSET', 'SVMEDIA', 'SVFMT'), ('MPRES', 'FLUPTSET', 'FLUMEDIA', 'FLUFMT'), ('ELSDCON', 'ESDPTSET', 'ESDMEDIA', 'ESDFMT'), ('GPSDCON', 'GSDPTSET', 'GSDMEDIA', 'GSDFMT'), ('BOUTPUT', 'CNTSET', 'CNTMEDIA', 'CNTFMT'), ('NLSTRESS', 'NLSSET', 'NLSMEDIA', 'NLSFMT'), ('GPSTRAIN', 'GPEPTSET', 'GPEMEDIA', 'GPEFMT'), ('EKE', 'EKEPTSET', 'EKEMEDIA', 'EKEFMT'), # EKETHRSH ('EDE', 'EDEPTSET', 'EDEMEDIA', 'EDEFMT'), # EDETHRSH ('GPKE', 'GPKESET', 'GPKEMEDI', 'GPKEFMT'), # ('ACFPM', 'ACFPMSET', 'ACFPMMED', 'ACFPMFMT'), ('ERP', 'ERPSID', 'ERPMED', 'ERPFMT'), ('NLLOAD', 'NONPTSET', 'NONMEDIA', 'NONFMT'), ('GPSTRESS', 'GPSPTSET', 'GPSMEDIA', 'GPSFMT'), ('STRFIELD', 'STFSET', 'STFMEDIA', 'STFFMT'), #('RCROSS', 'RCRSET', '', 'RCRFMT'), ('PFGRID', 'PFGSID', 'PFGMED', 'PFGFMT'), ('PFMODE(STRUCTURE)', 'PFMSSID', 'PFMSMED', 'PFMSFMT'), ('PFMODE(FLUID)', 'PFMFSID', 'PFMFMED', 'PFMFFMT'), ('GVECTOR', 'GVSET', 'GVMEDIA', 'GVFMT'), ('INTENSITY', 'INTENSET', 'INTENMED', 'INTENFMT'), ('DATAREC', 'DATSET', 'DATMEDIA', 'DATFMT'), ('VUGRID', 'VUGSET', 'VUGMEDIA', 'VUGFMT'), ('MAXMIN', 'MXMNGSET', 'MXMNGMDA', 'MXMNGFMT'), # MXMNESET, MXMNEMDA, MXMNEFMT #('MCFRACTION', 'MCFRSET', '', ''), # MCFRSOLN, MCFRSOLN, MCFROPT #('FATIGUE', 'FATIGUE', 'FTGMED', ''), ('ICF', 'ICFSET', 'ICFMED', 'ICFFMT' ), # ICFGENST, ICFGENNM, ICFUSEST, ICFUSENM ('ACPOWER', 'ACPOWSET', 'ACPOWMED', 'ACPOWFMT'), # ACPOWCSV ('MODALSE', 'MDLSSET', 'MDLSMEDIA', 'MDLSFMT'), # MDLSTHRE, MDLSTFVL ('MODALKE', 'MDLKSET', 'MDLKMEDIA', 'MDLKFMT'), # MDLKESRT, MDLKTHRE, MDLKTFVL #('CMSENRGY', 'CMSESET', 'CMSEMDIA', ''), # CMSEOPTS, CMSETHRE, CMSETOPN ] string_types = [ 'SUBTITLE', 'LABEL', 'TITLE', # trivial 'ANALYSIS', #'AECONFIG', # 'POSTO2NM', # matrices 'K2PP', 'M2PP', 'B2PP', 'P2G', 'K2GG', 'M2GG', 'B2GG', 'A2GG', 'K42GG', ] special_names = [ 'AESYMXY', 'AESYMXZ', 'VONMISES', # vonmises flag for STRESS 'GPQSTRS', # CQUAD4 corner stress output 'GPQFORC', # CQUAD4 corner force output 'GPQSTRN', # CQUAD4 corner strain output #'MXMNESET', # MAXMIN element set selection #'MXMNEMDA', # MAXMIN element output media #'MXMNEFMT', # MAXMIN element output format 'MCFRSET', # MCFRACTION: Modal contribution fraction set identification number 'MCFRSOLN', # MCFRACTION: SOLUTION=1001 'MCFRFILT', # MCFRACTION: FILTER=0.01 #'MCFROPT', # MCFRACTION: options bit pattern ] integer_mapped_names = {} stress_mapped_names = [] special_names = [] subcases = cc.subcases for name_str in string_types: assert name_str in names, name_str values = hdf5_case_control[name_str] names.remove(name_str) for sid, value in zip(sids, values): value = value.strip().decode('latin1') if len(value) == 0: continue options = [] subcase = subcases[sid] # type: Subcase assert isinstance(value, str), value subcase.add(name_str, value, options, 'STRING-type') for mapped_namesi in stress_mapped_names: (name_str, set_str, media_str, fmt_str) = mapped_namesi #if name_str not in names: #log.error(f'skipping {name_str} because it is missing...') #continue values = hdf5_case_control[set_str] medias = hdf5_case_control[media_str] fmts = hdf5_case_control[fmt_str] #names.remove(name_str) names.remove(set_str) names.remove(media_str) names.remove(fmt_str) for sid, value, media, fmt in zip(sids, values, medias, fmts): if value == 0: #log.debug(f'stress-type: {name_str} is empty; value={value}') continue elif value == -1: # default value = 'ALL' #log.debug(f'stress-type: {name_str} is default; value={value}') #continue options = [] if fmt == 0: # ?? pass # options.append('SORT1') elif fmt == 1: # ?? options.append('SORT1') elif fmt == 2: # ?? options.append('SORT1') else: raise RuntimeError((name_str, sid, value, media, fmt)) if media in (1, 3, 5, 7): options.append('PRINT') if media in (2, 3, 6, 7): options.append('PRINT') if media in (4, 5, 6, 7): options.append('PUNCH') #if media == 1: #options.append('PRINT') #elif media == 2: #options.append('PLOT') #elif media == 3: #options.extend(['PLOT', 'PRINT']) #elif media == 4: #options.append('PUNCH') #elif media == 5: #options.extend(['PRINT', 'PUNCH']) #elif media == 6: #options.extend(['PLOT', 'PUNCH']) #else: #raise RuntimeError((name_str, sid, value, media, fmt)) subcase = subcases[sid] # type: Subcase subcase.add(name_str, value, options, 'STRESS-type') names_copy = deepcopy(names) #skip_fields = ['NONFMT', 'NONMEDIA', ''] for name in names: names_copy.remove(name) values = hdf5_case_control[name] for sid, value in zip(sids, values): if name in integer_mapped_names: updated_name, default = integer_mapped_names[name] if value == default: continue # SPC = 1 subcase = subcases[sid] # type: Subcase options = [] subcase.add(updated_name, value, options, 'STRESS-type') elif name in special_names: continue #elif name.endswith('FMT'): #log.error(f'format skipping {name}={value}') elif name == 'DOMAIN_ID': log.warning(f'skipping {name}={value}') break #else: #log.warning(f'skipping {name}={value}') #cc.dtype.names ### _load_special_names(special_names, hdf5_case_control, subcases, sids, cc.log) #str(cc) geom_model.case_control_deck = cc