civil-tools-v 0.0.5__py3-none-any.whl → 0.0.6__py3-none-any.whl

CivilTools/ReportGenerator/StairCalculationReport.py

@@ -6,11 +6,107 @@ from CivilTools.YDBLoader.BuildingDefine.StairPart import (
     LoadParams,
     StairLoad,
     LoadCalulateType,
+    Component,
 )
-from .UtilFunctions import MatrixSolver
+from .UtilFunctions import MatrixSolver, ConcreteSolver
 from .DocTable import DocTable
 from .DocPicture import DocPicture
 from .DocParagraph import DocParagraph
+from typing import List
+from CivilTools.Const import Concrete, Steel
+from CivilTools.FigureGenerator import StairCalculationSheetPNGPlotter
+
+
+def analysis_moment_and_rebar(
+    moments: List[float], thickness, rebar_d, cover_thickness, concrete, rebar
+):
+    if len(moments) != 3:
+        raise ValueError("Length of Stair Moment Reult should be 3.")
+    total_result = []
+    for moment in moments:
+        result = ConcreteSolver.CalculateRebar(
+            moment, thickness, rebar_d, cover_thickness, concrete, rebar
+        )
+        total_result.append(result[0])
+        total_result.append(result[1])
+    return total_result
+
+
+def analysis_w(
+    moments: List[float],
+    current_stair: StairPart,
+    cover_thickness: float,
+    concrete,
+    rebar,
+):
+    w_list = []
+    for moment in moments:
+        if moment < 0:
+            As = current_stair.up_real_rebar_area
+            rebar_d = current_stair.up_d
+        else:
+            As = current_stair.down_real_rebar_area
+            rebar_d = current_stair.down_d
+        w = ConcreteSolver.CalculateW(
+            moment,
+            As,
+            current_stair.main_thick,
+            cover_thickness,
+            concrete,
+            rebar,
+            rebar_d,
+        )
+        if moment < 0:
+            w_list.append(w)
+            w_list.append(0)
+        else:
+            w_list.append(0)
+            w_list.append(w)
+    return w_list
+
+
+def analysis_real_rebar(
+    stair_part: StairPart, part: str, cal_rabar_area_list: List[float]
+):
+    if part == "left":
+        thick = stair_part.left_thick
+    elif part == "right":
+        thick = stair_part.right_thick
+    else:
+        thick = stair_part.main_thick
+    up_rebar = stair_part.up_real_rebar
+    up_rebar_area = stair_part.up_real_rebar_area
+    up_ratio = up_rebar_area / 1000 / thick
+    down_rebar = stair_part.down_real_rebar
+    down_rebar_area = stair_part.down_real_rebar_area
+    down_ratio = down_rebar_area / 1000 / thick
+
+    up_result = f"{up_rebar}({up_rebar_area:.1f},{up_ratio*100:.2f}%)"
+    down_result = f"{down_rebar}({down_rebar_area:.1f},{down_ratio*100:.2f}%)"
+    result = []
+    for i in range(len(cal_rabar_area_list)):
+        if i % 2 == 0:
+            if cal_rabar_area_list[i] <= up_rebar_area:
+                result.append(up_result)
+            else:
+                result.append("*{" + up_result + "}")
+        else:
+            if cal_rabar_area_list[i] <= down_rebar_area:
+                result.append(down_result)
+            else:
+                result.append("*{" + down_result + "}")
+    return result
+
+
+def get_qe_moment(stair: StairPart, components: List[Component]):
+    if stair.stair_type == "AT":
+        return components[0].m_2
+    elif stair.stair_type == "BT":
+        return components[1].m_2
+    elif stair.stair_type == "CT":
+        return components[0].m_2
+    else:
+        return components[1].m_2
 
 
 class StairCalculationReport(BasicGenerator):
