1.重新整理代码

2.收敛条件强制让不等式满足要求

auto_differentiation.py

@@ -1,9 +1,12 @@
 # 利用自动微分计算
+from typing import List
+
 import sympy
 import data
 import exp
 import math
 import main
+import numpy as np
 
 sympy.init_printing()
 # h_i 悬点高差
@@ -19,16 +22,6 @@ sympy.init_printing()
 # _t_m 导线架线时时导线温度 单位°C
 
 
-delta_Li__1 = sympy.symbols(
-    "delta_Li:{span_count}".format(span_count=data.span_count - 1)
-)
-delta_Li = (
-    *delta_Li__1,
-    sympy.symbols("delta_Li_i"),
-)
-# sigma_i = sympy.symbols("sigma_i:{span_count}".format(span_count=data.span_count))
-
-
 loop_end = data.loop_end  # 最大循环次数
 # 架线时的状态
 # 取外过无风
@@ -37,37 +30,37 @@ string_g = data.string_g  # 串重 单位N
 t_m_data = data.t_m  # 导线架设时的气温。单位°C
 t_e_data = data.t_e  # 架线时考虑初伸长的降温，取正值。单位°C
 alpha_data = data.alpha  # 导线膨胀系数  1/°C
-elastic = data.elastic  # 弹性系数 N/mm2
-area = data.area  # 导线面积 mm2
+elastic_data = data.elastic  # 弹性系数 N/mm2
+area_data = data.area  # 导线面积 mm2
 lambda_m_data = data.lambda_m  # 导线比载 N/(m.mm)
 sigma_m_data = data.sigma_m  # 架线时，初伸长未释放前的最低点水平应力。单位N/mm2
 span_count = data.span_count  # 几个档距
 # n个档距,n-1个直线塔
 h_array = data.h_array
-hi_matrix = sympy.Matrix(h_array)
-# sympy.pprint(hi_matrix)
 l_array = data.l_array
-l_matrix = sympy.Matrix(l_array)
 t_data = data.t
 conductor_n = data.conductor_n
-# ti_matrix = sympy.Matrix(t_array)
 lambda_i_array = data.lambda_i_array
 # TODO: 暂时没考虑荷载变化
-lambda_m_matrix = sympy.Matrix(lambda_i_array)
-lambda_i_matrix = sympy.Matrix(lambda_i_array)
-
-
 symbol_delta_l_i = exp.delta_li()
 sigma_i = sympy.symbols("sigma_i")
 d_delta_l_i_sigma_i = sympy.diff(symbol_delta_l_i, sigma_i)
+fx_d_delta_l_i_sigma_i = exp.get_lambdify_d_delta_l_i_sigma_i(d_delta_l_i_sigma_i)
+delta_Li__1 = sympy.symbols(
+    "delta_Li:{span_count}".format(span_count=data.span_count - 1)
+)
+delta_Li = (
+    *delta_Li__1,
+    sympy.symbols("delta_Li_i"),
+)
 symbol_sigma_i1 = exp.fun_sigma_i1(delta_Li)
-d_sigma_i1_sigma_i = sympy.diff(symbol_sigma_i1, sigma_i)
-# sigma_i1 = sympy.symbols("sigma_i1")
-# d_sigma_i1_sigma_i1 = sympy.diff(symbol_sigma_i1, sigma_i)
 delta_Li_i = sympy.symbols("delta_Li_i")
 d_sigma_i1_d_l_i = sympy.diff(symbol_sigma_i1, delta_Li_i)
 
 
+fx_d_sigma_i1_d_l_i = exp.get_lambdify_d_sigma_i1_d_l_i(d_sigma_i1_d_l_i, delta_Li)
+
+
 # 一共2n个变量，n个delta_Li，n个sigma_i
 # 分 [
 #     A B
@@ -79,53 +72,40 @@ d_sigma_i1_d_l_i = sympy.diff(symbol_sigma_i1, delta_Li_i)
 
 # B为dΔli/dσi
 def evaluate_d_delta_l_i_sigma_i(val_delta_l_li, val_sigma_i):
-    (
-        delta_l_i,
-        l_i,
-        lambda_i,
-        alpha,
-        E,
-        t_e,
-        t_i,
-        lambda_m,
-        t_m,
-        sigma_m,
-        _sigma_i,
-        beta_i,
-    ) = sympy.symbols(
-        """ 
-        delta_l_i,
-        l_i,
-        lambda_i,
-        alpha,
-        E,
-        t_e,
-        t_i,
-        lambda_m,
-        t_m,
-        sigma_m,
-        sigma_i,
-        beta_i
-        """
-    )
+
     val_list = []
     for i in range(span_count):
