more tests

Author: SteveDoyle2

pyNastran/converters/nastran/gui/nastran_io.py

@@ -418,7 +418,7 @@ def get_xyz_in_coord(self, model: BDF,
                    'renumbering; duplicate nids=\n%s' % duplicates(all_nids))
             raise NotImplementedError(msg)
 
-        if not is_monotonic(all_nids):
+        if not is_monotonic(all_nids, is_strict=True):
             # msg = ('superelement nodes are not monotonic; use superelement_renumber\n'
             #        'renumbering; nids=\n%s' % all_nids)
             # self.log.warning(msg)

pyNastran/f06/dev/flutter/test_gui_flutter.py

@@ -28,11 +28,14 @@ def test_action(self) -> None:
 
     def test_load_f06_op2(self) -> None:
         f06_filename = MODEL_PATH / 'aero' / '2_mode_flutter' / '0012_flutter.op2'
-        log = SimpleLogger(level='debug')
+        log = SimpleLogger(level='info')
         in_units = 'si'
         out_units = 'si'
         load_f06_op2(f06_filename, log, in_units, out_units, use_rhoref=False)
 
+        op2_filename = MODEL_PATH / 'bwb' / 'bwb_saero.op2'
+        load_f06_op2(op2_filename, log, in_units, out_units, use_rhoref=False)
+
 
 if __name__ == '__main__':
     unittest.main()

pyNastran/f06/test/all_tests.py

@@ -1,7 +1,9 @@
 from pyNastran.f06.test.test_f06_formatting import TestF06Formatting
 from pyNastran.f06.test.test_f06_utils import (
     TestF06Utils, TestF06Flutter, TestZonaFlutter)
+
 from pyNastran.f06.dev.flutter.test_zona import TestZona
+from pyNastran.f06.dev.flutter.test_gui_flutter import TestGuiFlutter
 
 
 if __name__ == "__main__":  # pragma: no cover

pyNastran/femutils/coord_utils.py

@@ -11,7 +11,7 @@
 from .matrix3d import axes_stack, normalize_vector2d
 
 
-def coords_from_vector_1d(v_array):
+def coords_from_vector_1d(v_array: np.ndarray) -> np.ndarray:
     """
     Gets the coordinate systems for a series of 1D vectors.
     Fakes the j and k axes.
@@ -209,7 +209,8 @@ def hexa_coord(xyz1, xyz2, xyz3, xyz4,
     #return coords
 
 
-def _coordinate_system_from_vector_2d(v21, normal):
+def _coordinate_system_from_vector_2d(v21: np.ndarray,
+                                      normal: np.ndarray) -> np.ndarray:
     r"""
     Helper method::
 

pyNastran/femutils/matrix3d.py

@@ -14,22 +14,25 @@
 import numpy as np
 
 
-def norm2d(v):
+def norm2d(v: np.ndarray) -> np.ndarray:
     """takes N norms of a (N,3) set of vectors"""
     mag = np.linalg.norm(v, axis=1)
     assert v.shape[0] == len(mag)
     return mag
 
 