@@ -36,38 +132,35 @@ class StairCalculationReport(BasicGenerator):
         self.symbol_explain = "钢筋：d-HPB300；D-HRB335；E-HRB400；F-RRB400；G-HRB500；Q-HRBF400；R-HRB550"
         self.cut_line = "---------------------------------------------------------------------------------------------"
         self.concrete_data = {
-            30: [14.3, 1.43, 2.01, 30000],  # // fc, ft, ftk, E
-            35: [16.7, 1.57, 2.20, 31500],  # // fc, ft, ftk, E
-            40: [19.1, 1.71, 2.39, 32500],  # // fc, ft, ftk, E
+            30: Concrete.C30,  # // fc, ft, ftk, E
+            35: Concrete.C35,  # // fc, ft, ftk, E
+            40: Concrete.C40,  # // fc, ft, ftk, E
         }
         self.concrete_density = 25
-        self.rebar_level = "HRB400"
-        self.rebar_fy = 360
+        self.rebar_level = Steel.HRB400
         self.indent = 0.22
         self.normal_font_size = 11
+        self.__clear_result()
+
+    def __clear_result(self):
+        self.left_calculate_rebar = None
+        self.middle_calculate_rebar = None
+        self.right_calculate_rabar = None
+        self.left_real_rebar = None
+        self.middle_real_rebar = None
+        self.right_real_rabar = None
+        self.disp_plastic = 0
+        self.crack_width = None
 
     # 数据入口！！！！
-    def set_stair_data(self):
+    def set_stair_data(self, stair_list: List[StairPart]):
         """这个函数需要重写！！！！！是数据流入的最主要的入口"""
-        position1 = Position(0, 2180, 0, 1910, 5030, 6850)
-        sp1 = StairPart(position1, 13)
-        sp1.left_thick = sp1.main_thick = sp1.right_thick = 130
-        position2 = Position(0, 2180, 0, 1910, 5030, 6850)
-        sp2 = StairPart(position2, 13)
-        sp2.set_beam_offset(1, 500)
-        position3 = Position(0, 2180, 0, 1910, 5030, 6850)
-        sp3 = StairPart(position3, 13)
-        sp3.set_beam_offset(2, 500)
-        position4 = Position(0, 2180, 0, 1910, 5030, 6850)
-        sp4 = StairPart(position4, 13)
-        sp4.set_beam_offset(1, 500)
-        sp4.set_beam_offset(2, 500)
-
-        self.stair_list = [sp1, sp2, sp3, sp4]
+        self.stair_list = stair_list
 
     # 数据入口！！！！
     def set_calculate_info(self):
-        self.load_param = LoadParams()
+        # 荷载相关的入口
+        self.load_param = LoadParams(1, 3.5)
         self.concrete_level = 30
         self.rebar_area_adjust_coef = 1
         self.cover_thickness = 15
@@ -106,6 +199,11 @@ class StairCalculationReport(BasicGenerator):
             self.left_slab_load.q, self.main_slab_load.q, self.right_slab_load.q
         )
         self.current_stair.set_calculate_result(solver.submit_problem())
+        sover_eq = MatrixSolver(self.current_stair)
+        sover_eq.set_load(
+            self.left_slab_load.qe, self.main_slab_load.qe, self.right_slab_load.qe
+        )
+        self.qe_result_components = sover_eq.submit_problem()
 
     def add_first_part(self):
         # 添加最大的标题
@@ -161,13 +259,13 @@ class StairCalculationReport(BasicGenerator):
 
         # 进行必要的计算
         self.load_calculate()
-
         self.do_the_math()
 
         # 添加part1已知条件
         self.add_1_basic_info()
         self.add_2_load_and_calculate()
         self.add_3_result()
+        self.draw_plots()
         self.add_blank_paragraph()
 
     def add_1_basic_info(self):
@@ -236,22 +334,22 @@ class StairCalculationReport(BasicGenerator):
             f"活载准永久值系数：{self.load_param.live_load_permenent_coef}"
         )
         self.add_paragraph(doc_par)
