kib-lap 0.5__cp313-cp313-win_amd64.whl

KIB_LAP/Betonbau/Materialkennwerte_Beton.py

@@ -0,0 +1,196 @@
+
+import numpy as np
+class Baustoffe:
+    def __init__(self, liste_baustoffe, h_c=0.13, b_c=4, traeger="FT", t0=1, t=365,ts = 1):
+        """
+        Klasse zur Berechnung der Baustoffparameter: Eingabe in [MN/m², m , MN, etc.]
+        liste_baustoffe: Eingabe von [fck,fyk] \n
+        h_c = Höhe des Betonträgers zur Berechnung von h0 in [m] \n
+        b_c = Bezugsbreite in [m] \n
+        traeger = Eingabe des Umfangs, welcher der freien Trocknung ausgesetzt ist \n
+                   Für Fertigteile ergibt sich hier: h0 = 2*h   ("FT")
+                   Für Ortbetonplatten folgt:        h0 = h     ("Ortbeton")
+        t0 = Tatsächliches Betonalter beim Belastungsbeginn  \n
+        t  = Betrachteter Zeitpunkt für die ermittelte Kriechzahl
+        """
+        # Teilsicherheitsbeiwerte für Baustoffe
+        self.gamma_c = 1.5
+        self.gamma_s = 1.15
+        # Stahlbeton
+        self.fck = liste_baustoffe[0]
+        self.fcd = self.fck / self.gamma_c * 0.85
+        self.fctm = 0.30 * self.fck ** (2 / 3)  # Nach Eurocode 2 Tabelle 3.1
+        self.fctk_005 = 0.7 * self.fctm
+        self.fcm = self.fck + 8
+        self.Ecm = 22000 * (0.1 * self.fcm) ** (0.3)
+
+        self.alpha_T = 1.2e-5
+
+        # Kriechen und Schwinden
+
+        self.traeger = traeger
+        self.Zement = "I42.5N"
+        self.LF = 80
+
+        self.t0 = t0  # Annahme: Belastungsbeginn der Fertigteile nach 28 d
+        self.t = t
+        self.ts = ts
+
+        # Querschnittswerte für Kriechen / Schwinden
+
+        self.b_c = b_c
+        self.h_c = h_c
+
+        self.A = self.b_c * self.h_c
+        if self.traeger == "FT":
+            self.u = self.b_c
+        elif self.traeger == "Normal":
+            self.u = self.b_c * 2  # Zur Trocknung freigesetzter Umfang
+        else:
+            self.u = self.b_c * 2
+
+        self.h_0 = 2 * self.A / self.u
+
+        # Stahl
+        self.fyk = liste_baustoffe[1]
+        self.fyd = self.fyk / self.gamma_s
+        self.Es = 2e5
+        self.Materialgesetz_Beton()
+        self.Kriechzahlen()
+        self.Schwindzahlen()
+
+    def Materialgesetz_Beton(self):
+        self.eps_c1 = 0.7 * self.fcm**0.31
+        self.eps_c1 = min(self.eps_c1, 2.8)  # Sicherstellen, dass eps_c1 <= 2.8
+
+    def Kriechzahlen(self):
+        self.Zement = "I42.5N"
+
+        if self.Zement == "I42.5N" or self.Zement == "I32.5R":
+            self.alpha = 0
+        elif (
+            self.Zement == "I42.5R"
+            or self.Zement == "I52.5N"
+            or self.Zement == "I52.5R"
+        ):
+            self.alpha = 1
+        else:
+            self.alpha = -1
+
+        self.t_0 = self.t0
+
+        self.t_0_eff = max(
+            self.t_0 * (1 + 9 / (2 + self.t_0 ** (1.2))) ** self.alpha, 0.5
+        )
+
+        self.t_infty = (
+            self.t
+        )  # self.t_0+15       #70 * 365  Annahme: 15 Tage nach der Betonage
+
+        self.RH = self.LF  # Außenliegendes Bauteil
+
+        # Fallunterscheidung für Druckfestigkeit
+        self.alpha_1 = min((35 / self.fcm) ** 0.7, 1)
+        self.alpha_2 = min((35 / self.fcm) ** 0.2, 1)
+        self.alpha_3 = min((35 / self.fcm) ** 0.5, 1)
+
+        # Einfluss der Luftfeuchte und wirksamer Bauteildicke
+        if self.fcm <= 35:
+            self.phi_rh = 1 + (1 - self.RH / 100) / (
+                0.1 * (self.h_0 * 1000) ** (0.3333333)
+            )
+        else:
+            self.phi_rh = (
+                1
+                + (1 - self.RH / 100)
+                / (0.1 * (self.h_0 * 1000) ** (0.3333333))
+                * self.alpha_1
+            ) * self.alpha_2
+
+        # Einfluss der Betondruckfestigkeit
+        self.beta_fcm = 16.8 / np.sqrt(self.fcm)
+        # Einfluss des Belastungsbeginns
+        self.beta_t0 = 1 / (0.1 + self.t_0_eff**0.2)
+
+        # Einfluss der Luftfeuchte - Beta-Beiwert
+        if self.fcm <= 35:
+            self.beta_h = min(
+                1.5 * (1 + (0.012 * self.RH) ** 18) * self.h_0 * 1000 + 250, 1500
+            )
+        else:
+            self.beta_h = min(
+                1.5 * (1 + (0.012 * self.RH) ** 18) * self.h_0 * 1000
+                + 250 * self.alpha_3,
+                1500 * self.alpha_3,
+            )
+
+        # Einfluss der Belastungsdauer und Belastungsbeginn
+
+        self.beta_c_t_t0 = (
+            (self.t_infty - self.t_0) / (self.beta_h + self.t_infty - self.t_0)
+        ) ** 0.30
+
+        self.phi_infty = (
+            self.phi_rh * self.beta_fcm * self.beta_t0 * self.beta_c_t_t0
+        )  # Kriechzahl zum Zeitpunkt t
+
+        print("Kriechzahl phi ", self.phi_infty)
+
+    def Schwindzahlen(self):
+        self.beta_rh = 1.55 * (1 - (self.RH / 100) ** 3)
+
+        if self.Zement == "I42.5N" or self.Zement == "I32.5R":
+            self.alpha_as = 700
+            self.alpha_ds1 = 4
+            self.alpha_ds2 = 0.12
+        elif (
+            self.Zement == "I42.5R"
+            or self.Zement == "I52.5N"
+            or self.Zement == "I52.5R"
+        ):
+            self.alpha_as = 600
+            self.alpha_ds1 = 6
+            self.alpha_ds2 = 0.12
+        else:
+            self.alpha_as = 800
+            self.alpha_ds1 = 3
+            self.alpha_ds2 = 0.12
+
+        self.epsilon_cd_0 = (
+            0.85
+            * ((220 + 110 * self.alpha_ds1) * np.exp(-self.alpha_ds2 * self.fcm / 10))
+            * 1e-6
+            * self.beta_rh
+        )
+
+        ts = self.ts
+        
+        t = self.t_infty
+        self.t_infty_s = t
+
+        self.beta_ds = (t - ts) / ((t - ts) + 0.04 * np.sqrt(self.h_0**3))
+
+        if self.h_0 * 1000 <= 100:
+            self.k_h = 1.00
+        elif self.h_0 * 1000 > 100 and self.h_0 * 1000 <= 200:
+            self.k_h = 1.00 - 0.15 / 100 * self.h_0 * 1000
+        elif self.h_0 * 1000 > 200 and self.h_0 * 1000 <= 300:
+            self.k_h = 0.85 - 0.10 / 100 * self.h_0 * 1000
+        elif self.h_0 * 1000 > 300 and self.h_0 * 1000 <= 500:
+            self.k_h = 0.75 - 0.05 / 100 * self.h_0 * 1000
+        elif self.h_0 * 1000 > 500:
+            self.k_h = 0.70
+
+        self.epsilon_cd = self.beta_ds * self.epsilon_cd_0 * self.k_h
+
+        # Autogenes Schwinden
+        self.epsilon_ca_infty = 2.5 * (self.fck - 10) * 1e-6
+        self.beta_as = 1 - np.exp(-0.2 * np.sqrt(t))
+
+        self.epsilon_ca = self.beta_as * self.epsilon_ca_infty
+
+        # Gesamtschwinden
+        self.epsilon_cs = self.epsilon_cd + self.epsilon_ca
+
+        print("Gesamtschwindmaß ", self.epsilon_cs)
+

