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

KIB_LAP/Betonbau/TEST_Rectangular.py

@@ -0,0 +1,21 @@
+from beam_sub_section import *
+from beam_rectangular import *
+
+
+moment_ed = 1.00
+normal_force_ed = 0
+shear_force_ed = 0.5
+effective_height = 0.55
+effective_height_pressure = 0.05
+elasticity_modulus_steel = 200000
+
+Section_1 = BeamSubSection( moment_ed, 
+normal_force_ed, 
+shear_force_ed, 
+effective_height, 
+effective_height_pressure, 
+elasticity_modulus_steel)
+
+BEAM = BeamRectangular(1,1.00,0.60)
+BEAM.calculate_beam_section(Section_1 , 30, 500, 0.296)
+BEAM.calculate_beam_section_without_shearreinforcement(Section_1 , 16.3e-4,30,500)

KIB_LAP/Betonbau/beam_rectangular.py

@@ -459,6 +459,10 @@ class BeamRectangular:
         else:
             print("Minimum reinforcement is dominant!")
             print("Required bending reinforcement: ", np.around(Asmin, 3), "cm²")
+            print("CHECK")
+            print("Iteration steps: ", num_iter)
+            print("Conrete Force ", np.around(Fc_1 + Fc_2 + Fc_3, 3), "MN")
+
             reinforcement = [float(Asmin), float(0.0)]
             needed_reinforcement.append(reinforcement)
 

KIB_LAP/FACHWERKEBEN/Elements.py