-        doc_par.context = f"混凝土等级：C{self.concrete_level}，f_{{c}} ={self.concrete_data[self.concrete_level][0]:.2f}MPa"
+        doc_par.context = f"混凝土等级：C{self.concrete_level}，f_{{c}} ={self.concrete_data[self.concrete_level].fc:.2f}MPa"
         self.add_paragraph(doc_par)
         doc_par.context = f"混凝土容重：{self.concrete_density:.2f}kN/mm^{{3}}"
         self.add_paragraph(doc_par)
         doc_par.context = f"配筋调整系数：{self.rebar_area_adjust_coef:.2f}；纵筋保护层厚度：c={self.cover_thickness}mm"
         self.add_paragraph(doc_par)
         doc_par.context = (
-            f"梯板纵筋等级：{self.rebar_level}；f_{{y}} ={self.rebar_fy}MPa"
+            f"梯板纵筋等级：{self.rebar_level.name}；f_{{y}} ={self.rebar_level.fy}MPa"
         )
         self.add_paragraph(doc_par)
         doc_par.context = (
-            f"梯梁纵筋等级：{self.rebar_level}；f_{{y}} ={self.rebar_fy}MPa"
+            f"梯梁纵筋等级：{self.rebar_level.name}；f_{{y}} ={self.rebar_level.fy}MPa"
         )
         self.add_paragraph(doc_par)
         doc_par.context = (
-            f"梯梁箍筋等级：{self.rebar_level}；f_{{y}} ={self.rebar_fy}MPa"
+            f"梯梁箍筋等级：{self.rebar_level.name}；f_{{y}} ={self.rebar_level.fy}MPa"
         )
         self.add_paragraph(doc_par)
 
@@ -397,25 +495,22 @@ class StairCalculationReport(BasicGenerator):
         doc_par.context = "弯        矩：kN·m\t\t剪        力：kN/m\t\t挠        度：mm"
         doc_par.first_line_indent = indent
         self.add_paragraph(doc_par)
-        doc_par.context = r"纵筋面积：mm^{2}/m\t\t截面尺寸：mm×mm\t\t裂        缝：mm"
+        doc_par.context = (
+            r"纵筋面积：mm^{2}/m" + "\t\t截面尺寸：mm×mm\t\t裂        缝：mm"
+        )
         self.add_paragraph(doc_par)
-
         self.add_blank_paragraph()
         doc_par.context = "板段配筋计算结果："
         doc_par.first_line_indent = 0
         self.add_paragraph(doc_par)
         doc_par.context = "---------------------------------------------------------------------------------------------"
         self.add_paragraph(doc_par)
-
         self.insert_calculate_table()
-
-        # self.insert_all_pictures()
-
         self.add_blank_paragraph()
 
     def insert_calculate_table(self):
         table_index = 1
-        ft = self.concrete_data[self.concrete_level][1]
+        ft = self.concrete_data[self.concrete_level].ft
         if (
             self.current_stair.stair_type == "BT"
             or self.current_stair.stair_type == "DT"
@@ -430,6 +525,20 @@ class StairCalculationReport(BasicGenerator):
             shear_context = self.current_stair.get_shear_validate(
                 "left", ft, self.cover_thickness
             )
+            total_rebar_result = analysis_moment_and_rebar(
+                moments,
+                self.current_stair.left_thick,
+                self.current_stair.down_d,
+                self.cover_thickness,
+                self.concrete_data[self.concrete_level],
+                self.rebar_level,
+            )
+
+            real_rebar_result = analysis_real_rebar(
+                self.current_stair, "left", total_rebar_result
+            )
+            self.left_calculate_rebar = total_rebar_result
+            self.left_real_rebar = real_rebar_result
 
             table_context = [
                 ["截面位置", "左", "中", "右"],
@@ -441,10 +550,30 @@ class StairCalculationReport(BasicGenerator):
                 ],
                 ["剪力(V)", f"{shears[0]:.2f}", f"{shears[1]:.2f}", f"{shears[2]:.2f}"],
                 ["抗剪截面验算", shear_context],
-                ["上部计算纵筋As'", "", "", ""],
-                ["下部计算纵筋As", "", "", ""],
-                ["上部纵筋实配", "", "", ""],
-                ["下部纵筋实配", "", "", ""],
+                [
+                    "上部计算纵筋As'",
+                    f"{total_rebar_result[0]:.1f}",
+                    f"{total_rebar_result[2]:.1f}",
+                    f"{total_rebar_result[4]:.1f}",
+                ],
+                [
+                    "下部计算纵筋As",
+                    f"{total_rebar_result[1]:.1f}",
+                    f"{total_rebar_result[3]:.1f}",
+                    f"{total_rebar_result[5]:.1f}",
+                ],
+                [
+                    "上部纵筋实配",
+                    real_rebar_result[0],
+                    real_rebar_result[2],
+                    real_rebar_result[4],
+                ],
+                [
+                    "下部纵筋实配",
+                    real_rebar_result[1],
+                    real_rebar_result[3],
+                    real_rebar_result[5],
+                ],
             ]
             left_table.set_table_context(table_context)
             self.add_table(left_table)
