kib-lap 0.5__cp313-cp313-win_amd64.whl → 0.7.7__cp313-cp313-win_amd64.whl

KIB_LAP/STABRAUM/Steifigkeitsmatrix.py

@@ -2,6 +2,7 @@ import sympy as sp
 import numpy as np
 import math
 
+
 class ElemStema:
     def __init__(self):
 
@@ -9,113 +10,86 @@ class ElemStema:
         self.Ke = np.zeros((14, 14))
 
     def TransformationMatrix(self, posI, posJ):
-        ix, iy, iz = posI
-        jx, jy, jz = posJ
+        Pi = np.asarray(posI, dtype=float).reshape(
+            3,
+        )
+        Pj = np.asarray(posJ, dtype=float).reshape(
+            3,
+        )
 
-        dx = jx - ix
-        dy = jy - iy
-        dz = jz - iz
-        length = math.sqrt(dx**2 + dy**2 + dz**2)
+        v = Pj - Pi
+        L = np.linalg.norm(v)
 
-        T = np.zeros((14, 14))
-        T_i = np.zeros((6, 6))
+        T = np.zeros((14, 14), dtype=float)
 
-        # Falls die Knoten identisch sind
-        if length < 1e-12:
+        # identische Knoten
+        if L < 1e-12:
             np.fill_diagonal(T, 1.0)
             return T
 
-        # 1. Spezialfall: Balken nur in z-Richtung
-        # (dx, dy ~ 0, dz != 0)
-        tol = 1e-12
-        if abs(dx) < tol and abs(dy) < tol:
-            # -> lokales x' = globales z
-            # Rotationsmatrix R:
-            #    x' -> z
-            #    y' -> y
-            #    z' -> -x  (z.B. so gewählt,
-            #                aber man kann auch x'->z, y'->x etc. nehmen)
-            if dz > 0:
-                # x' -> +z
-                R = np.array([
-                    [0,  0,  1],  # x'
-                    [0,  1,  0],  # y'
-                    [-1, 0,  0],  # z'
-                ], dtype=float)
-            else:
-                # x' -> -z
-                R = np.array([
-                    [0,  0, -1],  # x'
-                    [0,  1,  0],  # y'
-                    [1,  0,  0],  # z'
-                ], dtype=float)
-
-        else:
-            # 2. Allgemeiner Fall: Kreuzprodukt-Logik
-            ex_approx = np.array([dx, dy, dz]) / length
-
-            # Hilfsvektor für y'-Achse (wenn ex_approx zu parallel zu e_z, dann e_y)
-            ez_approx = np.array([0, 0, 1], dtype=float)
-            if abs(np.dot(ex_approx, ez_approx)) > 0.9999:
-                ez_approx = np.array([0, 1, 0], dtype=float)
-
-            ey = np.cross(ex_approx, ez_approx)
-            ey /= np.linalg.norm(ey)
-            ez = np.cross(ex_approx, ey)
-
-            R = np.column_stack((ex_approx, ey, ez))
-
-        cos_xX = R[0][0]
-        cos_xY = R[0][1]
-        cos_xZ = R[0][2]
-
-        cos_yX = R[1][0]
-        cos_yY = R[1][1]
-        cos_yZ = R[1][2]
-
-        cos_zX = R[2][0]
-        cos_zY = R[2][1]
-        cos_zZ = R[2][2]
-
-        # T_i: 6x6-Block
-
-        T_i[0,0] = cos_xX
-        T_i[0,1] = cos_xY
-        T_i[0,3] = cos_xZ
-
-        T_i[1,0] = cos_yX
-        T_i[1,1] = cos_yY
-        T_i[1,3] = cos_yZ
-
-        T_i[2,2] = cos_zZ
-        T_i[2,4] = cos_zY
-        T_i[2,5] = cos_zX
-
-        T_i[3,0] = cos_zX
-        T_i[3,1] = cos_zY
-        T_i[3,3] = cos_zZ
-
-        T_i[4,2] = cos_yZ
-        T_i[4,4] = cos_yY
-        T_i[4,5] = cos_yX
-
-        T_i[5,2] = cos_xZ
-        T_i[5,4] = cos_xY
-        T_i[5,5] = cos_xX
-
-
-
-        T[0:6,0:6] = T_i
-        T[7:13,7:13] = T_i
+        # lokale x-Achse
+        ex = v / L
+
+        # robuste Referenzachse wählen (nicht parallel zu ex)
+        g = np.array([0.0, 1.0, 0.0], dtype=float)  # bevorzugt global y
+        if abs(np.dot(ex, g)) > 0.95:
+            g = np.array([0.0, 0.0, 1.0], dtype=float)  # sonst global z
+            if abs(np.dot(ex, g)) > 0.95:
+                g = np.array([1.0, 0.0, 0.0], dtype=float)  # zur Not global x
+
+        # --- Stabiler Aufbau: erst ey als Projektion von g orthogonal zu ex ---
+        ey = g - np.dot(g, ex) * ex
+        ney = np.linalg.norm(ey)
+        if ney < 1e-12:
+            raise ValueError("Degeneriertes lokales Achsensystem (ey ~ 0).")
+        ey = ey / ney
+
+        # --- Rechtshändiges System erzwingen ---
+        ez = np.cross(ex, ey)
+        nez = np.linalg.norm(ez)
+        if nez < 1e-12:
+            raise ValueError("Degeneriertes lokales Achsensystem (ez ~ 0).")
+        ez = ez / nez
+
+        # Optional: Flip-Schutz (ey soll möglichst in Richtung g zeigen)
+        # verhindert, dass bei ähnlichen Elementen ey/ez um 180° springen
+        if np.dot(ey, g) < 0.0:
+            ey *= -1.0
+            ez *= -1.0
+
+        # R: local -> global (Spalten sind ex, ey, ez)
+        R = np.column_stack((ex, ey, ez))
+
+        # ---- 6x6 Transformationsblock passend zu deiner DOF-Reihenfolge ----
+        Ti = np.zeros((6, 6), dtype=float)
+
+        # translations: [ux, uy, uz] sitzen auf [0,1,3]
+        trans = [0, 1, 3]
+        # rotations: [rx, ry, rz] sitzen auf [5,4,2]
+        rot = [5, 4, 2]
+
+        Ti[np.ix_(trans, trans)] = R
+        Ti[np.ix_(rot, rot)] = R
+
+        # In 14x14 einbauen (Knoten a: 0..6, Knoten b: 7..13)
+        T[0:6, 0:6] = Ti
+        T[7:13, 7:13] = Ti
 
         # Warping
