kib-lap 0.5__cp313-cp313-win_amd64.whl

KIB_LAP/Dynamik/Pendulum_Spring_Linearized.py

@@ -0,0 +1,91 @@
+import numpy as np
+from matplotlib import pyplot as plt
+from math import cos, sin, pi
+
+
+class TwoMassesSpring_Lin:
+    def __init__(
+        self,
+        r_inp=5,
+        E_inp=30000e6,
+        I_inp=833.33,
+        l_inp=30,
+        m1_inp=5.625e6,
+        m2_inp=981250, dtinp = 1e-3, timeinp = 10,
+        dtinp = 1e-3, timeinp = 10,
+        _phi_0 = 30 , _x1_0 = 0,
+        _dphi_0 = 0 , _dx1_0 = 0
+    ):
+
+        self.r = r_inp
+        E = E_inp
+
+        I = I_inp
+        l = l_inp
+
+
+
+        # Mass parameters
+        self.m_1 = m1_inp
+        self.m_2 = m2_inp
+
+        self.k_1 = 3 * E * I / l**3  
+
+        self.g = 9.81  # Gravity constant
+
+        # Initial conditions
+        self.x1_0 = _x1_0
+        self.phi_0 =  _phi_0  / 180 * np.pi
+        self.xd1_0 =  _dphi_0
+        self.phid_0 = _x1_0
+
+        # Time steps
+        self.dt = dtinp
+        self.T_ges = timeinp
+        self.N_steps = int(self.T_ges / self.dt)
+
+    def construct_mass_matrix(self, phi):
+        m_11 = self.m_1 + self.m_2
+        m_12 = self.m_2 * self.r
+        m_21 = self.m_2 * self.r
+        m_22 = self.m_2 * self.r**2
+
+        M = np.array([[m_11, m_12], [m_21, m_22]])
+        return M
+
+    def construct_force_vector(self, phi, phid):
+        f_10 = -self.k_1 * self.x1_0
+        f_20 = -self.m_2 * self.g * self.r * phi
+
+        F = np.array([f_10, f_20])
+        return F
+
+    def equations_of_motion(self, state):
+        x1, phi, xd1, phid = state
+        M = self.construct_mass_matrix(phi)
+        F = self.construct_force_vector(phi, phid)
+        acc = np.linalg.solve(M, F)
+        return np.array([xd1, phid, acc[0], acc[1]])
+
+    def RK4_step(self, state):
+        k1 = self.equations_of_motion(state)
+        k2 = self.equations_of_motion(state + 0.5 * k1 * self.dt)
+        k3 = self.equations_of_motion(state + 0.5 * k2 * self.dt)
+        k4 = self.equations_of_motion(state + k3 * self.dt)
+        return state + self.dt * (k1 + 2 * k2 + 2 * k3 + k4) / 6
+
+    def solve(self):
+        state = np.array(
+            [self.x1_0, self.phi_0, self.xd1_0, self.phid_0]
+        )  # Initial state [x1, phi, xd1, phid]
+        list_x1 = []
+        list_phi = []
+        time = []
+
+        for i in range(self.N_steps):
+            state = self.RK4_step(state)
+            list_x1.append(state[0])
+            list_phi.append(state[1])
+            time.append(self.dt * i)
+
+        return time, list_x1, list_phi

KIB_LAP/Dynamik/Pendulum_Spring_Problem.py