@@ -461,21 +590,88 @@ class StairCalculationReport(BasicGenerator):
         shear_context = self.current_stair.get_shear_validate(
             "main", ft, self.cover_thickness
         )
+        total_rebar_result = analysis_moment_and_rebar(
+            moments,
+            self.current_stair.main_thick,
+            self.current_stair.down_d,
+            self.cover_thickness,
+            self.concrete_data[self.concrete_level],
+            self.rebar_level,
+        )
+        real_rebar_result = analysis_real_rebar(
+            self.current_stair, "middle", total_rebar_result
+        )
+        self.middle_calculate_rebar = total_rebar_result
+        self.middle_real_rebar = real_rebar_result
+        disp_limit = (
+            self.current_stair.total_horizental_length / self.displacement_limit
+        )
+        disp_E = self.current_stair.get_calculate_disp()[3]
+        Mq = get_qe_moment(self.current_stair, self.qe_result_components)
+        disp_p = ConcreteSolver.CalculateDisplacement(
+            self.current_stair.main_thick,
+            disp_E,
+            self.cover_thickness,
+            self.concrete_data[self.concrete_level],
+            self.rebar_level,
+            self.current_stair.down_real_rebar_area,
+            Mq,
+        )
+        disp_validate_context = self.current_stair.get_displacement_validate(
+            disp_p, self.displacement_limit
+        )
 
+        w_list = analysis_w(
+            moments,
+            self.current_stair,
+            self.cover_thickness,
+            self.concrete_data[self.concrete_level],
+            self.rebar_level,
+        )
+        w_validate_context = self.current_stair.get_w_validate(
+            w_list, self.crack_width_limit
+        )
+        self.crack_width = w_list
+        self.disp_plastic = disp_p
         table_context = [
             ["截面位置", "左", "中", "右"],
             ["弯矩(M)", f"{moments[0]:.2f}", f"{moments[1]:.2f}", f"{moments[2]:.2f}"],
             ["剪力(V)", f"{shears[0]:.2f}", f"{shears[1]:.2f}", f"{shears[2]:.2f}"],
             ["抗剪截面验算", shear_context],
-            ["上部计算纵筋As'", "", "", ""],
-            ["下部计算纵筋As", "", "", ""],
-            ["上部纵筋实配", "", "", ""],
-            ["下部纵筋实配", "", "", ""],
-            ["挠度限值", f"[f]={self.crack_width_limit:.2f}mm"],
-            ["挠度验算结果", "满足"],
-            ["裂缝宽度", "", "", ""],
+            [
+                "上部计算纵筋As'",
+                f"{total_rebar_result[0]:.1f}",
+                f"{total_rebar_result[2]:.1f}",
+                f"{total_rebar_result[4]:.1f}",
+            ],
+            [
+                "下部计算纵筋As",
+                f"{total_rebar_result[1]:.1f}",
+                f"{total_rebar_result[3]:.1f}",
+                f"{total_rebar_result[5]:.1f}",
+            ],
+            [
+                "上部纵筋实配",
+                real_rebar_result[0],
+                real_rebar_result[2],
+                real_rebar_result[4],
+            ],
+            [
+                "下部纵筋实配",
+                real_rebar_result[1],
+                real_rebar_result[3],
+                real_rebar_result[5],
+            ],
+            ["挠度限值", f"[f]={disp_limit:.2f}mm"],
+            ["挠度验算结果", disp_validate_context],
+            [
+                "裂缝宽度",
+                f"{max(w_list[0],w_list[1]):.3f}mm",
+                f"{max(w_list[2],w_list[3]):.3f}mm",
+                f"{max(w_list[4],w_list[5]):.3f}mm",
+            ],
             ["裂缝限值", f"[ω]={self.crack_width_limit:.2f}mm"],
-            ["裂缝验算结果", ""],
+            ["裂缝验算结果", w_validate_context],
         ]
         cal_table.set_table_context(table_context)
         self.add_table(cal_table)
