def _recover_strain_bar(f06_file,
op2,
model: BDF,
dof_map,
isubcase,
xb,
eids_str,
element_name,
fdtype='float32',
title: str = '',
subtitle: str = '',
label: str = '',
page_num: int = 1,
page_stamp='PAGE %s') -> None:
"""recovers static rod strain"""
neids, irod, eids = get_ieids_eids(model, element_name, eids_str)
if not neids:
return neids
strains = np.full((neids, 15), np.nan, dtype=fdtype)
if element_name == 'CBAR':
for ieid, eid in zip(irod, eids):
elem = model.elements[eid]
#[s1a, s2a, s3a, s4a, axial, smaxa, smina, MS_tension,
# s1b, s2b, s3b, s4b, sminb, sminb, MS_compression] - 15
strains[ieid, :] = _recover_straini_cbar(model, xb, dof_map, elem,
elem.pid_ref)
else: # pragma: no cover
raise NotImplementedError(element_name)
data = strains.reshape(1, *strains.shape)
table_name = 'OSTR1'
strain_obj = RealBarStrainArray.add_static_case(table_name,
element_name,
eids,
data,
isubcase,
is_stress=False,
is_sort1=True,
is_random=False,
is_msc=True,
random_code=0,
title=title,
subtitle=subtitle,
label=label)
if element_name == 'CBAR':
op2.cbar_strain[isubcase] = strain_obj
else: # pragma: no cover
raise NotImplementedError(element_name)
strain_obj.write_f06(f06_file,
header=None,
page_stamp=page_stamp,
page_num=page_num,
is_mag_phase=False,
is_sort1=True)
return neids
def _recover_stress_celas(f06_file,
op2,
model: BDF,
dof_map,
isubcase,
xg,
eids_str,
element_name: str,
fdtype='float32',
title: str = '',
subtitle: str = '',
label: str = '',
page_num: int = 1,
page_stamp='PAGE %s') -> None:
"""recovers static spring stress"""
neids, ielas, eids = get_ieids_eids(model, element_name, eids_str)
if not neids:
return neids
write_f06_stress = True
stress = np.full((neids, 1), np.nan, dtype=fdtype)
if element_name == 'CELAS1':
for ieid, eid in zip(ielas, eids):
elem = model.elements[eid]
pid_ref = elem.pid_ref
ki = pid_ref.K()
si = pid_ref.s
stress[ieid] = _recover_stressi_celas12(xg, dof_map, elem, ki, si)
elif element_name == 'CELAS2':
for ieid, eid in zip(ielas, eids):
elem = model.elements[eid]
ki = elem.K()
si = elem.s
stress[ieid] = _recover_stressi_celas12(xg, dof_map, elem, ki, si)
elif element_name == 'CELAS3':
for ieid, eid in zip(ielas, eids):
elem = model.elements[eid]
pid_ref = elem.pid_ref
ki = pid_ref.K()
si = pid_ref.s
stress[ieid] = _recover_stressi_celas34(xg, dof_map, elem, ki, si)
elif element_name == 'CELAS4':
for ieid, eid in zip(ielas, eids):
elem = model.elements[eid]
ki = elem.K()
si = 1.0 # TODO: is this right?
#si = elem.s
stress[ieid] = _recover_stressi_celas34(xg, dof_map, elem, ki, si)
else: # pragma: no cover
raise NotImplementedError(element_name)
_save_spring_stress(op2, f06_file, page_num, page_stamp, element_name,
stress, eids, write_f06_stress, isubcase, title,
subtitle, label)
return neids
def _recover_force_celas(f06_file,
op2,
model: BDF,
dof_map,
isubcase,
xg,
eids_str,
element_name: str,
fdtype='float32',
title: str = '',
subtitle: str = '',
label: str = '',
page_num: int = 1,
page_stamp='PAGE %s') -> None:
"""recovers static spring force"""
neids, ielas, eids, forces = get_ieids_eids(model,
element_name,
eids_str,
fdtype=fdtype)
if not neids:
return neids
for ieid, eid in zip(ielas, eids):
elem = model.elements[eid]
ki = elem.K()
force = _recover_forcei_celas12(xg, dof_map, elem, ki)
forces[ieid] = force
data = forces.reshape(1, *forces.shape)
table_name = 'OEF1'
spring_force = RealSpringForceArray.add_static_case(table_name,
element_name,
eids,
data,
isubcase,
is_sort1=True,
is_random=False,
is_msc=True,
random_code=0,
title=title,
subtitle=subtitle,
label=label)
if element_name == 'CELAS1':
op2.celas1_force[isubcase] = spring_force
elif element_name == 'CELAS2':
op2.celas2_force[isubcase] = spring_force
else: # pragma: no cover
raise NotImplementedError(element_name)
spring_force.write_f06(f06_file,
header=None,
page_stamp=page_stamp,
page_num=page_num,
is_mag_phase=False,
is_sort1=True)
return neids
def _recover_force_cbar(f06_file,
op2,
model: BDF,
dof_map,
isubcase,
xb,
eids_str,
element_name,
fdtype='float32',
title: str = '',
subtitle: str = '',
label: str = '',
page_num: int = 1,
page_stamp='PAGE %s') -> None:
"""
Recovers static CBAR force.
.. todo:: doesn't support CBAR-100
"""
neids, irod, eids = get_ieids_eids(model, element_name, eids_str)
if not neids:
return neids
forces = np.full((neids, 8), np.nan, dtype=fdtype)
for ieid, eid in zip(irod, eids):
elem = model.elements[eid]
forces[ieid, :] = _recover_forcei_cbar(model, xb, dof_map, elem,
elem.pid_ref)
data = forces.reshape(1, *forces.shape)
table_name = 'OEF1'
force_obj = RealCBarForceArray.add_static_case(table_name,
eids,
data,
isubcase,
is_sort1=True,
is_random=False,
is_msc=True,
random_code=0,
title=title,
subtitle=subtitle,
label=label)
op2.cbar_force[isubcase] = force_obj
force_obj.write_f06(f06_file,
header=None,
page_stamp=page_stamp,
page_num=page_num,
is_mag_phase=False,
is_sort1=True)
return neids
def _recover_strain_energy_celas(f06_file,
op2,
model: BDF,
dof_map,
isubcase,
xg,
eids_str,
element_name: str,
fdtype='float32',
title: str = '',
subtitle: str = '',
label: str = '',
page_num: int = 1,
page_stamp='PAGE %s') -> None:
"""recovers static spring strain energy"""
neids, ielas, eids = get_ieids_eids(model, element_name, eids_str)
if not neids:
return neids
write_f06_ese = True
strain_energies = np.full((neids, 1), np.nan, dtype=fdtype)
if element_name in {'CELAS1', 'CELAS2'}:
for ieid, eid in zip(ielas, eids):
elem = model.elements[eid]
ki = elem.K()
strain_energies[ieid] = _recover_strain_energyi_celas12(
xg, dof_map, elem, ki)
elif element_name in {'CELAS3', 'CELAS4'}:
for ieid, eid in zip(ielas, eids):
elem = model.elements[eid]
ki = elem.K()
strain_energies[ieid] = _recover_strain_energyi_celas34(
xg, dof_map, elem, ki)
else: # pragma: no cover
raise NotImplementedError(element_name)
_save_spring_strain_energy(op2, f06_file, page_num, page_stamp,
element_name, strain_energies, eids,
write_f06_ese, isubcase, title, subtitle, label)
return neids
def _recover_stress_rod(f06_file,
op2,
model: BDF,
dof_map,
isubcase,
xb,
eids_str,
element_name,
fdtype='float32',
title: str = '',
subtitle: str = '',
label: str = '',
page_num: int = 1,
page_stamp='PAGE %s') -> None:
"""recovers static rod stress"""
neids, irod, eids = get_ieids_eids(model, element_name, eids_str)
if not neids:
return neids
stresses = np.full((neids, 4), np.nan, dtype=fdtype)
if element_name == 'CONROD':
for ieid, eid in zip(irod, eids):
elem = model.elements[eid]
stresses[ieid, :] = _recover_stressi_rod(xb, dof_map, elem, elem)
elif element_name == 'CROD':
for ieid, eid in zip(irod, eids):
elem = model.elements[eid]
stresses[ieid, :] = _recover_stressi_rod(xb, dof_map, elem,
elem.pid_ref)
elif element_name == 'CTUBE':
for ieid, eid in zip(irod, eids):
elem = model.elements[eid]
stresses[ieid, :] = _recover_stressi_ctube(xb, dof_map, elem,
elem.pid_ref)
else: # pragma: no cover
raise NotImplementedError(element_name)
data = stresses.reshape(1, *stresses.shape)
table_name = 'OSTR1'
stress_obj = RealRodStressArray.add_static_case(table_name,
element_name,
eids,
data,
isubcase,
is_stress=True,
is_sort1=True,
is_random=False,
is_msc=True,
random_code=0,
title=title,
subtitle=subtitle,
label=label)
if element_name == 'CONROD':
op2.conrod_stress[isubcase] = stress_obj
elif element_name == 'CROD':
op2.crod_stress[isubcase] = stress_obj
elif element_name == 'CTUBE':
op2.ctube_stress[isubcase] = stress_obj
else: # pragma: no cover
raise NotImplementedError(element_name)
stress_obj.write_f06(f06_file,
header=None,
page_stamp=page_stamp,
page_num=page_num,
is_mag_phase=False,
is_sort1=True)
return neids
def recover_celas(f06_file,
op2,
model: BDF,
dof_map,
isubcase,
xg,
eids_str,
element_name: str,
write_f06_strain: bool,
write_op2_strain: bool,
write_f06_stress: bool,
write_op2_stress: bool,
write_f06_force: bool,
write_op2_force: bool,
write_f06_ese: bool,
write_op2_ese: bool,
fdtype='float32',
title: str = '',
subtitle: str = '',
label: str = '',
page_num: int = 1,
page_stamp='PAGE %s') -> None:
"""recovers static spring strain"""
neids, ielas, eids = get_ieids_eids(model, element_name, eids_str)
if not neids:
return neids
get_strain = write_f06_strain or write_op2_strain
get_stress = write_f06_stress or write_op2_stress
get_force = write_f06_force or write_op2_force
get_strain_energy = write_f06_ese or write_op2_ese
force = None
stress = None
strain = None
strain_energy = None
if get_force:
force = np.full((neids, 1), np.nan, dtype=fdtype)
if get_stress:
stress = np.full((neids, 1), np.nan, dtype=fdtype)
if get_strain:
strain = np.full((neids, 1), np.nan, dtype=fdtype)
if get_strain_energy:
strain_energy = np.full((neids, 1), np.nan, dtype=fdtype)
if element_name == 'CELAS1':
#strain_slot = 'celas1_strain'
#stress_slot = 'celas1_stress'
#force_slot = 'celas1_force'
#ese_slot = 'celas1_strain_energy'
celas1_mapper = {
# get_strain, get_stress, get_force, get_strain_energy
# 2^4 = 16
# ostr, oes, oef, ese
(True, True, True, True):
get_celas1_ostr_oes_oef_ese,
(True, True, True, False):
get_celas1_ostr_oes_oef,
(True, True, False, True):
get_celas1_ostr_oes_ese,
(True, True, False, False):
get_celas1_ostr_oes,
(True, False, True, True):
get_celas1_ostr_oef_ese,
(True, False, True, False):
get_celas1_ostr_oef,
(True, False, False, True):
get_celas1_ostr_ese,
(True, False, False, False):
get_celas1_ostr,
#(False, True, True, True): get_celas1_ostr_oes_oef_ese[1:],
#(False, True, True, False): get_celas1_ostr_oes_oef[1:],
#(False, True, False, True): get_celas1_ostr_oes_ese[1:],
#(False, True, False, False): get_celas1_ostr_oes[1:],
#(False, False, True, True): get_celas1_ostr_oef_ese[1:],
#(False, False, True, False): get_celas1_ostr_oef[1:],
#(False, False, False, True): get_celas1_ostr_ese[1:],
# ostr, oes, oef, ese
(False, True, True, True):
get_celas1_oes_oef_ese,
(False, True, True, False):
get_celas1_oes_oef,
(True, True, False, True):
get_celas1_oes_ese,
(False, True, False, False):
get_celas1_oes,
(False, False, True, True):
get_celas1_oef_ese,
(False, False, True, False):
get_celas1_oef,
(False, False, False, True):
get_celas1_ese,
#(False, False, False, False): passer,
}
celeas1_func = celas1_mapper[(get_strain, get_stress, get_force,
get_strain_energy)]
# --------------------------------------------------------------
# strain
for unused_key, celeas1_func in celas1_mapper.items():
celeas1_func(model, ielas, eids, xg, dof_map, strain, stress,
force, strain_energy)
elif element_name == 'CELAS2':
for ieid, eid in zip(ielas, eids):
elem = model.elements[eid]
si = elem.s
strain[ieid] = _recover_straini_celas12(xg, dof_map, elem, si)
elif element_name == 'CELAS3':
for ieid, eid in zip(ielas, eids):
elem = model.elements[eid]
si = elem.pid_ref.s
strain[ieid] = _recover_straini_celas34(xg, dof_map, elem, si)
elif element_name == 'CELAS4':
for ieid, eid in zip(ielas, eids):
elem = model.elements[eid]
si = 1.0 # TODO: is this right?
strain[ieid] = _recover_straini_celas34(xg, dof_map, elem, si)
else: # pragma: no cover
raise NotImplementedError(element_name)
_save_spring_strain(op2, f06_file, page_num, page_stamp, element_name,
strain, eids, write_f06_strain, isubcase, title,
subtitle, label)
_save_spring_stress(op2, f06_file, page_num, page_stamp, element_name,
stress, eids, write_f06_stress, isubcase, title,
subtitle, label)
_save_spring_force(op2, f06_file, page_num, page_stamp, element_name,
force, eids, write_f06_force, isubcase, title, subtitle,
label)
_save_spring_strain_energy(op2, f06_file, page_num, page_stamp,
element_name, strain_energy, eids,
write_f06_ese, isubcase, title, subtitle, label)
return neids
def _recover_force_rod(f06_file,
op2,
model: BDF,
dof_map,
isubcase,
xb,
eids_str,
element_name,
fdtype='float32',
title: str = '',
subtitle: str = '',
label: str = '',
page_num: int = 1,
page_stamp='PAGE %s') -> None:
"""recovers static rod force"""
neids, irod, eids, forces = get_ieids_eids(model,
element_name,
eids_str,
ncols=2,
fdtype=fdtype)
if not neids:
return neids
if element_name == 'CONROD':
for ieid, eid in zip(irod, eids):
elem = model.elements[eid]
forces[ieid, :] = _recover_forcei_rod(xb, dof_map, elem, elem)
else:
for ieid, eid in zip(irod, eids):
elem = model.elements[eid]
forces[ieid, :] = _recover_forcei_rod(xb, dof_map, elem,
elem.pid_ref)
data = forces.reshape(1, *forces.shape)
table_name = 'OEF1'
force_obj = RealRodForceArray.add_static_case(table_name,
element_name,
eids,
data,
isubcase,
is_sort1=True,
is_random=False,
is_msc=True,
random_code=0,
title=title,
subtitle=subtitle,
label=label)
if element_name == 'CONROD':
op2.conrod_force[isubcase] = force_obj
elif element_name == 'CROD':
op2.crod_force[isubcase] = force_obj
elif element_name == 'CROD':
op2.ctube_force[isubcase] = force_obj
else: # pragma: no cover
raise NotImplementedError(element_name)
force_obj.write_f06(f06_file,
header=None,
page_stamp=page_stamp,
page_num=page_num,
is_mag_phase=False,
is_sort1=True)
return neids
def _recover_stress_celas(f06_file,
op2,
model: BDF,
dof_map,
isubcase,
xg,
eids_str,
element_name: str,
fdtype='float32',
title: str = '',
subtitle: str = '',
label: str = '',
page_num: int = 1,
page_stamp='PAGE %s') -> None:
"""recovers static spring stress"""
neids, ielas, eids, stresses = get_ieids_eids(model,
element_name,
eids_str,
fdtype=fdtype)
if not neids:
return neids
if element_name == 'CELAS1':
for ieid, eid in zip(ielas, eids):
elem = model.elements[eid]
pid_ref = elem.pid_ref
ki = pid_ref.K()
si = pid_ref.s
stresses[ieid] = _recover_stressi_celas12(xg, dof_map, elem, ki,
si)
elif element_name == 'CELAS2':
for ieid, eid in zip(ielas, eids):
elem = model.elements[eid]
ki = elem.K()
si = elem.s
stresses[ieid] = _recover_stressi_celas12(xg, dof_map, elem, ki,
si)
elif element_name == 'CELAS3':
for ieid, eid in zip(ielas, eids):
elem = model.elements[eid]
pid_ref = elem.pid_ref
ki = pid_ref.K()
si = pid_ref.s
stresses[ieid] = _recover_stressi_celas34(xg, dof_map, elem, ki,
si)
elif element_name == 'CELAS4':
for ieid, eid in zip(ielas, eids):
elem = model.elements[eid]
ki = elem.K()
si = 1.0 # TODO: is this right?
#si = elem.s
stresses[ieid] = _recover_stressi_celas34(xg, dof_map, elem, ki,
si)
else: # pragma: no cover
raise NotImplementedError(element_name)
data = stresses.reshape(1, *stresses.shape)
table_name = 'OES1'
spring_stress = RealSpringStressArray.add_static_case(table_name,
element_name,
eids,
data,
isubcase,
is_stress=True,
is_sort1=True,
is_random=False,
is_msc=True,
random_code=0,
title=title,
subtitle=subtitle,
label=label)
if element_name == 'CELAS1':
op2.celas1_stress[isubcase] = spring_stress
elif element_name == 'CELAS2':
op2.celas2_stress[isubcase] = spring_stress
elif element_name == 'CELAS3':
op2.celas3_stress[isubcase] = spring_stress
elif element_name == 'CELAS4':
op2.celas4_stress[isubcase] = spring_stress
else: # pragma: no cover
raise NotImplementedError(element_name)
spring_stress.write_f06(f06_file,
header=None,
page_stamp=page_stamp,
page_num=page_num,
is_mag_phase=False,
is_sort1=True)
return neids