@@ -0,0 +1,94 @@
+import numpy as np
+from math import sin, cos
+from matplotlib import pyplot as plt
+
+
+class TwoMassesSpringRopeRK4:
+    def __init__(
+        self,
+        r_inp=5,
+        E_inp=30000e6,
+        I_inp=833.33,
+        l_inp=30,
+        m1_inp=5.625e6,
+        m2_inp=981250,
+        dtinp = 1e-3, timeinp = 10,
+        _phi_0 = 30 , _x1_0 = 0,
+        _dphi_0 = 0 , _dx1_0 = 0
+    ):
+        self.r = r_inp
+        E = E_inp
+        I = I_inp
+        l = l_inp
+
+
+        self.k_1 = 3 * E * I / l**3  
+
+        # Mass parameters
+        self.m_1 = m1_inp
+        self.m_2 = m2_inp
+
+        # Damping parameters
+
+        # Gravity
+
+        self.g = 9.81  # Gravity constant
+
+        # Initial conditions
+        self.x1_0 = _x1_0
+        self.phi_0 =  _phi_0  / 180 * np.pi
+        self.xd1_0 =  _dphi_0
+        self.phid_0 = _x1_0
+
+        # Time steps
+        self.dt = dtinp
+        self.T_ges = timeinp
+        self.N_steps = int(self.T_ges / self.dt)
+
+    def construct_mass_matrix(self, phi):
+        m_11 = self.m_1 + self.m_2
+        m_12 = self.m_2 * self.r * cos(phi)
+        m_21 = self.m_2 * self.r * cos(phi)
+        m_22 = self.m_2 * self.r**2
+
+        M = np.array([[m_11, m_12], [m_21, m_22]])
+        return M
+
+    def construct_force_vector(self, phi, phid):
+        f_10 = -self.k_1 * self.x1_0 + self.m_2 * self.r * phid**2 * sin(phi)
+        f_20 = -self.m_2 * self.g * self.r * sin(phi)
+
+        F = np.array([f_10, f_20])
+        return F
+
+    def equations_of_motion(self, state):
+        x1, phi, xd1, phid = state
+        M = self.construct_mass_matrix(phi)
+        F = self.construct_force_vector(phi, phid)
+        acc = np.linalg.solve(M, F)
+        return np.array([xd1, phid, acc[0], acc[1]])
+
+    def RK4_step(self, state):
+        k1 = self.equations_of_motion(state)
+        k2 = self.equations_of_motion(state + 0.5 * k1 * self.dt)
+        k3 = self.equations_of_motion(state + 0.5 * k2 * self.dt)
+        k4 = self.equations_of_motion(state + k3 * self.dt)
+        return state + self.dt * (k1 + 2 * k2 + 2 * k3 + k4) / 6
+
+    def solve(self):
+        state = np.array(
+            [self.x1_0, self.phi_0, self.xd1_0, self.phid_0]
+        )  # Initial state [x1, phi, xd1, phid]
+        list_x1 = []
+        list_phi = []
+        time = []
+
+        for i in range(self.N_steps):
+            state = self.RK4_step(state)
+            list_x1.append(state[0])
+            list_phi.append(state[1])
+            time.append(self.dt * i)
+
+        return time, list_x1, list_phi
+
+

KIB_LAP/Examples/Cross_Section_Thin.py

@@ -0,0 +1,61 @@
+
+import pandas as pd
+import os
+import sys
+import numpy as np
+
+# Absoluten Pfad des Projekts und des KIB-Ordners berechnen
+project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+kib_directory = os.path.join(project_root, "KIB_LAP")
+
+# Debug-Ausgabe, um die Pfade zu überprüfen
+print("Project Root:", project_root)
+print("KIB Directory:", kib_directory)
+
+# Füge das KIB-Verzeichnis zum sys.path hinzu, falls es nicht vorhanden ist
+if kib_directory not in sys.path:
+    sys.path.insert(0, kib_directory)
+
+# Importieren des Moduls
+try:
+    from KIB_LAP.Querschnittswerte import CrossSectionThin 
+    print("Import erfolgreich!")
+except ModuleNotFoundError as e:
+    print("Fehler beim Import:", e)
+
+
+Node_Cords = pd.DataFrame({
+    "Nr.": [1, 2, 3, 4, 5, 6],
+    "y": [-0.35, 0, 0.35, 0, -0.30, 0.30],
+    "z": [0, 0, 0, 0.400, 0.400, 0.400]
+})
+
+
+CrossSectionElements = pd.DataFrame({
+    "nr": [1, 2, 3, 4, 5],
+    "npa": [1, 2, 2, 4, 4],
+    "npe": [2, 3, 4, 5, 6],
+    "t [m]": [0.02, 0.02, 0.01, 0.02, 0.02]
+})
+
+Class = CrossSectionThin(
+    2.1e5,
+    0.3,
+    Node_Cords,
+    CrossSectionElements,
+    "Calculation"
+)
+
+
+Class.read_node_input()
+Class.CalculateElementStiffness()
+Class.Calculate_GesMat()
+Class.SolverTorsion()
+Class.CalculateAyzw()
+Class.Update_SMP()
+Class.Calculate_IwIt()
+Class.Calculate_WoWu()
+Class.Calculate_ShearStress_Vz()
+Class.Calculate_imryrzrw()
+Class.Export_Controll_Data()
+Class.Export_Cross_Section_Data()