-def normalize_vector2d(v):
+def normalize_vector2d(v: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
     """normalzes a series of (N,3) vectors"""
     mag = norm2d(v)
     nmag = len(mag)
     i = v / mag[:, np.newaxis]
     return i, nmag
 
 
-def axes_stack(i, j, k, nmag):
+def axes_stack(i: np.ndarray,
+               j: np.ndarray,
+               k: np.ndarray,
+               nmag: int) -> np.ndarray:
     """stack coordinate axes in 3d"""
     i.shape = (nmag, 1, 3)
     j.shape = (nmag, 1, 3)
@@ -38,7 +41,8 @@ def axes_stack(i, j, k, nmag):
     return ijk
 
 
-def dot_33_n33(A, B, debug=True):
+def dot_33_n33(A: np.ndarray, B: np.ndarray,
+               debug: bool=False) -> np.ndarray:
     """
     Multiplies a (3x3) matrix by a Nx3x3 matrix
 
@@ -62,19 +66,20 @@ def dot_33_n33(A, B, debug=True):
         dtype = A.dtype
         #print('------------------------')
         D = np.zeros(B.shape, dtype=dtype)
-        print('A.shape =', A.shape)
+        # print('A.shape =', A.shape)
         for i, Bi in zip(count(), B):
-            print('Bi.shape =', Bi.shape)
+            # print('Bi.shape =', Bi.shape)
             ABi = A @ Bi
-            print('A @ Bi.shape =', ABi.shape)
+            # print('A @ Bi.shape =', ABi.shape)
             D[i, :, :] = ABi
             #print(D[i, :, :])
             #print('------------------------')
         assert np.all(np.allclose(C, D))
     return D
 
 
-def dot_n33_33(A, B, debug=True):
+def dot_n33_33(A: np.ndarray, B: np.ndarray,
+               debug: bool=False) -> np.ndarray:
     """
     Multiplies a (3x3) matrix by a Nx3x3 matrix
 
@@ -113,7 +118,8 @@ def dot_n33_33(A, B, debug=True):
     return C
 
 
-def dot_n33_n33(A: np.ndarray, B: np.ndarray, debug: bool=True) -> np.ndarray:
+def dot_n33_n33(A: np.ndarray, B: np.ndarray,
+                debug: bool=False) -> np.ndarray:
     """
     Multiplies two matrices together
 
@@ -131,7 +137,8 @@ def dot_n33_n33(A: np.ndarray, B: np.ndarray, debug: bool=True) -> np.ndarray:
     assert A.shape[1:] == (3, 3), A.shape
     assert len(B.shape) == 3, B.shape
     assert B.shape[1:] == (3, 3), B.shape
-    #C = np.matmul(A, B)
+
+    C = np.einsum('ijk,ikm->ijm', A, B)
     if debug:
         dtype = A.dtype
         #print('------------------------')
@@ -140,13 +147,15 @@ def dot_n33_n33(A: np.ndarray, B: np.ndarray, debug: bool=True) -> np.ndarray:
             D[i, :, :] = Ai @ Bi
             #print(D[i, :, :])
             #print('------------------------')
+        assert np.allclose(C, D)
     #if not np.all(np.allclose(C, D)):
         #print('C:\n%s'% C)
         #print('D:\n%s'% D)
-    return D
+    return C
 
 
-def dot_n33_n3(A: np.ndarray, B: np.ndarray, debug: bool=True) -> np.ndarray:
+def dot_n33_n3(A: np.ndarray, B: np.ndarray,
+               debug: bool=False) -> np.ndarray:
     """
     Multiplies two N x 3 x 3 matrices together
 
@@ -189,7 +198,7 @@ def transpose3d(T: np.ndarray) -> np.ndarray:
     """
     return np.transpose(T, axes=(0, 2, 1))
 
-def triple_n33_n33(A, T, transpose: bool=False, debug: bool=True) -> np.ndarray:
+def triple_n33_n33(A, T, transpose: bool=False, debug: bool=False) -> np.ndarray:
     """
     Calculates the matrix triple product  for a series of::
 

pyNastran/femutils/test/test_utils.py

@@ -13,7 +13,10 @@
 import pyNastran
 from pyNastran.femutils.io import loadtxt_nice, savetxt_nice
 from pyNastran.femutils.matrix3d import dot_n33_n33, transpose3d, triple_n33_n33, triple_n33_33
-from pyNastran.femutils.utils import augmented_identity, perpendicular_vector, perpendicular_vector2d
+from pyNastran.femutils.utils import (
+    augmented_identity, perpendicular_vector,
+    perpendicular_vector2d, vstack_lists,
+    is_monotonic, duplicates, hstack_unique)
 from pyNastran.femutils.coord_transforms import cylindrical_rotation_matrix
 
 from pyNastran.femutils.test.utils import is_array_close
@@ -103,7 +106,8 @@ def test_triple_n33_n33(self):
              [0., 0., 1.],
              [1., 0., 9.],],
         ])
-        TtAT_actual = triple_n33_n33(A, T, transpose=False)
+        TtAT_actual = triple_n33_n33(A, T, transpose=False, debug=False)
+        TtAT_actual = triple_n33_n33(A, T, transpose=False, debug=True)
         TtAT_expected = [
             [[5., 6., 58.],
              [8., 9., 88.],
@@ -114,7 +118,8 @@ def test_triple_n33_n33(self):
              [74., 84., 820.],],
         ]
         assert is_array_close(TtAT_expected, TtAT_actual)
-        TATt_actual = triple_n33_n33(A, T, transpose=True)
+        TATt_actual = triple_n33_n33(A, T, transpose=True, debug=False)
+        TATt_actual = triple_n33_n33(A, T, transpose=True, debug=True)
         TATt_expected = [
             [[9., 7., 89.],
              [3., 1., 29.],
@@ -142,7 +147,8 @@ def test_triple_n33_33(self):
             [0., 0., 1.],
             [1., 0., 9.],
         ])
-        TtAT_actual = triple_n33_33(A, T, transpose=False)
+        TtAT_actual = triple_n33_33(A, T, transpose=False, debug=False)
+        TtAT_actual = triple_n33_33(A, T, transpose=False, debug=True)
         TtAT_expected = [
             [[5., 6., 58.],
              [8., 9., 88.],
@@ -153,7 +159,8 @@ def test_triple_n33_33(self):
              [74., 84., 820.],],
         ]
         assert is_array_close(TtAT_expected, TtAT_actual)
