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

KIB_LAP/STABRAUM/Programm.py

@@ -1,5 +1,14 @@
-from Steifigkeitsmatrix import *
-from InputData import Input
+# STABRAUM-Dependencies
+try:
+    from Steifigkeitsmatrix import *
+    from InputData import Input
+    from results import AnalysisResults
+except:
+    from KIB_LAP.STABRAUM.Steifigkeitsmatrix import *
+    from KIB_LAP.STABRAUM.InputData import Input
+    from KIB_LAP.STABRAUM.results import AnalysisResults
+
+
 import sympy as sp
 
 import matplotlib.pyplot as plt
@@ -10,6 +19,7 @@ import matplotlib.patches as mpatches
 from matplotlib.widgets import Slider
 from mpl_toolkits.mplot3d.art3d import Line3DCollection
 
+
 def _set_axes_equal(ax, extra: float = 0.0):
     """
     Erzwingt identische numerische Achsenlimits.
@@ -64,8 +74,96 @@ class mainloop:
         self.MTS_el_i_store = np.zeros((len(self.Inp.members), 2, 1))
         self.N_el_i_store = np.zeros((len(self.Inp.members), 2, 1))
 
-        ##_____ Class Functions____________##
-        self.MainConvergence()
+    # ------------------------------------------------------------
+    # DEBUG / SINGULARITÄTSTEST
+    # ------------------------------------------------------------
+    def check_singularity(self, K=None, tol_row=1e-10, tol_rank=1e-8, verbose=True):
+        """
+        Prüft typische Ursachen für Singularität:
+        - Rank-Defizit
+        - Nullzeilen/Nullspalten (DOFs ohne Steifigkeit)
+        - isolierte Knoten (nicht in members)
+        - 0-Längen-Elemente
+        Gibt ein Dict mit Diagnosen zurück.
+        """
+        if K is None:
+            K = self.GesMat
+
+        info = {}
+
+        # -------- Rank --------
+        try:
+            r = np.linalg.matrix_rank(K, tol=tol_rank)
+        except TypeError:
+            # falls numpy Version keine tol als kw hat
+            r = np.linalg.matrix_rank(K)
+        n = K.shape[0]
+        info["rank"] = int(r)
+        info["n"] = int(n)
+        info["deficit"] = int(n - r)
+
+        # -------- Nullzeilen/Nullspalten --------
+        row_norm = np.linalg.norm(K, axis=1)
+        col_norm = np.linalg.norm(K, axis=0)
+        zero_rows = np.where(row_norm < tol_row)[0]
+        zero_cols = np.where(col_norm < tol_row)[0]
+
+        info["zero_rows"] = zero_rows.tolist()
+        info["zero_cols"] = zero_cols.tolist()
+
+        # -------- DOF Mapping (nur wenn 7 dof/node) --------
+        def gdof_to_node_ldof(gdof):
+            return int(gdof // 7 + 1), int(gdof % 7)
+
+        info["zero_rows_nodes"] = [gdof_to_node_ldof(i) for i in zero_rows]
+        info["zero_cols_nodes"] = [gdof_to_node_ldof(i) for i in zero_cols]
+
+        # -------- isolierte Knoten --------
+        try:
+            na = list(self.Inp.members["na"])
+            ne = list(self.Inp.members["ne"])
+            used = set(na) | set(ne)
+            all_nodes = set(range(1, len(self.Inp.nodes["x[m]"]) + 1))
+            isolated = sorted(all_nodes - used)
+        except Exception:
+            isolated = []
+        info["isolated_nodes"] = isolated
+
+        # -------- 0-Längen-Elemente --------
+        zero_len_elems = []
+        try:
+            for eidx, (a, e) in enumerate(
+                zip(self.Inp.members["na"], self.Inp.members["ne"]), start=1
+            ):
+                xa = self.Inp.nodes["x[m]"][a - 1]
+                ya = self.Inp.nodes["y[m]"][a - 1]
+                za = self.Inp.nodes["z[m]"][a - 1]
+                xb = self.Inp.nodes["x[m]"][e - 1]
+                yb = self.Inp.nodes["y[m]"][e - 1]
+                zb = self.Inp.nodes["z[m]"][e - 1]
+                L = float(np.sqrt((xa - xb) ** 2 + (ya - yb) ** 2 + (za - zb) ** 2))
+                if L < 1e-12:
+                    zero_len_elems.append((eidx, int(a), int(e)))
+        except Exception:
+            pass
+        info["zero_length_elements"] = zero_len_elems
+
+        # -------- Ausgabe --------
+        if verbose:
+            print("\n=== Singularity check ===")
+            print(f"size n = {n}, rank = {r}, deficit = {n-r}")
+            print(f"zero rows: {len(zero_rows)}, zero cols: {len(zero_cols)}")
+            if len(zero_rows) > 0:
+                print("first zero rows (gdof -> node,ldof):")
+                for gdof in zero_rows[:30]:
+                    node, ldof = gdof_to_node_ldof(gdof)
+                    print(f"  gdof {gdof:4d} -> node {node}, ldof {ldof}")
+            if len(isolated) > 0:
+                print("isolated nodes:", isolated)
+            if len(zero_len_elems) > 0:
+                print("zero-length elements (eid, na, ne):", zero_len_elems)
+
+        return info
 
     def CalculateTransMat(self):
         print("Calculate Transmatrices")
@@ -185,7 +283,7 @@ class mainloop:
             )
 
             K_el_i = np.matmul(
-                self.TransMats[i].T, np.matmul(K_el_i, self.TransMats[i])
+                self.TransMats[i], np.matmul(K_el_i, self.TransMats[i].T)
             )
 
             self.K_el_i_store[i] = K_el_i
@@ -236,174 +334,124 @@ class mainloop:
 
     def LocalLoadVectorLine(self):
         """
-        This function calculates the local loadvectors for each element \n
-        and transforms them into the global coordinate system. \n
-        Each local force vector is stored in a separate local force vector, \n
-        which is taken into account, when the inner forces are calculated afterwards \n
-        Members of the local load vector are: \n
-            - Temperature loading  \n
-            - Member forces \n
+        Lokale Festendkräfte aus Linienlasten (lokales System!).
+        Speichert in self.S_loc_elem_line und gibt dieses Array zurück.
         """
-        self.S_loc_elem_line = np.zeros((14, len(self.Inp.members)))
-        S_glob_elem = np.zeros((14, len(self.Inp.members)))
-
-        # Element Loading (line loads, single loads)
+        n_elem = len(self.Inp.members["na"])
+        self.S_loc_elem_line = np.zeros((14, n_elem), dtype=float)
 
         res_mbr = self.Inp.ElementLoads["Member"]
         res_line_a = self.Inp.ElementLoads["qza"]
-        res_line_b = self.Inp.ElementLoads["qze"]
-
-        for i in range(0, len(res_mbr)):
-            j = int(res_mbr[i] - 1)
-            print("JJJ")
-            print(j)
-            print(res_mbr)
-            TransMatj = self.TransMats[j]
-
-            self.S_loc_elem_line[3, j] = (
-                +res_line_a[i] * self.member_length[j] / 2
-            )  # VZ
-            self.S_loc_elem_line[10, j] = +res_line_a[i] * self.member_length[j] / 2
-
-            self.S_loc_elem_line[4, j] = (
-                -res_line_a[i] * self.member_length[j] ** 2 / 12
-            )  # MY
-            self.S_loc_elem_line[11, j] = (
-                +res_line_a[i] * self.member_length[j] ** 2 / 12
-            )
+        res_line_b = self.Inp.ElementLoads["qze"]  # aktuell nicht benutzt
 
-            S_loc = self.S_loc_elem_line[:, j]
+        for k in range(len(res_mbr)):
+            e = int(res_mbr[k] - 1)
 
-            # global line loadings
+            L = float(self.member_length[e])
+            q = float(res_line_a[k])  # TODO: falls qza != qze -> konsistente Formeln
 
-            S_glob_elem[:, j] = np.matmul(np.transpose(TransMatj), S_loc)
+            # Lokale Festendkräfte (deine Konvention beibehalten)
+            # Vz
+            self.S_loc_elem_line[3, e] += +q * L / 2.0
+            self.S_loc_elem_line[10, e] += +q * L / 2.0
 
-        return S_glob_elem
+            # My
+            self.S_loc_elem_line[4, e] += -q * L**2 / 12.0
+            self.S_loc_elem_line[11, e] += +q * L**2 / 12.0
+
+        return self.S_loc_elem_line
 
     def LocalLoadVectorTemp(self):
         """