@@ -496,7 +692,19 @@ class StairCalculationReport(BasicGenerator):
             shear_context = self.current_stair.get_shear_validate(
                 "right", ft, self.cover_thickness
             )
-
+            total_rebar_result = analysis_moment_and_rebar(
+                moments,
+                self.current_stair.right_thick,
+                self.current_stair.down_d,
+                self.cover_thickness,
+                self.concrete_data[self.concrete_level],
+                self.rebar_level,
+            )
+            real_rebar_result = analysis_real_rebar(
+                self.current_stair, "right", total_rebar_result
+            )
+            self.right_calculate_rebar = total_rebar_result
+            self.right_real_rebar = real_rebar_result
             table_context = [
                 ["截面位置", "左", "中", "右"],
                 [
@@ -507,21 +715,107 @@ class StairCalculationReport(BasicGenerator):
                 ],
                 ["剪力(V)", f"{shears[0]:.2f}", f"{shears[1]:.2f}", f"{shears[2]:.2f}"],
                 ["抗剪截面验算", shear_context],
-                ["上部计算纵筋As'", "", "", ""],
-                ["下部计算纵筋As", "", "", ""],
-                ["上部纵筋实配", "", "", ""],
-                ["下部纵筋实配", "", "", ""],
+                [
+                    "上部计算纵筋As'",
+                    f"{total_rebar_result[0]:.1f}",
+                    f"{total_rebar_result[2]:.1f}",
+                    f"{total_rebar_result[4]:.1f}",
+                ],
+                [
+                    "下部计算纵筋As",
+                    f"{total_rebar_result[1]:.1f}",
+                    f"{total_rebar_result[3]:.1f}",
+                    f"{total_rebar_result[5]:.1f}",
+                ],
+                [
+                    "上部纵筋实配",
+                    real_rebar_result[0],
+                    real_rebar_result[2],
+                    real_rebar_result[4],
+                ],
+                [
+                    "下部纵筋实配",
+                    real_rebar_result[1],
+                    real_rebar_result[3],
+                    real_rebar_result[5],
+                ],
             ]
             right_table.set_table_context(table_context)
 
             self.add_table(right_table)
             table_index += 1
 
