def test_main(self):
"""tests various matrices"""
#from pyNastran.op4.utils import write_dmig
op4_filenames = [
# name, write_binary
('mat_t_dn.op4', False),
('mat_t_s1.op4', False),
('mat_t_s2.op4', False),
('mat_b_dn.op4', False),
('mat_b_s1.op4', False),
('mat_b_s2.op4', False),
#'b_sample.op4',
#'binary.op4',
]
#matrix_names = 'EYE10' # identity
#matrix_names = 'LOW'
#matrix_names = 'RND1RS' # real,single
#matrix_names = 'RND1RD' # real,double
#matrix_names = 'RND1CS' # complex,single
#matrix_names = 'RND1CD' # complex,double
#matrix_names = 'STRINGS'
#matrix_names = 'EYE5CD' # complex identity
matrix_names = None
strings = get_matrices()
unused_is_big_mat = True
with open('ascii.op4', 'w') as op4_filea, open('binary.op4', 'wb') as op4_fileb:
op4 = OP4(debug=False)
matrices = {'strings' : (2, strings)}
name = 'strings'
op4.write_op4(op4_filea, matrices, name_order=name,
is_binary=False)
#op4.write_op4(op4_fileb, matrices, name_order=name,
#is_binary=True)
for op4_filename, write_binary in op4_filenames:
op4 = OP4()
op4.endian = '>'
#if 't' in fname:
#else:
#f = open('binary.op4', 'wb')
op4_filename = os.path.join(OP4_PATH, op4_filename)
matrices = op4.read_op4(op4_filename, matrix_names=matrix_names,
precision='default')
#print("keys = %s" % matrices.keys())
#print("fname=%s" % fname)
for name, (unused_form, unused_matrix) in sorted(matrices.items()):
op4.write_op4(op4_filea, matrices, name_order=name,
is_binary=False)
if write_binary:
op4.write_op4(op4_fileb, matrices, name_order=name,
is_binary=True)
os.remove('ascii.op4')
os.remove('binary.op4')
def test_NULL(self):
for fname in [
'mat_t_dn.op4',
'mat_t_s1.op4',
'mat_t_s2.op4',
]:
#print('-------%s-------' % fname)
op4 = OP4()
matrices = op4.read_op4(os.path.join(op4Path, fname))
(form, A) = matrices['NULL']
self.assertEquals(form, 6) # form=6 -> Symmetric
#print A.shape
# kind of strange that the NULL matrix is dense...
#if 's' in fname: # sparse
if 0:
self.assertTrue(array_equal(A.row, range(3)))
self.assertTrue(array_equal(A.col, range(3)))
msg = 'fname=%s NULL sparse matrix error' % fname
self.assertTrue(array_equal(A.data, [0] * 3), msg)
else: # real
E = zeros((3, 3))
msg = 'fname=%s NULL dense matrix error' % fname
self.assertTrue(array_equal(A, E))
del A
def create_input_modes(self, params):
N = self.N
Phi_m = params['Phi_m']
# Split Phi_m into modes and put them into a list
Phi_m_list = np.hsplit(Phi_m, N)
# Flatten the modes
Phi_m_flat_list = [mode.flatten() for mode in Phi_m_list]
# Remove zero values from the mode vectors
Phi_m_flat_list = [mode[np.nonzero(mode)] for mode in Phi_m_flat_list]
# Create array to be written on OP4 file
PHDH = np.zeros((len(Phi_m_flat_list[0]), N))
for i in range(len(Phi_m_flat_list[0])):
for j in range(N):
PHDH[i][j] = Phi_m_flat_list[j][i]
# Write PHDH matrix into OP4 file
op4 = OP4()
op4.write_op4('fort.21', {'PHDH': (2, PHDH)},
name_order=['PHDH'],
is_binary=False)
def test_null(self):
"""tests the NULL matrices"""
fnames = [
'mat_t_dn.op4',
'mat_t_s1.op4',
'mat_t_s2.op4',
]
for fname in fnames:
#print('-------%s-------' % fname)
op4 = OP4(debug=False)
matrices = op4.read_op4(os.path.join(OP4_PATH, fname))
(form, A) = matrices['NULL']
self.assertEqual(form, 6) # form=6 -> Symmetric
#print A.shape
# kind of strange that the NULL matrix is dense...
#if 's' in fname: # sparse
if 0:
self.assertTrue(array_equal(A.row, range(3)))
self.assertTrue(array_equal(A.col, range(3)))
msg = 'fname=%s NULL sparse matrix error' % fname
self.assertTrue(array_equal(A.data, [0] * 3), msg)
else: # real
zero_matrix = zeros((3, 3))
msg = 'fname=%s NULL dense matrix error' % fname
self.assertTrue(array_equal(A, zero_matrix))
del A
def test_bad_inputs_1(self):
op4 = OP4(debug=False)
op4_filename = os.path.join(OP4_PATH, 'bad_inputs.op4')
form1 = 1
A1 = ones((3, 3), dtype='float64')
matrices = {
'A1': (form1, A1),
'A2': ('bad', A1),
'A3': (form1, 'bad'),
}
with self.assertRaises(ValueError):
op4.write_op4(op4_filename, matrices, name_order=None, precision='default_bad',
is_binary=False)
with self.assertRaises(ValueError):
op4.write_op4(op4_filename, matrices, name_order='A1', precision='default',
is_binary='bad')
with self.assertRaises(ValueError):
op4.write_op4(op4_filename, matrices, name_order='A2', precision='default',
is_binary=True)
with self.assertRaises(NotImplementedError):
op4.write_op4(op4_filename, matrices, name_order='A3', precision='default',
is_binary=True)
# now lets write the op4, so we can test bad reading
op4.write_op4(op4_filename, matrices, name_order='A1', precision='default',
is_binary=False)
with self.assertRaises(ValueError):
op4.read_op4(op4_filename, precision='default_bad')
with self.assertRaises(IOError):
op4.read_op4('op4_filename', precision='default')
# now the inputs are valid, so this works
unused_matrices2 = op4.read_op4(op4_filename, precision='default')
def test_file_obj_binary():
op4 = OP4(debug=False)
form1 = 1
A1 = ones((3, 3), dtype='float64')
matrices = {
'A1': (form1, A1),
}
op4_filename = os.path.join(OP4_PATH, 'file_binary.op4')
with open(op4_filename, 'wb') as op4_file:
op4.write_op4(op4_file, matrices, name_order='A1', precision='default',
is_binary=True)
os.remove(op4_filename)
def test_file_obj_binary():
op4 = OP4()
form1 = 1
A1 = ones((3, 3), dtype='float64')
matrices = {
'A1': (form1, A1),
}
with open(os.path.join(op4_path, 'file_binary.op4'), 'wb') as op4_file:
op4.write_op4(op4_file,
matrices,
name_order='A1',
precision='default',
is_binary=True)
def test_op4_ascii(self):
for fname in ['mat_t_dn.op4',
'mat_t_s1.op4',
'mat_t_s2.op4',
]:
op4 = OP4()
matrices = op4.readOP4(os.path.join(op4Path, fname))
for name, (form, matrix) in sorted(matrices.items()):
print("name = %s" % (name))
if isinstance(matrix, ndarray):
print(matrix)
else:
#print(matrix.todense())
print(matrix)
def test_op4_ascii(self):
for fname in [
'mat_t_dn.op4',
'mat_t_s1.op4',
'mat_t_s2.op4',
]:
op4 = OP4()
matrices = op4.read_op4(os.path.join(op4Path, fname))
for name, (form, matrix) in sorted(iteritems(matrices)):
#print("name = %s" % name)
if isinstance(matrix, ndarray):
#print(matrix)
pass
else:
pass
def test_op4_ascii(self):
fnames = [
'mat_t_dn.op4',
'mat_t_s1.op4',
'mat_t_s2.op4',
]
for fname in fnames:
op4 = OP4()
matrices = op4.read_op4(os.path.join(OP4_PATH, fname))
for unused_name, (unused_form, matrix) in sorted(matrices.items()):
#print("name = %s" % name)
if isinstance(matrix, ndarray):
#print(matrix)
pass
else:
pass
def test_file_obj_ascii():
op4 = OP4()
form1 = 1
A1 = ones((3, 3), dtype='float64')
matrices = {
'A1': (form1, A1),
}
if PY2:
wb = 'wb'
else:
wb = 'w'
with open(os.path.join(op4_path, 'file_ascii.op4'), wb) as op4_file:
op4.write_op4(op4_file,
matrices,
name_order='A1',
precision='default',
is_binary=False)
def test_op4_binary(self):
for fname in [
'mat_b_dn.op4',
'mat_b_s1.op4',
'mat_b_s2.op4',
]:
op4 = OP4()
matrices = op4.read_op4(os.path.join(op4Path, fname))
for name, (form, matrix) in sorted(iteritems(matrices)):
#print("name = %s" % (name))
if isinstance(matrix, ndarray):
pass
#print(matrix)
else:
#print(matrix.todense())
pass
def test_file_obj_ascii():
"""tests ascii writing"""
op4 = OP4(debug=False)
form1 = 1
A1 = ones((3, 3), dtype='float64')
matrices = {
'A1': (form1, A1),
}
if PY2:
wb = 'wb'
else:
wb = 'w'
op4_filename = os.path.join(OP4_PATH, 'file_ascii.op4')
with open(op4_filename, wb) as op4_file:
op4.write_op4(op4_file, matrices, name_order='A1', precision='default',
is_binary=False)
os.remove(op4_filename)
def test_EYE10(self):
for fname in [
'mat_t_dn.op4',
'mat_t_s1.op4',
'mat_t_s2.op4',
]:
op4 = OP4()
matrices = op4.read_op4(os.path.join(op4Path, fname))
(form, A) = matrices['EYE10']
self.assertEquals(form, 6) # form=6 -> Symmetric
if 's' in fname: # sparse
self.assertTrue(array_equal(A.row, range(10)))
self.assertTrue(array_equal(A.col, range(10)))
self.assertTrue(array_equal(A.data, [1] * 10))
else: # real
E = eye(10)
self.assertTrue(array_equal(A, E))
def test_eye5cd(self):
fnames = [
'mat_t_dn.op4',
'mat_t_s1.op4',
'mat_t_s2.op4',
]
for fname in fnames:
op4 = OP4()
matrices = op4.read_op4(os.path.join(op4_path, fname))
(form, A) = matrices['EYE5CD']
self.assertEqual(form, 6) # form=6 -> Symmetric
if 's' in fname: # sparse
self.assertTrue(array_equal(A.row, range(5)))
self.assertTrue(array_equal(A.col, range(5)))
self.assertTrue(array_equal(A.data, [-1 + 1j] * 5))
else: # real
E = -eye(5) + 1j * eye(5)
self.assertTrue(array_equal(A, E))
def test_eye5cd(self):
"""tests the EYE5CD matrices"""
fnames = [
'mat_t_dn.op4',
'mat_t_s1.op4',
'mat_t_s2.op4',
]
for fname in fnames:
op4 = OP4(debug=False)
matrices = op4.read_op4(os.path.join(OP4_PATH, fname))
(form, A) = matrices['EYE5CD']
self.assertEqual(form, 6) # form=6 -> Symmetric
if 's' in fname: # sparse
self.assertTrue(array_equal(A.row, range(5)))
self.assertTrue(array_equal(A.col, range(5)))
self.assertTrue(array_equal(A.data, [-1+1j] * 5))
else: # real
eye_matrix = -eye(5) + 1j * eye(5)
self.assertTrue(array_equal(A, eye_matrix))
def run_model(bdf_name=None,
op2_name=None,
f06_name=None,
op4_name=None,
dynamic_vars=None,
f06_has_weight=True,
vectorized=False,
encoding=None): # pragma: no cover
outputs = []
if bdf_name:
bdf = BDF(debug=False, log=None)
if dynamic_vars is not None:
bdf.set_dynamic_syntax(dynamic_vars)
bdf.read_bdf(bdf_name, encoding=encoding)
bdf.write_bdf(bdf_name + '.out', interspersed=False)
bdf.write_bdf(bdf_name + '.out', interspersed=True)
outputs.append(bdf)
if op2_name:
op2 = OP2(debug=False)
op2.read_op2(op2_name)
op2.write_f06(op2_name[:-4] + '.test_op2.out', quiet=True)
outputs.append(op2)
if f06_name:
f06 = F06(debug=False, log=None)
f06.read_f06(f06_name)
f06.write_f06(f06_name[:-4] + '.test_f06.out', quiet=True)
outputs.append(f06)
if f06_has_weight:
assert f06.grid_point_weight.reference_point is not None
else:
assert f06.grid_point_weight.reference_point is None
if op4_name:
op4 = OP4()
op4.read_op4(op4_name, matrix_names=None, precision='default')
outputs.append(op4)
assert len(outputs) > 0
if len(outputs) == 1:
return outputs[0]
return outputs
def test_eye10(self):
"""tests the EYE10 matrices"""
fnames = [
'mat_t_dn.op4',
'mat_t_s1.op4',
'mat_t_s2.op4',
]
for fname in fnames:
op4 = OP4(debug=False)
matrices = op4.read_op4(os.path.join(op4_path, fname))
(form, A) = matrices['EYE10']
self.assertEqual(form, 6) # form=6 -> Symmetric
if 's' in fname: # sparse
self.assertTrue(array_equal(A.row, range(10)))
self.assertTrue(array_equal(A.col, range(10)))
self.assertTrue(array_equal(A.data, [1] * 10))
else: # real
E = eye(10)
self.assertTrue(array_equal(A, E))
def test_square_matrices_1(self):
"""tests reading/writing square matrices (A1, A2, A3)"""
op4 = OP4(debug=False)
#matrices = op4.read_op4(os.path.join(OP4_PATH, fname))
form1 = 1
form2 = 2
form3 = 2
A1 = np.ones((3, 3), dtype='float64')
A2 = reshape(arange(9, dtype='float64'), (3, 3))
A3 = np.ones((1, 1), dtype='float32')
matrices = {
'A1': (form1, A1),
'A2': (form2, A2),
'A3': (form3, A3),
}
for (is_binary, fname) in [(False, 'small_ascii.op4'),
(True, 'small_binary.op4')]:
op4_filename = os.path.join(OP4_PATH, fname)
op4.write_op4(op4_filename,
matrices,
name_order=None,
precision='default',
is_binary=False)
matrices2 = op4.read_op4(op4_filename, precision='default')
(form1b, A1b) = matrices2['A1']
(form2b, A2b) = matrices2['A2']
self.assertEqual(form1, form1b)
self.assertEqual(form2, form2b)
(form1b, A1b) = matrices2['A1']
(form2b, A2b) = matrices2['A2']
(form3b, A3b) = matrices2['A3']
self.assertEqual(form1, form1b)
self.assertEqual(form2, form2b)
self.assertEqual(form3, form3b)
self.assertTrue(array_equal(A1, A1b))
self.assertTrue(array_equal(A2, A2b))
self.assertTrue(array_equal(A3, A3b))
del A1b, A2b, A3b
del form1b, form2b, form3b
def test_square_matrices_1(self):
op4 = OP4()
#matrices = op4.read_op4(os.path.join(op4Path, fname))
form1 = 1
form2 = 2
form3 = 2
from numpy import matrix, ones, reshape, arange
A1 = matrix(ones((3, 3), dtype='float64'))
A2 = reshape(arange(9, dtype='float64'), (3, 3))
A3 = matrix(ones((1, 1), dtype='float32'))
matrices = {
'A1': (form1, A1),
'A2': (form2, A2),
'A3': (form3, A3),
}
for (is_binary, fname) in [(False, 'small_ascii.op4'),
(True, 'small_binary.op4')]:
op4_filename = os.path.join(op4Path, fname)
op4.write_op4(op4_filename,
matrices,
name_order=None,
precision='default',
is_binary=False)
matrices2 = op4.read_op4(op4_filename, precision='default')
(form1b, A1b) = matrices2['A1']
(form2b, A2b) = matrices2['A2']
self.assertEquals(form1, form1b)
self.assertEquals(form2, form2b)
(form1b, A1b) = matrices2['A1']
(form2b, A2b) = matrices2['A2']
(form3b, A3b) = matrices2['A3']
self.assertEquals(form1, form1b)
self.assertEquals(form2, form2b)
self.assertEquals(form3, form3b)
self.assertTrue(array_equal(A1, A1b))
self.assertTrue(array_equal(A2, A2b))
self.assertTrue(array_equal(A3, A3b))
del A1b, A2b, A3b
del form1b, form2b, form3b
def test_file_obj(self):
op4 = OP4()
form1 = 1
from numpy import ones
A1 = ones((3, 3), dtype='float64')
matrices = {
'A1': (form1, A1),
}
f = open(os.path.join(op4Path, 'file_ascii.op4'), 'wb')
op4.write_op4(f,
matrices,
name_order='A1',
precision='default',
is_binary=False)
f.close()
f = open(os.path.join(op4Path, 'file_binary.op4'), 'wb')
op4.write_op4(f,
matrices,
name_order='A1',
precision='default',
is_binary=False)
f.close()
def run_model(self,
bdf_name=None,
f06_name=None,
op2_name=None,
op4_name=None,
dynamic_vars=None):
outputs = []
if bdf_name:
bdf = BDF(debug=False, log=None)
if dynamic_vars is not None:
print('dynamic')
bdf.set_dynamic_syntax(dynamic_vars)
bdf.read_bdf(bdf_name)
bdf.write_bdf(bdf_name + '.out', interspersed=False)
bdf.write_bdf(bdf_name + '.out', interspersed=True)
outputs.append(bdf)
if f06_name:
f06 = F06(f06_name, debug=False, log=None)
f06.read_f06()
f06.write_f06(f06_name + '.out')
outputs.append(f06)
if op2_name:
op2 = OP2(op2_name, debug=False)
op2.read_op2()
op2.write_f06(op2_name + '.out')
outputs.append(op2)
if op4_name:
op4 = OP4(op4_name)
op4.read_op4(op4Name, matrixNames=None, precision='default')
assert len(outputs) > 0
if len(outputs) == 1: return outputs[0]
return outputs
def run_op4(op4_filename, write_op4=True, debug=True,
stop_on_failure=False):
print('***debug=%s' % debug)
assert '.op4' in op4_filename.lower(), 'op4_filename=%s is not an OP4' % op4_filename
is_passed = False
stop_on_failure = True
delete_op4 = True
#debug = True
try:
op4 = OP4(debug=debug)
op4._new = True
matrices = op4.read_op4(op4_filename)
if 0:
matrices2 = op4.read_op4(op4_filename)
print(matrices)
print('matrices =', matrices.keys())
assert list(sorted(matrices.keys())) == list(sorted(matrices2.keys()))
for key, (form, matrix) in sorted(iteritems(matrices)):
form2, matrix2 = matrices2[key]
assert form == form2
delta = matrix - matrix2
assert np.array_equal(matrix, matrix2), 'delta=\n%s' % delta
if write_op4:
model = os.path.splitext(op4_filename)[0]
op4.write_op4(model+'.test_op4_ascii.op4', matrices, is_binary=False)
op4.write_op4(model+'.test_op4_binary.op4', matrices, is_binary=True)
if delete_op4:
try:
os.remove(model+'.test_op4_ascii.op4')
os.remove(model+'.test_op4_binary.op4')
except:
pass
del op4
is_passed = True
except KeyboardInterrupt:
sys.stdout.flush()
print_exc(file=sys.stdout)
sys.stderr.write('**file=%s\n' % op4_filename)
sys.exit('keyboard stop...')
#except RuntimeError: # the op2 is bad, not my fault
# is_passed = True
# if stop_on_failure:
# raise
# else:
# is_passed = True
except IOError: # missing file
if stop_on_failure:
raise
#except AssertionError:
# is_passed = True
#except RuntimeError:
# is_passed = True
except SystemExit:
#print_exc(file=sys.stdout)
#sys.exit('stopping on sys.exit')
raise
#except NameError: # variable isnt defined
# if stop_on_failure:
# raise
# else:
# is_passed = True
#except IndexError:
# is_passed = True
except SyntaxError: #Param Parse
if stop_on_failure:
raise
is_passed = True
except:
#print(e)
if stop_on_failure:
raise
else:
print_exc(file=sys.stdout)
is_passed = False
return is_passed
# -*- coding: utf-8 -*- # <nbformat>3.0</nbformat> # <codecell> import os from pyNastran.utils import print_bad_path from pyNastran.op4.op4 import OP4 from numpy import float32, float64, int32, int64, product # <codecell> # define the OP4 object op4 = OP4() # print the docstring #op4.read_op4? help(op4.read_op4) # <codecell> # read the op4, will pop open a dialog box #matrices = op4.read_op4() #print matrices.keys() #key = 'CMPLX' #print matrices[key] # <codecell> op4_filename = r'C:\Users\Steve\Desktop\ISat_Launch_Sm_4pt.op4'
def run_op4(op4_filename, write_op4=True, debug=True):
assert '.op4' in op4_filename.lower(), 'op4_filename=%s is not an OP4' % op4_filename
isPassed = False
stopOnFailure = True
delete_op4 = True
#debug = True
try:
op4 = OP4()
matrices = op4.read_op4(op4_filename)
print(matrices)
print('matrices =', matrices.keys())
if write_op4:
(model, ext) = os.path.splitext(op4_filename)
op4.write_op4(model+'.test_op4_ascii.op4', matrices, is_binary=False)
op4.write_op4(model+'.test_op4_binary.op4', matrices, is_binary=True)
if delete_op4:
try:
os.remove(model+'.test_op4_ascii.op4')
os.remove(model+'.test_op4_binary.op4')
except:
pass
del op4
isPassed = True
except KeyboardInterrupt:
sys.stdout.flush()
print_exc(file=sys.stdout)
sys.stderr.write('**file=%s\n' % op2FileName)
sys.exit('keyboard stop...')
#except RuntimeError: # the op2 is bad, not my fault
# isPassed = True
# if stopOnFailure:
# raise
# else:
# isPassed = True
except IOError: # missing file
if stopOnFailure:
raise
#except AssertionError:
# isPassed = True
#except RuntimeError:
# isPassed = True
except SystemExit:
#print_exc(file=sys.stdout)
#sys.exit('stopping on sys.exit')
raise
#except NameError: # variable isnt defined
# if stopOnFailure:
# raise
# else:
# isPassed = True
#except IndexError:
# isPassed = True
except SyntaxError: #Param Parse
if stopOnFailure:
raise
isPassed = True
except:
#print e
if stopOnFailure:
raise
else:
print_exc(file=sys.stdout)
isPassed = False
return isPassed