-        This function calculates the local loadvectors for each element \n
-        and transforms them into the global coordinate system. \n
-        Each local force vector is stored in a separate local force vector, \n
-        which is taken into account, when the inner forces are calculated afterwards \n
-        Members of the local load vector are: \n
-            - Temperature loading  \n
-            - Member forces \n
+        Lokale Festendkräfte aus Temperatur (lokales System!).
+        Speichert in self.S_loc_elem_temp und gibt dieses Array zurück.
         """
-        self.S_loc_elem_temp = np.zeros((14, len(self.Inp.members)))
-        S_glob_elem = np.zeros((14, len(self.Inp.members)))
-
-        # Temperature Loading
+        n_elem = len(self.Inp.members["na"])
+        self.S_loc_elem_temp = np.zeros((14, n_elem), dtype=float)
 
         res_mbr = self.Inp.TemperatureForces["Member"]
-
         res_tem_dT = self.Inp.TemperatureForces["dT[K]"]
         res_tem_dTz = self.Inp.TemperatureForces["dTz[K]"]
         res_tem_dTy = self.Inp.TemperatureForces["dTy[K]"]
 
-        for i in range(0, len(res_mbr)):
-            j = int(res_mbr[i] - 1)
-            TransMatj = self.TransMats[j]
-            # Local temperature loadings
-            self.S_loc_elem_temp[0, j] = (
-                -self.ElemStem.E * self.ElemStem.A * 1e-5 * res_tem_dT[i]
-            )  # N
-            self.S_loc_elem_temp[7, j] = (
-                +self.ElemStem.E * self.ElemStem.A * 1e-5 * res_tem_dT[i]
-            )
+        for k in range(len(res_mbr)):
+            e = int(res_mbr[k] - 1)
 
-            self.S_loc_elem_temp[2, j] = (
-                -self.ElemStem.E * self.ElemStem.I_z * 1e-5 * res_tem_dTy[i]
-            )  # MZ
-            self.S_loc_elem_temp[9, j] = (
-                +self.ElemStem.E * self.ElemStem.I_z * 1e-5 * res_tem_dTy[i]
-            )
+            EA = self.ElemStem.E * self.ElemStem.A
+            EIz = self.ElemStem.E * self.ElemStem.I_z
+            EIy = self.ElemStem.E * self.ElemStem.I_y
 
-            self.S_loc_elem_temp[4, j] = (
-                -self.ElemStem.E * self.ElemStem.I_y * 1e-5 * res_tem_dTz[i]
-            )  # MY
-            self.S_loc_elem_temp[11, j] = (
-                +self.ElemStem.E * self.ElemStem.I_y * 1e-5 * res_tem_dTz[i]
-            )
+            dT = float(res_tem_dT[k])
+            dTz = float(res_tem_dTz[k])
+            dTy = float(res_tem_dTy[k])
 
-            S_loc = self.S_loc_elem_temp[:, j]
+            # N
+            self.S_loc_elem_temp[0, e] += -EA * 1e-5 * dT
+            self.S_loc_elem_temp[7, e] += +EA * 1e-5 * dT
 
-            # global temperature loadings
+            # Mz
+            self.S_loc_elem_temp[2, e] += -EIz * 1e-5 * dTy
+            self.S_loc_elem_temp[9, e] += +EIz * 1e-5 * dTy
 
-            S_glob_elem[:, j] = np.matmul(np.transpose(TransMatj), S_loc)
+            # My
+            self.S_loc_elem_temp[4, e] += -EIy * 1e-5 * dTz
+            self.S_loc_elem_temp[11, e] += +EIy * 1e-5 * dTz
 
-        return S_glob_elem
+        return self.S_loc_elem_temp
 
     def GlobalLoadVector(self):
-        F_loc_temp = self.LocalLoadVectorTemp()
-        F_loc_line = self.LocalLoadVectorLine()
-
-        print("Local element temp")
-        print(F_loc_temp)
-
-        print("Local element line")
-        print(F_loc_line)
+        """
+        Globaler Lastvektor:
+        - Element-Festendkräfte (Temp + Linienlast) lokal -> global via T
+        - Knotenlasten (global) addieren
+        """
+        # erzeugt/updated self.S_loc_elem_temp / self.S_loc_elem_line
+        self.LocalLoadVectorTemp()
+        self.LocalLoadVectorLine()
 
-        F_glob = np.zeros(self.Inp.nDoF)
+        n_elem = len(self.Inp.members["na"])
+        F_glob = np.zeros(self.Inp.nDoF, dtype=float)
 
         na_memb = self.Inp.members["na"]
         ne_memb = self.Inp.members["ne"]
 
-        # Input of Member Forces
-        for i in range(0, len(self.Inp.members)):
-            node_i = na_memb[i]
-            node_j = ne_memb[i]
+        for e in range(n_elem):
+            node_i = int(na_memb[e])
+            node_j = int(ne_memb[e])
 
-            dof_Na = 7 * (node_i - 1)
-            dof_Ne = 7 * (node_j - 1)
+            base_i = 7 * (node_i - 1)
+            base_j = 7 * (node_j - 1)
 
-            dof_Vya = 7 * (node_i - 1) + 1
-            dof_Vye = 7 * (node_j - 1) + 1
-
-            dof_Vza = 7 * (node_i - 1) + 3
-            dof_Vze = 7 * (node_j - 1) + 3
-
-            dof_Mza = 7 * (node_i - 1) + 2
-            dof_Mze = 7 * (node_j - 1) + 2
-
-            dof_Mya = 7 * (node_i - 1) + 2
-            dof_Mye = 7 * (node_j - 1) + 2
-
-            F_glob[dof_Na] += F_loc_temp[0, i] + F_loc_line[0, i]
-            F_glob[dof_Ne] += F_loc_temp[7, i] + F_loc_line[7, i]
-
-            F_glob[dof_Vya] += F_loc_temp[1, i]
-            F_glob[dof_Vye] += F_loc_temp[8, i]
-
-            F_glob[dof_Vza] += F_loc_temp[3, i] + F_loc_line[3, i]
-            F_glob[dof_Vze] += F_loc_temp[10, i] + F_loc_line[10, i]
+            F_e_loc = (self.S_loc_elem_temp[:, e] + self.S_loc_elem_line[:, e]).reshape(
+                14, 1
+            )
 
-            F_glob[dof_Mza] += F_loc_temp[2, i]
-            F_glob[dof_Mze] += F_loc_temp[9, i]
+            T = self.TransMats[e]  # local -> global
+            F_e_glob = (T @ F_e_loc).ravel()  # (14,)
 
-            F_glob[dof_Mya] += F_loc_temp[4, i] + F_loc_line[4, i]
-            F_glob[dof_Mye] += F_loc_temp[11, i] + F_loc_line[11, i]
+            F_glob[base_i : base_i + 7] += F_e_glob[0:7]
+            F_glob[base_j : base_j + 7] += F_e_glob[7:14]
 
-        # Input of Nodal Forces
+        # Knotenlasten (global)
         res_nodes = self.Inp.NodalForces["Node"]
         res_dof = self.Inp.NodalForces["Dof"]
         res_forc = self.Inp.NodalForces["Value[MN/MNm]"]
 
-        for i in range(0, len(res_nodes)):
-            node_i = res_nodes[i]
-            glob_index = (node_i - 1) * 7
-
-            if res_dof[i] == "Fx" or res_dof[i] == "fx" or res_dof[i] == "FX":
-                glob_index += 0
-            elif res_dof[i] == "Fy" or res_dof[i] == "fy" or res_dof[i] == "FY":
-                glob_index += 1
-            elif res_dof[i] == "Fz" or res_dof[i] == "fz" or res_dof[i] == "FZ":
-                glob_index += 3
-
-            F_glob[glob_index] += res_forc[i]
+        for k in range(len(res_nodes)):
+            node = int(res_nodes[k])
+            base = 7 * (node - 1)
+            dof = str(res_dof[k]).strip().lower()
+
+            if dof == "fx":
+                idx = base + 0
+            elif dof == "fy":
+                idx = base + 1
+            elif dof == "fz":
+                idx = base + 3
+            else:
+                continue
 
-        print("Force vector ", F_glob)
-        print("Local force vectors ", self.S_loc_elem_temp)
+            F_glob[idx] += float(res_forc[k])
 
         return F_glob
 
@@ -431,973 +479,417 @@ class mainloop:
         return u_el
 
     def CalculateLocalInnerForces(self):
-        s_el = np.zeros([14, len(self.Inp.members["na"])])
-
-        for i in range(0, len(self.Inp.members["na"]), 1):
-            s_el[:, i] = np.matmul(self.K_el_i_store[i], self.u_el[:, i])
-            self.MZ_el_i_store[i] = np.array([s_el[2, i] * (-1), s_el[9, i]]).reshape(
-                2, 1
-            )  # Left is *(-1)
-            self.MY_el_i_store[i] = np.array([s_el[4, i] * (-1), s_el[11, i]]).reshape(
-                2, 1
-            )  # Left is *(-1)
-            self.MX_el_i_store[i] = np.array([s_el[5, i] * (-1), s_el[12, i]]).reshape(
-                2, 1
-            )  # Left is *(-1)
-
-            self.N_el_i_store[i] = np.array([s_el[0, i] * (-1), s_el[7, i]]).reshape(
-                2, 1
-            )  # Left is *(-1)
-            self.VY_el_i_store[i] = np.array([s_el[1, i] * (-1), s_el[8, i]]).reshape(
-                2, 1
-            )  # Left is *(-1)
-            self.VZ_el_i_store[i] = np.array([s_el[3, i] * (-1), s_el[10, i]]).reshape(
-                2, 1
-            )  # Left is *(-1)
-
-            # Explicit transformation in local coordinates
-
-            self.N_el_i_store[i] = (
-                self.N_el_i_store[i] * self.TransMats[i][0, 0]
-                + self.VY_el_i_store[i] * self.TransMats[i][0, 1]
-                + self.VZ_el_i_store[i] * self.TransMats[i][0, 3]
-                - np.array(
-                    [-self.S_loc_elem_temp[0, i], self.S_loc_elem_temp[7, i]]
-                ).reshape(
-                    2, 1
-                )  # Left is * (-1)
-                # - np.array([-self.S_loc_elem_line[0, i], self.S_loc_elem_line[7, i]]).reshape(2, 1)   # Left is * (-1)
-            )
-
-            self.MY_el_i_store[i] = (
-                self.MX_el_i_store[i] * self.TransMats[i][4, 5]
-                + self.MY_el_i_store[i] * self.TransMats[i][4, 4]
-                + self.MZ_el_i_store[i] * self.TransMats[i][4, 2]
-                - np.array(
-                    [-self.S_loc_elem_temp[4, i], self.S_loc_elem_temp[11, i]]
-                ).reshape(
-                    2, 1
-                )  # Left is * (-1)
-                # - np.array([-self.S_loc_elem_line[4, i], self.S_loc_elem_line[11, i]]).reshape(2, 1)   # Left is * (-1)
-            )
-
-        return s_el
-
-    def MainConvergence(self):
-
-        self.TransMats = self.CalculateTransMat()
-        self.GesMat = self.BuildStructureStiffnessMatrix()
-
-        self.RestraintData()
-
-        self.FGes = self.GlobalLoadVector()
-
-        self.u_ges = self.SolveDisplacement()
-
-        self.u_el = self.StoreLocalDisplacements()
-
-        self.s_el = self.CalculateLocalInnerForces()
-
-    def plot_structure_3d(self, nodes, na_memb, ne_memb):
         """