KIB_LAP/Betonbau/Querschnittsbreite.py

@@ -0,0 +1,194 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+class PolygonSection:
+    def __init__(self, vertices=None):
+        """
+        Initialisiert das Polygon mit den gegebenen Eckpunkten.
+
+        Parameter:
+        vertices (Liste von Listen): Nx2-Array der Polygoneckpunkte [[y, z], [y, z], ...]
+        """
+        if vertices is None:
+            vertices = []
+
+        self.vertices = np.array(vertices)
+        self.original_vertices = self.vertices.copy()
+
+        # Extrahieren der y- und z-Koordinaten
+        self.y_coords = self.vertices[:, 0]
+        self.z_coords = self.vertices[:, 1]
+
+        self.len = len(self.vertices)
+
+        # Initialisierung der Querschnittsgrößen
+        self.A = 0
+        self.S_y = 0
+        self.S_z = 0
+        self.I_yy = 0
+        self.I_zz = 0
+        self.I_yz = 0
+        self.ys = 0
+        self.zs = 0
+
+        if self.len > 0:
+            self.calculate_area()
+            self.calculate_first_moments()
+            self.calculate_centroid()
+            self.calculate_second_moments()
+            self.calculate_deviation_moment_yz()
+
+    # Berechnung der Querschnittsgrößen
+
+    def calculate_area(self):
+        self.A = 0
+        n = self.len
+        for i in range(n):
+            j = (i + 1) % n
+            self.A += 0.5 * (self.z_coords[j] * self.y_coords[i] - self.z_coords[i] * self.y_coords[j])
+
+    def calculate_first_moments(self):
+        self.S_y = 0
+        self.S_z = 0
+        n = self.len
+        for i in range(n):
+            j = (i + 1) % n
+            common = self.y_coords[i] * self.z_coords[j] - self.y_coords[j] * self.z_coords[i]
+            self.S_y += (self.z_coords[i] + self.z_coords[j]) * common
+            self.S_z += (self.y_coords[i] + self.y_coords[j]) * common
+        self.S_y /= 6
+        self.S_z /= 6
+
+    def calculate_centroid(self):
+        # Berechnet den Schwerpunkt des Polygons
+        self.ys = self.S_y / self.A
+        self.zs = self.S_z / self.A
+        self.centroid = np.array([self.ys, self.zs])
+
+    def calculate_second_moments(self):
+        self.I_yy = 0
+        self.I_zz = 0
+        n = self.len
+        for i in range(n):
+            j = (i + 1) % n
+            common = self.y_coords[i] * self.z_coords[j] - self.y_coords[j] * self.z_coords[i]
+            Iyy_term = (self.z_coords[i]**2 + self.z_coords[i]*self.z_coords[j] + self.z_coords[j]**2) * common
+            Izz_term = (self.y_coords[i]**2 + self.y_coords[i]*self.y_coords[j] + self.y_coords[j]**2) * common
+            self.I_yy += Iyy_term
+            self.I_zz += Izz_term
+        self.I_yy = self.I_yy / 12 - self.zs**2 * self.A  # Steiner-Anteil
+        self.I_zz = self.I_zz / 12 - self.ys**2 * self.A  # Steiner-Anteil
+
+    def calculate_deviation_moment_yz(self):
+        self.I_yz = 0
+        n = self.len
+        for i in range(n):
+            j = (i + 1) % n
+            common = self.y_coords[i] * self.z_coords[j] - self.y_coords[j] * self.z_coords[i]
+            term = (self.y_coords[i]*self.z_coords[j] + 2*self.y_coords[i]*self.z_coords[i] +
+                    2*self.y_coords[j]*self.z_coords[j] + self.y_coords[j]*self.z_coords[i])
+            self.I_yz += term * common
+        self.I_yz = self.I_yz / 24 - self.ys * self.zs * self.A  # Steiner-Anteil
+
+    # Funktionen zur Manipulation des Polygons
+
+    def rotate(self, angle_degrees):
+        """
+        Rotiert das Polygon um seinen Schwerpunkt um den angegebenen Winkel.
+
+        Parameter:
+        angle_degrees (float): Rotationswinkel in Grad.
+        """
+        angle_radians = np.deg2rad(angle_degrees)
+        # Translation zum Ursprung (Schwerpunkt am Ursprung)
+        translated_polygon = self.original_vertices - self.centroid
+        # Rotationsmatrix erstellen
+        rotation_matrix = np.array([
+            [np.cos(angle_radians), -np.sin(angle_radians)],
+            [np.sin(angle_radians),  np.cos(angle_radians)]
+        ])
+        # Polygon rotieren
+        rotated_polygon = np.dot(translated_polygon, rotation_matrix)
+        # Zurück zum ursprünglichen Ort verschieben
+        self.vertices = rotated_polygon + self.centroid
+        # Aktualisieren der Koordinaten
+        self.y_coords = self.vertices[:, 0]
+        self.z_coords = self.vertices[:, 1]
+        # Aktualisieren der ursprünglichen Vertices für weitere Rotationen
+        self.original_vertices = self.vertices.copy()
+        # Neu berechnen der Querschnittsgrößen
+        self.calculate_area()
+        self.calculate_first_moments()
+        self.calculate_centroid()
+        self.calculate_second_moments()
+        self.calculate_deviation_moment_yz()
+
+    def calculate_section_width_at_height(self, height):
+        """
+        Berechnet die Breite des Querschnitts auf einer bestimmten Höhe (y-Wert).
+
+        Parameter:
+        height (float): Der y-Wert, bei dem die Querschnittsbreite berechnet werden soll.
+
+        Rückgabe:
+        float: Breite des Querschnitts an der angegebenen Höhe.
+        """
+        # Kanten des Polygons erhalten
+        edges = []
+        for i in range(len(self.vertices)):
+            p1 = self.vertices[i]
+            p2 = self.vertices[(i + 1) % len(self.vertices)]
+            edges.append((p1, p2))
+
+        # Schnittpunkte mit der horizontalen Linie auf der angegebenen Höhe finden
+        intersections = []
+        for p1, p2 in edges:
+            if (p1[1] <= height <= p2[1]) or (p2[1] <= height <= p1[1]):
+                if p1[1] != p2[1]:  # Division durch Null vermeiden
+                    x_intersect = p1[0] + (height - p1[1]) * (p2[0] - p1[0]) / (p2[1] - p1[1])
+                    intersections.append(x_intersect)
+
+        # Breite berechnen
+        if len(intersections) >= 2:
+            intersections.sort()
+            return intersections[-1] - intersections[0]
+        return 0.0
+
+    # Plot-Funktion
+    def plot(self, height=None):
+        """
+        Zeichnet das ursprüngliche und das aktuelle Polygon und optional eine horizontale Linie auf der angegebenen Höhe.
+
+        Parameter:
+        height (float, optional): Der y-Wert, bei dem eine horizontale Linie gezeichnet werden soll.
+        """
+        plt.figure()
+        plt.plot(*self.original_vertices.T, 'b-', label='Ursprüngliches Polygon')
+        plt.plot(*self.vertices.T, 'r-', label='Aktuelles Polygon')
+        plt.fill(*self.original_vertices.T, 'b', alpha=0.3)
+        plt.fill(*self.vertices.T, 'r', alpha=0.3)
+        if height is not None:
+            plt.axhline(y=height, color='g', linestyle='--', label=f'Höhe = {height}')
+        plt.legend()
+        plt.xlabel('y')
+        plt.ylabel('z')
+        plt.title('Polygon und Querschnittsbreite auf spezifischer Höhe')
+        plt.axis('equal')
+        plt.show()
+
+
+# vertices = [
+#     [0, 0],
+#     [0.40, 0],
+#     [0.40, 0.40],
+#     [0, 0.40]
+# ]
+
+# polygon = PolygonSection(vertices)
+
+# print("Fläche A:", polygon.A)
+# print("Flächenträgheitsmoment I_yy:", polygon.I_yy)
+# print("Flächenträgheitsmoment I_zz:", polygon.I_zz)
+# print("Produktträgheitsmoment I_yz:", polygon.I_yz)
+# print("Schwerpunkt ys:", polygon.ys)
+# print("Schwerpunkt zs:", polygon.zs)