KIB_LAP/Examples/Cross_Section_Thin_2.py

@@ -0,0 +1,14 @@
+from KIB_LAP.Querschnittswerte import CrossSectionThin
+import pandas as pd
+
+# Lade die hochgeladenen CSV-Dateien
+node_file_path = 'Querschnittswerte/Knoten.csv'
+element_file_path = 'Querschnittswerte/Elemente.csv'
+
+# Dateien einlesen
+node_data = pd.read_csv(node_file_path)
+element_data = pd.read_csv(element_file_path)
+
+CS = CrossSectionThin(210000,0.30,node_param=node_data, element_param=element_data, Speichername = "Calculation_2")
+
+CS.Calculation_Start()

KIB_LAP/Examples/Plattentragwerke.py

@@ -0,0 +1,39 @@
+# Beispielhafte Nutzung der Klasse
+from KIB_LAP.Plattentragwerke import PlateBendingKirchhoffClass
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib import cm
+import pandas as pd
+import time
+import os
+
+if __name__ == "__main__":
+    a = 14
+    b = 4.5
+
+    Plate = PlateBendingKirchhoffClass(
+        E=35000,
+        t=0.35,
+        a=a,
+        b=b,
+        p0=1,
+        x0=0.5,
+        u=0.5,
+        y0=0.5,
+        v=0.5,
+        nu=0.0,
+        n_inte=30,
+        loading="Regular",
+        support="hhhh",
+        reihen=20
+    )
+
+    start_time = time.time()
+    Plate.CalculateAll()
+    end_time = time.time()
+    duration = end_time - start_time
+
+    print("Berechnungszeit:", duration, "Sekunden")
+
+    Plate.PlotLoad()
+    Plate.PlotMomentGrid()

KIB_LAP/Examples/Plattentragwerke_2.py

@@ -0,0 +1,60 @@
+from KIB_LAP.Plattentragwerke import PlateBendingKirchhoffClass
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib import cm
+import pandas as pd
+import time
+import os
+
+
+a = 10.5
+b = 10
+
+Plate = PlateBendingKirchhoffClass(
+    35000, 0.35, a, b, 1, 0.5, 0.5, 0.5, 0.5, 0.0, 0, 0, n_inte=50, loading="Liste", support = "hhff",reihen = 8)
+
+
+# Daten als Liste von Listen
+new_data = [
+    ["No.","x0[m]","x1[m]","y0[m]","y1[m]","p0[MN/m**2]"],
+    [1,2-0.2,2+0.2,0.5,0.9,150/0.4**2/1000],
+    [2,3.2-0.2,3.2+0.2,0.5,0.9,150/0.4**2/1000],
+    [3,3.2-0.2,3.2+0.2,2.5,2.9,150/0.4**2/1000],
+    [4,2-0.2,2+0.2,2.5,2.9,150/0.4**2/1000], 
+
+    [6,2-0.2,2+0.2,3.5,3.9,100/0.4**2/1000],
+    [7,3.2-0.2,3.2+0.2,3.5,3.9,100/0.4**2/1000],
+    [8,3.2-0.2,3.2+0.2,5.5,5.9,100/0.4**2/1000],
+    [9,2-0.2,2+0.2,5.5,5.9,100/0.4**2/1000],
+
+    [10,2-0.2,2+0.2,6.5,6.9,100/0.4**2/1000],
+    [11,3.2-0.2,3.2+0.2,6.5,6.9,100/0.4**2/1000],
+    [12,3.2-0.2,3.2+0.2,8.5,8.9,100/0.4**2/1000],
+    [13,2-0.2,2+0.2,8.5,8.9,100/0.4**2/1000]
+
+]
+
+# Konvertiere die Daten in ein DataFrame
+df = pd.DataFrame(new_data[1:], columns=new_data[0])
+
+# Dateipfad zur CSV-Datei
+file_path = 'Loading/Constant_Loading.csv'
+
+# Schreibe das DataFrame in eine CSV-Datei
+df.to_csv(file_path, index=False)
+
+
+Plate.CalculateAll()
+
+Plate.SolutionPointDisp(0.5,0.5)
+Plate.SolutionPointMomentx(0.5,0.5)
+Plate.SolutionPointMomenty(0.5,0.5)
+
+
+Plate.PlotLoad()
+print("BENDING MOMENTS")
+Plate.PlotMomentGrid()
+print("SHEAR FORCES")
+Plate.PlotShearForceGrid()
+print("DRILL MOMENTS")
+Plate.PlotTorsionalMomentGrid()