-        Plot the undeformed 3D structure.
+        Berechnet lokale Schnittgrößen an linkem und rechtem Schnittufer:
 
-        Parameters:
-        nodes: dict with keys ['x[m]', 'y[m]', 'z[m]']
-        na_memb, ne_memb: lists with node IDs for start and end of members
-        """
-        fig = plt.figure()
-        ax = fig.add_subplot(projection="3d")
-
-        # Plot all members
-        for i in range(len(na_memb)):
-            node_i = na_memb[i]
-            node_j = ne_memb[i]
-
-            ix = nodes["x[m]"][node_i - 1]
-            iy = nodes["y[m]"][node_i - 1]
-            iz = nodes["z[m]"][node_i - 1]
-
-            jx = nodes["x[m]"][node_j - 1]
-            jy = nodes["y[m]"][node_j - 1]
-            jz = nodes["z[m]"][node_j - 1]
+        - f_glob = K_el_global @ u_el_global  (wie bei dir gespeichert)
+        - f_loc  = T.T @ f_glob               (global -> local, da T local->global)
+        - f_eff  = f_loc - (f0_temp_loc + f0_line_loc)
 
-            X = [ix, jx]
-            Y = [iy, jy]
-            Z = [iz, jz]
+        Konvention:
+        - Linkes Schnittufer:   s_L = - f_I,loc
+        - Rechtes Schnittufer:  s_R = + f_J,loc
+        - Zug positiv
 
-            ax.plot(X, Y, Z, color="black", lw=1.0)
-
-        # Achsenbeschriftung und Titel
-        ax.set_xlabel("X [m]")
-        ax.set_ylabel("Y [m]")
-        ax.set_zlabel("Z [m]")
-        ax.set_title("Unverformte Struktur")
-
-        return fig, ax
-
-    def calculate_orthogonal_unit_vector_cross_product(self, xi, zi, xj, zj):
+        Ergebnis in self.*_el_i_store[i] jeweils als (2,1): [links; rechts]
         """
-        Berechnet einen normierten orthogonalen Vektor zur Strukturlinie von (xi, zi) nach (xj, zj)
-        mittels Kreuzprodukt.
 
-        Parameter:
-        - xi, zi: Koordinaten des Startknotens
-        - xj, zj: Koordinaten des Endknotens
+        n_elem = len(self.Inp.members["na"])
+        s_el = np.zeros((14, n_elem), dtype=float)
 
-        Rückgabe:
-        - unit_vector_pos: NumPy-Array des normierten orthogonalen Vektors für positives My
-        - unit_vector_neg: NumPy-Array des normierten orthogonalen Vektors für negatives My
-        """
-        # Richtungsvektor in 3D (y-Komponente ist 0)
-        v = np.array([xj - xi, 0, zj - zi])
+        # Hole (lokale) Festendkräfte. Falls du die Arrays noch nicht als Attribute speicherst,
+        # werden sie hier neu erzeugt.
+        F_loc_temp = self.LocalLoadVectorTemp()
+        F_loc_line = self.LocalLoadVectorLine()
 
-        # Einheitsvektor entlang der y-Achse
-        y_unit = np.array([0, 1, 0])
+        for e in range(n_elem):
 
-        # Kreuzprodukt berechnen
-        perp_vector = np.cross(v, y_unit)  # Ergebnis ist ebenfalls ein 3D-Vektor
+            # 1) Element-Endkräfte aus K*u (im Koordinatensystem von K_el_i_store & u_el)
+            f_glob = (self.K_el_i_store[e] @ self.u_el[:, e]).reshape(14, 1)
+            s_el[:, e] = f_glob.ravel()
 
-        # Extrahiere die x und z Komponenten
-        perp_vector_2d = perp_vector[[0, 2]]
+            # 2) global -> local
+            T = self.TransMats[e]  # local -> global
+            f_loc = T.T @ f_glob  # global -> local
 
-        # Normierung
-        norm = np.linalg.norm(perp_vector_2d)
-        if norm == 0:
-            raise ValueError(
-                "Die Strukturlinie hat keine Länge. Start- und Endknoten sind identisch."
-            )
+            # 3) lokale Festendkräfte (Temp + Linienlast)
+            f0_loc = (F_loc_temp[:, e] + F_loc_line[:, e]).reshape(14, 1)
 
-        unit_vector = perp_vector_2d / norm
+            # 4) wirksame lokale Endkräfte
+            f_eff = f_loc - f0_loc
 
-        # Für positives und negatives My
-        unit_vector_pos = unit_vector
-        unit_vector_neg = -unit_vector
+            # 5) Schnittufer-Abbildung: links = -f_I, rechts = +f_J
+            # Indizes laut Layout:
+            # [0] Na  [1] Vya [2] Mza [3] Vza [4] Mya [5] Mxa [6] Mwa
+            # [7] Nb  [8] Vyb [9] Mzb [10]Vzb [11]Myb [12]Mxb [13]Mwb
 
-        return unit_vector_pos, unit_vector_neg
+            N_L, N_R = -f_eff[0, 0], f_eff[7, 0]
+            Vy_L, Vy_R = -f_eff[1, 0], f_eff[8, 0]
+            Mz_L, Mz_R = -f_eff[2, 0], f_eff[9, 0]
+            Vz_L, Vz_R = -f_eff[3, 0], f_eff[10, 0]
+            My_L, My_R = -f_eff[4, 0], f_eff[11, 0]
+            Mx_L, Mx_R = -f_eff[5, 0], f_eff[12, 0]
 
-    def plot_moment_my_2d(self, ax, xi, zi, my_local, unit_vector, scale=1):
-        """
-        Plot eines Biegemoments My in 2D (x-z-Ebene) orthogonal zur Strukturlinie.
-
-        Parameter:
-        ax : matplotlib.axes.Axes
-            Die 2D-Achse zum Plotten
-        xi, zi : float
-            Startpunkt (globale Koordinaten in x und z)
-        my_local : float
-            Lokaler My-Wert
-        unit_vector : array-like, shape (2,)
-            Normalisierter orthogonaler Vektor für das Moment
-        scale : float, optional
-            Maßstabsfaktor für die Pfeillänge
-        """
-        if my_local == 0:
-            return  # Kein Moment zu plotten
-
-        # Kleine Verbindungslinie vom Knoten zum Start des Pfeils
-        connection_length = 0.05 * scale  # Anpassbarer Wert
-
-        conn_x = xi + connection_length * unit_vector[0] * my_local * scale
-        conn_z = zi + connection_length * unit_vector[1] * my_local * scale
-
-        if my_local >= 0:
-            ax.plot([xi, conn_x], [zi, conn_z], color="blue", linewidth=1)
-        if my_local < 0:
-            ax.plot([xi, conn_x], [zi, conn_z], color="red", linewidth=1)
-
-        # Berechnung des Vektors, skaliert durch Moment und Maßstabsfaktor
-        vec = scale * my_local * unit_vector
-
-        # Farbwahl basierend auf dem Vorzeichen des Moments
-        color = "blue" if my_local >= 0 else "red"
-
-        # Plotten des Pfeils
-        # ax.arrow(conn_x, conn_z, vec[0], vec[1],
-        #          head_width=0.05 * scale, head_length=0.1 * scale,
-        #          fc=color, ec=color, length_includes_head=True)
-
-        # Berechnung des Endpunkts für die Textplatzierung
-        x_end = conn_x
-        z_end = conn_z
-
-        # Moment-Text
-        moment_text = f"My = {my_local:.3f} MNm"
-
-        # Textversatz für bessere Sichtbarkeit
-        text_offset = 0  # 0.05 * scale
-        ax.text(
-            x_end + text_offset * unit_vector[0],
-            z_end + text_offset * unit_vector[1],
-            moment_text,
-            color=color,
-            fontsize=8,
-        )
+            self.N_el_i_store[e] = np.array([N_L, N_R]).reshape(2, 1)
+            self.VY_el_i_store[e] = np.array([Vy_L, Vy_R]).reshape(2, 1)
+            self.VZ_el_i_store[e] = np.array([Vz_L, Vz_R]).reshape(2, 1)
 
-        return conn_x, conn_z
+            self.MZ_el_i_store[e] = np.array([Mz_L, Mz_R]).reshape(2, 1)
+            self.MY_el_i_store[e] = np.array([My_L, My_R]).reshape(2, 1)
+            self.MX_el_i_store[e] = np.array([Mx_L, Mx_R]).reshape(2, 1)
 
-    def plot_all_My_2d(self, ax, nodes, na_memb, ne_memb, My_el_i_store, scale=0.4):
-        """
-        Plot My-Momente für alle Elemente an ihren Knoten in 2D (x-z-Ebene).
-
-        Parameter:
-        ax : matplotlib.axes.Axes
-            Die 2D-Achse zum Plotten
-        nodes : dict
-            Dictionary mit Knotenkordinaten
-        na_memb, ne_memb : Listen
-            Listen von Knotennummern für die Elemente
-        My_el_i_store : ndarray
-            Array von My-Werten pro Element und Knoten
-        scale : float, optional
-            Maßstabsfaktor für die Pfeile
-        """
-        for i in range(len(na_memb)):
-            node_i = na_memb[i]
-            node_j = ne_memb[i]
-
-            ix = nodes["x[m]"][node_i - 1]
-            iz = nodes["z[m]"][node_i - 1]
-
-            jx = nodes["x[m]"][node_j - 1]
-            jz = nodes["z[m]"][node_j - 1]
-
-            # Berechne die Einheitsvektoren für positives und negatives My mittels Kreuzprodukt
-            try:
-                unit_vector_pos, unit_vector_neg = (
-                    self.calculate_orthogonal_unit_vector_cross_product(ix, iz, jx, jz)
-                )
-                print(
-                    f"Element {i+1}: unit_vector_pos = {unit_vector_pos}, unit_vector_neg = {unit_vector_neg}"
-                )
-            except ValueError as e:
-                print(f"Fehler bei Mitglied {i+1}: {e}")
-                continue
+        return s_el
 
-            # Lokales My an Knoten a / b
-            My_a = My_el_i_store[i, 0, 0]  # [i,0] -> Knoten a
-            My_b = My_el_i_store[i, 1, 0]  # [i,1] -> Knoten b
-
-            try:
-                # 1) Pfeil am Knoten a
-                conn_ix, conn_iz = self.plot_moment_my_2d(
-                    ax, ix, iz, My_a, unit_vector_pos, scale=scale
-                )
-                # 2) Pfeil am Knoten b
-                conn_jx, conn_jz = self.plot_moment_my_2d(
-                    ax, jx, jz, My_b, unit_vector_pos, scale=scale
-                )
-                ax.plot(
-                    [conn_ix, conn_jx], [conn_iz, conn_jz], color="black", linewidth=1
-                )
-            except:
-                pass
-
-        # Hinzufügen einer Legende zur Unterscheidung
-        red_patch = mpatches.Patch(color="blue", label="Positives My")
-        blue_patch = mpatches.Patch(color="red", label="Negatives My")
-        ax.legend(handles=[red_patch, blue_patch])
-
-    def plot_normalforce_N_2d(self, ax, xi, zi, N_local, unit_vector, scale=1):
+    def SpringsData(self):
         """