-        TATt_actual = triple_n33_33(A, T, transpose=True)
+        TATt_actual = triple_n33_33(A, T, transpose=True, debug=False)
+        TATt_actual = triple_n33_33(A, T, transpose=True, debug=True)
         TATt_expected = [
             [[9., 7., 89.],
              [3., 1., 29.],
@@ -168,6 +175,70 @@ def test_triple_n33_33(self):
 
 class TestNumpyUtils(unittest.TestCase):
     """tests functions in femutils.utils"""
+    def test_hstack_unique(self):
+        list_of_arrays = [
+            [1, 2, 3], [4, 5, 6, 7, 3],
+        ]
+        stacked = [1, 2, 3, 4, 5, 6, 7, 3]
+        unique_stacked = [1, 2, 3, 4, 5, 6, 7]
+        a = hstack_unique(list_of_arrays, unique=False)
+        b = hstack_unique(list_of_arrays, unique=True)
+        assert np.array_equal(a, stacked)
+        assert np.array_equal(b, unique_stacked)
+
+        list_of_arrays = [
+            [1, 2, 3, 4, 5, 6, 7, 3],
+        ]
+        c = hstack_unique(list_of_arrays, unique=False)
+        d = hstack_unique(list_of_arrays, unique=True)
+        assert np.array_equal(c, stacked)
+        assert np.array_equal(d, unique_stacked)
+
+    def test_vstack_list(self):
+        list_of_arrays = [
+                [[1, 2, 3]],
+            [
+                [1, 2, 3],
+                [1, 2, 3],
+            ]
+        ]
+        stacked = [
+            [1, 2, 3],
+            [1, 2, 3],
+            [1, 2, 3],
+        ]
+        stacked_array = vstack_lists(list_of_arrays)
+        assert np.array_equal(stacked_array, stacked)
+
+        list_of_arrays = [
+            [[1, 2, 3]],
+        ]
+        stacked = [[1, 2, 3]]
+        stacked_array = vstack_lists(list_of_arrays)
+        assert np.array_equal(stacked_array, stacked), stacked_array
+
+    def test_duplicates(self):
+        a = [1, 2, 3, 4, 5, 2, 3]
+        b= duplicates(a)
+        assert np.array_equal(b, [2, 3])
+
+        a = [3, 2, 1, 3, 2, 4, 5]
+        b= duplicates(a)
+        assert np.array_equal(b, [2, 3])
+
+    def test_is_monotonic(self):
+        a = np.array([1, 2, 3])
+        b = np.array([1, -2, 3])
+        c = np.array([1, 2, 2, 3])
+
+        assert is_monotonic(a, is_strict=True), (np.diff(a), aa)
+        assert not is_monotonic(b, is_strict=True), np.diff(b)
+        assert not is_monotonic(c, is_strict=True), np.diff(c)
+
+        assert is_monotonic(a, is_strict=False)
+        assert not is_monotonic(b, is_strict=False)
+        assert is_monotonic(c, is_strict=False)
+
     def test_perpendicular_vector(self):
         """tests perpendicular_vector"""
         with self.assertRaises(ValueError):

pyNastran/femutils/utils.py

@@ -72,14 +72,15 @@ def vstack_lists(list_of_arrays: list[np.ndarray]) -> np.ndarray:
     Stacks an array
 
     list_of_arrays = [
+        [
             [1, 2, 3],
         ],
         [
             [1, 2, 3],
             [1, 2, 3],
         ]
     ]
-    stacked [
+    stacked = [
         [1, 2, 3],
         [1, 2, 3],
         [1, 2, 3],
@@ -210,15 +211,22 @@ def unique2d(a: np.ndarray, return_index=False):
     #return uniq.view(data.dtype).reshape(-1, data.shape[1])
 
 
-def duplicates(ids):
+def duplicates(ids: np.ndarray) -> np.ndarray:
     """finds the duplicate ids"""
     counts = np.bincount(ids)
     return np.where(counts > 1)[0]
 
 
-def is_monotonic(int_array: np.ndarray) -> bool:
+def is_monotonic(int_array: np.ndarray,
+                 is_strict: bool=False,
+                 ) -> bool:
     """is the array monotonic?"""
-    return np.all(int_array[1:] >= int_array[:-1])
+    diff = np.diff(int_array, n=1)
+    if is_strict:
+        out = np.all(diff > 0)
+    else:
+        out = np.all(diff >= 0)
+    return out
 
 
 def unique_rows(A: np.ndarray, return_index=False, return_inverse=False):