-
         T[6, 6] = 1.0
         T[13, 13] = 1.0
 
+        # Debug-Sanity
+        if not np.isfinite(T).all():
+            print("TM NaN/Inf:", posI, posJ)
+            print(T)
+            raise ValueError("TM enthält NaN/Inf")
+
         return T
 
-    def insert_elements(self, S, E, G, A, I_y, I_z, I_omega, I_T, cv, z1, cw, z2, c_thet, l):
+    def insert_elements(
+        self, S, E, G, A, I_y, I_z, I_omega, I_T, cv, z1, cw, z2, c_thet, l
+    ):
         """
         Element-Stiffness-Matrix:
         Na
@@ -133,6 +107,7 @@ class ElemStema:
         Mxb
         Mwb
         """
+        self.Ke[:, :] = 0.0
         self.S = S  # Stiffness of shear field
 
         self.E = E  # Material stiffness of the beam
@@ -158,41 +133,86 @@ class ElemStema:
         self.Ke[0, 7] = self.Ke[7, 0] = -self.E * self.A / self.l
 
         self.Ke[1, 1] = self.Ke[8, 8] = (
-            12 * self.E * self.I_z / self.l**3 + 13 / 35 * self.cv * self.l + 1.2 * self.S / self.l
+            12 * self.E * self.I_z / self.l**3
+            + 13 / 35 * self.cv * self.l
+            + 1.2 * self.S / self.l
+        )
+        self.Ke[1, 2] = (
+            6 * self.E * self.I_z / self.l**2
+            + 11 / 210 * self.cv * self.l**2
+            + 0.1 * self.S
         )