-        Plot eines Biegemoments My in 2D (x-z-Ebene) orthogonal zur Strukturlinie.
-
-        Parameter:
-        ax : matplotlib.axes.Axes
-            Die 2D-Achse zum Plotten
-        xi, zi : float
-            Startpunkt (globale Koordinaten in x und z)
-        N_local : float
-            Lokaler N-Wert
-        unit_vector : array-like, shape (2,)
-            Normalisierter orthogonaler Vektor für das Moment
-        scale : float, optional
-            Maßstabsfaktor für die Pfeillänge
+        Baut Koppel-Federn zwischen zwei Knoten in die globale Matrix self.GesMat ein.
+        CSV: node_a,node_e,dof,cp/cm[MN,m]
+        Annahmen:
+        - node_* ist 1-basiert
+        - dof ist 0-basiert (0..6)
+        - 7 DoF pro Knoten
         """
+        # Wenn Input die Datei nicht geladen hat: nichts tun
+        if not hasattr(self.Inp, "SpringsData"):
+            return
+        if self.Inp.SpringsData is None or len(self.Inp.SpringsData) == 0:
+            return
 
-        if N_local == 0:
-            return  # Keine Kraft zu plotten
+        for _, row in self.Inp.SpringsData.iterrows():
+            na  = int(row["node_a"])
+            ne  = int(row["node_e"])
+            dof = int(row["dof"])
+            k   = float(row["cp[MN]"])
 
-        # Kleine Verbindungslinie vom Knoten zum Start des Pfeils
-        connection_length = 0.05 * scale  # Anpassbarer Wert
+            ia = 7 * (na - 1) + dof
+            ie = 7 * (ne - 1) + dof
 
-        conn_x = xi + connection_length * unit_vector[0] * N_local * scale
-        conn_z = zi + connection_length * unit_vector[1] * N_local * scale
+            # 2x2 Feder-Block
+            self.GesMat[ia, ia] += k
+            self.GesMat[ia, ie] -= k
+            self.GesMat[ie, ia] -= k
+            self.GesMat[ie, ie] += k
 
-        if N_local >= 0:
-            ax.plot([xi, conn_x], [zi, conn_z], color="blue", linewidth=1)
-        if N_local < 0:
-            ax.plot([xi, conn_x], [zi, conn_z], color="red", linewidth=1)
 
-        # Berechnung des Vektors, skaliert durch Moment und Maßstabsfaktor
-        vec = scale * N_local * unit_vector
 
-        # Farbwahl basierend auf dem Vorzeichen des Moments
-        color = "blue" if N_local >= 0 else "red"
+    def MainConvergence(self):
 
-        # Plotten des Pfeils
-        # ax.arrow(conn_x, conn_z, vec[0], vec[1],
-        #          head_width=0.05 * scale, head_length=0.1 * scale,
-        #          fc=color, ec=color, length_includes_head=True)
+        self.TransMats = self.CalculateTransMat()
+        self.GesMat = self.BuildStructureStiffnessMatrix()
 
-        # Berechnung des Endpunkts für die Textplatzierung
-        x_end = conn_x
-        z_end = conn_z
+        self.RestraintData()
+        self.SpringsData()          # ✅ HIER   
+        # <<< HIER: Singularitäts-Check >>>
+        self.check_singularity(self.GesMat, verbose=True)
 
-        # Moment-Text
-        moment_text = f"N = {N_local:.3f} MNm"
+        self.FGes = self.GlobalLoadVector()
 
-        # Textversatz für bessere Sichtbarkeit
-        text_offset = 0  # 0.05 * scale
-        ax.text(
-            x_end + text_offset * unit_vector[0],
-            z_end + text_offset * unit_vector[1],
-            moment_text,
-            color=color,
-            fontsize=8,
-        )
+        self.u_ges = self.SolveDisplacement()
 
-        return conn_x, conn_z
+        self.u_el = self.StoreLocalDisplacements()
 
-    def plot_all_N_2d(self, ax, nodes, na_memb, ne_memb, N_el_i_store, scale=0.4):
-        """
-        Plot N-Momente für alle Elemente an ihren Knoten in 2D (x-z-Ebene).
-
-        Parameter:
-        ax : matplotlib.axes.Axes
-            Die 2D-Achse zum Plotten
-        nodes : dict
-            Dictionary mit Knotenkordinaten
-        na_memb, ne_memb : Listen
-            Listen von Knotennummern für die Elemente
-        N_el_i_store : ndarray
-            Array von N-Werten pro Element und Knoten
-        scale : float, optional
-            Maßstabsfaktor für die Pfeile
-        """
-        for i in range(len(na_memb)):
-            node_i = na_memb[i]
-            node_j = ne_memb[i]
-
-            ix = nodes["x[m]"][node_i - 1]
-            iz = nodes["z[m]"][node_i - 1]
-
-            jx = nodes["x[m]"][node_j - 1]
-            jz = nodes["z[m]"][node_j - 1]
-
-            # Berechne die Einheitsvektoren für positives und negatives My mittels Kreuzprodukt
-            try:
-                unit_vector_pos, unit_vector_neg = (
-                    self.calculate_orthogonal_unit_vector_cross_product(ix, iz, jx, jz)
-                )
-                print(
-                    f"Element {i+1}: unit_vector_pos = {unit_vector_pos}, unit_vector_neg = {unit_vector_neg}"
-                )
-            except ValueError as e:
-                print(f"Fehler bei Mitglied {i+1}: {e}")
-                continue
+        self.s_el = self.CalculateLocalInnerForces()
 
-            # Lokales My an Knoten a / b
-            N_a = N_el_i_store[i, 0, 0]  # [i,0] -> Knoten a
-            N_b = N_el_i_store[i, 1, 0]  # [i,1] -> Knoten b
-
-            try:
-                # 1) Pfeil am Knoten a
-                conn_ix, conn_iz = self.plot_normalforce_N_2d(
-                    ax, ix, iz, N_a, unit_vector_pos, scale=scale
-                )
-                # 2) Pfeil am Knoten b
-                conn_jx, conn_jz = self.plot_normalforce_N_2d(
-                    ax, jx, jz, N_b, unit_vector_pos, scale=scale
-                )
-                ax.plot(
-                    [conn_ix, conn_jx], [conn_iz, conn_jz], color="black", linewidth=1
-                )
-            except:
-                pass
-
-        # Hinzufügen einer Legende zur Unterscheidung
-        red_patch = mpatches.Patch(color="blue", label="Positives N")
-        blue_patch = mpatches.Patch(color="red", label="Negatives N")
-        ax.legend(handles=[red_patch, blue_patch])
-
-    def plot_structure_2d(self, nodes, na_memb, ne_memb):
+    def run(self) -> AnalysisResults:
         """
