def __init__(self, make_geom=True,
debug=False, log=None, debug_file=None):
"""
Initializes the OP2 object
:param make_geom: reads the BDF tables (default=False)
:param debug: enables the debug log and sets the debug in the logger (default=False)
:param log: a logging object to write debug messages to
(.. seealso:: import logging)
:param debug_file: sets the filename that will be written to (default=None -> no debug)
"""
assert make_geom == True, make_geom
BDF.__init__(self, debug=debug, log=log)
GEOM1.__init__(self)
GEOM2.__init__(self)
GEOM3.__init__(self)
GEOM4.__init__(self)
EPT.__init__(self)
MPT.__init__(self)
DIT.__init__(self)
DYNAMICS.__init__(self)
OP2.__init__(self, debug, log=log, debug_file=debug_file)
self.make_geom = make_geom
def __init__(self, make_geom=True, debug=False, log=None, debug_file=None):
"""
Initializes the OP2 object
:param make_geom: reads the BDF tables (default=False)
:param debug: enables the debug log and sets the debug in the logger (default=False)
:param log: a logging object to write debug messages to
(.. seealso:: import logging)
:param debug_file: sets the filename that will be written to (default=None -> no debug)
"""
assert make_geom == True, make_geom
BDF.__init__(self, debug=debug, log=log)
GEOM1.__init__(self)
GEOM2.__init__(self)
GEOM3.__init__(self)
GEOM4.__init__(self)
EPT.__init__(self)
MPT.__init__(self)
DIT.__init__(self)
DYNAMICS.__init__(self)
OP2.__init__(self, debug, log=log, debug_file=debug_file)
self.make_geom = make_geom
def __init__(self,
make_geom: bool = True,
debug: bool = False,
log: Any = None,
debug_file: Optional[str] = None,
mode: Optional[str] = None):
"""
Initializes the OP2 object
Parameters
----------
make_geom : bool; default=False
reads the BDF tables
debug : bool; default=False
enables the debug log and sets the debug in the logger
log: log()
a logging object to write debug messages to
(.. seealso:: import logging)
debug_file : default=None -> no debug
sets the filename that will be written to
mode : str; default=None -> 'msc'
{msc, nx}
"""
GEOM1.__init__(self)
GEOM2.__init__(self)
GEOM3.__init__(self)
GEOM4.__init__(self)
EPT.__init__(self)
MPT.__init__(self)
EDT.__init__(self)
EDOM.__init__(self)
CONTACT.__init__(self)
DIT.__init__(self)
DYNAMICS.__init__(self)
AXIC.__init__(self)
OP2.__init__(self,
debug=debug,
log=log,
debug_file=debug_file,
mode=mode)
self.make_geom = True
# F:\work\pyNastran\examples\Dropbox\move_tpl\beamp10.op2
# F:\work\pyNastran\examples\Dropbox\move_tpl\ifsr22r.op2
# F:\work\pyNastran\examples\Dropbox\move_tpl\ifssh22.op2
# F:\work\pyNastran\examples\Dropbox\move_tpl\ifsr22r.op2
# F:\work\pyNastran\examples\Dropbox\move_tpl\ifsv02pp.op2
self._viewtb_map = {
(10300, 103, 16): ['QUADP', self._read_fake],
(10400, 104, 15): ['TRIAP', self._read_fake],
(10500, 105, 14): ['BEAMP', self._read_fake],
(14100, 141, 18): ['HEXAP', self._read_view_hexa],
(14200, 142, 16): ['PENTAP', self._read_fake],
(14300, 143, 14): ['TETRAP', self._read_fake],
#(10500, 105, 14) : ['???', self._read_fake],
#(10500, 105, 14) : ['???', self._read_fake],
}
def __init__(self, make_geom=True,
debug=False, log=None, debug_file=None, mode='msc'):
"""
Initializes the OP2 object
Parameters
----------
make_geom : bool; default=False
reads the BDF tables
debug : bool; default=False
enables the debug log and sets the debug in the logger
log: log()
a logging object to write debug messages to
(.. seealso:: import logging)
debug_file : default=None -> no debug
sets the filename that will be written to
mode : str; default='msc'
{msc, nx}
"""
# make_geom=False, debug=True, log=None, debug_file=None
BDF.__init__(self, debug=debug, log=log)
GEOM1.__init__(self)
GEOM2.__init__(self)
GEOM3.__init__(self)
GEOM4.__init__(self)
EPT.__init__(self)
MPT.__init__(self)
DIT.__init__(self)
DYNAMICS.__init__(self)
OP2.__init__(self, debug, log=log, debug_file=debug_file, mode=mode)
self.make_geom = True
def read_op2(self, op2_filename=None, combine=True,
build_dataframe=None, skip_undefined_matrices=False, encoding=None):
"""see ``OP2.read_op2``"""
OP2.read_op2(self, op2_filename=op2_filename, combine=combine,
build_dataframe=build_dataframe,
skip_undefined_matrices=skip_undefined_matrices,
encoding=encoding)
if len(self.nodes) == 0:
self.gpdt_to_nodes()
def __init__(self):
F06.__initAlt__(self)
OP2.__objectsInit__(self)
self.nU = 0
self.nUs = 0
self.nUm = 0
# displacments
self.U = []
self.Us = []
self.Um = []
# indicies in U that correspond to Us/Um
self.iUs = []
self.iUm = []
def test_set_results(self):
folder = os.path.abspath(os.path.join(testPath, '..', 'models'))
op2Filename = os.path.join(folder, 'solid_bending',
'solid_bending.op2')
op2 = OP2()
op2.set_results('stress')
op2.read_op2(op2Filename)
self.assertEqual(len(op2.solidStress), 1), len(op2.solidStress)
self.assertEqual(len(op2.displacements), 0), len(op2.displacements)
op2 = OP2()
op2.set_results(['stress', 'displacements'])
op2.read_op2(op2Filename)
self.assertEqual(len(op2.solidStress), 1), len(op2.solidStress)
self.assertEqual(len(op2.displacements), 1), len(op2.displacements)
def read_op2(self,
op2_filename: Optional[Union[str, PurePath]] = None,
combine: bool = True,
build_dataframe: Optional[bool] = False,
skip_undefined_matrices: bool = False,
encoding: Optional[str] = None):
"""see ``OP2.read_op2``"""
OP2.read_op2(self,
op2_filename=op2_filename,
combine=combine,
build_dataframe=build_dataframe,
skip_undefined_matrices=skip_undefined_matrices,
encoding=encoding)
if len(self.nodes) == 0:
self.gpdt_to_nodes()
def __init__(self):
F06.__initAlt__(self)
OP2.__objectsInit__(self)
self.nU = 0
self.nUs = 0
self.nUm = 0
# displacments
self.U = []
self.Us = []
self.Um = []
# indicies in U that correspond to Us/Um
self.iUs = []
self.iUm = []
def __init__(self, op2_filename='fem.op2'):
log.info('---starting deflectionReader.init of %s---' % op2_filename)
op2 = OP2()
op2.set_results('displacements')
op2.read_op2(infilename)
self.deflections = op2.displacements.translations
log.info('---finished deflectionReader.init of %s---' % infilename)
def readFiles(self):
i = 0
for fname, subcaseList in sorted(self.cases.iteritems()):
#print "case[%s] = %s" %(key,self.cases[key])
subcaseList = list(set(subcaseList))
print "subcaseList[%s] = %s" % (fname, subcaseList)
op2 = OP2(fname, debug=False)
op2.setSubcases(subcaseList)
op2.readOP2()
for subcaseID in subcaseList:
print "subcaseID = ", subcaseID
print "i = ", i
self.displacementResults[i] = op2.displacements[subcaseID]
#self.solidStrainResults[i] = op2.solidStrain
#self.plateStrainResults[i] = op2.plateStrain
#self.compositePlateStressResults[i] = op2.compositePlateStress
#self.compositePlateStrainResults[i] = op2.compositePlateStrain
self.cleanStress(i, op2, subcaseID)
i += 1
del op2 # makes sure that unneeded data is not stored to save memory
def _get_table_mapper(self):
table_mapper = OP2._get_table_mapper(self)
table_mapper[b'CONTACT'] = [self._read_contact_4, self._read_contact_4]
table_mapper[b'CONTACTS'] = [
self._read_contact_4, self._read_contact_4
]
table_mapper[b'VIEWTB'] = [self._read_viewtb_4, self._read_viewtb_4]
table_mapper[b'EDT'] = [self._read_edt_4, self._read_edt_4]
table_mapper[b'EDTS'] = [self._read_edt_4, self._read_edt_4]
# geometry
table_mapper[b'GEOM1'] = [self._read_geom1_4, self._read_geom1_4]
table_mapper[b'GEOM2'] = [self._read_geom2_4, self._read_geom2_4]
table_mapper[b'GEOM3'] = [self._read_geom3_4, self._read_geom3_4]
table_mapper[b'GEOM4'] = [self._read_geom4_4, self._read_geom4_4]
# superelements
table_mapper[b'GEOM1S'] = [self._read_geom1_4, self._read_geom1_4]
table_mapper[b'GEOM2S'] = [self._read_geom2_4, self._read_geom2_4]
table_mapper[b'GEOM3S'] = [self._read_geom3_4, self._read_geom3_4]
table_mapper[b'GEOM4S'] = [self._read_geom4_4, self._read_geom4_4]
table_mapper[b'GEOM1N'] = [self._read_geom1_4, self._read_geom1_4]
table_mapper[b'GEOM2N'] = [self._read_geom2_4, self._read_geom2_4]
table_mapper[b'GEOM3N'] = [self._read_geom3_4, self._read_geom3_4]
table_mapper[b'GEOM4N'] = [self._read_geom4_4, self._read_geom4_4]
table_mapper[b'GEOM1OLD'] = [self._read_geom1_4, self._read_geom1_4]
table_mapper[b'GEOM2OLD'] = [self._read_geom2_4, self._read_geom2_4]
table_mapper[b'GEOM3OLD'] = [self._read_geom3_4, self._read_geom3_4]
table_mapper[b'GEOM4OLD'] = [self._read_geom4_4, self._read_geom4_4]
table_mapper[b'GEOM1ATV'] = [self._read_geom1_4, self._read_geom1_4]
table_mapper[b'GEOM2ATV'] = [self._read_geom2_4, self._read_geom2_4]
table_mapper[b'EDOM'] = [self._read_edom4_4,
self._read_edom4_4] # optimization
table_mapper[b'EPT'] = [self._read_ept_4, self._read_ept_4]
table_mapper[b'EPTS'] = [self._read_ept_4, self._read_ept_4]
table_mapper[b'EPTOLD'] = [self._read_ept_4, self._read_ept_4]
table_mapper[b'EPTATV'] = [self._read_ept_4, self._read_ept_4]
table_mapper[b'MPT'] = [self._read_mpt_4, self._read_mpt_4]
table_mapper[b'MPTS'] = [self._read_mpt_4, self._read_mpt_4]
table_mapper[b'DYNAMIC'] = [
self._read_dynamics_4, self._read_dynamics_4
]
table_mapper[b'DYNAMICS'] = [
self._read_dynamics_4, self._read_dynamics_4
]
table_mapper[b'AXIC'] = [self._read_axic_4, self._read_axic_4]
# table objects (e.g. TABLED1)
table_mapper[b'DIT'] = [self._read_dit_4, self._read_dit_4]
table_mapper[b'DITS'] = [self._read_dit_4, self._read_dit_4]
return table_mapper
def loadOp2(self, isTesting=False):
print("self.class = ", self.__class__.__name__)
if isTesting == False: ## @todo implement in way that doesnt require a variable (e.g. check parent class)
raise RuntimeError(
"Don't call this method unless you're testing the F06Writer. It breaks the F06 and OP2 classes."
)
from pyNastran.op2.op2 import OP2
self.op2Name = model + '.op2'
op2 = OP2(self.op2Name)
op2.readOP2()
# oug
self.eigenvectors = op2.eigenvectors
self.displacements = op2.displacements
self.temperatures = op2.temperatures
# oes
#CBEAM
#CSHEAR
#CELASi
self.rodStress = op2.rodStress
self.rodStrain = op2.rodStrain
self.barStress = op2.barStress
self.barStrain = op2.barStrain
self.plateStress = op2.plateStress
self.plateStrain = op2.plateStrain
self.compositePlateStress = op2.compositePlateStress
self.compositePlateStrain = op2.compositePlateStrain
def test_force(self):
log = get_logger(level='warning')
for folder, prefix, subcase in CASES:
bdf = BDF(debug=False, log=log)
op2 = OP2(debug=False, log=log)
basepath = os.path.join(pkg_path, 'op2', 'test', 'examples',
folder)
bdf.read_bdf(os.path.join(basepath, prefix + '.bdf'))
op2.read_op2(os.path.join(basepath, prefix + '.op2'))
op2_new = data_in_material_coord(bdf, op2)
for vecname in force_vectors:
vector = getattr(op2_new, vecname).get(subcase)
if vector is None:
continue
name = os.path.join(
basepath,
'{0}_subcase_{1:02d}.txt'.format(vecname, subcase))
if not os.path.isfile(name):
raise AssertionError(
'Not found reference result {0}\n{1}'.format(
name, print_bad_path(name)))
ref_result = np.loadtxt(name)
data = vector.data
eids = get_eids_from_op2_vector(vector)
check = eids != 0
if 'cquad8' in vecname:
assert np.allclose(data[:, check][:, 0::5, :],
ref_result[0::5],
rtol=RTOL,
atol=ATOL)
else:
assert np.allclose(data[:, check],
ref_result,
rtol=RTOL,
atol=ATOL)
def test_write_2(self):
"""tests basic op2 writing"""
log = SimpleLogger(level='warning', encoding='utf-8')
folder = os.path.join(MODEL_PATH, 'solid_bending')
op2_filename = os.path.join(folder, 'solid_bending.op2')
op2_filename_debug = os.path.join(folder, 'solid_bending.debug.out')
op2_filename_out = os.path.join(folder, 'solid_bending_out.op2')
op2_filename_debug_out = os.path.join(folder,
'solid_bending_out.debug.out')
#debug_file = 'solid_bending.debug.out'
#model = os.path.splitext(op2_filename)[0]
#debug_file = model + '.debug.out'
op2 = OP2(debug=True,
log=log,
debug_file=op2_filename_debug,
mode=None)
op2.read_op2(op2_filename)
op2.write_op2(op2_filename_out) #, is_mag_phase=False)
op2b = read_op2_geom(op2_filename_out,
debug_file=op2_filename_debug_out,
log=log)
assert op2 == op2b
os.remove(op2_filename_debug_out)
def read_files(self):
i = 0
for fname, subcaseList in sorted(iteritems(self.cases)):
#print("case[%s] = %s" % (key, self.cases[key]))
subcaseList = list(set(subcaseList))
print("subcaseList[%s] = %s" % (fname, subcaseList))
op2 = OP2(debug=False)
op2.set_subcases(subcaseList)
op2.read_op2(fname)
for subcaseID in subcaseList:
print("subcaseID = %s" % subcaseID)
print("i = %s" % i)
self.displacementResults[i] = op2.displacements[subcaseID]
#self.solidStrainResults[i] = op2.solidStrain
#self.plateStrainResults[i] = op2.plateStrain
#self.compositePlateStressResults[i] = op2.compositePlateStress
#self.compositePlateStrainResults[i] = op2.compositePlateStrain
self.clean_stress(i, op2, subcaseID)
i += 1
del op2 # makes sure that unneeded data is not stored to save memory
def __init__(self, op2_filename='fem.op2', isubcase=1):
log.info('---starting deflectionReader.init of %s---' % op2_filename)
op2 = OP2()
op2.set_results('displacements')
op2.read_op2(op2_filename)
self.deflections = op2.displacements[isubcase].data
log.info('---finished deflectionReader.init of %s---' % op2_filename)
def test_op2_dmi_01(self):
"""tests DMI matrix style"""
folder = os.path.abspath(os.path.join(PKG_PATH, '..', 'models'))
bdf_filename = os.path.join(folder, 'matrix', 'matrix.dat')
op2_filename = os.path.join(folder, 'matrix', 'mymatrix.op2')
matrices = {
'A' : True,
'B' : False,
'ATB' : False,
'BTA' : False,
'MYDOF' : True,
}
model = read_bdf(bdf_filename, debug=False)
dmi_a = model.dmis['A']
assert dmi_a.shape == (4, 2), 'shape=%s' % (dmi_a.shape)
#print('dmi_a\n', dmi_a)
a, rows_reversed, cols_reversed = dmi_a.get_matrix(is_sparse=False, apply_symmetry=False)
#print('model.dmi.A =\n%s' % dmi_a)
#print('model.dmi.A =\n%s' % str(a))
#return
op2 = OP2(debug=False)
op2.set_additional_matrices_to_read(matrices)
try:
op2.read_op2(op2_filename)
raise RuntimeError('this is wrong...')
except FatalError:
# the OP2 doesn't have a trailing zero marker
pass
# M rows, Ncols
A = np.array([
[1., 0.],
[3., 6.],
[5., 0.],
[0., 8.],
], dtype='float32')
B = A
mydof = np.array([
-1.0, 1.0, 1.0, -1.0, 1.0,
2.0, -1.0, 1.0, 3.0, -1.0, 1.0, 4.0, -1.0,
1.0, 5.0, -1.0, 1.0, 6.0, -1.0, 2.0, 1.0,
-1.0, 2.0, 2.0, -1.0, 2.0, 3.0, -1.0, 2.0,
4.0, -1.0, 2.0, 5.0, -1.0, 2.0, 6.0,
])
BTA = np.dot(B.T, A)
ATB = np.dot(A.T, B)
ATB_expected = np.array([
[35., 18.],
[18., 100.]
], dtype='float32')
#BTA_expected = ATB_expected
expecteds = [A, ATB, B, BTA, mydof]
matrix_names = sorted(matrices.keys())
for matrix_name, expected in zip(matrix_names, expecteds):
assert matrix_name in op2.matrices, matrix_name
actual = op2.matrices[matrix_name].data.todense()
compare_dmi_matrix_from_bdf_to_op2(model, op2, expected, actual, matrix_name)
def test_pload4_cquad4(self):
"""tests a PLOAD4 with a CQUAD4"""
bdf_filename = os.path.join(test_path, '..', 'models', 'pload4',
'cquad4.bdf')
op2_filename = os.path.join(test_path, '..', 'models', 'pload4',
'cquad4.op2')
op2 = OP2(debug=False, log=log)
op2.read_op2(op2_filename)
model_b = BDF(debug=False)
model_b.read_bdf(bdf_filename)
# p0 = (model_b.nodes[21].xyz + model_b.nodes[22].xyz + model_b.nodes[23].xyz) / 3.
p0 = model_b.nodes[21].xyz
eids = None
nids = None
for isubcase, subcase in sorted(iteritems(model_b.subcases)):
if isubcase == 0:
continue
#if isubcase != 17:
#continue
loadcase_id = subcase.get_parameter('LOAD')[0]
load = model_b.loads[loadcase_id]
loadi = load[0]
if loadi.type == 'PLOAD4':
elem = loadi.eids_ref[0]
area = 1.0
centroid = elem.Centroid()
normal = elem.Normal()
msg = '%s%s%s\n' % (elem.nodes[0], elem.nodes[1],
elem.nodes[2])
assert array_equal(centroid, array(
[0.5, 0.5, 0.])), 'centroid=%s\n%s' % (centroid, msg)
assert array_equal(normal,
array([0., 0., 1.
])), 'normal=%s\n%s' % (normal, msg)
f, m = model_b.sum_forces_moments(p0,
loadcase_id,
include_grav=False)
f2, m2 = model_b.sum_forces_moments_elements(p0,
loadcase_id,
eids,
nids,
include_grav=False)
assert allclose(f, f2), 'f=%s f2=%s' % (f, f2)
assert allclose(m, m2), 'm=%s m2=%s' % (m, m2)
case = op2.spc_forces[isubcase]
fm = -case.data[0, :, :].sum(axis=0)
assert len(fm) == 6, fm
if not allclose(f[0], fm[0]):
print('%-2i Fx f=%s fexpected=%s' % (isubcase, f, fm))
if not allclose(f[1], fm[1]):
print('%-2i Fy f=%s fexpected=%s' % (isubcase, f, fm))
if not allclose(f[2], fm[2]):
print('%-2i Fz f=%s fexpected=%s' % (isubcase, f, fm))
def _get_op2_stats_short(model: OP2, table_types: List[str], log) -> List[str]:
"""helper for get_op2_stats(...)"""
msg = []
no_data_classes = [
'RealEigenvalues', 'ComplexEigenvalues', 'BucklingEigenvalues'
]
for table_type in table_types:
#table_type_print = ''
if table_type in ['params']:
msg.extend(_write_params(model.params))
continue
elif table_type in ['gpdt', 'bgpdt', 'eqexin']:
obj = model.get_result(table_type)
if obj is None:
continue
stats = obj.get_stats(short=True)
msg.extend(f'op2_results.{table_type}: ' +
stats) # TODO: a hack...not quite right...
continue
table_type_print = 'op2_results.' + table_type if '.' in table_type else table_type
table = model.get_result(table_type)
for isubcase, subcase in sorted(table.items(), key=_compare):
class_name = subcase.__class__.__name__
if class_name in no_data_classes:
msg.append('%s[%r]\n' % (table_type_print, isubcase))
elif hasattr(subcase, 'data'):
#data = subcase.data
#shape = [int(i) for i in subcase.data.shape]
#headers = subcase.get_headers()
#headers_str = str(', '.join(headers))
#msg.append('%s[%s]; %s; %s; [%s]\n' % (
#table_type, isubcase, class_name, shape, headers_str))
msg.append('%s[%s]\n' % (table_type_print, isubcase))
elif table_type == 'params': # TODO: remove
msgi = str(subcase)
elif hasattr(subcase, 'get_stats'):
msgi = '%s[%s] # unvectorized\n' % (table_type_print, isubcase)
msg.append(msgi)
else:
msgi = 'skipping %r %s[%s]\n' % (class_name, table_type_print,
isubcase)
msg.append(msgi)
#raise RuntimeError(msgi)
return msg
def _get_op2_stats_full(model: OP2, table_types: List[str], log):
"""helper for get_op2_stats(...)"""
msg = []
for table_type in table_types:
table = model.get_result(table_type)
if table_type == 'params':
msg.extend(_write_params(model.params))
continue
elif table_type in ['gpdt', 'bgpdt', 'eqexin']:
obj = model.get_result(table_type)
if obj is None:
continue
elif isinstance(obj, dict):
print(obj)
stats = obj.get_stats(short=False)
msg.extend(f'op2_results.{table_type}: ' +
stats) # TODO: a hack...not quite right...
continue
table_type_print = 'op2_results.' + table_type if '.' in table_type else table_type
try:
for isubcase, subcase in sorted(table.items(), key=_compare):
class_name = subcase.__class__.__name__
if hasattr(subcase, 'get_stats'):
try:
stats = subcase.get_stats() # short=short
except:
msgi = 'errored reading %s %s[%s]\n\n' % (
class_name, table_type_print, isubcase)
msg.append(msgi)
raise
else:
msg.append('%s[%s]\n' % (table_type_print, isubcase))
msg.extend(stats)
msg.append('\n')
else:
msgi = 'skipping %s %s[%s]\n\n' % (
class_name, table_type_print, isubcase)
msg.append(msgi)
raise RuntimeError(msgi)
except:
log.warning('type(table)=%s' % type(table))
log.warning(table)
raise
return msg
def read_op2(self, op2path):
if not os.path.isfile(op2path):
print('ERROR - op2 "{0}" does not exist!'.format(op2path))
return
op2 = OP2()
print('Reading op2 file...')
op2.read_op2(op2path)
self.op2 = data_in_material_coord(self.bdf, op2, in_place=True)
print('finished!')
def loadNastranResults(self, op2FileName, dirname, isNodal, isCentroidal):
#self.gridResult.SetNumberOfComponents(self.nElements)
self.TurnTextOn()
self.scalarBar.VisibilityOn()
self.scalarBar.Modified()
op2 = OP2(op2FileName, debug=True)
op2.readOP2()
#print op2.printResults()
#case = op2.displacements[1]
#print "case = ",case
#for nodeID,translation in sorted(case.translations.iteritems()):
#print "nodeID=%s t=%s" %(nodeID,translation)
#self.iSubcaseNameMap[self.iSubcase] = [Subtitle,Label]
cases = {}
subcaseIDs = op2.iSubcaseNameMap.keys()
self.iSubcaseNameMap = op2.iSubcaseNameMap
nElements = len(self.eidMap)
#print "nElements = ",nElements
nidsSet = False # set to False to disable nodeIDs
eidsSet = True
for subcaseID in subcaseIDs:
if nidsSet:
nids = zeros(self.nNodes, 'd')
for (nid, nid2) in self.nidMap.iteritems():
nids[nid2] = nid
cases[(subcaseID, 'Node_ID', 1, 'node', '%.0f')] = nids
nidsSet = True
if eidsSet:
eids = zeros(nElements, 'd')
for (eid, eid2) in self.eidMap.iteritems():
eids[eid2] = eid
eKey = (subcaseID, 'isElementOn', 1, 'centroid', '%.0g')
cases[(subcaseID, 'Element_ID', 1, 'centroid', '%.0f')] = eids
cases[eKey] = zeros(nElements) # is the element supported
eidsSet = True
if False:
if subcaseID in op2.displacements: # not correct?
case = op2.displacements[subcaseID]
key = (subcaseID, 'DisplacementX', 3, 'node', '%g')
#cases[key] = case.translations
if subcaseID in op2.temperatures:
case = op2.temperatures[subcaseID]
#print case
temps = zeros(self.nNodes)
key = (subcaseID, 'Temperature', 1, 'node', '%g')
for (nid, T) in case.temperatures.iteritems():
#print T
nid2 = self.nidMap[nid]
temps[nid2] = T
def read_op2(op2_filename, isubcase=1):
log.info('---starting deflectionReader.init of %s---' % op2_filename)
op2 = OP2()
op2.set_results('displacements')
op2.read_op2(op2_filename)
displacment_obj = op2.displacements[isubcase]
log.info('---finished deflectionReader.init of %s---' % op2_filename)
return displacment_obj.translations
def test_op2_dmi_02(self):
"""tests DMI matrix style"""
bdf_filename = os.path.join(MODEL_PATH, 'matrix', 'matrix.dat')
op2_filename = os.path.join(MODEL_PATH, 'matrix', 'mymatrix.op2')
matrices = {
'A' : True,
'B' : False,
'ATB' : False,
'BTA' : False,
'MYDOF' : True,
}
model = read_bdf(bdf_filename, debug=False)
dmi_a = model.dmis['A']
a, rows_reversed, cols_reversed = dmi_a.get_matrix(is_sparse=False, apply_symmetry=False)
#print('model.dmi.A =\n%s' % dmi_a)
#print('model.dmi.A =\n%s' % str(a))
#return
op2 = OP2(debug=False)
try:
op2.read_op2(op2_filename, skip_undefined_matrices=True)
raise RuntimeError('this is wrong...')
except FatalError:
# the OP2 doesn't have a trailing zero marker
pass
# M rows, Ncols
A = np.array([
[1., 0.],
[3., 6.],
[5., 0.],
[0., 8.],
], dtype='float32')
B = A
mydof = np.array([
-1.0, 1.0, 1.0, -1.0, 1.0,
2.0, -1.0, 1.0, 3.0, -1.0, 1.0, 4.0, -1.0,
1.0, 5.0, -1.0, 1.0, 6.0, -1.0, 2.0, 1.0,
-1.0, 2.0, 2.0, -1.0, 2.0, 3.0, -1.0, 2.0,
4.0, -1.0, 2.0, 5.0, -1.0, 2.0, 6.0,
])
BTA = B.T @ A
ATB = A.T @ B
ATB_expected = np.array([
[35., 18.],
[18., 100.]
], dtype='float32')
#BTA_expected = ATB_expected
expecteds = [A, ATB, B, BTA, mydof]
matrix_names = sorted(matrices.keys())
for matrix_name, expected in zip(matrix_names, expecteds):
assert matrix_name in op2.matrices, matrix_name
actual = op2.matrices[matrix_name].data.toarray()
compare_dmi_matrix_from_bdf_to_op2(model, op2, expected, actual, matrix_name)
def read_op2(op2_filename, isubcase=1, log=None):
"""loads the deflections from the op2 for the specified subcase"""
log.info('---starting deflection_reader.init of %s---' % op2_filename)
op2 = OP2(log=log)
op2.set_subcases(subcases=[isubcase])
op2.set_results('displacements')
op2.read_op2(op2_filename)
displacment_obj = op2.displacements[isubcase]
log.info('---finished deflection_reader.init of %s---' % op2_filename)
return displacment_obj
def __init__(self, make_geom=False,
debug=True, log=None,
debug_file=None):
"""
Initializes the OP2 object
:param make_geom: reads the BDF tables (default=False)
:param debug: enables the debug log and sets the debug in the logger (default=False)
:param log: a logging object to write debug messages to
(.. seealso:: import logging)
:param debug_file: sets the filename that will be written to (default=None -> no debug)
"""
debug = False
assert make_geom == False, make_geom
OP2.__init__(self, #make_geom=make_geom,
debug=debug, log=log, debug_file=None)
#print(self.binary_debug)
#self.binary_debug = None
self.ask = False
def eigenvector():
"""
Example 3: Eigenvector (transient) - Level 2
"""
# This example will demonstate:
# - calculate von mises stress and max shear for solid elements for a static case for an OP2
####.. math:: \sqrt\left(T_x^2 + T_y^2 + T_z^2\right)
# our model
import pyNastran
pkg_path = pyNastran.__path__[0]
test_path = os.path.join(pkg_path, '..', 'models', 'solid_bending')
op2_filename = os.path.join(test_path, 'solid_bending.op2')
out_filename = os.path.join(test_path, 'solid_bending.out')
# instantiate the model
from pyNastran.op2.op2 import OP2
model = OP2()
model.read_op2(op2_filename)
print(model.get_op2_stats())
####
## op2.ctetra_stress[1]
## type=RealSolidStressArray nelements=186 nnodes=930
## nodes_per_element=5 (including centroid)
## eType, cid
## data: [1, nnodes, 10] where 10=[oxx, oyy, ozz, txy, tyz, txz, o1, o2, o3, von_mises]
## data.shape = (1, 930, 10)
## element types: CTETRA
## lsdvmns = [1]
# we're analyzing a static problem, so itime=0
# we're also assuming subcase 1
itime = 0
isubcase = 1
# get the stress object (there is also cpenta_stress and chexa_stress as well as ctetra_strain/cpenta_strain/chexa_strain)
stress = model.ctetra_stress[isubcase]
# The stress/strain data can often be von_mises/max_shear (same for fiber_distance/curvature), so check!
#### #data = [oxx, oyy, ozz, txy, tyz, txz, o1, o2, o3, von_mises]
o1 = stress.data[itime, :, 6]
o3 = stress.data[itime, :, 8]
if stress.is_von_mises():
max_shear = (o1 - o3) / 2.
von_mises = stress.data[itime, :, 9]
else:
from numpy import sqrt
o2 = data[itime, :, 8]
von_mises = sqrt(0.5 * ((o1 - o2)**2 + (o2 - o3)**2, (o3 - o1)**2))
max_shear = stress.data[itime, :, 9]
for (eid, node), vm, ms in zip(stress.element_node, von_mises, max_shear):
print(eid, 'CEN/4' if node == 0 else node, vm, ms)
def __init__(self, make_geom=False, debug=True, log=None, debug_file=None):
"""
Initializes the OP2 object
:param make_geom: reads the BDF tables (default=False)
:param debug: enables the debug log and sets the debug in the logger (default=False)
:param log: a logging object to write debug messages to
(.. seealso:: import logging)
:param debug_file: sets the filename that will be written to (default=None -> no debug)
"""
debug = False
assert make_geom == False, make_geom
OP2.__init__(
self, #make_geom=make_geom,
debug=debug,
log=log,
debug_file=None)
#print(self.binary_debug)
#self.binary_debug = None
self.ask = False
def read_op2(op2_filename):
log.info('---starting deflectionReader.init of %s---' % op2_filename)
op2 = OP2(op2_filename)
#terms = ['force','stress','stress_comp','strain','strain_comp','displacement','grid_point_forces']
op2.read_op2()
subcase0 = op2.displacements.keys()[0] # get the 0th subcase
displacment_obj = op2.displacements[subcase0]
log.info('---finished deflectionReader.init of %s---' % op2_filename)
return displacment_obj.translations
def load_op2_from_hdf5(hdf5_filename, combine=True, log=None):
"""loads an hdf5 file into an OP2 object"""
assert os.path.exists(hdf5_filename), print_bad_path(hdf5_filename)
model = OP2(log=None)
model.op2_filename = hdf5_filename
log.info('hdf5_op2_filename = %r' % hdf5_filename)
debug = False
with h5py.File(hdf5_filename, 'r') as h5_file:
load_op2_from_hdf5_file(model, h5_file, log, debug=debug)
model.combine_results(combine=combine)
return model
def test_pload4_cquad4(self):
"""tests a PLOAD4 with a CQUAD4"""
bdf_filename = os.path.join(test_path, '..', 'models', 'pload4', 'cquad4.bdf')
op2_filename = os.path.join(test_path, '..', 'models', 'pload4', 'cquad4.op2')
op2 = OP2(debug=False, log=log)
op2.read_op2(op2_filename)
model = BDF(debug=False)
model.read_bdf(bdf_filename)
# p0 = (model.nodes[21].xyz + model.nodes[22].xyz + model.nodes[23].xyz) / 3.
p0 = model.nodes[21].xyz
eids = None
nids = None
subcase_ids = [1, 2, 3, 4, 5, 6, 7, 8]
for isubcase in subcase_ids:
subcase = model.subcases[isubcase]
loadcase_id = subcase.get_parameter('LOAD')[0]
load = model.Load(loadcase_id)
loadi = load[0]
if loadi.type == 'PLOAD4':
elem = loadi.eids_ref[0]
#area = 1.0
centroid = elem.Centroid()
normal = elem.Normal()
# centroid = [0.5, 0.5, 0.]
# normal = [0., 0., 1.]
#print('centroid=%s normal=%s' % (centroid, normal))
msg = '%s%s%s\n' % (elem.nodes[0], elem.nodes[1], elem.nodes[2])
assert array_equal(centroid, array([0.5, 0.5, 0.])), 'centroid=%s\n%s' % (centroid, msg)
assert array_equal(normal, array([0., 0., 1.])), 'normal=%s\n%s' % (normal, msg)
f1, m1 = model.sum_forces_moments(p0, loadcase_id, include_grav=False)
f2, m2 = model.sum_forces_moments_elements(p0, loadcase_id, eids, nids, include_grav=False)
assert allclose(f1, f2), 'f1=%s f2=%s' % (f1, f2)
assert allclose(m1, m2), 'm1=%s m2=%s' % (m1, m2)
case = op2.spc_forces[isubcase]
fm = -case.data[0, :, :].sum(axis=0)
assert len(fm) == 6, fm
force = fm[:3]
if not allclose(f1[0], force[0]):
model.log.error('subcase=%-2i Fx f=%s force_expected=%s' % (
isubcase, f1.tolist(), force.tolist()))
if not allclose(f1[1], force[1]):
model.log.error('subcase=%-2i Fy f=%s force_expected=%s' % (
isubcase, f1.tolist(), force.tolist()))
if not allclose(f1[2], force[2]):
model.log.error('subcase=%-2i Fz f=%s force_expected=%s' % (
isubcase, f1.tolist(), force.tolist()))
save_load_deck(model, punch=False)
def main(bdf_name, run_first_nastran=True, debug=True):
base = os.path.splitext(bdf_name)[0]
print("len(sys.argv) = %s" % len(sys.argv))
#===========================
if run_first_nastran:
# run nastran and verify the starting model is correct
os.system('nastran scr=yes bat=no news=no old=no %s' % bdf_name)
f06_name = base + '.f06'
try:
model2 = F06()
model2.read_f06(f06_name)
except FatalError as e:
print(e)
#return
else:
pass
#===========================
# read/write the model in double precision
out_bdf_8 = base + '_8.bdf'
out_bdf_16 = base + '_16.bdf'
out_bdf_16s = base + '_16s.bdf'
model3 = BDF(debug=debug)
model3.read_bdf(bdf_name)
update_bdf(model3, post=-1)
model3.write_bdf(out_bdf_8, size=8, is_double=False)
model3.write_bdf(out_bdf_16s, size=16, is_double=False)
model3.write_bdf(out_bdf_16, size=16, is_double=True)
if debug:
print("---wrote the bdf---")
#===========================
# run nastran again
os.system('nastran scr=yes bat=no news=no old=no %s' % out_bdf_8)
os.system('nastran scr=yes bat=no news=no old=no %s' % out_bdf_16)
#===========================
# verify it's correct
if is_f06:
out_f06_8 = base + '_8.f06'
out_f06_16 = base + '_16.f06'
model4 = F06(debug=False)
model4.read_f06(out_f06_8)
model5 = F06(debug=False)
model5.read_f06(out_f06_16)
out_op2_8 = base + '_8.op2'
out_op2_16 = base + '_16.op2'
model6 = OP2(debug=False)
model6.read_op2(out_op2_16)
print('\n\npassed!!')
def read_op2(self, op2_filename=None):
"""
Starts the OP2 file reading
"""
assert self.ask in [True, False], self.ask
self.is_vectorized = True
if self.is_vectorized:
self.log.info('-------- reading the op2 with read_mode=1 --------')
self.read_mode = 1
self._close_op2 = False
# get GUI object names, build objects, but don't read data
OP2.read_op2(self, op2_filename=op2_filename)
# TODO: stuff to figure out objects
# TODO: stuff to show gui of table names
# TODO: clear out objects the user doesn't want
self.read_mode = 2
self._close_op2 = True
self.log.info('-------- reading the op2 with read_mode=2 --------')
OP2.read_op2(self, op2_filename=op2_filename)
else:
#self.read_mode = 0
OP2.read_op2(self, op2_filename=op2_filename)
return
#raise NotImplementedError()
self.f.close()
self.combine_results()
self.log.info('finished reading op2')
def read_op2(self, op2_filename=None):
"""
Starts the OP2 file reading
"""
assert self.ask in [True, False], self.ask
self.is_vectorized = True
if self.is_vectorized:
self.log.info('-------- reading the op2 with read_mode=1 --------')
self.read_mode = 1
self._close_op2 = False
# get GUI object names, build objects, but don't read data
OP2.read_op2(self, op2_filename=op2_filename)
# TODO: stuff to figure out objects
# TODO: stuff to show gui of table names
# TODO: clear out objects the user doesn't want
self.read_mode = 2
self._close_op2 = True
self.log.info('-------- reading the op2 with read_mode=2 --------')
OP2.read_op2(self, op2_filename=op2_filename)
else:
#self.read_mode = 0
OP2.read_op2(self, op2_filename=op2_filename)
return
#raise NotImplementedError()
self.f.close()
self.combine_results()
self.log.info('finished reading op2')
def _get_table_mapper(self):
table_mapper = OP2._get_table_mapper(self)
# geometry
table_mapper[b'GEOM1'] = [self._read_geom1_4, self._read_geom1_4]
table_mapper[b'GEOM2'] = [self._read_geom2_4, self._read_geom2_4]
table_mapper[b'GEOM3'] = [self._read_geom3_4, self._read_geom3_4]
table_mapper[b'GEOM4'] = [self._read_geom4_4, self._read_geom4_4]
# superelements
table_mapper[b'GEOM1S'] = [self._read_geom1_4, self._read_geom1_4]
table_mapper[b'GEOM2S'] = [self._read_geom2_4, self._read_geom2_4]
table_mapper[b'GEOM3S'] = [self._read_geom3_4, self._read_geom3_4]
table_mapper[b'GEOM4S'] = [self._read_geom4_4, self._read_geom4_4]
table_mapper[b'GEOM1N'] = [self._read_geom1_4, self._read_geom1_4]
table_mapper[b'GEOM2N'] = [self._read_geom2_4, self._read_geom2_4]
table_mapper[b'GEOM3N'] = [self._read_geom3_4, self._read_geom3_4]
table_mapper[b'GEOM4N'] = [self._read_geom4_4, self._read_geom4_4]
table_mapper[b'GEOM1OLD'] = [self._read_geom1_4, self._read_geom1_4]
table_mapper[b'GEOM2OLD'] = [self._read_geom2_4, self._read_geom2_4]
table_mapper[b'GEOM3OLD'] = [self._read_geom3_4, self._read_geom3_4]
table_mapper[b'GEOM4OLD'] = [self._read_geom4_4, self._read_geom4_4]
table_mapper[b'EPT'] = [self._read_ept_4, self._read_ept_4]
table_mapper[b'EPTS'] = [self._read_ept_4, self._read_ept_4]
table_mapper[b'EPTOLD'] = [self._read_ept_4, self._read_ept_4]
table_mapper[b'MPT'] = [self._read_mpt_4, self._read_mpt_4]
table_mapper[b'MPTS'] = [self._read_mpt_4, self._read_mpt_4]
table_mapper[b'DYNAMIC'] = [self._read_dynamics_4, self._read_dynamics_4]
table_mapper[b'DYNAMICS'] = [self._read_dynamics_4, self._read_dynamics_4]
table_mapper[b'DIT'] = [self._read_dit_4, self._read_dit_4] # table objects (e.g. TABLED1)
return table_mapper
def _get_table_mapper(self):
table_mapper = OP2._get_table_mapper(self)
# geometry
table_mapper['GEOM1'] = [self._read_geom1_4, self._read_geom1_4]
table_mapper['GEOM2'] = [self._read_geom2_4, self._read_geom2_4]
table_mapper['GEOM3'] = [self._read_geom3_4, self._read_geom3_4]
table_mapper['GEOM4'] = [self._read_geom4_4, self._read_geom4_4]
# superelements
table_mapper['GEOM1S'] = [self._read_geom1_4, self._read_geom1_4]
table_mapper['GEOM2S'] = [self._read_geom2_4, self._read_geom2_4]
table_mapper['GEOM3S'] = [self._read_geom3_4, self._read_geom3_4]
table_mapper['GEOM4S'] = [self._read_geom4_4, self._read_geom4_4]
table_mapper['GEOM1N'] = [self._read_geom1_4, self._read_geom1_4]
table_mapper['GEOM2N'] = [self._read_geom2_4, self._read_geom2_4]
table_mapper['GEOM3N'] = [self._read_geom3_4, self._read_geom3_4]
table_mapper['GEOM4N'] = [self._read_geom4_4, self._read_geom4_4]
table_mapper['GEOM1OLD'] = [self._read_geom1_4, self._read_geom1_4]
table_mapper['GEOM2OLD'] = [self._read_geom2_4, self._read_geom2_4]
table_mapper['GEOM3OLD'] = [self._read_geom3_4, self._read_geom3_4]
table_mapper['GEOM4OLD'] = [self._read_geom4_4, self._read_geom4_4]
table_mapper['EPT'] = [self._read_ept_4, self._read_ept_4]
table_mapper['EPTS'] = [self._read_ept_4, self._read_ept_4]
table_mapper['EPTOLD'] = [self._read_ept_4, self._read_ept_4]
table_mapper['MPT'] = [self._read_mpt_4, self._read_mpt_4]
table_mapper['MPTS'] = [self._read_mpt_4, self._read_mpt_4]
table_mapper['DYNAMIC'] = [self._read_dynamics_4, self._read_dynamics_4]
table_mapper['DYNAMICS'] = [self._read_dynamics_4, self._read_dynamics_4]
table_mapper['DIT'] = [self._read_dit_4, self._read_dit_4] # table objects (e.g. TABLED1)
return table_mapper
table_mapper = {
#=======================
# OEF
# element forces
'OEFIT' : [self._read_oef1_3, self._read_oef1_4],
'OEF1X' : [self._read_oef1_3, self._read_oef1_4],
'OEF1' : [self._read_oef1_3, self._read_oef1_4],
'DOEF1' : [self._read_oef1_3, self._read_oef1_4],
#=======================
# OQG
# spc forces
'OQG1' : [self._read_oqg1_3, self._read_oqg1_4], # spc forces in the nodal frame
'OQGV1' : [self._read_oqg1_3, self._read_oqg1_4], # spc forces in the nodal frame
# mpc forces
'OQMG1' : [self._read_oqg1_3, self._read_oqg1_4],
# ???? - passer
#'OQP1': [self._table_passer, self._table_passer],
#=======================
# OPG
# applied loads
'OPG1' : [self._read_opg1_3, self._read_opg1_4], # applied loads in the nodal frame
'OPGV1' : [self._read_opg1_3, self._read_opg1_4],
'OPNL1' : [self._read_opg1_3, self._read_opg1_4],
# OGPFB1
# grid point forces
'OGPFB1' : [self._read_ogpf1_3, self._read_ogpf1_4], # grid point forces
# ONR/OEE
# strain energy density
'ONRGY1' : [self._read_onr1_3, self._read_onr1_4], # strain energy density
#=======================
# OES
# stress
'OES1X1' : [self._read_oes1_3, self._read_oes1_4], # stress
'OES1' : [self._read_oes1_3, self._read_oes1_4], # stress
'OES1X' : [self._read_oes1_3, self._read_oes1_4], # stress
'OES1C' : [self._read_oes1_3, self._read_oes1_4], # stress - composite
'OESCP' : [self._read_oes1_3, self._read_oes1_4],
'OESNLXR' : [self._read_oes1_3, self._read_oes1_4],
'OESNLXD' : [self._read_oes1_3, self._read_oes1_4],
'OESNLBR' : [self._read_oes1_3, self._read_oes1_4],
'OESTRCP' : [self._read_oes1_3, self._read_oes1_4],
'OESNL1X' : [self._read_oes1_3, self._read_oes1_4],
'OESRT' : [self._read_oes1_3, self._read_oes1_4],
# strain
'OSTR1X' : [self._read_oes1_3, self._read_oes1_4], # strain - isotropic
'OSTR1C' : [self._read_oes1_3, self._read_oes1_4], # strain - composite
#=======================
# OUG
# displacement/velocity/acceleration/eigenvector/temperature
'OUG1' : [self._read_oug1_3, self._read_oug1_4], # displacements in nodal frame
'OUGV1' : [self._read_oug1_3, self._read_oug1_4], # displacements in nodal frame
'BOUGV1' : [self._read_oug1_3, self._read_oug1_4], # OUG1 on the boundary???
'OUGV1PAT': [self._read_oug1_3, self._read_oug1_4], # OUG1 + coord ID
'OUPV1' : [self._read_oug1_3, self._read_oug1_4],
#=======================
# OGPWG
# grid point weight
'OGPWG' : [self._read_ogpwg_3, self._read_ogpwg_4], # grid point weight
'OGPWGM' : [self._read_ogpwg_3, self._read_ogpwg_4], # modal? grid point weight
#=======================
# OGS
# grid point stresses
'OGS1' : [self._read_ogs1_3, self._read_ogs1_4], # grid point stresses
#=======================
# eigenvalues
'BLAMA': [self._read_buckling_eigenvalue_3, self._read_buckling_eigenvalue_4], # buckling eigenvalues
'CLAMA': [self._read_complex_eigenvalue_3, self._read_complex_eigenvalue_4], # complex eigenvalues
'LAMA' : [self._read_real_eigenvalue_3, self._read_real_eigenvalue_4], # eigenvalues
# ===geom passers===
# geometry
b'GEOM1': [self._table_passer, self._table_passer],
b'GEOM2': [self._table_passer, self._table_passer],
b'GEOM3': [self._table_passer, self._table_passer],
b'GEOM4': [self._table_passer, self._table_passer],
# superelements
b'GEOM1S': [self._table_passer, self._table_passer], # GEOMx + superelement
b'GEOM2S': [self._table_passer, self._table_passer],
b'GEOM3S': [self._table_passer, self._table_passer],
b'GEOM4S': [self._table_passer, self._table_passer],
b'GEOM1N': [self._table_passer, self._table_passer],
b'GEOM2N': [self._table_passer, self._table_passer],
b'GEOM3N': [self._table_passer, self._table_passer],
b'GEOM4N': [self._table_passer, self._table_passer],
b'GEOM1OLD': [self._table_passer, self._table_passer],
b'GEOM2OLD': [self._table_passer, self._table_passer],
b'GEOM3OLD': [self._table_passer, self._table_passer],
b'GEOM4OLD': [self._table_passer, self._table_passer],
b'EPT' : [self._table_passer, self._table_passer], # elements
b'EPTS': [self._table_passer, self._table_passer], # elements - superelements
b'EPTOLD' : [self._table_passer, self._table_passer],
'MPT' : [self._table_passer, self._table_passer], # materials
'MPTS': [self._table_passer, self._table_passer], # materials - superelements
'DYNAMIC': [self._table_passer, self._table_passer],
'DYNAMICS': [self._table_passer, self._table_passer],
'DIT': [self._table_passer, self._table_passer],
# geometry
#'GEOM1': [self._read_geom1_4, self._read_geom1_4],
#'GEOM2': [self._read_geom2_4, self._read_geom2_4],
#'GEOM3': [self._read_geom3_4, self._read_geom3_4],
#'GEOM4': [self._read_geom4_4, self._read_geom4_4],
# superelements
#'GEOM1S': [self._read_geom1_4, self._read_geom1_4],
#'GEOM2S': [self._read_geom2_4, self._read_geom2_4],
#'GEOM3S': [self._read_geom3_4, self._read_geom3_4],
#'GEOM4S': [self._read_geom4_4, self._read_geom4_4],
#'GEOM1N': [self._read_geom1_4, self._read_geom1_4],
#'GEOM2N': [self._read_geom2_4, self._read_geom2_4],
#'GEOM3N': [self._read_geom3_4, self._read_geom3_4],
#'GEOM4N': [self._read_geom4_4, self._read_geom4_4],
#'GEOM1OLD': [self._read_geom1_4, self._read_geom1_4],
#'GEOM2OLD': [self._read_geom2_4, self._read_geom2_4],
#'GEOM3OLD': [self._read_geom3_4, self._read_geom3_4],
#'GEOM4OLD': [self._read_geom4_4, self._read_geom4_4],
#'EPT' : [self._read_ept_4, self._read_ept_4],
#'EPTS': [self._read_ept_4, self._read_ept_4],
#'EPTOLD' : [self._read_ept_4, self._read_ept_4],
#'MPT' : [self._read_mpt_4, self._read_mpt_4],
#'MPTS': [self._read_mpt_4, self._read_mpt_4],
#'DYNAMIC': [self._read_dynamics_4, self._read_dynamics_4],
#'DYNAMICS': [self._read_dynamics_4, self._read_dynamics_4],
#'DIT': [self._read_dit_4, self._read_dit_4], # table objects (e.g. TABLED1)
# ===passers===
'EQEXIN': [self._table_passer, self._table_passer],
'EQEXINS': [self._table_passer, self._table_passer],
'GPDT': [self._table_passer, self._table_passer], # grid points?
'BGPDT': [self._table_passer, self._table_passer],
'BGPDTS': [self._table_passer, self._table_passer],
'BGPDTOLD': [self._table_passer, self._table_passer],
'PVT0': [self._table_passer, self._table_passer],
'DESTAB': [self._table_passer, self._table_passer],
'STDISP': [self._table_passer, self._table_passer],
'R1TABRG': [self._table_passer, self._table_passer],
'CASECC': [self._table_passer, self._table_passer], # case control deck
'HISADD': [self._table_passer, self._table_passer], # optimization history (SOL200)
'EDTS': [self._table_passer, self._table_passer],
'FOL': [self._table_passer, self._table_passer],
'MONITOR': [self._table_passer, self._table_passer], # monitor points
'PERF': [self._table_passer, self._table_passer],
'VIEWTB': [self._table_passer, self._table_passer], # view elements
#==================================
'OUGATO2': [self._table_passer, self._table_passer],
'OUGCRM2': [self._table_passer, self._table_passer],
'OUGNO2': [self._table_passer, self._table_passer],
'OUGPSD2': [self._table_passer, self._table_passer], # psd
'OUGRMS2': [self._table_passer, self._table_passer], # rms
'OQGATO2': [self._table_passer, self._table_passer],
'OQGCRM2': [self._table_passer, self._table_passer],
'OQGNO2': [self._table_passer, self._table_passer],
'OQGPSD2': [self._table_passer, self._table_passer],
'OQGRMS2': [self._table_passer, self._table_passer],
'OFMPF2M': [self._table_passer, self._table_passer],
'OLMPF2M': [self._table_passer, self._table_passer],
'OPMPF2M': [self._table_passer, self._table_passer],
'OSMPF2M': [self._table_passer, self._table_passer],
'OGPMPF2M': [self._table_passer, self._table_passer],
'OEFATO2': [self._table_passer, self._table_passer],
'OEFCRM2': [self._table_passer, self._table_passer],
'OEFNO2': [self._table_passer, self._table_passer],
'OEFPSD2': [self._table_passer, self._table_passer],
'OEFRMS2': [self._table_passer, self._table_passer],
'OESATO2': [self._table_passer, self._table_passer],
'OESCRM2': [self._table_passer, self._table_passer],
'OESNO2': [self._table_passer, self._table_passer],
'OESPSD2': [self._table_passer, self._table_passer],
'OESRMS2': [self._table_passer, self._table_passer],
'OVGATO2': [self._table_passer, self._table_passer],
'OVGCRM2': [self._table_passer, self._table_passer],
'OVGNO2': [self._table_passer, self._table_passer],
'OVGPSD2': [self._table_passer, self._table_passer],
'OVGRMS2': [self._table_passer, self._table_passer],
#==================================
#'GPL': [self._table_passer, self._table_passer],
'OMM2': [self._table_passer, self._table_passer],
'ERRORN': [self._table_passer, self._table_passer],
#==================================
'OCRPG': [self._table_passer, self._table_passer],
'OCRUG': [self._table_passer, self._table_passer],
'EDOM': [self._table_passer, self._table_passer],
'OAGPSD2': [self._table_passer, self._table_passer],
'OAGATO2': [self._table_passer, self._table_passer],
'OAGRMS2': [self._table_passer, self._table_passer],
'OAGNO2': [self._table_passer, self._table_passer],
'OAGCRM2': [self._table_passer, self._table_passer],
'OPGPSD2': [self._table_passer, self._table_passer],
'OPGATO2': [self._table_passer, self._table_passer],
'OPGRMS2': [self._table_passer, self._table_passer],
'OPGNO2': [self._table_passer, self._table_passer],
'OPGCRM2': [self._table_passer, self._table_passer],
'OSTRPSD2': [self._table_passer, self._table_passer],
'OSTRATO2': [self._table_passer, self._table_passer],
'OSTRRMS2': [self._table_passer, self._table_passer],
'OSTRNO2': [self._table_passer, self._table_passer],
'OSTRCRM2': [self._table_passer, self._table_passer],
'OQMPSD2': [self._table_passer, self._table_passer],
'OQMATO2': [self._table_passer, self._table_passer],
'OQMRMS2': [self._table_passer, self._table_passer],
'OQMNO2': [self._table_passer, self._table_passer],
'OQMCRM2': [self._table_passer, self._table_passer],
'AAA': [self._table_passer, self._table_passer],
'AAA': [self._table_passer, self._table_passer],
'AAA': [self._table_passer, self._table_passer],
'AAA': [self._table_passer, self._table_passer],
}
return table_mapper