-        self.Ke[1, 2] = 6 * self.E * self.I_z / self.l**2   + 11 / 210 * self.cv * self.l**2 + 0.1 * self.S
 
-        self.Ke[1, 5] = 13 / 35 * self.cv * self.l * self.z1 - 1.2 * self.S / self.l * self.z2
-        self.Ke[1, 6] = -11 / 210 * self.cv * self.l**2 * self.z1 + 0.1 * self.S * self.z2
+        self.Ke[1, 5] = (
+            13 / 35 * self.cv * self.l * self.z1 - 1.2 * self.S / self.l * self.z2
+        )
+        self.Ke[1, 6] = (
+            -11 / 210 * self.cv * self.l**2 * self.z1 + 0.1 * self.S * self.z2
+        )
 
-        self.Ke[1, 8] = -12 * self.E * self.I_z / self.l**3 + 9 / 70 * self.cv * self.l - 1.2 * self.S / self.l
-        self.Ke[1, 9] = 6 * self.E * self.I_z / self.l**2 - 13 / 420 * self.cv * self.l**2 + 0.1 * self.S
+        self.Ke[1, 8] = (
+            -12 * self.E * self.I_z / self.l**3
+            + 9 / 70 * self.cv * self.l
+            - 1.2 * self.S / self.l
+        )
+        self.Ke[1, 9] = (
+            6 * self.E * self.I_z / self.l**2
+            - 13 / 420 * self.cv * self.l**2
+            + 0.1 * self.S
+        )
 
-        self.Ke[1, 12] = 9 / 70 * self.cv * self.l * self.z1 + 1.2 * self.S / self.l * self.z2
+        self.Ke[1, 12] = (
+            9 / 70 * self.cv * self.l * self.z1 + 1.2 * self.S / self.l * self.z2
+        )
         self.Ke[1, 13] = 13 / 420 * self.cv * self.l**2 * z1 + 0.1 * self.S * self.z2
 
-        self.Ke[2, 2] = 4 * self.E * self.I_z / self.l + 1 / 105 * self.cv * self.l**3 + 2 / 15 * self.S * self.l
+        self.Ke[2, 2] = (
+            4 * self.E * self.I_z / self.l
+            + 1 / 105 * self.cv * self.l**3
+            + 2 / 15 * self.S * self.l
+        )
         self.Ke[9, 9] = self.Ke[2, 2]
 
         self.Ke[2, 5] = 11 / 210 * self.cv * l**2 * self.z1 - 0.1 * self.S * self.z2
-        self.Ke[2, 6] = -1 / 105 * self.cv * self.l**3 * self.z1 + 2 / 15 * self.S * self.l * self.z2
-        self.Ke[2, 8] = -6 * self.E * self.I_z / self.l**2 + 13 / 420 * self.cv * l**2 - 0.1 * self.S
+        self.Ke[2, 6] = (
+            -1 / 105 * self.cv * self.l**3 * self.z1
+            + 2 / 15 * self.S * self.l * self.z2
+        )
+        self.Ke[2, 8] = (
+            -6 * self.E * self.I_z / self.l**2
+            + 13 / 420 * self.cv * l**2
+            - 0.1 * self.S
+        )
 
-        self.Ke[2, 9] = 2 * self.E * self.I_z / self.l - 1 / 140 * self.cv * self.l**3 - 1 / 30 * self.S * self.l
-        self.Ke[2, 12] = 13 / 420 * self.cv * self.l**2 * self.z1 + 0.1 * self.S * self.z2
-        self.Ke[2, 13] = 1 / 140 * self.cv * self.l**3 * self.z1 - 1 / 30 * self.S * self.l * self.z2
+        self.Ke[2, 9] = (
+            2 * self.E * self.I_z / self.l
+            - 1 / 140 * self.cv * self.l**3
+            - 1 / 30 * self.S * self.l
+        )
+        self.Ke[2, 12] = (
+            13 / 420 * self.cv * self.l**2 * self.z1 + 0.1 * self.S * self.z2
+        )
+        self.Ke[2, 13] = (
+            1 / 140 * self.cv * self.l**3 * self.z1 - 1 / 30 * self.S * self.l * self.z2
+        )
 
         self.Ke[3, 3] = 12 * self.E * self.I_y / self.l**3 + 13 / 35 * self.cw * self.l
         self.Ke[10, 10] = self.Ke[3, 3]
 