-        Plot der unverformten 2D-Struktur in der x-z-Ebene.
-
-        Parameter:
-        nodes: dict mit den Schlüsseln ['x[m]', 'y[m]', 'z[m]']
-        na_memb, ne_memb: Listen mit Knoten-IDs für Start und Ende der Elemente
+        Führt die komplette Berechnung aus und gibt ein Results-Objekt zurück.
         """
-        fig, ax = plt.subplots(figsize=(10, 8))
-
-        # Alle Elemente plotten
-        for i in range(len(na_memb)):
-            node_i = na_memb[i]
-            node_j = ne_memb[i]
+        self.MainConvergence()
 
-            ix = nodes["x[m]"][node_i - 1]
-            iz = nodes["z[m]"][node_i - 1]
+        return AnalysisResults(
+            Inp=self.Inp,
+            u_ges=self.u_ges,
+            GesMat=self.GesMat,
+            FGes=self.FGes,
+            TransMats=self.TransMats,
+            K_el_i_store=self.K_el_i_store,
+            u_el=self.u_el,
+            s_el=self.s_el,
+            N_el_i_store=self.N_el_i_store,
+            VY_el_i_store=self.VY_el_i_store,
+            VZ_el_i_store=self.VZ_el_i_store,
+            MX_el_i_store=self.MX_el_i_store,
+            MY_el_i_store=self.MY_el_i_store,
+            MZ_el_i_store=self.MZ_el_i_store,
+            member_length=np.array(self.member_length, dtype=float),
+        )
 
-            jx = nodes["x[m]"][node_j - 1]
-            jz = nodes["z[m]"][node_j - 1]
+    def check_global_equilibrium(self):
+        r = (
+            self.GesMat @ self.u_ges - self.FGes
+        ).ravel()  # Reaktionsvektor auf allen DOFs
 
-            X = [ix, jx]
-            Z = [iz, jz]
+        # welche DOFs sind "gelagert"? (klassisch: Cp groß oder Fix)
+        # Bei dir: RestraintData addiert Cp auf Diagonale.
+        # -> als Näherung: DOF ist gelagert, wenn Cp > 0 in Input.
+        restrained = np.zeros_like(r, dtype=bool)
+        for _, row in self.Inp.RestraintData.iterrows():
+            gdof = 7 * (int(row["Node"]) - 1) + int(row["Dof"])
+            restrained[gdof] = True
 
-            ax.plot(X, Z, color="black", lw=1.0)
+        free = ~restrained
 
-        # Achsenbeschriftung und Titel
-        ax.set_xlabel("X [m]")
-        ax.set_ylabel("Z [m]")
-        ax.set_title("Unverformte Struktur (x-z-Ebene)")
-        ax.grid(True)
+        print("max residual on FREE dofs:", np.max(np.abs(r[free])))
+        print("sum residual on FREE dofs:", np.sum(r[free]))
 
-        return fig, ax
+    def debug_single_fx(self, node=2, Fx=1.0):
+        # setze alle Lasten leer
+        self.Inp.ElementLoads = self.Inp.ElementLoads.iloc[0:0].copy()
+        self.Inp.TemperatureForces = self.Inp.TemperatureForces.iloc[0:0].copy()
+        self.Inp.NodalForces = self.Inp.NodalForces.iloc[0:0].copy()
 
-    def plot_structure_with_moments_2d(self, scale=0.4):
-        """
-        Kombinierte Methode zum Plotten der Struktur und der Biegemomente My in 2D (x-z-Ebene).
+        # eine Last
+        import pandas as pd
 
-        Parameter:
-        scale : float, optional
-            Skalierungsfaktor für die Momente
-        """
-        fig, ax = self.plot_structure_2d(
-            self.Inp.nodes, self.Inp.members["na"], self.Inp.members["ne"]
+        self.Inp.NodalForces = pd.DataFrame(
+            [{"Node": node, "Dof": "Fx", "Value[MN/MNm]": Fx}]
         )
 
-        # Plot der Biegemomente My mittels Kreuzprodukt
-        self.plot_all_My_2d(
-            ax,
-            self.Inp.nodes,
-            self.Inp.members["na"],
-            self.Inp.members["ne"],
-            self.MY_el_i_store,
-            scale=scale,
-        )
+        self.MainConvergence()
 
-        # Achsenlimits automatisch anpassen und gleiches Seitenverhältnis
-        ax.set_aspect("equal", adjustable="datalim")
-        ax.relim()
-        ax.autoscale_view()
+        ux = self.u_ges[7 * (node - 1) + 0]
+        uy = self.u_ges[7 * (node - 1) + 1]
+        uz = self.u_ges[7 * (node - 1) + 3]
+        print("ux, uy, uz =", ux, uy, uz)
+
+    def sum_reactions_fx(self):
+        r = (self.GesMat @ self.u_ges - self.FGes).ravel()
+
+        Rx = 0.0
+        for _, row in self.Inp.RestraintData.iterrows():
+            node = int(row["Node"])
+            dof = int(row["Dof"])
+            if dof == 0:  # ux-DOF
+                Rx += r[7 * (node - 1) + 0]
+
+        Fx = 0.0
+        for _, row in self.Inp.NodalForces.iterrows():
+            if str(row["Dof"]).strip().lower() == "fx":
+                Fx += float(row["Value[MN/MNm]"])
+
+        print("Sum Fx (applied) =", Fx)
+        print("Sum Rx (support) =", Rx)
+        print("Fx + Rx          =", Fx + Rx)
+
+    def sum_spring_reactions_fx(self):
+        u = self.u_ges.ravel()
+
+        Rx = 0.0
+        Fx = 0.0
+
+        # aufgebrachte nodale Fx
+        for _, row in self.Inp.NodalForces.iterrows():
+            if str(row["Dof"]).strip().lower() == "fx":
+                Fx += float(row["Value[MN/MNm]"])
+
+        # Federkräfte aus RestraintData: k * u an genau diesen DOFs
+        for _, row in self.Inp.RestraintData.iterrows():
+            node = int(row["Node"])
+            dof = int(row["Dof"])
+            k = float(row["Cp[MN/m]/[MNm/m]"])
+            gdof = 7 * (node - 1) + dof
+
+            if dof == 0:  # ux
+                Rx += k * u[gdof]
+
+        print("Sum Fx (applied) =", Fx)
+        print("Sum spring Rx    =", Rx)
+        print("Fx - Rx          =", Fx - Rx)
+
+    ####________________________Iteration Theorie II.Order___________________________####
+    def BuildGeometricStiffnessMatrix(self):
+        """
+        Baut globale geometrische Steifigkeitsmatrix Kg(u) aus aktuellen Schnittgrößen.
+        Voraussetzung: self.u_ges, self.u_el, self.s_el bzw. *_store sind aktuell.
+        """
+        nD = self.Inp.nDoF
+        Kg_glob = np.zeros((nD, nD), dtype=float)
+
+        na_memb = self.Inp.members["na"].to_numpy()
+        ne_memb = self.Inp.members["ne"].to_numpy()
+
+        # Default: keine qy/qz (wenn du es noch nicht sauber mapst)
+        # Du kannst qy/qz später elementweise aus ElementLoads ableiten.
+        qy = 0.0
+        qz = 0.0
+        yq = 0.0
+        zq = 0.0
+
+        # Schwerpunkt/Schubmittelpunkt des Querschnitts
+        # (muss aus Input kommen; hier: fallback = 0)
+        yM = 0.0
+        zM = 0.0
+
+        for e in range(len(na_memb)):
+            ni = int(na_memb[e])
+            nj = int(ne_memb[e])
+            L = float(self.member_length[e])
+
+            # Schnittgrößen aus deinen Stores (links/rechts)
+            N_L, N_R = float(self.N_el_i_store[e][0, 0]), float(
+                self.N_el_i_store[e][1, 0]
+            )
+            My_L, My_R = float(self.MY_el_i_store[e][0, 0]), float(
+                self.MY_el_i_store[e][1, 0]
+            )
+            Mz_L, Mz_R = float(self.MZ_el_i_store[e][0, 0]), float(
+                self.MZ_el_i_store[e][1, 0]
+            )
+            Mx_L, Mx_R = float(self.MX_el_i_store[e][0, 0]), float(
+                self.MX_el_i_store[e][1, 0]
+            )
 
-        return fig, ax
+            # Für Kg brauchst du i.d.R. konstante N, lineare M-Verläufe:
+            Nbar = 0.5 * (N_L + N_R)
+
+            # Mr: je nach Definition (Torsion/Warping). Als Start: mittleres Torsionsmoment
+            Mr = 0.5 * (Mx_L + Mx_R)
+
+            # lokale Kg nach deiner Formel
+            Kg_loc = self.ElemStem.Kg_theory_II_order(
+                L=L,
+                N=Nbar,
+                My_a=My_L,
+                My_b=My_R,
+                Mz_a=Mz_L,
+                Mz_b=Mz_R,
+                Mr=Mr,
+                qy=qy,
+                qz=qz,
+                yq=yq,
+                zq=zq,
+                yM=yM,
+                zM=zM,
+            )
 
-    def plot_structure_with_normalforces_2d(self, scale=0.4):
-        """
-        Kombinierte Methode zum Plotten der Struktur und der Biegemomente My in 2D (x-z-Ebene).
+            # local -> global
+            T = self.TransMats[e]
+            Kg_e_glob = T @ Kg_loc @ T.T
 