-        val = d_delta_l_i_sigma_i.subs(
-            [
-                (delta_l_i, val_delta_l_li[i]),
-                (l_i, l_array[i]),
-                (lambda_i, lambda_i_array[i]),
-                (alpha, alpha_data),
-                (E, elastic),
-                (t_e, t_e_data),
-                (t_i, t_data),
-                (lambda_m, lambda_m_data),
-                (t_m, t_m_data),
-                (sigma_m, sigma_m_data),
-                (_sigma_i, val_sigma_i[i]),
-                (beta_i, math.atan(h_array[i] / l_array[i])),
-            ]
+        val = sympy.Float(
+            fx_d_delta_l_i_sigma_i(
+                val_delta_l_li[i],
+                l_array[i],
+                lambda_i_array[i],
+                alpha_data,
+                elastic_data,
+                t_e_data,
+                t_data,
+                lambda_m_data,
+                t_m_data,
+                sigma_m_data,
+                val_sigma_i[i],
+                math.atan(h_array[i] / l_array[i]),
+            )
         )
+        manual_val = exp.manual_diff_delta_li_sigma_i(
+            h_array[i],
+            l_array[i],
+            lambda_m_data,
+            lambda_i_array[i],
+            val_sigma_i[i],
+            sigma_m_data,
+            alpha_data,
+            t_data,
+            t_e_data,
+            t_m_data,
+            elastic_data,
+        )
+        if math.fabs(val - manual_val) > 1e-5:
+            raise Exception("d_delta_l_i_sigma_i 自动和手动微分不匹配")
         val_list.append(val)
     return val_list
 
@@ -133,37 +113,7 @@ def evaluate_d_delta_l_i_sigma_i(val_delta_l_li, val_sigma_i):
 # C为dσi1dΔli
 # C只有n-1行
 def evaluate_d_sigma_i1_d_delta_l_i(val_delta_l_li, val_sigma_i):
-    (
-        G_i,
-        A,
-        lambda_i,
-        lambda_i1,
-        _sigma_i,
-        h_i,
-        h_i1,
-        l_i,
-        l_i1,
-        stringlen_i,
-        _sigma_i1,
-        beta_i,
-        beta_i1,
-    ) = sympy.symbols(
-        """
-        G_i,
-        A,
-        lambda_i,
-        lambda_i1,
-        sigma_i,
-        h_i,
-        h_i1,
-        l_i,
-        l_i1,
-        stringlen_i,
-        sigma_i1,
-        beta_i,
-        beta_i1,
-        """
-    )
+
     row = []
     for i in range(span_count - 1):
         col = []
@@ -171,36 +121,46 @@ def evaluate_d_sigma_i1_d_delta_l_i(val_delta_l_li, val_sigma_i):
             if i < j:
                 col.append(0)
             else:
-                _val = d_sigma_i1_d_l_i.subs(
-                    [
-                        (G_i, string_g / conductor_n),
-                        (A, area),
-                        (lambda_i, lambda_i_array[i]),
-                        (lambda_i1, lambda_i_array[i + 1]),
-                        (_sigma_i, val_sigma_i[i]),
-                        (h_i, h_array[i]),
-                        (h_i1, h_array[i + 1]),
-                        (l_i, l_array[i]),
-                        (l_i1, l_array[i + 1]),
-                        (stringlen_i, string_length),
-                        (_sigma_i1, val_sigma_i[i + 1]),
-                        (beta_i, math.atan(h_array[i] / l_array[i])),
-                        (beta_i1, math.atan(h_array[i + 1] / l_array[i + 1])),
-                    ]
-                )
                 _val_delta_l_li = list(val_delta_l_li)
                 _val_delta_l_li[-1] = _val_delta_l_li[j]  # 把需要求导的Δlj放最后一个位置
                 _val_delta_l_li[j] = 0
                 # σi1的第i+1行至倒数第2行全部清0
                 for k in range(i + 1, len(_val_delta_l_li) - 1):
                     _val_delta_l_li[k] = 0
-                # if index == i:
-                #     _val = _val.subs(li, val_delta_l_li[index])
-                # if index > i:
-                #     _val = _val.subs(li, 0)
-                for index, li in enumerate(delta_Li):
-                    _val = _val.subs(li, _val_delta_l_li[index])
-                    pass
+                _val = sympy.Float(
+                    fx_d_sigma_i1_d_l_i(
+                        string_g / conductor_n,
+                        area_data,
+                        lambda_i_array[i],
+                        lambda_i_array[i + 1],
+                        val_sigma_i[i],
+                        h_array[i],
+                        h_array[i + 1],
+                        l_array[i],
+                        l_array[i + 1],
+                        string_length,
+                        val_sigma_i[i + 1],
+                        math.atan(h_array[i] / l_array[i]),
+                        math.atan(h_array[i + 1] / l_array[i + 1]),
+                        *_val_delta_l_li
+                    )
+                )
+
+                manual_val = exp.manual_diff_sigma_i1_d_l_i(
+                    h_array[i],
+                    l_array[i],
+                    h_array[i + 1],
+                    l_array[i + 1],
+                    string_g / conductor_n,
+                    area_data,
+                    lambda_i_array[i],
+                    lambda_i_array[i + 1],
+                    val_sigma_i[i],
+                    string_length,
+                    math.fsum(val_delta_l_li[0 : i + 1]),
+                )
+                if math.fabs(manual_val - _val) > 1e-5:
+                    raise Exception("d_sigma_i1_delta_L_i 自动和手动微分不匹配")
                 col.append(_val)
         row.append(col)
     return sympy.Matrix(row)
@@ -237,12 +197,8 @@ def evaluate_d_sigma_i1_d_delta_sigma_i(val_delta_li):
 
 def solve():
     # 初始化
-    val_delta_li = [0.1 for i in range(span_count)]
-    # val_delta_li = [0.15864687475316822, -0.1935189734784845, 0.03478489898855073]
-
+    val_delta_li = [0.1 for _ in range(span_count)]
     val_sigma_i = [sigma_m_data for _ in range(span_count)]
-    # val_sigma_i = [175.38451579479482, 176.01015153076614, 175.88355419459572]
-
     loop = 0
     while True:
         loop += 1
@@ -268,7 +224,6 @@ def solve():
         A = sympy.Matrix([[M_A, M_B], [M_C, M_D], [M_E]])
         fx_delta_Li = []
         fx_sigma_i1 = []
-        b_i = 0
         for i in range(span_count):
             fx_delta_Li.append(
                 val_delta_li[i]
@@ -277,7 +232,7 @@ def solve():
                     l_array[i],
                     lambda_i_array[i],
                     alpha_data,
-                    elastic,
+                    elastic_data,
                     t_e_data,
                     t_data,
                     val_sigma_i[i],
@@ -290,7 +245,7 @@ def solve():
                 fx_sigma_i1.append(
                     val_sigma_i[i + 1]
                     - main.fun_sigma_i1(
-                        area,
+                        area_data,
                         val_sigma_i[i],
                         math.fsum(val_delta_li[0 : i + 1]),
                         string_length,
@@ -303,35 +258,19 @@ def solve():
                         lambda_i_array[i + 1],
                     )
                 )
-
-                # lambda_i1 = lambda_i_array[i + 1]
-                # h_i1 = h_array[i + 1]
-                # l_i1 = l_array[i + 1]
-                # h_i = h_array[i]
-                # l_i = l_array[i]
-                # beta_i = math.atan(h_i / l_i)
-                # beta_i1 = math.atan(h_i1 / l_i1)
-                # w_i = (
-                #         lambda_i_array[i] * l_array[i] / 2 / math.cos(beta_i)
-                #         + val_sigma_i[i] * h_i / l_i
-                #         + (lambda_i1 * l_i1 / 2 / math.cos(beta_i1) - val_sigma_i[i+1] * h_i1 / l_i1)
-                # )
-                # b_i += val_delta_li[i]
-                # # 新版大手册p329 (5-61) 最上方公式
-                # right_equ = val_sigma_i[i] + b_i / math.sqrt(string_length ** 2 - b_i ** 2) * (
-                #         string_g/conductor_n / 2 / area + w_i  # string_g已在传入时考虑了导线分裂数
-                # )
-
         fx_sum_Li = [math.fsum(val_delta_li)]
         b_list = []
         b_list.extend(fx_delta_Li)
         b_list.extend(fx_sigma_i1)
         b_list.extend(fx_sum_Li)
-        b = sympy.Matrix(b_list)
-        # sympy.pprint(b)
-        x = sympy.linsolve((-A, b))
-        x_list = list(x)[0]
-        abs_min = [math.fabs(_x) for _x in x_list]
+        AA = np.array(A.tolist(), dtype=np.float64)
+        b = np.array(b_list, dtype=np.float64)
+        x = np.linalg.solve(-AA, b)
+        x_list = x
+        # 强制要求等式满足
+        abs_min: List[float] = [
+            math.fabs(_x) for _x in [*x_list, *fx_delta_Li, *fx_sigma_i1]
+        ]
         abs_min.sort()
         if abs_min[-1] < 1e-5:
             break
@@ -343,10 +282,33 @@ def solve():
     if loop >= loop_end:
         print("不收敛")
     else:
-        print(loop)
-        print(val_delta_li)
-        print(val_sigma_i)
+        print("经过{loop}次迭代收敛,最大偏差{bias}".format(loop=loop, bias=abs_min[-1]))
+        # print(val_delta_li)
+        # print(val_sigma_i)
+        verify(val_delta_li, val_sigma_i)
+
+
+def verify(val_delta_li, val_sigma_i):
+    main.verify(
+        area_data,
+        h_array,
+        l_array,
+        string_length,
+        string_g / conductor_n,
+        val_sigma_i,
+        val_delta_li,
+        lambda_i_array,
+        t_data,
+        alpha_data,
+        elastic_data,
+        t_e_data,
+        lambda_m_data,
+        t_m_data,
+        sigma_m_data,
+        1e-5,
+    )
 
 
 solve()
+
 print("Finished.")

data.py

@@ -1,4 +1,4 @@
-#loop_end = 10000000  # 最大循环次数
+# loop_end = 10000000  # 最大循环次数
 loop_end = 1000000  # 最大循环次数
 # 架线时的状态
 # 取外过无风
@@ -10,13 +10,61 @@ alpha = 0.0000155  # 导线膨胀系数  1/°C
 elastic = 95900  # 弹性系数 N/mm2
 area = 154.48  # 导线面积 mm2
 lambda_m = 14.8129 / area  # 导线比载 N/(m.mm)
-lambda_i_array = [lambda_m*0.9,lambda_m*1.3,lambda_m,lambda_m,lambda_m]
+lambda_i_array = [
+    lambda_m * 0.9,
+    lambda_m * 1.2,
+    lambda_m,
+    lambda_m,
+    lambda_m,
+    lambda_m * 0.9,
+    lambda_m * 1.5,
+    lambda_m,
+    lambda_m,
+    lambda_m,
+    lambda_m,
+    lambda_m,
+    lambda_m,
+    lambda_m * 0.9,
+    lambda_m * 1.3,
+]
 # 取400m代表档距下
 sigma_m = 28517 / area  # 架线时，初伸长未释放前的最低点水平应力。单位N/mm2
-span_count = 3 # 几个档距
+span_count = 14  # 几个档距
 # n个档距,n-1个直线塔
-h_array = [0, 0, 0, 0, 0]
-l_array = [400, 300, 300, 500, 300]
+h_array = [
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+]
+l_array = [
+    400,
+    300,
+    300,
+    500,
+    300,
+    400,
+    300,
+    300,
+    500,
+    300,
+    300,
+    500,
+    300,
+    400,
+    300,
+]
 t = 15
 epsilon = 1e-4  # 收敛判据
 conductor_n = 6  # 导线分裂数

exp.py

@@ -27,7 +27,7 @@ def delta_li():
         t_m,
         sigma_m,
         sigma_i,
-        beta_i
+        beta_i,
     ) = sympy.symbols(
         """ 
         delta_l_i,
@@ -43,7 +43,6 @@ def delta_li():
         sigma_i,
         beta_i,"""
     )
-    # beta_i = sympy.atan(h_i / l_i)  # 高差角
     _delta_li = delta_l_i - (
         l_i
         / ((sympy.cos(beta_i) ** 2) * (1 + (lambda_i * l_i / sigma_i) ** 2 / 8))
@@ -55,7 +54,6 @@ def delta_li():
             + alpha * (t_i + t_e - t_m)
         )
     )