+    def draw_plots(self):
+        self.__prepare_draw_data()
+        plot_width = 11
+        plotter = StairCalculationSheetPNGPlotter(self.current_stair)
+        plotter.plot_moment(self.current_stair.get_calculate_moments())
+        moment_figure = DocPicture(plotter.to_stream(), width=plot_width)
+        self.add_picture(moment_figure)
+
+        plotter = StairCalculationSheetPNGPlotter(self.current_stair)
+        shears = self.current_stair.get_calculate_shears()
+        plotter.plot_shear(shears[:3] + shears[-3:])
+        shear_figure = DocPicture(plotter.to_stream(), width=plot_width)
+        self.add_picture(shear_figure)
+
+        plotter = StairCalculationSheetPNGPlotter(self.current_stair)
+        plotter.plot_calculate_rebar_area(
+            self.left_calculate_rebar,
+            self.middle_calculate_rebar,
+            self.right_calculate_rabar,
+        )
+        cal_rebar_figure = DocPicture(plotter.to_stream(), width=plot_width)
+        self.add_picture(cal_rebar_figure)
+
+        plotter = StairCalculationSheetPNGPlotter(self.current_stair)
+        plotter.plot_real_rebar(
+            self.left_real_rebar, self.middle_real_rebar, self.right_real_rabar
+        )
+        real_rebar_figure = DocPicture(plotter.to_stream(), width=plot_width)
+        self.add_picture(real_rebar_figure)
+
+        plotter = StairCalculationSheetPNGPlotter(self.current_stair)
+        plotter.plot_displacement(self.disp_plastic)
+        disp_figure = DocPicture(plotter.to_stream(), width=plot_width)
+        self.add_picture(disp_figure)
+
+        plotter = StairCalculationSheetPNGPlotter(self.current_stair)
+        plotter.plot_crack(self.crack_width)
+        crack_figure = DocPicture(plotter.to_stream(), width=plot_width)
+        self.add_picture(crack_figure)
+
+    def __prepare_draw_data(self):
+        if self.current_stair.left_extend_length > 0:
+            self.left_calculate_rebar[2] = -999
+            self.left_real_rebar = [i.split("(")[0] for i in self.left_real_rebar]
+            self.left_real_rebar[0] = ""
+            self.left_real_rebar[1] = ""
+            self.left_real_rebar[4] = ""
+            self.left_real_rebar[5] = ""
+
+        if self.current_stair.right_extend_length > 0:
+            self.right_calculate_rebar[2] = -999
+            self.right_real_rebar = [i.split("(")[0] for i in self.right_real_rebar]
+            self.right_real_rebar[0] = ""
+            self.right_real_rebar[1] = ""
+            self.right_real_rebar[4] = ""
+            self.right_real_rebar[5] = ""
+
+        self.middle_calculate_rebar[2] = -999
+        self.middle_real_rebar = [i.split("(")[0] for i in self.middle_real_rebar]
+        self.middle_real_rebar[1] = ""
+        self.middle_real_rebar[2] = ""
+        self.middle_real_rebar[5] = ""
+
+        self.crack_width = [f"{i:.3f}mm" if i > 0 else "" for i in self.crack_width]
+
     def create(self):
         self.add_first_part()
         for i in range(len(self.stair_list)):
             stair = self.stair_list[i]
             self.add_single_stair(stair, i + 1)
+            self.__clear_result()
             if i < len(self.stair_list) - 1:
                 self.add_page_break()
 

CivilTools/ReportGenerator/UtilFunctions.py

@@ -2,6 +2,8 @@ from docx.oxml.xmlchemy import BaseOxmlElement
 from docx.oxml.ns import qn, nsdecls
 from CivilTools.YDBLoader.BuildingDefine.StairPart import StairPart, Component
 import numpy as np
+from CivilTools.Const import ConcreteLevel, SteelLevel
+from typing import List
 
 
 # 网上找的代码，有点东西
@@ -226,4 +228,93 @@ class MatrixSolver:
             comp_f -= comp.create_f()
             comp.set_f(comp_f[0][0], comp_f[1][0], comp_f[3][0], comp_f[4][0])
             comp.set_m(comp_f[2][0], comp_f[5][0])
+            comp.set_u(
+                comp_u[0][0],
+                comp_u[1][0],
+                comp_u[2][0],
+                comp_u[3][0],
+                comp_u[4][0],
+                comp_u[5][0],
+            )
         return self.comp_list