-        Parameter:
-        scale : float, optional
-            Skalierungsfaktor für die Momente
-        """
-        fig, ax = self.plot_structure_2d(
-            self.Inp.nodes, self.Inp.members["na"], self.Inp.members["ne"]
-        )
+            # Assembling in globale Matrix
+            bi = 7 * (ni - 1)
+            bj = 7 * (nj - 1)
 
-        # Plot der Biegemomente My mittels Kreuzprodukt
-        self.plot_all_N_2d(
-            ax,
-            self.Inp.nodes,
-            self.Inp.members["na"],
-            self.Inp.members["ne"],
-            self.N_el_i_store,
-            scale=scale,
-        )
+            Kg_glob[bi : bi + 7, bi : bi + 7] += Kg_e_glob[0:7, 0:7]
+            Kg_glob[bi : bi + 7, bj : bj + 7] += Kg_e_glob[0:7, 7:14]
+            Kg_glob[bj : bj + 7, bi : bi + 7] += Kg_e_glob[7:14, 0:7]
+            Kg_glob[bj : bj + 7, bj : bj + 7] += Kg_e_glob[7:14, 7:14]
 
-        # Achsenlimits automatisch anpassen und gleiches Seitenverhältnis
-        ax.set_aspect("equal", adjustable="datalim")
-        ax.relim()
-        ax.autoscale_view()
-
-        return fig, ax
-
-    def plot_structure_deformed_3d(
-        self,
-        scale: float = 1.0,
-        show_undeformed: bool = True,
-        node_labels: bool = False,
-        undeformed_kwargs: dict | None = None,
-        deformed_kwargs: dict | None = None,
-    ):
-        """
-        Zeichnet das räumliche Tragwerk samt skalierter Verformungen.
-
-        Parameters
-        ----------
-        scale : float, optional
-            Maßstabsfaktor für die Verschiebungen.
-        show_undeformed : bool, optional
-            Wenn True, wird das unverformte System zusätzlich angezeigt.
-        node_labels : bool, optional
-            Beschriftet die Knoten mit ihrer Nummer.
-        undeformed_kwargs / deformed_kwargs : dict, optional
-            Extra-Keyword-Argumente für die Linien (Farbe, Linienstärke …).
-        """
-        if undeformed_kwargs is None:
-            undeformed_kwargs = dict(color="lightgray", lw=1.0, zorder=1)
-        if deformed_kwargs is None:
-            deformed_kwargs = dict(color="blue", lw=2.0, zorder=3)
-
-        fig = plt.figure(figsize=(10, 8))
-        ax: Axes3D = fig.add_subplot(projection="3d")
-
-        na = self.Inp.members["na"]
-        ne = self.Inp.members["ne"]
-
-        # Kurzfunktionen für Verschiebungen
-        def ux(n):
-            return self.u_ges[7 * (n - 1) + 0]  # u_x
-
-        def uy(n):
-            return self.u_ges[7 * (n - 1) + 1]  # u_y
-
-        def uz(n):
-            return self.u_ges[7 * (n - 1) + 3]  # u_z
-
-        # 1) Unverformte Struktur
-        if show_undeformed:
-            for a, e in zip(na, ne):
-                xa, ya, za = (
-                    self.Inp.nodes[k][a - 1] for k in ("x[m]", "y[m]", "z[m]")
-                )
-                xe, ye, ze = (
-                    self.Inp.nodes[k][e - 1] for k in ("x[m]", "y[m]", "z[m]")
-                )
-                ax.plot([xa, xe], [ya, ye], [za, ze], **undeformed_kwargs)
-
-        # 2) Verformte Struktur
-        for a, e in zip(na, ne):
-            xa, ya, za = (self.Inp.nodes[k][a - 1] for k in ("x[m]", "y[m]", "z[m]"))
-            xe, ye, ze = (self.Inp.nodes[k][e - 1] for k in ("x[m]", "y[m]", "z[m]"))
-
-            ax.plot(
-                [xa + scale * ux(a), xe + scale * ux(e)],
-                [ya + scale * uy(a), ye + scale * uy(e)],
-                [za + scale * uz(a), ze + scale * uz(e)],
-                **deformed_kwargs,
-            )
+        return Kg_glob
 
-        # 3) Knotennummern (optional)
-        if node_labels:
-            for n in range(1, len(self.Inp.nodes) + 1):
-                x0 = self.Inp.nodes["x[m]"][n - 1] + scale * ux(n)
-                y0 = self.Inp.nodes["y[m]"][n - 1] + scale * uy(n)
-                z0 = self.Inp.nodes["z[m]"][n - 1] + scale * uz(n)
-                ax.text(x0, y0, z0, f"{n}", fontsize=8, ha="center", va="center")
-
-        # Achsen und Optik
-        ax.set_xlabel("X [m]")
-        ax.set_ylabel("Y [m]")
-        ax.set_zlabel("Z [m]")
-        ax.set_title(f"Verformte Struktur 3-D (Skalierung {scale:g})")
-        ax.set_box_aspect((1, 1, 1))  # gleiches Seitenverhältnis
-        fig.tight_layout()
-
-        # Optional: Blickwinkel anpassen (z. B. isometrisch)
-        # ax.view_init(elev=20, azim=-60)
-
-        return fig, ax
-
-    def plot_structure_deformed_3d_interactive(
-        self,
-        scale_init: float = 1.0,
-        show_undeformed: bool = True,
-        node_labels: bool = False,
-    ):
+    def SolveSecondOrder(self, max_iter=30, tol=1e-8, verbose=True):
         """