@@ -0,0 +1,209 @@
+# DEPENDENCIES
+import copy  # Allows us to create copies of objects in memory
+import math  # Math functionality
+import numpy as np  # Numpy for working with arrays
+import matplotlib.pyplot as plt  # Plotting functionality
+import matplotlib.colors  # For colormap functionality
+import ipywidgets as widgets
+from glob import glob  # Allows check that file exists before import
+from numpy import genfromtxt  # For importing structure data from csv
+import pandas as pd
+
+
+class Rope_Elements_III:
+    def __init__(self, InputData):
+        print("Rope elements")
+        self.Inp = InputData
+
+    def calculateTransMatrix(self, posI, posJ):
+        """
+        Takes in the position of node I and J and returns the transformation matrix for the member
+        This will to be recalculated as the structure deflects with each iteration
+        """
+        T = np.zeros([2, 4])
+        ix = posI[0]  # x-coord for node i
+        iy = posI[1]  # y-coord for node i
+        jx = posJ[0]  # x-coord for node j
+        jy = posJ[1]  # y-coord for node j
+
+        dx = jx - ix  # x-component of vector along member
+        dy = jy - iy  # y-component of vector along member
+        length = math.sqrt(dx**2 + dy**2)  # Magnitude of vector (length of member)
+
+        lp = dx / length
+        mp = dy / length
+        lq = -mp
+        mq = lp
+
+        T = np.array([[-lp, -mp, lp, mp], [-lq, -mq, lq, mq]])
+
+        return T
+
+    def buildElementStiffnessMatrix(self, n, UG, TMs, lengths, P0, E, Areas):
+        """
+        Build element stiffness matrix based on current position and axial force
+        n = member index
+        UG = vector of global cumulative displacements
+        """
+
+        # Calculate 'new' positions of nodes using UG
+        node_i = self.Inp.members[n][0]  # Node number for node i of this member
+        node_j = self.Inp.members[n][1]  # Node number for node j of this member
+
+        # Index of DoF for this member
+        ia = 2 * node_i - 2  # horizontal DoF at node i of this member
+        ib = 2 * node_i - 1  # vertical DoF at node i of this member
+        ja = 2 * node_j - 2  # horizontal DoF at node j of this member
+        jb = 2 * node_j - 1  # vertical DoF at node j of this member
+
+        # Displacements
+        d_ix = UG[ia, 0]
+        d_iy = UG[ib, 0]
+        d_jx = UG[ja, 0]
+        d_jy = UG[jb, 0]
+
+        # Extract current version of transformation matrix [T]
+        TM = TMs[n, :, :]
+
+        # Calculate local displacements [u, v, w] using global cumulative displacements UG
+        localDisp = np.matmul(TM, np.array([[d_ix, d_iy, d_jx, d_jy]]).T)
+        u = localDisp[0].item()
+        v = localDisp[1].item()
+
+        # Calculate extension, e
+        Lo = lengths[n]
+        e = math.sqrt((Lo + u) ** 2 + v**2) - Lo
+
+        # Calculate matrix [AA]
+        a1 = (Lo + u) / (Lo + e)
+        a2 = v / (Lo + e)
+        AA = np.array([[a1, a2]])
+
+        # Calculate axial load, P
+
+        P = P0[n] + (E[n] * Areas[n] / Lo) * e
+
+        # Calculate matrix [d]
+        d11 = P * v**2
+        d12 = -P * v * (Lo + u)
+        d21 = -P * v * (Lo + u)
+        d22 = P * (Lo + u) ** 2
+        denominator = (Lo + e) ** 3
+
+        d = (1 / denominator) * np.array([[d11, d12], [d21, d22]])
+
+        # Calculate element stiffness matrix
+
+        NL = np.matrix((AA.T * (E[n] * Areas[n] / Lo) * AA) + d)
+        k = TM.T * NL * TM
+
+        # Return element stiffness matrix in quadrants
+        K11 = k[0:2, 0:2]
+        K12 = k[0:2, 2:4]
+        K21 = k[2:4, 0:2]
+        K22 = k[2:4, 2:4]
+
+        return [K11, K12, K21, K22]
+
+
+import numpy as np
+import math
+
+
+class BarElements_I:
+    """
+    2D Bar/Truss element (Theorie I. Ordnung, small displacement).
+    2 DOF per node: ux, uy
+
+    - Uses UNDEFORMED geometry for transformation and stiffness (linear).
+    - Optional initial axial force P0 can be included in member force reporting,
+      but is NOT used as geometric stiffness here (Theorie I. Ordnung).
+    """
+
+    def __init__(self, InputData):
+        self.Inp = InputData
+
+        # Precompute direction cosines + lengths from undeformed geometry (constant)
+        self.L0 = np.zeros(len(self.Inp.members), dtype=float)
+        self.c  = np.zeros(len(self.Inp.members), dtype=float)
+        self.s  = np.zeros(len(self.Inp.members), dtype=float)
+
+        for n, (ni, nj) in enumerate(self.Inp.members):
+            ix, iy = self.Inp.nodes[ni - 1, 0], self.Inp.nodes[ni - 1, 1]
+            jx, jy = self.Inp.nodes[nj - 1, 0], self.Inp.nodes[nj - 1, 1]
+            dx, dy = (jx - ix), (jy - iy)
+            L = math.sqrt(dx * dx + dy * dy)
+            if L == 0.0:
+                raise ValueError(f"Bar element has zero length at member index {n} (nodes {ni}-{nj})")
+
+            self.L0[n] = L
+            self.c[n]  = dx / L
+            self.s[n]  = dy / L
+
+    def buildElementStiffnessMatrix(self, n, UG, TMs_unused, lengths_unused, P0, E, Areas):
+        """
+        Returns [K11, K12, K21, K22] (each 2x2) in GLOBAL coordinates.
+        """
+        L  = self.L0[n]
+        EA = E[n] * Areas[n]
+        k0 = EA / L
+
+        c = self.c[n]
+        s = self.s[n]
+
+        # 4x4 global stiffness for 2D truss
+        k = k0 * np.array([
+            [ c*c,  c*s, -c*c, -c*s],
+            [ c*s,  s*s, -c*s, -s*s],
+            [-c*c, -c*s,  c*c,  c*s],
+            [-c*s, -s*s,  c*s,  s*s]
+        ], dtype=float)
+
+        K11 = k[0:2, 0:2]
+        K12 = k[0:2, 2:4]
+        K21 = k[2:4, 0:2]
+        K22 = k[2:4, 2:4]
+        return [K11, K12, K21, K22]
+
+    def axial_force(self, n, UG, E, Areas, P0=None):
+        """
+        Member axial force (tension +) from SMALL displacement theory:
+            N = (EA/L) * ( [-c -s c s] * u_e )
+        Optionally + P0[n] if you want to report pretension as part of N.
+        """
+        ni, nj = self.Inp.members[n]
+        ia, ib = 2 * ni - 2, 2 * ni - 1
+        ja, jb = 2 * nj - 2, 2 * nj - 1
+
+        ue = np.array([UG[ia, 0], UG[ib, 0], UG[ja, 0], UG[jb, 0]], dtype=float)
+
+        c = self.c[n]
+        s = self.s[n]
+        L = self.L0[n]
+        EA = E[n] * Areas[n]
+
+        N = (EA / L) * (-c * ue[0] - s * ue[1] + c * ue[2] + s * ue[3])
+
+        if P0 is not None:
+            N = N + float(P0[n])
+        return float(N)
+
+    def internal_nodal_forces_global(self, n, UG, E, Areas, P0=None):
+        """
+        Equivalent internal nodal force vector (4x1) in global coords:
+            f_int_e = N * [-c, -s, c, s]^T
+        """
+        c = self.c[n]
+        s = self.s[n]
+        N = self.axial_force(n, UG, E, Areas, P0=P0)
+
+        f = N * np.array([[-c], [-s], [c], [s]], dtype=float)
+        return f
+
+
+
+class Rope_Elements_II:
+    def __init__(self):
+        print("Rope elements")
+
+

KIB_LAP/FACHWERKEBEN/InputData.py