KIB_LAP/Betonbau/Querschnittsbreite_Kreis.py

@@ -0,0 +1,63 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+class CircleSection:
+    def __init__(self, radius):
+        """
+        Initializes the circle with the given radius.
+        
+        Parameters:
+        radius (float): Radius of the circle.
+        """
+        self.radius = radius
+
+    def calculate_section_width_at_height(self, height):
+        """
+        Calculates the width of the circle section at a specific height (y-value).
+        
+        Parameters:
+        height (float): The y-value at which to calculate the section width.
+        
+        Returns:
+        float: Width of the circle section at the specified height.
+        """
+        if abs(height) > self.radius:
+            return 0.0
+        return 2 * np.sqrt(self.radius**2 - height**2)
+
+    def plot(self, height=None):
+        """
+        Plots the circle and optionally a horizontal line at the specified height.
+        
+        Parameters:
+        height (float, optional): The y-value at which to plot a horizontal line.
+        """
+        theta = np.linspace(0, 2 * np.pi, 100)
+        x = self.radius * np.cos(theta)
+        y = self.radius * np.sin(theta)
+
+        plt.figure()
+        plt.plot(x, y, 'b-', label='Circle')
+        plt.fill(x, y, 'b', alpha=0.3)
+        if height is not None:
+            plt.axhline(y=height, color='g', linestyle='--', label=f'Height = {height}')
+            section_width = self.calculate_section_width_at_height(height)
+            plt.plot([-section_width / 2, section_width / 2], [height, height], 'r-', linewidth=2, label=f'Section Width = {section_width:.2f}')
+        plt.legend()
+        plt.xlabel('x')
+        plt.ylabel('y')
+        plt.title('Circle and Section Width at Specific Height')
+        plt.axis('equal')
+        plt.show()
+
+# Example usage
+radius = 1.0
+circle = CircleSection(radius)
+
+# Define the height at which to calculate the section width
+height = -0.5
+section_width = circle.calculate_section_width_at_height(height)
+print(f"Section width at height {height} is: {section_width}")
+
+# Plot the circle and the horizontal line
+circle.plot(height)

KIB_LAP/Betonbau/__init__.py

@@ -0,0 +1,2 @@
+from .beam_rectangular import BeamRectangular
+from .beam_sub_section import BeamSubSection