-        self.Ke[3, 4] = -6 * self.E * self.I_y / self.l**2 - 11 / 210 * self.cw * self.l**2
+        self.Ke[3, 4] = (
+            -6 * self.E * self.I_y / self.l**2 - 11 / 210 * self.cw * self.l**2
+        )
         self.Ke[3, 10] = -12 * self.E * self.I_y / self.l**3 + 9 / 70 * self.cw * self.l
-        self.Ke[3, 11] = -6 * self.E * self.I_y / self.l**2 + 13 / 420 * self.cw * self.l**2
+        self.Ke[3, 11] = (
+            -6 * self.E * self.I_y / self.l**2 + 13 / 420 * self.cw * self.l**2
+        )
 
         self.Ke[4, 4] = 4 * self.E * self.I_y / self.l + 1 / 105 * self.cw * self.l**3
         self.Ke[11, 11] = self.Ke[4, 4]
 
-        self.Ke[4, 10] = 6 * self.E * self.I_y / self.l**2 - 13 / 420 * self.cw * self.l**2
+        self.Ke[4, 10] = (
+            6 * self.E * self.I_y / self.l**2 - 13 / 420 * self.cw * self.l**2
+        )
         self.Ke[4, 11] = 2 * self.E * self.I_y / self.l - 1 / 140 * self.cw * self.l**3
 
         self.Ke[5, 5] = self.Ke[12, 12] = (
@@ -233,8 +253,12 @@ class ElemStema:
             + 2 / 15 * self.S * self.l * self.z2**2
         )
 
-        self.Ke[6, 8] = -13 / 420 * self.cv * self.l**2 * self.z1 - 0.1 * self.S * self.z2
-        self.Ke[6, 9] = 1 / 140 * self.cv * self.l**3 * self.z1 - 1 / 30 * self.S * self.l * self.z2
+        self.Ke[6, 8] = (
+            -13 / 420 * self.cv * self.l**2 * self.z1 - 0.1 * self.S * self.z2
+        )
+        self.Ke[6, 9] = (
+            1 / 140 * self.cv * self.l**3 * self.z1 - 1 / 30 * self.S * self.l * self.z2
+        )
         self.Ke[6, 12] = (
             6 * self.E * self.I_omega / self.l**2
             + 0.1 * self.G * self.I_T
@@ -249,11 +273,23 @@ class ElemStema:
             - 1 / 140 * self.cv * l**3 * self.z1**2
             - 1 / 30 * self.S * self.l * self.z2**2
         )