+
+
+class ConcreteSolver:
+    @classmethod
+    def CalculateRebar(
+        cls,
+        moment: float,
+        thickness: float,
+        rebar_d: float,
+        cover_thickness: float,
+        concrete: ConcreteLevel,
+        rebar: SteelLevel,
+        min_rebar_ratio: float = 0.002,
+    ) -> List[float]:
+        h0 = thickness - rebar_d / 2 - cover_thickness
+        alpha_s = abs(moment) * 1000000 / concrete.fc / 1000 / h0 / h0
+        temp_yita = 1 - (1 - 2 * alpha_s) ** 0.5
+        rebar_cal = temp_yita * concrete.fc * 1000 * h0 / rebar.fy
+        rebar_min = thickness * min_rebar_ratio * 1000
+        result = [max(rebar_cal, rebar_min), rebar_min]
+        if moment < 0:
+            return result
+        else:
+            return result[::-1]
+
+    @classmethod
+    def CalculateDisplacement(
+        cls,
+        thickness: float,
+        disp_E: float,
+        cover_thickness: float,
+        concrete: ConcreteLevel,
+        rebar: SteelLevel,
+        As: float,
+        Mq: float,
+    ):
+        Es = rebar.elastic_module
+        Ec = concrete.elastic_module
+        ftk = concrete.ftk
+        h0 = thickness - cover_thickness
+        EI = Ec / 12 * 1000 * (thickness) ** 3
+        rhote = As / (thickness * 1000 / 2)
+        sigmas = Mq * 1000000 / (0.87 * h0 * As)
+        psi = 1.1 - 0.65 * ftk / (rhote * sigmas)
+        psi = max(min(psi, 1), 0.2)
+        alphaE = Es / Ec
+        rho = As / (1000 * h0)
+        Bs = Es * As * (h0) ** 2 / (1.15 * psi + 0.2 + 6 * alphaE * rho / (1 + 3.5 * 0))
+        B = Bs / 1.6
+        disp_P = disp_E * EI / B
+        return float(disp_P)
+
+    @classmethod
+    def CalculateW(
+        cls,
+        moment: float,
+        As: float,
+        thickness: float,
+        cover_thickness: float,
+        concrete: ConcreteLevel,
+        rebar: SteelLevel,
+        rebar_d: float,
+    ):
+        if moment == 0:
+            return 0
+        ftk = concrete.ftk
+        Es = rebar.elastic_module
+        h0 = thickness - cover_thickness
+        rhote = As / (thickness * 1000 / 2)
+        sigmas = abs(moment) * 1000000 / (0.87 * h0 * As)
+        psi = 1.1 - 0.65 * ftk / (rhote * sigmas)
+        psi = max(min(psi, 1), 0.2)
+        alphacr = 1.9  # 普通混凝土受弯构件
+        w = (
+            alphacr
+            * psi
+            * sigmas
+            / Es
+            * (1.9 * cover_thickness + 0.08 * rebar_d / rhote)
+        )
+        return w

CivilTools/YDBLoader/BuildingDefine/StairPart/LoadDefine.py

@@ -2,13 +2,21 @@ from enum import Enum
 
 
 class LoadParams:
-    def __init__(self):
-        self.append_dead_load = 1
-        self.live_load = 3.5
-        self.dead_load_coef = 1.3
-        self.live_load_coef = 1.5
-        self.live_load_adjust_coef = 1
-        self.live_load_permenent_coef = 0.5
+    def __init__(
+        self,
+        append_dead_load: float = 1,
+        live_load: float = 3.5,
+        dead_load_coef: float = 1.3,
+        live_load_coef: float = 1.5,
+        live_load_adjust_coef=1,
+        live_load_permenent_coef=0.5,
+    ):
+        self.append_dead_load = append_dead_load
+        self.live_load = live_load
+        self.dead_load_coef = dead_load_coef
+        self.live_load_coef = live_load_coef
+        self.live_load_adjust_coef = live_load_adjust_coef
+        self.live_load_permenent_coef = live_load_permenent_coef
 
 
 class LoadType(Enum):

CivilTools/YDBLoader/BuildingDefine/StairPart/StairComponent.py

@@ -90,6 +90,14 @@ class Component:
         self.m_1 = m_1 / 1e6
         self.m_2 = m_2 / 1e6
 
+    def set_u(self, u1x, u1y, u1r, u2x, u2y, u2r):
+        self.u_1_x = u1x
+        self.u_1_y = u1y
+        self.u_1_r = u1r
+        self.u_2_x = u2x
+        self.u_2_y = u2y
+        self.u_2_r = u2r
+
     @property
     def v1(self):
         return self.f_1_y * np.cos(self.alpha) - self.f_1_x * np.sin(self.alpha)