KIB_LAP/Examples/ShearDesign.py

@@ -0,0 +1,28 @@
+from KIB_LAP.Betonbau import BeamRectangular
+from KIB_LAP.Betonbau import BeamSubSection
+
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib import cm
+import pandas as pd
+import time
+import os
+
+
+Beam = BeamRectangular(1,1.00,0.60)
+
+moment_ed = 0.20
+normal_force_ed = 0.20
+shear_force_ed  = 0.30
+effective_height = 0.65
+effective_height_pressure = 0.08
+elasticity_modulus_steel = 200000 
+
+BeamSection = BeamSubSection(moment_ed, normal_force_ed,shear_force_ed, effective_height,effective_height_pressure, elasticity_modulus_steel)
+
+
+Beam.calculate_beam_section_without_shearreinforcement(BeamSection,30*0.01**2,35,500)
+
+
+print(Beam.v_rdcs * 1000)
+print(Beam.v_rdcmin * 1000)

KIB_LAP/Plattenbeulen/Plate_Design.py

@@ -0,0 +1,276 @@
+
+
+import numpy as np
+import matplotlib.pyplot as plt
+
+from pylatex import (
+    Document,
+    Section,
+    Subsection,
+    Command,
+    Tabular,
+    Math,
+    TikZ,
+    Axis,
+    Plot,
+    Figure,
+    Matrix,
+    Alignat,
+    MultiRow,
+    MultiColumn, 
+    Tabularx,
+    Tabu,
+    ColumnType,
+    LongTable,
+    Table, 
+    Center
+
+)
+
+from pylatex.utils import escape_latex, fix_filename, dumps_list, bold, \
+    italic, verbatim, NoEscape
+
+
+
+class Beulnachweise_Platten:
+    """
+    Das ist eine Klasse zur Berechnung einfacher Beulfelder.
+
+    self.sigma_1_x =    Größte Druckspannung an einer Seite des Beulfeldes.
+                        Hier wird üblicherweise ein positives Vorzeichen        
+                        für Druckspannungen gewählt.
+
+
+
+    """
+    def __init__(self):
+        # Spannungen aus Sofistik
+        self.sigma_1_x = 387.5       # Druckspannung (Positiv)
+        self.sigma_2_x = -262.9      # Zugspannung negativ
+        self.sigma_1_v = 387.5
+        self.sigma_2_v = 262.9
+        self.tau_1 = 0
+        self.tau_2 = 0
+
+        # Materialkenngrößen
+        self.fyd = 460
+        self.E_s = 210e3 
+
+        # Faktoren bis zum Erreichen der kritischen Beulvergleichsspannungen
+        self.alpha_ult_k_1_x = self.fyd/self.sigma_1_x
+        # Geometrie des Beulfeldes
+        self.b = 5.00
+        self.a = 1.90
+        self.t = 0.02
+        self.alpha = self.a/self.b
+
+        self.chi_w  = 0
+        self.rho    = 0
+
+    def Nachweisfuehrung(self):
+        # Ermittlung linear elastischer Beulspannungen
+
+        self.sigma_e = 1.9*(100*self.t/self.b)**2*10
+        self.psi = self.sigma_2_x/self.sigma_1_x       # Randspannungsverhältnis bezogen auf die größe Druckspannung (Druck positiv)
+
+        self.k_sigma = (self.alpha + 1/self.alpha)**2 * (2.1)/(self.psi+1.1)
+
+        self.sigma_cr = self.k_sigma*self.sigma_e
+        self.alpha_cr = self.sigma_cr/self.sigma_1_x
+
+        self.alpha_ult_k = self.fyd/self.sigma_1_v
+    
+        #____Abminderungsfaktoren für das Plattenbeulen für ein beidseitig gestützes Feld___#
+        self.lambda_p = np.sqrt(self.alpha_ult_k/self.alpha_cr)
+
+        # Abminderungsfaktor chi_w
+
+        self.eta = 1.20
+        if (self.fyd > 460):
+            self.eta = 1.00
+        if (self.lambda_p < 0.83/self.eta):
+            self.chi_w = self.eta
+        elif(self.lambda_p >= 0.83 / self.eta):
+            self.chi_w = 0.83 / self.lambda_p
+        
+        print(self.chi_w)
+
+        # Abminderungskenngröße rho_x
+        # Für plattenartiges Versagen
+
+        if (self.lambda_p <= 0.5 + np.sqrt(0.085 - 0.055 * self.psi)):
+            self.rho = 1.0
+        elif (self.lambda_p > 0.5 + np.sqrt(0.085 - 0.055 * self.psi)):
+            self.rho = min((self.lambda_p - 0.055 * (3+self.psi))/(self.lambda_p**2),1.00)
+
+        # Für Knickstabähnliches Verhalten
+
+        self.alpha_e    = 0.21 # Für nicht ausgesteifte Blechfelder: alpha_e = 0.21
+
+        self.phi        = 0.5*(1+self.alpha_e*(self.lambda_p -0.2) + self.lambda_p**2)
+
+        self.chi_c      = 1/(self.phi + np.sqrt(self.phi**2 - self.lambda_p**2))
+
+        # Knickspannung
+
+        self.sigma_cr_r = (np.pi**2 * self.E_s * self.t**2)/(12 * (1-0.3)*self.a**2)
+        self.sigma_cr_p_x = self.sigma_1_x
+
+        # Interpolation zwischen plattenartigen / knickstabähnlichem Verhalten
+
+        self.xi = self.sigma_cr_p_x/self.sigma_cr_r-1
+
+        print(self.xi)
+
+        self.xi = max(min(self.xi,1),0)
+
+        print(self.xi)
+
+        self.rho_x = (self.rho - self.chi_c)*self.xi*(2-self.xi) + self.chi_c
+
+        print(self.rho_x)
+
+
+        # Nachweisführung
+
+        self.eta = (self.sigma_1_x/(self.fyd * self.rho_x / 1.10))
+
+    def Ausgabe_Pdf_Latex(self,width ,*args, **kwargs):
+        fname = "Beulnachweise"
+        geometry_options = {"right": "2cm", "left": "2cm"}
+        self.doc = Document(fname, geometry_options=geometry_options)
+
+        with self.doc.create(Section("Berechnung der Beulnachweise nach DIN EN 1993-1-5")):
+            self.doc.append("Take a look at this beautiful plot:")
+
+            # with doc.create(Figure(position="htbp")) as plot:
+            #     plot.add_plot(width=NoEscape(width), *args, **kwargs)
+            #     plot.add_caption("I am a caption.")
+
+            self.doc.create(Subsection("Materialkenngrößen"))
+            self.doc.append("")
+            #self.doc.append(Math(data=["2*3", "=", 3 * 2]))
+
+        self.doc.create(Subsection("Geometrische und materielle Kenngrößen"))
+
+        def Material_Properties():
+            # Tabular
+
+            self.doc.append(NoEscape(r"\centering"))
+            
+            table = Table(position="htb")
+
+            self.doc.append(Command('centering'))
+            table.add_caption("Material properties")
+
+
+            t = Tabular(table_spec='|c|c|c|', data=None, pos=1, width=3)
+
+            t.add_hline(start=None, end=None)
+
+            t.add_row(("Kenngröße", "Wert", "Einheit"), escape=False, strict=True, mapper=[bold])
+            t.add_hline(start=None, end=None)
+
+            t.add_row(["Streckgrenze", self.fyd, "MN/m²"])
+            t.add_row([NoEscape(r"Streckgrenze - $$\gamma_{\text{M1}}$$") , f"{self.fyd/1.10:.2f}", "MN/m²"])
+            t.add_row(["E-Modul", self.E_s, "MN/m²"])
+            t.add_hline(start=None, end=None)
+            # t.add_row(1, 2, escape=False, strict=True, mapper=[bold])
+
+            # # MultiColumn/MultiRow.
+            # t.add_row((MultiColumn(size=2, align='|c|', data='MultiColumn'),),
+            #         strict=True)
+
+            # # One multiRow-cell in that table would not be proper LaTeX,
+            # # so strict is set to False
+
+            # t.add_row((MultiRow(size=2, width='*', data='MultiRow'),), strict=False)
+
+            # append tabular to table
+            table.append(t)
+
+            table = self.doc.append(table)
+
+
+
+        Material_Properties()
+
+        def Section_Entry_Parameters():
+            
+            table = Table(position="htb")
+
+            
+            table.add_caption("Eingangsgrößen")
+
+            t = Tabular(table_spec='|c|c|c|', data=None, pos=1, width=3)
+            self.doc.append(Command('centering'))
+
+            t.add_hline(start=None, end=None)
+
+            t.add_row(("Kenngröße", "Wert", "Einheit"), escape=False, strict=True, mapper=[bold])
+            t.add_hline(start=None, end=None)
+
+            t.add_row(["Länge des Beulfeldes a", self.a, "m"])
+            t.add_row(["Breite des Beulfeldes a", self.b, "m"])
+            t.add_row(["Blechdicke t ", self.t, "m"])
+
+            t.add_row([NoEscape(r"Seitenverhältnis $$\alpha $$"), f"{self.a/self.b:.2f}", "-"])
+            t.add_row([NoEscape(r"Spannungsverhältnis  $$\psi $$"), f"{self.psi:.2f}", "-"])
+
+            t.add_hline(start=None, end=None)
+            # t.add_row(1, 2, escape=False, strict=True, mapper=[bold])
+
+            # # MultiColumn/MultiRow.
+            # t.add_row((MultiColumn(size=2, align='|c|', data='MultiColumn'),),
+            #         strict=True)
+
+            # # One multiRow-cell in that table would not be proper LaTeX,
+            # # so strict is set to False
+
+            # t.add_row((MultiRow(size=2, width='*', data='MultiRow'),), strict=False)
+
+            # append tabular to table
+            table.append(t)
+
+            table = self.doc.append(table)
+
+        Section_Entry_Parameters()
+
+        self.doc.create(Subsection("Abminderungsfaktoren für die Streckgrenze"))
+
+        def Abschnitt_Beulwerte():
+            self.doc.append(NoEscape(f"Die Beulwerte werden zunächst in Abhängigkeit des Seitenverhältnisses {{\alpha}} bestimmt. "))
+            self.doc.append(NoEscape(f"Für Seitenverhältnisse <= 1  sind die Beulwerte (rechnerisch) unabhängig vom Seitenverhältnis."))
+
+                                
+            if (self.alpha < 1.0):
+                self.doc.append(Math(data=[NoEscape(f"k_{{\sigma}} = ({self.alpha:.2f} + 1/{self.alpha:.2f} ){{^2}} {{\cdot}} 2.1/({self.psi:.2f} +1.1) = {self.k_sigma:.2f}")])) 
+            elif (self.alpha > 1.0):
+                if (self.psi == -1):
+                    self.doc.append(Math(data=[23.9]))
+                elif(self.psi <0 and self.psi > -1):
+                    self.res_biegung_normal = 7.81 - 6.29 * self.psi + 9.78 * self.psi**2
+                    self.doc.append(Math(data=[NoEscape(f"k_{{\sigma}} = 7.81 - 6.29 {{\cdot \psi}} + 9.78 {{\cdot \psi^2 }} = {self.res_biegung_normal}")]))
+
+        Abschnitt_Beulwerte()
+
+
+
+
+
+
+
+        self.doc.generate_pdf(clean_tex=False)
+
+
+
+
+        
+
+# a = Beulnachweise_Platten()
+# a.Nachweisfuehrung()
+# a.Ausgabe_Pdf_Latex(10)
+
+        
+
+