-    # d_delta_li_sigma_i = sympy.diff(_delta_li, sigma_i)
     return _delta_li
 
 
@@ -106,6 +104,7 @@ def fun_sigma_i1(delta_Li):
         for f in delta_Li:
             _t += f
         return _t
+
     _sigma_i1 = sigma_i1 - (
         (
             G_i / 2 / A  # G_i传入时已考虑导线分裂数
@@ -116,3 +115,157 @@ def fun_sigma_i1(delta_Li):
         + sigma_i / b_i() * sympy.sqrt(stringlen_i ** 2 - b_i() ** 2)
     ) / (sympy.sqrt(stringlen_i ** 2 - b_i() ** 2) / b_i() + h_i1 / l_i1)
     return _sigma_i1
+
+
+def manual_diff_delta_li_sigma_i(
+    h_i, l_i, lambda_m, lambda_i, sigma_i, sigma_m, alpha, t_i, t_e, t_m, E
+):
+    beta_i = math.atan(h_i / l_i)
+    A = (
+        (l_i * math.cos(beta_i)) ** 2
+        / 24
+        * ((lambda_m / sigma_m) ** 2 - (lambda_i / sigma_i) ** 2)
+        + (sigma_i - sigma_m) / E / math.cos(beta_i)
+        + alpha * (t_i + t_e - t_m)
+    )
+    B = 1 + (lambda_i * l_i / sigma_i) ** 2 / 8
+    dA_dsigma_i = ((l_i * math.cos(beta_i)) ** 2) / 24 * 2 * lambda_i ** 2 * (
+        sigma_i ** (-3)
+    ) + 1 / E / math.cos(beta_i)
+    dB_dsigma_i = -2 * (lambda_i * l_i) ** 2 / 8 * (sigma_i ** (-3))
+    _t = -l_i / (math.cos(beta_i) ** 2) * (dA_dsigma_i * B - A * dB_dsigma_i) / (B ** 2)
+    return _t
+
+
+def manual_diff_sigma_i1_d_l_i(
+    h_i, l_i, h_i1, l_i1, Gi, A, lambda_i, lambda_i1, sigma_i, stringlen, b_i
+):
+    beta_i = math.atan(h_i / l_i)
+    beta_i1 = math.atan(h_i1 / l_i1)
+    A = (
+        Gi / 2 / A
+        + lambda_i * l_i / 2 / math.cos(beta_i)
+        + lambda_i1 * l_i1 / 2 / math.cos(beta_i1)
+        + sigma_i * h_i / l_i
+        + sigma_i / b_i * ((stringlen ** 2 - b_i ** 2) ** 0.5)
+    )
+    B = ((stringlen ** 2 - b_i ** 2) ** 0.5)/b_i + h_i1 / l_i1
+    dA_d_delta_L1 = (
+        sigma_i
+        * (
+            -((stringlen ** 2 - b_i ** 2) ** -0.5) * (b_i ** 2)
+            - (stringlen ** 2 - b_i ** 2) ** 0.5
+        )
+        / (b_i ** 2)
+    )
+    dB_d_delta_L1 = (
+        1
+        / (b_i ** 2)
+        * (
+            -((stringlen ** 2 - b_i ** 2) ** -0.5) * (b_i ** 2)
+            - (stringlen ** 2 - b_i ** 2) ** 0.5
+        )
+    )
+    _t = -(dA_d_delta_L1 * B - A * dB_d_delta_L1) / (B ** 2)
+    return _t
+
+def get_lambdify_d_delta_l_i_sigma_i(_d_delta_l_i_sigma_i):
+    (
+        delta_l_i,
+        l_i,
+        lambda_i,
+        alpha,
+        E,
+        t_e,
+        t_i,
+        lambda_m,
+        t_m,
+        sigma_m,
+        _sigma_i,
+        beta_i,
+    ) = sympy.symbols(
+        """ 
+        delta_l_i,
+        l_i,
+        lambda_i,
+        alpha,
+        E,
+        t_e,
+        t_i,
+        lambda_m,
+        t_m,
+        sigma_m,
+        sigma_i,
+        beta_i
+        """
+    )
+    return sympy.lambdify(
+        (
+            delta_l_i,
+            l_i,
+            lambda_i,
+            alpha,
+            E,
+            t_e,
+            t_i,
+            lambda_m,
+            t_m,
+            sigma_m,
+            _sigma_i,
+            beta_i,
+        ),
+        _d_delta_l_i_sigma_i,
+    )
+
+def get_lambdify_d_sigma_i1_d_l_i(_d_sigma_i1_d_l_i,delta_Li):
+    (
+        G_i,
+        A,
+        lambda_i,
+        lambda_i1,
+        _sigma_i,
+        h_i,
+        h_i1,
+        l_i,
+        l_i1,
+        stringlen_i,
+        _sigma_i1,
+        beta_i,
+        beta_i1,
+    ) = sympy.symbols(
+        """
+        G_i,
+        A,
+        lambda_i,
+        lambda_i1,
+        sigma_i,
+        h_i,
+        h_i1,
+        l_i,
+        l_i1,
+        stringlen_i,
+        sigma_i1,
+        beta_i,
+        beta_i1,
+        """
+    )
+
+    return sympy.lambdify(
+        (
+            G_i,
+            A,
+            lambda_i,
+            lambda_i1,
+            _sigma_i,
+            h_i,
+            h_i1,
+            l_i,
+            l_i1,
+            stringlen_i,
+            _sigma_i1,
+            beta_i,
+            beta_i1,
+            *delta_Li,
+        ),
+        _d_sigma_i1_d_l_i,
+    )

main.py

@@ -106,7 +106,7 @@ def cal_loop():
     while True:
         b_i = 0
         # 一次增加0.1N
-        sigma_0 = sigma_0 + 0.1 / data.area
+        sigma_0 = sigma_0 + 0.01 / data.area
         sigma_array = [sigma_0 for j in range(span_count)]
         delta_l_i_array = []
         for i in range(span_count):
@@ -132,10 +132,10 @@ def cal_loop():
             b_i += _delta_l_i
             length_i = string_length
             g_i = string_g / data.conductor_n
-            h_i1 = h_array[i + 1]
-            l_i1 = l_array[i + 1]
-            if i<span_count-1:
+            if i < span_count - 1:
                 lambda_i1 = lambda_i_array[i + 1]
+                h_i1 = h_array[i + 1]
+                l_i1 = l_array[i + 1]
                 try:
                     sigma_i1 = fun_sigma_i1(
                         area,
@@ -160,7 +160,9 @@ def cal_loop():
             for i in range(span_count):
                 print("第{i}档导线应力为{tension}".format(i=i, tension=sigma_array[i]))
             for i in range(span_count - 1):
-                print("第{i}串偏移值为{bias}".format(i=i, bias=math.fsum(delta_l_i_array[0:i])))
+                print(
+                    "第{i}串偏移值为{bias}".format(i=i, bias=math.fsum(delta_l_i_array[0:i]))
+                )
             verify(
                 area,
                 h_array,
@@ -204,9 +206,13 @@ def verify(
     lambda_m,
     t_m,
     sigma_m,
+    epsilon=1e-4,
 ):
     # 用新版大手册p329页(5-61)第一个公式校验
     b_i = 0
+    if math.fabs((math.fsum(delta_l_i_array)))>1e-5:
+        print('偏移累加不等于0')
+        return
     for i in range(len(delta_l_i_array)):
         sigma_i = sigma_array[i]
         _delta_l_i = delta_l_i_array[i]
@@ -230,7 +236,7 @@ def verify(
         )
         if math.fabs(cal_delta_l_i - _delta_l_i) > 1e-4:
             print("!!!偏移等式不满足。")
-        if i<len(delta_l_i_array)-1:
+        if i < len(delta_l_i_array) - 1:
             sigma_i1 = sigma_array[i + 1]
             left_equ = sigma_array[i + 1]
             lambda_i1 = lambda_array[i + 1]
@@ -244,18 +250,23 @@ def verify(
                 + (lambda_i1 * l_i1 / 2 / math.cos(beta_i1) - sigma_i1 * h_i1 / l_i1)
             )
             b_i += delta_l_i_array[i]
-            #新版大手册p329 (5-61) 最上方公式
+            # 新版大手册p329 (5-61) 最上方公式
             right_equ = sigma_i + b_i / math.sqrt(string_length ** 2 - b_i ** 2) * (
                 string_g / 2 / area + w_i  # string_g已在传入时考虑了导线分裂数
             )
             # TODO 等式允许误差是否可调？
-            if math.fabs(right_equ - left_equ) > 1e-4:
+            if math.fabs(right_equ - left_equ) > epsilon:
                 print(math.fabs(right_equ - left_equ))
                 print("!!!应力等式不满足")
                 return
     print("等式满足。")
+    # print('sigma')
+    # print(sigma_array)
+    print('delta_li')
+    print(delta_l_i_array)
 
-if __name__=='__main__':
+
+if __name__ == "__main__":
     cal_loop()
 import sympy