-        self.Ke[8, 9] = -6 * self.E * self.I_z / self.l**2 - 11 / 210 * self.cv * self.l**2 - 0.1 * self.S
-        self.Ke[8, 12] = 13 / 35 * self.cv * self.l * self.z1 - 1.2 * self.S / self.l * self.z2
-        self.Ke[8, 13] = 11 / 210 * self.cv * self.l**2 * self.z1 - 0.1 * self.S * self.z2
-        self.Ke[9, 12] = -11 / 210 * self.cv * self.l**2 * self.z1 + 0.1 * self.S * self.z2
-        self.Ke[9, 13] = -1 / 105 * self.cv * self.l**3 * z1 + 2 / 15 * self.S * self.l * self.z2
+        self.Ke[8, 9] = (
+            -6 * self.E * self.I_z / self.l**2
+            - 11 / 210 * self.cv * self.l**2
+            - 0.1 * self.S
+        )
+        self.Ke[8, 12] = (
+            13 / 35 * self.cv * self.l * self.z1 - 1.2 * self.S / self.l * self.z2
+        )
+        self.Ke[8, 13] = (
+            11 / 210 * self.cv * self.l**2 * self.z1 - 0.1 * self.S * self.z2
+        )
+        self.Ke[9, 12] = (
+            -11 / 210 * self.cv * self.l**2 * self.z1 + 0.1 * self.S * self.z2
+        )
+        self.Ke[9, 13] = (
+            -1 / 105 * self.cv * self.l**3 * z1 + 2 / 15 * self.S * self.l * self.z2
+        )
         self.Ke[10, 11] = 6 * E * I_y / l**2 + 11 / 210 * cw * l**2
         self.Ke[12, 13] = (
             6 * E * I_omega / l**2
@@ -273,3 +309,188 @@ class ElemStema:
 
     def print_elem_matrix(self):
         sp.pprint(self.Ke)
+
+    def Kg_theory_II_order(
+        self, L, N, My_a, My_b, Mz_a, Mz_b, Mr, qy, qz, yq, zq, yM, zM
+    ):
+        """
+        Geometrische Steifigkeitsmatrix K_g (14x14) für Theorie II. Ordnung
+        inkl. Biegedrillknicken (Vlasov-Element mit Warping), gemäß deiner Belegung.
+
+        DOF-Reihenfolge (1..14) wie in deinem Element:
+          1: Na
+          2: Vya
+          3: Mza
+          4: Vza
+          5: Mya
+          6: Mxa
+          7: Mwa
+          8: Nb
+          9: Vyb
+         10: Mzb
+         11: Vzb
+         12: Myb
+         13: Mxb
+         14: Mwb
+        """
+        Kg = np.zeros((14, 14), dtype=float)
+
+        mq = qy * (yq - yM) + qz * (zq - zM)
+
+        def setg(i, j, val):
+            # i,j in 1-based
+            Kg[i - 1, j - 1] = val
+            Kg[j - 1, i - 1] = val  # Symmetrie
+
+        # --- Einträge gemäß Screenshot ---
+        for i, j in [(2, 2), (4, 4), (9, 9), (11, 11)]:
+            setg(i, j, 1.2 * N / L)
+
+        for i, j in [(2, 3), (2, 10), (5, 11), (11, 12)]:
+            setg(i, j, 0.1 * N)
+
+        setg(
+            2,
+            6,
+            -1.1 * My_a / L - 0.1 * My_b / L - qz * L * (9 / 140) + 1.2 * (zM / L) * N,
+        )
+        setg(2, 7, 0.1 * My_a + qz * (L**2) / 140 - 0.1 * zM * N)
+        setg(2, 9, -1.2 * N / L)
+        setg(4, 11, -1.2 * N / L)
+        setg(
+            2,
+            13,
+            0.1 * My_a / L + 1.1 * My_b / L + qz * L * (9 / 140) - 1.2 * (zM / L) * N,
+        )
+        setg(2, 14, 0.1 * My_b + qz * (L**2) / 140 + 0.1 * zM * N)
+
+        for i, j in [(3, 3), (5, 5), (10, 10), (12, 12)]:
+            setg(i, j, (2 / 15) * N * L)
+
+        setg(3, 6, -0.9 * My_a - 0.2 * My_b - qz * (L**2) * (31 / 420) + 0.1 * zM * N)
+        setg(3, 7, 0.1 * My_a + (1 / 30) * My_b + qz * (L**2) / 84 - (2 / 15) * zM * N)
+
+        for i, j in [(3, 9), (4, 5), (4, 12), (9, 10)]:
+            setg(i, j, -0.1 * N)
+
+        for i, j in [(3, 10), (5, 12)]:
+            setg(i, j, -(1 / 30) * N * L)
+
+        setg(3, 13, -0.1 * My_a + 0.2 * My_b - qz * (L**2) / 105 + 0.1 * zM * N)
+        setg(3, 14, -(1 / 30) * My_a * L - qz * (L**2) / 210 + (1 / 30) * L * zM * N)
+
+        setg(4, 6, -1.1 * Mz_a / L - 0.1 * Mz_b / L - 1.2 * (yM / L) * N)
+        setg(4, 7, 0.1 * Mz_a + 0.1 * yM * N)
+        setg(4, 13, 0.1 * Mz_a / L + 1.1 * Mz_b / L + 1.2 * (yM / L) * N)
+        setg(4, 14, 0.1 * Mz_b + 0.1 * yM * N)
+
+        setg(5, 6, 0.9 * Mz_a + 0.2 * Mz_b + 0.1 * yM * N)
+        setg(5, 7, -0.1 * Mz_a * L - (1 / 30) * Mz_b * L - (2 / 15) * L * yM * N)
+        setg(5, 13, 0.1 * Mz_a - 0.2 * Mz_b - 0.1 * yM * N)
+        setg(5, 14, (1 / 30) * Mz_a * L + (1 / 30) * L * yM * N)
+
+        setg(6, 6, 1.2 * Mr / L + mq * (13 / 35) * L)
+        setg(13, 13, 1.2 * Mr / L + mq * (13 / 35) * L)
+
+        setg(6, 7, -0.1 * Mr - mq * (11 / 210) * (L**2))
+        setg(
+            6,
+            9,
+            1.1 * My_a / L + 0.1 * My_b / L + qz * L * (9 / 140) - 1.2 * (zM / L) * N,
+        )
+        setg(6, 10, -0.2 * My_a + 0.1 * My_b + qz * (L**2) / 105 + 0.1 * zM * N)
+        setg(6, 11, 1.1 * Mz_a / L + 0.1 * Mz_b / L + 1.2 * (yM / L) * N)
+        setg(6, 12, 0.2 * Mz_a - 0.1 * Mz_b + 0.1 * yM * N)
+        setg(6, 13, -1.2 * Mr / L - mq * L * (9 / 70))
+        setg(6, 14, -0.1 * Mr + mq * (13 / 420) * (L**2))
+
+        setg(7, 7, (L / 7.5) * Mr + mq * (L**3) / 105)
+        setg(14, 14, (L / 7.5) * Mr + mq * (L**3) / 105)
+
+        setg(7, 9, -0.1 * My_a - qz * (L**2) / 140 + 0.1 * zM * N)
+        setg(7, 10, -(1 / 30) * My_a * L - qz * (L**2) / 210 + (1 / 30) * L * zM * N)
+        setg(7, 11, -0.1 * Mz_a - 0.1 * yM * N)
+        setg(7, 12, (1 / 30) * Mz_b * L + (1 / 30) * L * yM * N)
+        setg(7, 13, 0.1 * Mr - mq * (13 / 420) * (L**2))
+        setg(7, 14, -(1 / 30) * Mr * L - mq * (L**3) / 140)
+
+        setg(
+            9,
+            13,
+            -0.1 * My_a / L - 1.1 * My_b / L - qz * L * (9 / 140) + 1.2 * (zM / L) * N,
+        )
+        setg(9, 14, -0.1 * My_b - qz * (L**2) / 140 + 0.1 * zM * N)
+
+        setg(10, 13, 0.2 * My_a - 0.9 * My_b + qz * (L**2) * (31 / 420) - 0.1 * zM * N)
+        setg(
+            10,
+            14,
+            (1 / 30) * My_a * L
+            + 0.1 * My_b * L
+            + qz * (L**2) / 84
+            - (2 / 15) * L * zM * N,
+        )
+
+        setg(11, 13, -0.1 * Mz_a / L - 1.1 * Mz_b / L - 1.2 * (yM / L) * N)
+        setg(11, 14, -0.1 * Mz_b - 0.1 * yM * N)
+
+        setg(12, 13, -0.2 * Mz_a - 0.9 * Mz_b - 0.1 * yM * N)
+        setg(12, 14, -(1 / 30) * Mz_a * L - 0.1 * Mz_b * L - (2 / 15) * L * yM * N)
+
+        setg(13, 14, 0.1 * Mr + mq * (11 / 210) * (L**2))
+
+        return Kg
+
+    def element_stiffness_theory_II(
+        self,
+        # Material-/Elementparameter für Ke:
+        S,
+        E,
+        G,
+        A,
+        I_y,
+        I_z,
+        I_omega,
+        I_T,
+        cv,
+        z1,
+        cw,
+        z2,
+        c_thet,
+        l,
+        # Schnittgrößen/Lasten für Kg:
+        N,
+        My_a,
+        My_b,
+        Mz_a,
+        Mz_b,
+        Mr,
+        qy,
+        qz,
+        yq,
+        zq,
+        yM,
+        zM,
+    ):
+        """
+        Liefert K_total = Ke + Kg (lokal).
+        """
+        Ke = self.insert_elements(
+            S, E, G, A, I_y, I_z, I_omega, I_T, cv, z1, cw, z2, c_thet, l
+        )
+        Kg = self.Kg_theory_II_order(
+            L=l,
+            N=N,
+            My_a=My_a,
+            My_b=My_b,
+            Mz_a=Mz_a,
+            Mz_b=Mz_b,
+            Mr=Mr,
+            qy=qy,
+            qz=qz,
+            yq=yq,
+            zq=zq,
+            yM=yM,
+            zM=zM,
+        )
+        return Ke + Kg, Ke, Kg

KIB_LAP/STABRAUM/main.py

@@ -0,0 +1,58 @@
+from Programm import mainloop
+from Plotting import StructurePlotter
+from Output_Data import OutputData
+import matplotlib
+
+matplotlib.use("TkAgg")
+import matplotlib.pyplot as plt
+
+
+if __name__ == "__main__":
+    calc = mainloop()
+    res = calc.run()
+
+    plotter = StructurePlotter(res)
+    Output = OutputData()
+
+    calc.check_global_equilibrium()
+
+    # print(type(res), hasattr(res, "Inp"), hasattr(res, "GesMat"), hasattr(res, "u_ges"), hasattr(res, "FGes"))
+
+    # res = calc.run()
+
+    out = OutputData()
+    df = out.support_reactions_from_springs_table(res)
+    print(df)
+
+    calc.sum_reactions_fx()
+    calc.sum_spring_reactions_fx()
+
+    # plotter.plot_support_reactions_2d_interactive()
+    # plt.show()
+
+    # plotter.plot_nodal_loads_2d_interactive()
+
+    # plt.show()
+
+    fig, ax, s = plotter.plot_endforces_2d_interactive(
+        kind="MY", scale_init=0.2, node_labels=True, elem_labels=True
+    )
+
+    plt.show()
+
+    # fig, ax, s = plotter.plot_endforces_2d_interactive(kind="N", scale_init=0.2, node_labels=True, elem_labels=True)
+
+    # plt.show()
+
+    # fig, ax, s = plotter.plot_endforces_2d_interactive(kind="VZ", scale_init=0.2, node_labels=True, elem_labels=True)
+
+    # plt.show()
+
+    plotter.plot_diagram_3d_interactive(kind="MY", scale_init=0.2,springs_size_frac=0.01,springs_rot_radius_frac=0.01)
+    plt.show()
+
+    plotter.plot_diagram_3d_interactive(kind="N", scale_init=0.2,springs_size_frac=0.01,springs_rot_radius_frac=0.01)
+    plt.show()
+
+    plotter.plot_diagram_3d_interactive(kind="VZ", scale_init=0.2,springs_size_frac=0.01,springs_rot_radius_frac=0.01)
+    plt.show()

KIB_LAP/STABRAUM/results.py

@@ -0,0 +1,37 @@
+# results.py
+from dataclasses import dataclass
+import numpy as np
+from typing import Any
+
+
+@dataclass
+class AnalysisResults:
+    """
+    Reiner Datencontainer für Analyse-Ergebnisse.
+    KEINE Berechnungen, KEIN Plotting.
+    """
+
+    # Input (Geometrie, Materialien, Knoten, Stäbe)
+    Inp: Any
+
+    # Globale Ergebnisse
+    u_ges: np.ndarray
+    GesMat: np.ndarray
+    FGes: np.ndarray
+
+    # Elementweise Matrizen
+    TransMats: np.ndarray
+    K_el_i_store: np.ndarray
+    u_el: np.ndarray
+    s_el: np.ndarray
+
+    # Schnittgrößen an den Elementenden
+    N_el_i_store: np.ndarray
+    VY_el_i_store: np.ndarray
+    VZ_el_i_store: np.ndarray
+    MX_el_i_store: np.ndarray
+    MY_el_i_store: np.ndarray
+    MZ_el_i_store: np.ndarray
+
+    # Zusatzinfos
+    member_length: np.ndarray