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
