Add Type overloads for improved typing

anastruct/fem/elements.py

@@ -91,9 +91,11 @@ def __init__(
         self.shear_force: Optional[np.ndarray] = None
         self.axial_force: Optional[np.ndarray] = None
         self.deflection: Optional[np.ndarray] = None
+        self.total_deflection: Optional[np.ndarray] = None
         self.extension: Optional[np.ndarray] = None
-        self.max_deflection = None
-        self.max_extension = None
+        self.max_deflection: Optional[float] = None
+        self.max_total_deflection: Optional[float] = None
+        self.max_extension: Optional[float] = None
         self.nodes_plastic: List[bool] = [False, False]
         self.compile_constitutive_matrix(initial=True)
         self.compile_stiffness_matrix()

anastruct/fem/plotter/mpl.py

@@ -1287,13 +1287,10 @@ def displacements(  # pylint: disable=arguments-renamed
             max_displacement = max(
                 map(
                     lambda el: (
-                        max(
-                            abs(el.node_1.ux),
-                            abs(el.node_1.uy),
-                            el.max_deflection or 0,
+                        np.sqrt(
+                            (el.max_extension or 0) ** 2
+                            + (el.max_total_deflection or 0) ** 2
                         )
-                        if el.type == "general"
-                        else 0
                     ),
                     self.system.element_map.values(),
                 )

anastruct/fem/plotter/values.py

@@ -80,11 +80,10 @@ def displacements(
             max_displacement = max(
                 map(
                     lambda el: (
-                        max(
-                            abs(el.node_1.ux), abs(el.node_1.uy), el.max_deflection or 0
+                        np.sqrt(
+                            (el.max_extension or 0) ** 2
+                            + (el.max_total_deflection or 0) ** 2
                         )
-                        if el.type == "general"
-                        else 0
                     ),
                     self.system.element_map.values(),
                 )

anastruct/fem/postprocess.py

@@ -280,8 +280,11 @@ def determine_displacements(element: "Element", con: int) -> None:
             w2 = w2[::-1] - lx[::-1] * np.tan(alpha2)
 
             element.deflection = -(w1 + w2) / 2.0
-            assert element.deflection is not None
-            element.max_deflection = np.max(np.abs(element.deflection))
+        else:  # truss element has no bending
+            element.deflection = np.zeros(con)
+
+        assert element.deflection is not None
+        element.max_deflection = np.max(np.abs(element.deflection))
 
         # Extension
         assert element.axial_force is not None
@@ -300,8 +303,30 @@ def determine_displacements(element: "Element", con: int) -> None:
         element.extension = -1 * (u1 + u2) / 2.0
         element.max_extension = np.max(np.abs(element.extension))
 
-        # assert element.N_1 is not None
-        # assert element.N_2 is not None
-        # u = 0.5 * (element.N_1 + element.N_2) / element.EA * element.l
-        # du = u / con
-        # element.extension = du * (np.arange(con) + 1)
+        # Total deflection
+        ux1 = element.node_1.ux
+        uz1 = -element.node_1.uy
+        ux2 = element.node_2.ux
+        uz2 = -element.node_2.uy
+
+        if element.type == "general":
+            n = len(element.deflection)
+            x_val = np.linspace(ux1, ux2, n)
+            y_val = np.linspace(uz1, uz2, n)
+
+            element.total_deflection = (
+                element.deflection
+                + x_val * math.sin(element.angle)
+                + y_val * math.cos(element.angle)
+            )
+
+        else:  # truss element has no bending
+            n = len(element.extension)
+            x_val = np.linspace(ux1, ux2, n)
+            y_val = np.linspace(uz1, uz2, n)
+
+            element.total_deflection = x_val * math.sin(
+                element.angle
+            ) + y_val * math.cos(element.angle)
+
+        element.max_total_deflection = np.max(np.abs(element.total_deflection))