-        Öffnet ein 3-D-Fenster mit interaktiven Slidern:
-          • Elevation (θ)   • Azimut (φ)   • Skalierung s der Verformungen
-        Die x-, y-, z-Achsen werden stets auf identische Länge gebracht.
+        II.-Ordnung: Picard-Iteration
+        1) K = Ke + Kg(u_k)
+        2) löse u_{k+1}
+        3) update Schnittgrößen, Kg, ...
         """
+        self.TransMats = self.CalculateTransMat()
 
-        # ─── Kurzfunktionen für Verschiebungen ────────────────────────────
-        ux = lambda n: self.u_ges[7 * (n - 1) + 0]  # DOF 0
-        uy = lambda n: self.u_ges[7 * (n - 1) + 1]  # DOF 1
-        uz = lambda n: self.u_ges[7 * (n - 1) + 3]  # DOF 3
-
-        # ─── Grundplot anlegen ───────────────────────────────────────────
-        import matplotlib.pyplot as plt
-
-        fig = plt.figure(figsize=(8, 6))
-        ax = fig.add_subplot(projection="3d")
-
-        # 1) nach dem allerersten Zeichnen
-        _set_axes_equal(ax)
-
-        na, ne = self.Inp.members["na"], self.Inp.members["ne"]
-
-        # Listen zum schnellen Updaten
-        deformed_lines: list[Line3D] = []
-
-        # ── Linien zeichnen (undeformed + deformed) ───────────────────────
-        for a, e in zip(na, ne):
-            xa0, ya0, za0 = (self.Inp.nodes[k][a - 1] for k in ("x[m]", "y[m]", "z[m]"))
-            xe0, ye0, ze0 = (self.Inp.nodes[k][e - 1] for k in ("x[m]", "y[m]", "z[m]"))
-
-            if show_undeformed:
-                ax.plot(
-                    [xa0, xe0],
-                    [ya0, ye0],
-                    [za0, ze0],
-                    color="lightgray",
-                    lw=1,
-                    zorder=1,
-                )
-
-            # deformed-Linie initial
-            xd = [xa0 + scale_init * ux(a), xe0 + scale_init * ux(e)]
-            yd = [ya0 + scale_init * uy(a), ye0 + scale_init * uy(e)]
-            zd = [za0 + scale_init * uz(a), ze0 + scale_init * uz(e)]
-
-            (ld,) = ax.plot(xd, yd, zd, color="tab:blue", lw=2, zorder=3)
-            deformed_lines.append(ld)
-
-        # Knotennummern (optional) – als separate Textobjekte
-        text_elems = []
-        if node_labels:
-            for n in range(1, len(self.Inp.nodes) + 1):
-                x0, y0, z0 = (
-                    self.Inp.nodes[k][n - 1] for k in ("x[m]", "y[m]", "z[m]")
-                )
-                t = ax.text(
-                    x0 + scale_init * ux(n),
-                    y0 + scale_init * uy(n),
-                    z0 + scale_init * uz(n),
-                    f"{n}",
-                    fontsize=8,
-                    ha="center",
-                    va="center",
-                    zorder=4,
-                )
-                text_elems.append(t)
-
-        # ─── Achsenformatierung ───────────────────────────────────────────
-        ax.set_xlabel("X [m]")
-        ax.set_ylabel("Y [m]")
-        ax.set_zlabel("Z [m]")
-        ax.set_title("Verformte Struktur – interaktiv")
-        try:
-            ax.set_box_aspect((1, 1, 1))  # Matplotlib ≥ 3.3
-        except AttributeError:
-            _set_axes_equal(ax)
-
-        # ─── Slider-UI unter dem Plot platzieren ──────────────────────────
-        fig.subplots_adjust(bottom=0.25)  # Platz für drei Slider
-
-        # Achsen-Koordinaten [links, unten, breite, höhe]
-        ax_elev = fig.add_axes([0.13, 0.15, 0.74, 0.03])
-        ax_azim = fig.add_axes([0.13, 0.10, 0.74, 0.03])
-        ax_scale = fig.add_axes([0.13, 0.05, 0.74, 0.03])
-
-        s_elev = Slider(ax_elev, "Elev (°)", -90, 90, valinit=20, valstep=1)
-        s_azim = Slider(ax_azim, "Azim (°)", -180, 180, valinit=-60, valstep=1)
-        s_scale = Slider(ax_scale, "Scale", 0.0, scale_init * 10000, valinit=scale_init)
-
-        # ─── Callback-Funktionen ──────────────────────────────────────────
-        def _update_view(_):
-            ax.view_init(elev=s_elev.val, azim=s_azim.val)
-            fig.canvas.draw_idle()
-
-        def _update_scale(_):
-            s = s_scale.val
-            for (a, e), line in zip(zip(na, ne), deformed_lines):
-                xa0, ya0, za0 = (
-                    self.Inp.nodes[k][a - 1] for k in ("x[m]", "y[m]", "z[m]")
-                )
-                xe0, ye0, ze0 = (
-                    self.Inp.nodes[k][e - 1] for k in ("x[m]", "y[m]", "z[m]")
-                )
-                # neue Koordinaten
-                line.set_data_3d(
-                    [xa0 + s * ux(a), xe0 + s * ux(e)],
-                    [ya0 + s * uy(a), ye0 + s * uy(e)],
-                    [za0 + s * uz(a), ze0 + s * uz(e)],
-                )
-            # Knotentexte mit skalieren
-            if node_labels:
-                for n, txt in enumerate(text_elems, start=1):
-                    x0, y0, z0 = (
-                        self.Inp.nodes[k][n - 1] for k in ("x[m]", "y[m]", "z[m]")
-                    )
-                    txt.set_position((x0 + s * ux(n), y0 + s * uy(n)))
-                    txt.set_3d_properties(z0 + s * uz(n), zdir="z")
-            # Limits neu auf Würfel setzen
-            try:
-                ax.set_box_aspect((1, 1, 1))
-            except AttributeError:
-                _set_axes_equal(ax)
-            fig.canvas.draw_idle()
-
-        # Slider verbinden
-        s_elev.on_changed(_update_view)
-        s_azim.on_changed(_update_view)
-        s_scale.on_changed(_update_scale)
-
-        # Startansicht
-        _update_view(None)
-        _update_scale(None)
-
-        return fig, ax, (s_elev, s_azim, s_scale)
-
-    def orthogonal_unit_vector_3d(self,pt_i, pt_j, prefer_axis="y"):
-        """
-        Liefert einen normierten Vektor w, der senkrecht auf der
-        Stabachse v = (pt_j - pt_i) steht.
-
-        Parameters
-        ----------
-        pt_i, pt_j : array-like (3,)
-            Globale xyz-Koordinaten der Knoten i und j.
-        prefer_axis : {"x","y","z"}, optional
-            Welcher globale Achsvektor soll primär verwendet werden,
-            um das Kreuzprodukt zu bilden?  Wähle eine Achse, die
-            im Regelfall nicht parallel zur Elementachse v ist.
-
-        Returns
-        -------
-        w : ndarray (3,)
-            Normierter Orthogonalvektor.
-        """
-        v = np.asarray(pt_j) - np.asarray(pt_i)
-        v_norm = np.linalg.norm(v)
-        if v_norm == 0:
-            raise ValueError("Elementlänge 0 – identische Knoten?")
-
-        v = v / v_norm
-
-        # Globalen Hilfsvektor wählen
-        axes = {"x": np.array([1, 0, 0]),
-                "y": np.array([0, 1, 0]),
-                "z": np.array([0, 0, 1])}
-        u = axes.get(prefer_axis, axes["y"])
-
-        # Prüfen, ob v und u (fast) parallel sind
-        if abs(np.dot(v, u)) > 0.95:           # nahezu kollinear
-            u = axes["z"] if prefer_axis != "z" else axes["x"]
-
-        w = np.cross(v, u)
-        w_norm = np.linalg.norm(w)
-        if w_norm == 0:
-            raise ValueError("Konnte keinen Orthogonal­vektor berechnen.")
-        return w / w_norm
-
-    def plot_moment_my_3d(self,ax, x0, y0, z0, m_val, w, scale=1.0,
-                        color_pos="tab:blue", color_neg="tab:red",
-                        text=True):
-        """
-        Zeichnet einen Momentenpfeil (My) im 3-D-Plot.
-
-        Parameter
-        ---------
-        ax          : mpl_toolkits.mplot3d.Axes3D
-        x0,y0,z0    : float
-            Koordinaten des Ausgangsknotens (global).
-        m_val       : float
-            Momentwert (positiv / negativ gemäß System).
-        w           : ndarray (3,)
-            Normierter Orthogonalvektor (Ausgabe der o.g. Funktion).
-        scale       : float
-            Skalierungs­faktor für die Pfeillänge.
-        """
-        if m_val == 0:
-            return None   # nichts zu plotten
-
-        # Farbe
-        col = color_pos if m_val >= 0 else color_neg
-
-        # kleine Verbindungslinie vom Knoten nach außen
-        link_len = 0.05 * scale
-        P1 = np.array([x0, y0, z0])
-        P2 = P1 + link_len * w * abs(m_val)
-
-        # Pfeil
-        vec = scale * m_val * w
-        Q = P2 + vec
-
-        # Plotten
-        ax.plot([P1[0], P2[0]], [P1[1], P2[1]], [P1[2], P2[2]], color=col, lw=1)
-        ax.quiver(P2[0], P2[1], P2[2],
-                vec[0], vec[1], vec[2],
-                arrow_length_ratio=0.15, color=col, linewidth=1)
-
-        # Text
-        if text:
-            txt = f"My={m_val:.2f}"
-            ax.text(Q[0], Q[1], Q[2], txt, fontsize=8, color=col)
-
-        return (P1, P2, Q)    # falls du später noch updaten willst
-
-    def plot_My_3d(
-        self,
-        scale: float = 1,
-        show_axes: bool = True,
-        show_stabs: bool = True,
-        text: bool = True,
-        prefer_axis: str = "y",
-    ):
-        """
-        Erstellt EINEN separaten 3-D-Plot, in dem ausschließlich die
-        My-Momente (Biegung um lokale y-Achse) dargestellt werden.
-
-        Parameter
-        ---------
-        scale        : float   globaler Faktor für die Pfeillängen (Moment * scale)
-        show_axes    : bool    Achsenbeschriftungen + Würfelanzeige?
-        show_stabs   : bool    graue Stabachsen als Anhalt zeichnen?
-        text         : bool    Momentwert als Text an Pfeilspitze?
-        prefer_axis  : {"x","y","z"}  welche globale Achse zur Bildung
-                    des Orthogonal­vektors primär verwenden?
-        """
-        fig = plt.figure(figsize=(8, 6))
-        ax  = fig.add_subplot(projection="3d")
-        ax.set_title("My-Momente 3-D")
-
-        na, ne = self.Inp.members["na"], self.Inp.members["ne"]
-
-        # ----- 1. optional: Stabachsen als helle Linien --------------------
-        if show_stabs:
-            segs = []
-            for a, e in zip(na, ne):
-                Pi = [self.Inp.nodes[k][a - 1] for k in ("x[m]", "y[m]", "z[m]")]
-                Pj = [self.Inp.nodes[k][e - 1] for k in ("x[m]", "y[m]", "z[m]")]
-                segs.append([Pi, Pj])
-            lc = Line3DCollection(segs, colors="lightgray", linewidths=1, zorder=0)
-            ax.add_collection3d(lc)
-
-        # ----- 2. Momente plotten ------------------------------------------
-        for idx, (a, e) in enumerate(zip(na, ne)):
-            Pi = np.array([self.Inp.nodes[k][a - 1] for k in ("x[m]", "y[m]", "z[m]")])
-            Pj = np.array([self.Inp.nodes[k][e - 1] for k in ("x[m]", "y[m]", "z[m]")])
-
-            w = self.orthogonal_unit_vector_3d(Pi, Pj, prefer_axis=prefer_axis)
-
-            My_a = float(self.MY_el_i_store[idx, 0, 0])
-            My_b = float(self.MY_el_i_store[idx, 1, 0])
-
-            self.plot_moment_my_3d(ax, *Pi, My_a, w, scale=scale, text=text)
-            self.plot_moment_my_3d(ax, *Pj, My_b, w, scale=scale, text=text)
-
-        # ----- 3. Optik -----------------------------------------------------
-        if show_axes:
-            ax.set_xlabel("X [m]")
-            ax.set_ylabel("Y [m]")
-            ax.set_zlabel("Z [m]")
-        else:           # Achsen ausblenden
-            ax.set_axis_off()
-
-        # kubische Limits
-        _set_axes_equal(ax)
-        fig.tight_layout()
-
-        return fig, ax
-
-    def plot_My_3d_interactive(
-        self,
-        scale_init: float = 1e-3,
-        show_axes: bool = True,
-        show_stabs: bool = True,
-        text: bool = True,
-        prefer_axis: str = "y",
-    ):
-        """
-        Interaktive 3-D-Darstellung der My-Momente mit drei Slidern:
-        • Elevation (θ)   • Azimut (φ)   • Skalierung s
-        """
-        import matplotlib.pyplot as plt
-
-        # ---------- Grundplot zeichnen -------------------------------------
-        fig, ax = self.plot_My_3d(
-            scale=scale_init,
-            show_axes=show_axes,
-            show_stabs=show_stabs,
-            text=text,
-            prefer_axis=prefer_axis,
-        )
+        # 1) Ke aufbauen (wie bisher)
+        Ke_glob = self.BuildStructureStiffnessMatrix()
+        self.GesMat = Ke_glob.copy()
+
+        # Lager/Federn in Ke
+        self.RestraintData()
+
+        # Lastvektor (global) einmal
+        self.FGes = self.GlobalLoadVector()
 
-        # ── alle momentan gezeichneten Artists merken (fürs Löschen) ───────
-        base_children = set(ax.get_children())   # alles, was NICHT neu erzeugt wird
+        # Start: lineare Lösung
+        u = np.linalg.solve(self.GesMat, self.FGes)
+        if verbose:
+            print("II-Order: initial linear solve done.")
 
-        # ---------- UI-Platz reservieren -----------------------------------
-        fig.subplots_adjust(bottom=0.25)
+        for it in range(1, max_iter + 1):
+            self.u_ges = u
+            self.u_el = self.StoreLocalDisplacements()
+            self.s_el = self.CalculateLocalInnerForces()  # update N,My,Mz,...
 
-        ax_elev  = fig.add_axes([0.14, 0.15, 0.72, 0.03])
-        ax_azim  = fig.add_axes([0.14, 0.10, 0.72, 0.03])
-        ax_scale = fig.add_axes([0.14, 0.05, 0.72, 0.03])
+            Kg_glob = self.BuildGeometricStiffnessMatrix()
 
-        s_elev  = Slider(ax_elev,  "Elev (°)",  -90,  90,  valinit=20,  valstep=1)
-        s_azim  = Slider(ax_azim,  "Azim (°)", -180, 180, valinit=-60, valstep=1)
-        s_scale = Slider(ax_scale, "Scale",      0.0, scale_init*100, valinit=scale_init)
+            # Totalmatrix neu: Ke + Kg + restraints
+            Ktot = Ke_glob + Kg_glob
 
-        # ---------- Helfer: Momente neu zeichnen ---------------------------
-        def _redraw_moments(scale):
-            # 1) alles löschen, was nach dem Basisset erzeugt wurde
-            for art in list(ax.get_children()):
-                if art not in base_children:
-                    art.remove()
+            # restraints nochmal addieren (weil Ktot neu)
+            self.GesMat = Ktot
+            self.RestraintData()
 
-            # 2) neu zeichnen (ohne Achsen neu zu beschriften)
-            na, ne = self.Inp.members["na"], self.Inp.members["ne"]
-            for idx, (a, e) in enumerate(zip(na, ne)):
-                Pi = np.array([self.Inp.nodes[k][a - 1] for k in ("x[m]","y[m]","z[m]")])
-                Pj = np.array([self.Inp.nodes[k][e - 1] for k in ("x[m]","y[m]","z[m]")])
+            # lösen
+            u_new = np.linalg.solve(self.GesMat, self.FGes)
 
-                w = self.orthogonal_unit_vector_3d(Pi, Pj, prefer_axis=prefer_axis)
-                My_a = float(self.MY_el_i_store[idx, 0, 0])
-                My_b = float(self.MY_el_i_store[idx, 1, 0])
+            # Konvergenz
+            rel = np.linalg.norm(u_new - u) / (np.linalg.norm(u_new) + 1e-16)
+            if verbose:
+                print(f"II-Order iter {it}: rel_du = {rel:.3e}")
 
-                self.plot_moment_my_3d(ax, *Pi, My_a, w, scale=scale, text=text)
-                self.plot_moment_my_3d(ax, *Pj, My_b, w, scale=scale, text=text)
+            u = u_new
+            if rel < tol:
+                break
 
-            _set_axes_equal(ax)
-            fig.canvas.draw_idle()
+        # final speichern
+        self.u_ges = u
+        self.u_el = self.StoreLocalDisplacements()
+        self.s_el = self.CalculateLocalInnerForces()
+        return u
 
-        # ---------- Callbacks ----------------------------------------------
-        def _update_view(_):
-            ax.view_init(elev=s_elev.val, azim=s_azim.val)
-            fig.canvas.draw_idle()
+    #####_______________________  BUCKLING ___________________________#####
+    def get_free_dofs_mask(self):
+        restrained = np.zeros(self.Inp.nDoF, dtype=bool)
+        for _, row in self.Inp.RestraintData.iterrows():
+            gdof = 7 * (int(row["Node"]) - 1) + int(row["Dof"])
+            restrained[gdof] = True
+        return ~restrained
+
+    def BucklingEigen_alpha_crit(self, use_second_order_prestate=False, verbose=True):
+        """
+        Linear buckling: (Ke + alpha Kg) phi = 0
+        -> solve Ke phi = -alpha Kg phi
+        Returns: eigenvalues alpha (sorted), eigenvectors in full dof size (optional)
+        """
+        self.TransMats = self.CalculateTransMat()
 
-        def _update_scale(_):
-            _redraw_moments(s_scale.val)
+        # Ke inkl. Lager
+        Ke = self.BuildStructureStiffnessMatrix()
+        self.GesMat = Ke.copy()
+        self.RestraintData()
 
-        s_elev.on_changed(_update_view)
-        s_azim.on_changed(_update_view)
-        s_scale.on_changed(_update_scale)
+        # Vorzustand bestimmen (für Kg):
+        self.FGes = self.GlobalLoadVector()
 
-        # ---------- Initiale Ansicht ---------------------------------------
-        _update_view(None)           # stellt Kamera
-        # (Momenten-Plot ist schon mit scale_init gezeichnet)
+        if use_second_order_prestate:
+            self.SolveSecondOrder(max_iter=30, tol=1e-8, verbose=False)
+        else:
+            self.u_ges = np.linalg.solve(self.GesMat, self.FGes)
+            self.u_el = self.StoreLocalDisplacements()
+            self.s_el = self.CalculateLocalInnerForces()
 
-        return fig, ax, (s_elev, s_azim, s_scale)
+        Kg = self.BuildGeometricStiffnessMatrix()
 
-# Beispielhafte Hauptfunktion
-if __name__ == "__main__":
-    import matplotlib
-    # Für Desktop-Skripte (nicht im Notebook) ein GUI-Backend wählen:
-    matplotlib.use("TkAgg")          # oder "QtAgg"
-    import matplotlib.pyplot as plt
+        free = self.get_free_dofs_mask()
+        Ke_ff = self.GesMat[np.ix_(free, free)]
+        Kg_ff = Kg[np.ix_(free, free)]
 
-    # ── Instanz erzeugen (rechnet nur einmal) ───────────────────────────
-    calc = mainloop()
+        # EVP: Ke_ff^{-1} (-Kg_ff) v = alpha v
+        # -> solve A v = alpha v with A = inv(Ke_ff) @ (-Kg_ff)
+        A = np.linalg.solve(Ke_ff, -Kg_ff)
 
-    # 2-D-Momente --------------------------------------------------------
-    fig1, ax1 = calc.plot_structure_with_moments_2d(scale=5)
-    ax1.invert_yaxis()
-    fig1.savefig("plots/ClampHinged_Inclination.eps", format="eps")
+        # Eigenwerte
+        eigvals, eigvecs = np.linalg.eig(A)
 
-    # 2-D-Normalkräfte ---------------------------------------------------
-    fig2, ax2 = calc.plot_structure_with_normalforces_2d(scale=5)
-    ax2.invert_yaxis()
+        # reell filtern & sortieren (kleinster positiver)
+        eigvals = np.real_if_close(eigvals, tol=1e-6)
+        eigvals_real = np.real(eigvals)
 
-    # 3-D-Plot mit Slidern ----------------------------------------------
-    fig3, ax3, sliders = calc.plot_structure_deformed_3d_interactive(
-        scale_init=10,
-        node_labels=True,
-    )
+        # sinnvolle Kandidaten: alpha > 0
+        pos = eigvals_real[eigvals_real > 1e-9]
+        pos_sorted = np.sort(pos)
 
-    calc.plot_My_3d_interactive(scale_init=1e-3, text=True)
+        if verbose:
+            if len(pos_sorted) == 0:
+                print("No positive alpha found (check sign convention of N/Kg).")
+            else:
+                print("alpha_crit =", pos_sorted[0])
+                print("next alphas:", pos_sorted[:5])
 
-    # ── genau EIN Aufruf ────────────────────────────────────────────────
-    plt.show()          # Fenster offen → hier läuft die Event-Schleife
-                        # Fenster zu → show() kehrt zurück → Script endet
+        return pos_sorted, (eigvals_real, eigvecs)