@@ -0,0 +1,118 @@
+# DEPENDENCIES
+import copy  # Allows us to create copies of objects in memory
+import math  # Math functionality
+import numpy as np  # Numpy for working with arrays
+import matplotlib.pyplot as plt  # Plotting functionality
+import matplotlib.colors  # For colormap functionality
+import ipywidgets as widgets
+from glob import glob  # Allows check that file exists before import
+from numpy import genfromtxt  # For importing structure data from csv
+import pandas as pd
+
+class Input:
+    def __init__(self):
+        print("Input-Class")
+        self.NodalData()
+        self.EdgeData()
+        self.CableData()
+        self.RestraintData()
+        self.SpringData()
+        self.ForceData()
+
+
+    # =================================START OF DATA IMPORT================================
+    def NodalData(self):
+        # MANDATORY IMPORT: nodal coordinates
+        if glob("data/Vertices.csv"):
+            self.nodes = genfromtxt("data/Vertices.csv", delimiter=",")
+            print("1. 🟢 Vertices.csv imported")
+        else:
+            print("1. 🛑 STOP: Vertices.csv not found")
+
+    def EdgeData(self):
+        # MANDATORY IMPORT: member definitions
+        if glob("data/Edges.csv"):
+            self.members = genfromtxt("data/Edges.csv", delimiter=",")
+            self.members = np.int_(self.members)
+            self.nDoF = (
+                np.amax(self.members) * 2
+            )  # Total number of degrees of freedom in the problem
+            print("2. 🟢 Edges.csv imported")
+        else:
+            print("2. 🛑 STOP: Edges.csv not found")
+
+    def RestraintData(self):
+        # Prüfen, ob die Datei existiert
+        if glob("data/Restraint-Data.csv"):
+            # CSV einlesen; da es sich um eine einzelne Spalte handelt, reicht der Standard
+            self.restraintData = genfromtxt("data/Restraint-Data.csv")
+            # Sicherstellen, dass die Daten mindestens ein 1D-Array sind
+            self.restraintData = np.atleast_1d(self.restraintData)
+            # In Integer umwandeln (falls als float gelesen)
+            self.restraintData = np.int_(self.restraintData)
+            # Daten flach machen (bei einer einzelnen Spalte ist das optional)
+            flatData = self.restraintData.flatten()
+            # 0-Werte entfernen (0 = kein Einspannen)
+            self.restrainedDoF = flatData[flatData != 0].tolist()
+            # Von den in der CSV angegebenen Freiheitsgraden (beginnend bei 1)
+            # zu Python-Index (beginnend bei 0) konvertieren
+            self.restrainedIndex = [x - 1 for x in self.restrainedDoF]
+            # Unbeschränkte Freiheitsgrade berechnen
+            self.freeDoF = np.delete(np.arange(0, self.nDoF), self.restrainedIndex)
+            print("3. 🟢 Restraint-Data.csv imported")
+        else:
+            print("3. 🛑 STOP: Restraint-Data.csv not found")
+
+    def SpringData(self):
+        if glob("data/springs.csv"):
+            # Annahme: Die erste Zeile enthält Header
+            df = pd.read_csv("data/springs.csv")
+            # Numerische Spalten
+            numeric_columns = ['no','Node', 'c_const[N/m]']
+            df_numeric = df[numeric_columns]
+            # Konvertiere das DataFrame zu einem NumPy-Array vom Typ int
+            self.springLocationData = df_numeric.to_numpy(dtype=int)
+            # Save the spring directions
+            self.SpringDirections = df['Dir'].to_numpy()
+            print("4. 🟢 springs.csv imported")
+        else:
+            self.forceLocationData = []
+            print("4. ⚠️ springs.csv not found")
+
+    def ForceData(self):
+        # OPTIONAL IMPORT: force location data
+        if glob("data/Force-Data.csv"):
+            # Annahme: Die erste Zeile enthält Header
+            df = pd.read_csv("data/Force-Data.csv")
+            
+            # Wähle nur die numerischen Spalten aus (z.B. 'Node' und 'P[N]')
+            numeric_columns = ['Node', 'P[N]']
+            df_numeric = df[numeric_columns]
+            
+            # Konvertiere das DataFrame zu einem NumPy-Array vom Typ int
+            self.forceLocationData = df_numeric.to_numpy(dtype=int)
+            
+            # Bestimme die Anzahl der Dimensionen des Arrays
+            self.nForces = self.forceLocationData.ndim
+            
+            # Falls das Array weniger als 2-dimensional ist, füge eine zusätzliche Dimension hinzu
+            if self.nForces < 2:
+                self.forceLocationData = np.expand_dims(self.forceLocationData, axis=0)
+
+            # (Optional) Verarbeite die 'Dir'-Spalte, falls benötigt
+            # Beispiel: Speichere die Richtungen separat
+            self.forceDirections = df['Dir'].to_numpy()
+            
+            print("4. 🟢 Force-Data.csv imported")
+        else:
+            self.forceLocationData = []
+            print("4. ⚠️ Force-Data.csv not found")
+
+    def CableData(self):
+        #MANDATORY IMPORT: cable definitions
+        if glob('data/Cables.csv'): 
+            self.cables = genfromtxt('data/Cables.csv', delimiter=',') 
+            print('3. 🟢 Cables.csv imported')
+        else: 
+            self.cables = []
+            print('3. 🛑 STOP: Cables.csv not found')