def get_spring_stress_strains(eids, cases, model: OP2, times, key, icase,
form_dict, header_dict, keys_map, is_stress):
"""
helper method for _fill_op2_time_centroidal_stress.
"""
subcase_id = key[0]
results = model
if is_stress:
springs = [
results.celas1_stress, results.celas2_stress,
results.celas3_stress, results.celas4_stress]
word = 'Stress'
else:
springs = [
results.celas1_strain, results.celas2_strain,
results.celas3_strain, results.celas4_strain]
word = 'Strain'
spring_cases = []
spring_ieids = []
for result in springs:
if key not in result:
continue
case = result[key]
eidsi = case.element
i = np.searchsorted(eids, eidsi)
if len(i) != len(np.unique(i)):
#print(case.element_node)
#print('element_name=%s nnodes_per_element=%s' % (case.element_name, nnodes_per_element))
#print('iplate = %s' % i)
#print(' eids = %s' % eids)
#print(' eidsiA = %s' % case.element_node[:, 0])
#print(' eidsiB = %s' % eidsi)
msg = 'i%s (spring)=%s is not unique' % (case.element_name, str(i))
#msg = 'iplate=%s is not unique' % str(i)
model.log.warning(msg)
continue
if i.max() == len(eids):
model.log.error('skipping because lookup is out of range...')
continue
spring_cases.append(case)
spring_ieids.append(i)
if not spring_ieids:
return icase
spring_ieids = np.hstack(spring_ieids)
ieid_max = len(eids)
case = spring_cases[0]
case_headers = case.get_headers()
if is_stress:
method_map = {
'spring_stress' : 'σxx',
}
data_format = '%.3f'
else:
method_map = {
'spring_strain' : 'ϵxx',
}
data_format = '%.3e'
methods = [method_map[headeri] for headeri in case_headers]
#headersi = case.get_headers()
#print('headersi =', headersi)
scalars_array = []
for case in spring_cases:
keys_map[key] = (case.subtitle, case.label,
case.superelement_adaptivity_index, case.pval_step)
scalars = case.data
scalars_array.append(scalars)
if len(scalars_array) == 0:
return icase
scalars_array = concatenate_scalars(scalars_array)
headers = [] # sidebar word
res = SimpleTableResults(
subcase_id, headers, spring_ieids, ieid_max, scalars_array, methods,
data_format=data_format,
colormap='jet', uname='Spring ' + word)
icase = add_simple_methods_to_form(icase, cases, key, subcase_id, word, res, case,
form_dict, header_dict, methods,
name='Spring')
return icase
def get_beam_stress_strains(eids, cases, model: OP2, times, key, icase,
form_dict, header_dict, keys_map, is_stress):
"""
helper method for _fill_op2_time_centroidal_stress.
"""
#print("***stress eids=", eids)
subcase_id = key[0]
if is_stress:
beams = [model.cbeam_stress]
word = 'Stress'
else:
beams = [model.cbeam_strain]
word = 'Strain'
#titles = []
beam_cases = []
beam_ieids = []
for result in beams:
if key not in result:
continue
case = result[key]
eidsi = np.unique(case.element_node[:, 0])
print(eidsi)
i = np.searchsorted(eids, eidsi)
if len(i) != len(np.unique(i)):
#print(case.element_node)
#print('element_name=%s nnodes_per_element=%s' % (case.element_name, nnodes_per_element))
#print('iplate = %s' % i)
#print(' eids = %s' % eids)
#print(' eidsiA = %s' % case.element_node[:, 0])
#print(' eidsiB = %s' % eidsi)
msg = 'i%s (beam)=%s is not unique' % (case.element_name, str(i))
#msg = 'iplate=%s is not unique' % str(i)
model.log.warning(msg)
continue
if i.max() == len(eids):
model.log.error('skipping because lookup is out of range...')
continue
i2 = np.hstack([i, i + 1]).T.flatten()
print('i =', i)
print('i2 =', i2)
#aa
#print('i =', i, i.max())
#print('eids =', eids, len(eids))
#print('eidsi =', eidsi, eids)
#print(f'------------adding i={i} for {case.element_name}-----------')
beam_cases.append(case)
beam_ieids.append(i2)
if not beam_ieids:
return icase
beam_ieids = np.hstack(beam_ieids)
#inid_max = len(nids)
ieid_max = len(eids)
print('ieid_max =', ieid_max)
case = beam_cases[0]
case_headers = case.get_headers()
#print(case_headers)
if is_stress:
#sigma = 'σ'
method_map = {
'sxc' : 'σxx C',
'sxd' : 'σxx D',
'sxe' : 'σxx E',
'sxf' : 'σxx F',
#'torsion' : 'τxy',
'MS_tension' : 'MS_tension',
'MS_compression' : 'MS_compression',
'smax' : 'σmax',
'smin' : 'σmin',
#'von_mises' : 'σ von Mises',
}
else:
#sigma = 'ϵ'
method_map = {
'sxc' : 'ϵxx C',
'sxd' : 'ϵxx D',
'sxe' : 'ϵxx E',
'sxf' : 'ϵxx F',
'exc' : 'ϵxx C',
'exd' : 'ϵxx D',
'exe' : 'ϵxx E',
'exf' : 'ϵxx F',
#'torsion' : 'τxy',
'MS_tension' : 'MS_tension',
'MS_compression' : 'MS_compression',
'smax' : 'ϵmax',
'smin' : 'ϵmin',
#'von_mises' : 'ϵ von Mises',
}
methods = [method_map[headeri] for headeri in case_headers]
return icase
#if 'Mises' in methods:
#methods.append('Max shear')
#else:
#methods.append(f'{sigma} von Mises')
#if case.is_von_mises:
#vm_word = 'vonMises'
#else:
#vm_word = 'maxShear'
#headersi = case.get_headers()
#print('headersi =', headersi)
scalars_array = []
for case in beam_cases:
if case.is_complex:
model.log.warning(f'skipping complex Beam {word}')
continue
#ntimes, nelements, nresults = case.data.shape
#self.data[self.itime, self.itotal, :] = [fd, oxx, oyy,
# txy, angle,
# majorP, minorP, ovm]
keys_map[key] = (case.subtitle, case.label,
case.superelement_adaptivity_index, case.pval_step)
#nnodes_per_element = case.nnodes
#nelements_nnodes = nnodes_nlayers // 2
#nelements = nelements_nnodes // nnodes_per_element
#nlayers = 2
scalars = case.data
scalars_array.append(scalars)
if len(scalars_array) == 0:
return icase
scalars_array = concatenate_scalars(scalars_array)
#titles = [] # legend title
headers = [] # sidebar word
res = SimpleTableResults(
subcase_id, headers, beam_ieids, ieid_max, scalars_array, methods,
data_formats=None,
colormap='jet', location='node', uname='Beam ' + word)
times = case._times
for itime, dt in enumerate(times):
#dt = case._times[itime]
header = _get_nastran_header(case, dt, itime)
header_dict[(key, itime)] = header
formi = []
form = form_dict[(key, itime)]
form.append(('Beam ' + word, None, formi))
# formi = form[0][2]
for imethod, method in enumerate(methods):
#cases[icase] = (res, (subcase_id, header))
cases[icase] = (res, (subcase_id, (itime, imethod, header)))
formi.append((method, icase, []))
icase += 1
return icase
def get_solid_stress_strains(eids, cases, model: OP2, times, key, icase,
form_dict, header_dict, keys_map, is_stress):
"""
helper method for _fill_op2_time_centroidal_stress.
"""
#print("***stress eids=", eids)
subcase_id = key[0]
results = model
if is_stress:
solids = [
results.ctetra_stress, results.cpenta_stress, results.chexa_stress, # results.cpyram_stress,
]
word = 'Stress'
else:
solids = [
results.ctetra_strain, results.cpenta_strain, results.chexa_strain, # results.cpyram_strain,
]
word = 'Strain'
#titles = []
solid_cases = []
solid_ieids = []
for result in solids:
if key not in result:
continue
case = result[key]
#print(case)
nnodes = case.nnodes_per_element
all_eidsi = case.element_node[:, 0]
nall_eidsi = len(all_eidsi)
nelementsi = nall_eidsi // nnodes
eidsi = all_eidsi.reshape(nelementsi, nnodes)[:, 0]
i = np.searchsorted(eids, eidsi)
if len(i) != len(np.unique(i)):
#print(case.element_node)
#print('element_name=%s nnodes_per_element=%s' % (case.element_name, nnodes_per_element))
#print('iplate = %s' % i)
#print(' eids = %s' % eids)
#print(' eidsiA = %s' % case.element_node[:, 0])
#print(' eidsiB = %s' % eidsi)
msg = 'i%s (solid)=%s is not unique' % (case.element_name, str(i))
#msg = 'iplate=%s is not unique' % str(i)
model.log.warning(msg)
continue
if i.max() == len(eids):
model.log.error('skipping because lookup is out of range...')
continue
#print('i =', i, i.max())
#print('eids =', eids, len(eids))
#print('eidsi =', eidsi, eids)
#print(f'------------adding i={i} for {case.element_name}-----------')
solid_cases.append(case)
solid_ieids.append(i)
if not solid_ieids:
return icase
solid_ieids = np.hstack(solid_ieids)
ieid_max = len(eids)
#print('ieid_max =', ieid_max)
case = solid_cases[0]
case_headers = case.get_headers()
if is_stress:
#sigma = 'σ'
method_map = {
'oxx' : 'σxx',
'oyy' : 'σyy',
'ozz' : 'σzz',
'txy' : 'τxy',
'tyz' : 'τyz',
'txz' : 'τxz',
'omax' : 'σmax',
'omin' : 'σmin',
'omid' : 'σmid',
'von_mises' : 'σ von Mises',
}
data_format = '%.3f'
else:
#sigma = 'ϵ'
method_map = {
'exx' : 'ϵxx',
'eyy' : 'ϵyy',
'ezz' : 'ϵzz',
'exy' : 'ϵxy',
'eyz' : 'ϵyz',
'exz' : 'ϵxz',
'emax' : 'ϵmax',
'emin' : 'ϵmin',
'emid' : 'ϵmid',
'von_mises' : 'ϵ von Mises',
}
data_format = '%.3e'
methods = [method_map[headeri] for headeri in case_headers]
#if 'Mises' in methods:
#methods.append('Max shear')
#else:
#methods.append(f'{sigma} von Mises')
#if case.is_von_mises:
#vm_word = 'vonMises'
#else:
#vm_word = 'maxShear'
#headersi = case.get_headers()
#print('headersi =', headersi)
scalars_array = []
for case in solid_cases:
#if case.is_complex:
#model.log.warning(f'skipping complex Rod {word}')
#continue
#ntimes, nelements, nresults = case.data.shape
#self.data[self.itime, self.itotal, :] = [fd, oxx, oyy,
# txy, angle,
# majorP, minorP, ovm]
keys_map[key] = (case.subtitle, case.label,
case.superelement_adaptivity_index, case.pval_step)
#nnodes_per_element = case.nnodes
#nelements_nnodes = nnodes_nlayers // 2
#nelements = nelements_nnodes // nnodes_per_element
#nlayers = 2
nnodes = case.nnodes_per_element
scalars = case.data
#print('scalars.shape', scalars.shape)
ntimes, nall, nresults = scalars.shape
nelements = nall // nnodes
scalars_save = scalars.reshape(ntimes, nelements, nnodes, nresults)
scalars_array.append(scalars_save[:, :, 0, :])
if len(scalars_array) == 0:
return icase
scalars_array = concatenate_scalars(scalars_array)
#titles = [] # legend title
headers = [] # sidebar word
res = SimpleTableResults(
subcase_id, headers, solid_ieids, ieid_max, scalars_array, methods,
data_format=data_format,
colormap='jet', uname='Solid ' + word)
icase = add_simple_methods_to_form(icase, cases, key, subcase_id, word, res, case,
form_dict, header_dict, methods,
name='Solid')
return icase
def get_bar_stress_strains(eids, cases, model: OP2, times, key, icase,
form_dict, header_dict, keys_map, is_stress):
"""
helper method for _fill_op2_time_centroidal_stress.
"""
#print("***stress eids=", eids)
subcase_id = key[0]
if is_stress:
bars = [model.cbar_stress]
word = 'Stress'
else:
bars = [model.cbar_strain]
word = 'Strain'
#titles = []
bar_cases = []
bar_ieids = []
for result in bars:
if key not in result:
continue
case = result[key]
eidsi = case.element
i = np.searchsorted(eids, eidsi)
if len(i) != len(np.unique(i)):
#print(case.element_node)
#print('element_name=%s nnodes_per_element=%s' % (case.element_name, nnodes_per_element))
#print('iplate = %s' % i)
#print(' eids = %s' % eids)
#print(' eidsiA = %s' % case.element_node[:, 0])
#print(' eidsiB = %s' % eidsi)
msg = 'i%s (bar)=%s is not unique' % (case.element_name, str(i))
#msg = 'iplate=%s is not unique' % str(i)
model.log.warning(msg)
continue
if i.max() == len(eids):
model.log.error('skipping because lookup is out of range...')
continue
#print('i =', i, i.max())
#print('eids =', eids, len(eids))
#print('eidsi =', eidsi, eids)
#print(f'------------adding i={i} for {case.element_name}-----------')
bar_cases.append(case)
bar_ieids.append(i)
if not bar_ieids:
return icase
bar_ieids = np.hstack(bar_ieids)
ieid_max = len(eids)
#print('ieid_max =', ieid_max)
case = bar_cases[0]
case_headers = case.get_headers()
#print(case_headers)
if is_stress:
#sigma = 'σ'
method_map = {
's1a' : 'σxx 1A',
's2a' : 'σxx 2A',
's3a' : 'σxx 3A',
's4a' : 'σxx 4A',
's1b' : 'σxx 1B',
's2b' : 'σxx 2B',
's3b' : 'σxx 3B',
's4b' : 'σxx 4B',
'axial' : 'σxx',
'MS_tension' : 'MS_tension',
'MS_compression' : 'MS_compression',
'smaxa' : 'σmax A',
'smina' : 'σmin A',
'smaxb' : 'σmax B',
'sminb' : 'σmin B',
#'von_mises' : 'σ von Mises',
}
data_format = '%.3f'
else:
#sigma = 'ϵ'
method_map = {
'e1a' : 'ϵxx 1A',
'e2a' : 'ϵxx 2A',
'e3a' : 'ϵxx 3A',
'e4a' : 'ϵxx 4A',
'e1b' : 'ϵxx 1B',
'e2b' : 'ϵxx 2B',
'e3b' : 'ϵxx 3B',
'e4b' : 'ϵxx 4B',
'e1c': 'ϵxx 1C',
'e1d': 'ϵxx 1D',
'e2c': 'ϵxx 2C',
'e2d': 'ϵxx 2D',
'axial' : 'ϵxx',
'MS_tension' : 'MS_tension',
'MS_compression' : 'MS_compression',
'emaxa' : 'ϵmax A',
'emina' : 'ϵmin A',
'emaxb' : 'ϵmax B',
'eminb' : 'ϵmin B',
#'emax' : 'ϵmax',
#'emin' : 'ϵmin',
#'von_mises' : 'ϵ von Mises',
}
data_format = '%.3e'
methods = [method_map[headeri] for headeri in case_headers]
#if 'Mises' in methods:
#methods.append('Max shear')
#else:
#methods.append(f'{sigma} von Mises')
#if case.is_von_mises:
#vm_word = 'vonMises'
#else:
#vm_word = 'maxShear'
#headersi = case.get_headers()
#print('headersi =', headersi)
scalars_array = []
for case in bar_cases:
#ntimes, nelements, nresults = case.data.shape
#self.data[self.itime, self.itotal, :] = [fd, oxx, oyy,
# txy, angle,
# majorP, minorP, ovm]
keys_map[key] = (case.subtitle, case.label,
case.superelement_adaptivity_index, case.pval_step)
#nnodes_per_element = case.nnodes
#nelements_nnodes = nnodes_nlayers // 2
#nelements = nelements_nnodes // nnodes_per_element
#nlayers = 2
scalars = case.data
scalars_array.append(scalars)
if len(scalars_array) == 0:
return icase
scalars_array = concatenate_scalars(scalars_array)
exclude_tension_margin = False
exclude_compression_margin = False
if 'MS_tension' in methods:
# real
itension = methods.index('MS_tension')
icompression = methods.index('MS_compression')
exclude_tension_margin = np.allclose(np.abs(scalars_array[:, :, itension]).max(), 0.0)
exclude_compression_margin = np.allclose(np.abs(scalars_array[:, :, icompression]).max(), 0.0)
iresults = list(range(len(methods)))
if exclude_compression_margin:
methods.pop(icompression)
iresults.pop(icompression)
if exclude_tension_margin:
methods.pop(itension)
iresults.pop(itension)
if exclude_compression_margin or exclude_compression_margin:
scalars_array = scalars_array[:, :, iresults]
#titles = [] # legend title
headers = [] # sidebar word
res = SimpleTableResults(
subcase_id, headers, bar_ieids, ieid_max, scalars_array, methods,
data_format=data_format,
colormap='jet', uname='Bar ' + word)
icase = add_simple_methods_to_form(icase, cases, key, subcase_id, word, res, case,
form_dict, header_dict, methods,
name='Bar')
return icase
def get_rod_stress_strains(eids, cases, model: OP2, times, key, icase,
form_dict, header_dict, keys_map, is_stress):
"""
helper method for _fill_op2_time_centroidal_stress.
"""
subcase_id = key[0]
if is_stress:
rods = [
model.crod_stress, model.conrod_stress, model.ctube_stress,
]
word = 'Stress'
else:
rods = [
model.crod_strain, model.conrod_strain, model.ctube_strain,
]
word = 'Strain'
#titles = []
rod_cases = []
rod_ieids = []
for result in rods:
if key not in result:
continue
case = result[key]
eidsi = case.element
i = np.searchsorted(eids, eidsi)
if len(i) != len(np.unique(i)):
#print(case.element_node)
#print('element_name=%s nnodes_per_element=%s' % (case.element_name, nnodes_per_element))
#print('iplate = %s' % i)
#print(' eids = %s' % eids)
#print(' eidsiA = %s' % case.element_node[:, 0])
#print(' eidsiB = %s' % eidsi)
msg = 'i%s (rod)=%s is not unique' % (case.element_name, str(i))
#msg = 'iplate=%s is not unique' % str(i)
model.log.warning(msg)
continue
if i.max() == len(eids):
model.log.error('skipping because lookup is out of range...')
continue
#print('i =', i, i.max())
#print('eids =', eids, len(eids))
#print('eidsi =', eidsi, eids)
#print(f'------------adding i={i} for {case.element_name}-----------')
rod_cases.append(case)
rod_ieids.append(i)
if not rod_ieids:
return icase
rod_ieids = np.hstack(rod_ieids)
ieid_max = len(eids)
#print('ieid_max =', ieid_max)
case = rod_cases[0]
case_headers = case.get_headers()
#print(case_headers)
if is_stress:
#sigma = 'σ'
method_map = {
'axial' : 'σxx',
'torsion' : 'τxy',
'SMa' : 'MS_axial',
'SMt' : 'MS_torsion',
#'omax' : 'σmax',
#'omin' : 'σmin',
#'von_mises' : 'σ von Mises',
}
data_format = '%.3f'
else:
#sigma = 'ϵ'
method_map = {
'axial' : 'ϵxx',
'torsion' : 'ϵxy',
'SMa' : 'MS_axial',
'SMt' : 'MS_torsion',
#'emax' : 'ϵmax',
#'emin' : 'ϵmin',
#'von_mises' : 'ϵ von Mises',
}
data_format = '%.3e'
methods = [method_map[headeri] for headeri in case_headers]
#if 'Mises' in methods:
#methods.append('Max shear')
#else:
#methods.append(f'{sigma} von Mises')
#if case.is_von_mises:
#vm_word = 'vonMises'
#else:
#vm_word = 'maxShear'
scalars_array = []
for case in rod_cases:
keys_map[key] = (case.subtitle, case.label,
case.superelement_adaptivity_index, case.pval_step)
scalars = case.data
scalars_array.append(scalars)
if len(scalars_array) == 0:
return icase
scalars_array = concatenate_scalars(scalars_array)
headers = [] # sidebar word
res = SimpleTableResults(
subcase_id, headers, rod_ieids, ieid_max, scalars_array, methods,
data_format=data_format,
colormap='jet', uname='Rod ' + word)
icase = add_simple_methods_to_form(icase, cases, key, subcase_id, word, res, case,
form_dict, header_dict, methods,
name='Rod')
return icase
if len(scalars_array) == 0:
return icase
scalars_array = concatenate_scalars(scalars_array)
#titles = [] # legend title
headers = [] # sidebar word
assert scalars_array.shape[2] == len(
methods
), f'shape={scalars_array.shape}; methods={methods} n={len(methods)}'
res = SimpleTableResults(subcase_id,
headers,
solid_ieids,
ieid_max,
scalars_array,
methods,
data_format=data_format,
colormap='jet',
uname='Solid ' + word)
icase = add_simple_methods_to_form(icase,
cases,
key,
subcase_id,
word,
res,
case,
form_dict,
header_dict,
methods,
name='Solid')
def get_bar_force(eids, cases, model: OP2, times, key, icase,
form_dict, header_dict, keys_map):
"""
helper method for _fill_op2_time_centroidal_stress.
"""
#print("***stress eids=", eids)
subcase_id = key[0]
bars = [model.cbar_force]
#titles = []
bar_cases = []
bar_ieids = []
for result in bars:
if key not in result:
continue
case = result[key]
eidsi = case.element
i = np.searchsorted(eids, eidsi)
if len(i) != len(np.unique(i)):
#print(case.element_node)
#print('element_name=%s nnodes_per_element=%s' % (case.element_name, nnodes_per_element))
#print('iplate = %s' % i)
#print(' eids = %s' % eids)
#print(' eidsiA = %s' % case.element_node[:, 0])
#print(' eidsiB = %s' % eidsi)
msg = 'i%s (bar)=%s is not unique' % (case.element_name, str(i))
#msg = 'iplate=%s is not unique' % str(i)
model.log.warning(msg)
continue
if i.max() == len(eids):
model.log.error('skipping because lookup is out of range...')
continue
#print('i =', i, i.max())
#print('eids =', eids, len(eids))
#print('eidsi =', eidsi, eids)
#print(f'------------adding i={i} for {case.element_name}-----------')
bar_cases.append(case)
bar_ieids.append(i)
if not bar_ieids:
return icase
bar_ieids = np.hstack(bar_ieids)
ieid_max = len(eids)
#print('ieid_max =', ieid_max)
case = bar_cases[0]
case_headers = case.get_headers()
#print(case_headers)
word = 'Force'
method_map = {
# real
'bending_moment_a1' : 'My Bending 1',
'bending_moment_a2' : 'My Bending 2',
'bending_moment_b1' : 'Mz Bending 1',
'bending_moment_b2' : 'Mz Bending 2',
# complex
'bending_moment_1a' : 'My Bending 1',
'bending_moment_2a' : 'My Bending 2',
'bending_moment_1b' : 'Mz Bending 1',
'bending_moment_2b' : 'Mz Bending 2',
'shear1' : 'Fy Shear',
'shear2' : 'Fz Shear',
'axial' : 'Fx',
'torque' : 'Torque',
}
data_format = '%.3f'
methods = [method_map[headeri] for headeri in case_headers]
scalars_array = []
for case in bar_cases:
#if case.is_complex:
#model.log.warning(f'skipping complex Bar {word}')
#continue
#ntimes, nelements, nresults = case.data.shape
#self.data[self.itime, self.itotal, :] = [fd, oxx, oyy,
# txy, angle,
# majorP, minorP, ovm]
keys_map[key] = (case.subtitle, case.label,
case.superelement_adaptivity_index, case.pval_step)
#nnodes_per_element = case.nnodes
#nelements_nnodes = nnodes_nlayers // 2
#nelements = nelements_nnodes // nnodes_per_element
#nlayers = 2
scalars = case.data
scalars_array.append(scalars)
if len(scalars_array) == 0:
return icase
scalars_array = concatenate_scalars(scalars_array)
#include_tension_margin = True
#include_compression_margin = True
headers = [] # sidebar word
res = SimpleTableResults(
subcase_id, headers, bar_ieids, ieid_max, scalars_array, methods,
data_format=data_format,
colormap='jet', uname='Bar ' + word)
icase = add_simple_methods_to_form(icase, cases, key, subcase_id, word, res, case,
form_dict, header_dict, methods,
name='Bar')
return icase
def get_plate_force(eids, cases, model: OP2, times, key, icase,
form_dict, header_dict, keys_map):
"""
helper method for _fill_op2_time_centroidal_stress.
"""
#print("***stress eids=", eids)
subcase_id = key[0]
plates = [
model.ctria3_force, model.ctria6_force, model.ctriar_force,
model.cquad4_force, model.cquad8_force, model.cquadr_force,
]
plate_cases = []
plate_ieids = []
for result in plates:
if key not in result:
continue
case = result[key]
nnodes = case.nnodes_per_element
if nnodes > 1:
# element_node.shape = (20, 2)
# element type: QUAD144
#RealPlateBilinearForceArray
# 8=[mx, my, mxy, bmx, bmy, bmxy, tx, ty]
all_eids = case.element_node[:, 0]
nids = case.element_node[:, 1]
if nids[-1] != 0:
eidsi = all_eids[::nnodes]
#print(nids[::nnodes])
#print('nnodes =', nnodes)
else:
eidsi = case.element
#print(case)
#print(eids)
#print(eidsi)
i = np.searchsorted(eids, eidsi)
if len(i) != len(np.unique(i)):
#print(case.element_node)
#print('element_name=%s nnodes_per_element=%s' % (case.element_name, nnodes_per_element))
#print('iplate = %s' % i)
#print(' eids = %s' % eids)
#print(' eidsiA = %s' % case.element_node[:, 0])
#print(' eidsiB = %s' % eidsi)
msg = 'i%s (plate)=%s is not unique' % (case.element_name, str(i))
#msg = 'iplate=%s is not unique' % str(i)
model.log.warning(msg)
continue
if i.max() == len(eids):
model.log.error('skipping because lookup is out of range...')
continue
#model.log.info('saving i%s (plate)' % (case.element_name))
#print(f'------------adding i={i} for {case.element_name}-----------')
plate_cases.append(case)
plate_ieids.append(i)
if not plate_ieids:
return icase
plate_ieids = np.hstack(plate_ieids)
ieid_max = len(eids)
#print('ieid_max =', ieid_max)
case = plate_cases[0]
case_headers = case.get_headers()
#print(case_headers)
word = 'Force'
method_map = {
# real
'mx': 'Fx',
'my': 'Fy',
'mxy': 'Fxy',
'bmx': 'Mx',
'bmy': 'My',
'bmxy': 'Mxy',
'tx': 'Vx',
'ty': 'Vy',
# complex
#'bending_moment_1a' : 'M bending 1A',
#'bending_moment_2a' : 'M bending 2A',
#'bending_moment_1b' : 'M bending 1B',
#'bending_moment_2b' : 'M bending 2B',
#'shear1' : 'F shear 1',
#'shear2' : 'F shear 2',
#'axial' : 'F axial',
#'torque' : 'torque',
#'s1a' : 'σxx 1A',
#'e1a' : 'ϵxx 1A',
}
data_format = '%.3f'
methods = [method_map[headeri] for headeri in case_headers]
scalars_array = []
for case in plate_cases:
keys_map[key] = (case.subtitle, case.label,
case.superelement_adaptivity_index, case.pval_step)
nnodes = case.nnodes_per_element
if nnodes == 1:
scalars = case.data
else:
scalars = case.data[:, ::nnodes, :]
scalars_array.append(scalars)
if len(scalars_array) == 0:
return icase
scalars_array = concatenate_scalars(scalars_array)
headers = [] # sidebar word
res = SimpleTableResults(
subcase_id, headers, plate_ieids, ieid_max, scalars_array, methods,
data_format=data_format,
colormap='jet', uname='Plate ' + word)
icase = add_simple_methods_to_form(icase, cases, key, subcase_id, word, res, case,
form_dict, header_dict, methods,
name='Plate')
return icase
