增加等式满足校验。

main.py

@@ -3,36 +3,219 @@
 
 import math
 
-# 架线时的状态
-t_m = 100  # 导线架设时的气温。单位°C
-sigma_m = 10  # 架线时，初伸长未释放前的最低点水平应力。单位N/mm2
-lambda_m = 10  # 导线比载 N/(m.mm)
-t_e = 25  # 架线时考虑初伸长的降温，取正值。单位°C
-
-
 # h_i 悬点高差
 # l_i 悬点档距
-# alpha 导线膨胀系数  1/°C
-# E 弹性系数 N/mm2
+# _alpha 导线膨胀系数  1/°C
+# _elastic 弹性系数 N/mm2
+# _t_e 架线时考虑初伸长的降温，取正值。单位°C
 # lambda_i 计算不平衡张力时导线比载 N/(m.mm)
 # sigma_i 计算不平衡张力时最低点水平应力 单位N/mm2
 # t_i 计算不平衡张力时导线温度 单位°C
-# lambda_m 导线架线时时导线比载 N/(m.mm)
-# sigma_m 导线架线时时最低点水平应力 单位N/mm2
-# t_m 导线架线时时导线温度 单位°C
-def delta_li(h_i, l_i, lambda_i, alpha, E, t_i, sigma_i, lambda_m, t_m, sigma_m):
-    beta_i = math.atan(h_i / l_i)
-    t = (
+# _lambda_m 导线架线时时导线比载 N/(m.mm)
+# _sigma_m 导线架线时时最低点水平应力 单位N/mm2
+# _t_m 导线架线时时导线温度 单位°C
+
+
+def delta_li(
+    h_i: float,
+    l_i: float,
+    lambda_i: float,
+    _alpha: float,
+    _elastic: float,
+    _t_e: float,
+    t_i: float,
+    sigma_i: float,
+    _lambda_m: float,
+    _t_m: float,
+    _sigma_m: float,
+) -> float:
+    beta_i = math.atan(h_i / l_i)  # 高差角
+    _delta_li = (
         l_i
         / ((math.cos(beta_i) ** 2) * (1 + (lambda_i * l_i / sigma_i) ** 2 / 8))
         * (
             (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)
+            * ((_lambda_m / _sigma_m) ** 2 - (lambda_i / sigma_i) ** 2)
+            + ((sigma_i - _sigma_m) / _elastic / math.cos(beta_i))
+            + _alpha * (t_i + _t_e - _t_m)
         )
     )
+    return _delta_li
+
+
+# area 导线截面 单位mm2
+# sigma_i 第i档内水平应力 单位N/mm2
+# b_i 悬垂串沿线路方向水平偏移距离，沿大号方向为正，反之为负。 单位m
+# length_i 第i基直线塔串长 单位m
+# g_i 第i基直线塔串重 单位N
+# h_i 悬垂串处千中垂位置时，,第 i 基对第 i-1 杆塔上导线悬挂点间的高差大号比小号杆塔悬挂点高者h本身为正值，反之为负值。
+# lambda_i 第i档导线比载 N/(m.mm)
+# h_i1 悬垂串处千中垂位置时，第 i+1 基对第 i 杆塔上导线悬挂点间的高差大号比小号杆塔悬挂点高者h本身为正值，反之为负值。
+# lambda_i1
+def fun_sigma_i1(
+    area: float,
+    sigma_i: float,
+    b_i: float,
+    length_i: float,
+    g_i: float,
+    h_i: float,
+    l_i: float,
+    lambda_i: float,
+    h_i1: float,
+    l_i1: float,
+    lambda_i1: float,
+):
+    beta_i = math.atan(h_i / l_i)
+    beta_i1 = math.atan(h_i1 / l_i1)
+    _sigma_i1 = (
+        (
+            g_i / 2 / area
+            + 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 * math.sqrt(length_i ** 2 - b_i ** 2)
+    ) / (math.sqrt(length_i ** 2 - b_i ** 2) / b_i + h_i1 / l_i1)
+    return _sigma_i1
+
+
+# 求解循环。
+def cal_loop():
+    loop_end = 100000  # 最大循环次数
+    # 架线时的状态
+    # 取外过无风
+    string_length = 9.2  # 串长 单位m
+    string_g = 60 * 9.8  # 串重 单位N
+    t_m = 15  # 导线架设时的气温。单位°C
+    t_e = 20  # 架线时考虑初伸长的降温，取正值。单位°C
+    alpha = 0.0000155  # 导线膨胀系数  1/°C
+    elastic = 95900  # 弹性系数 N/mm2
+    area = 154.48  # 导线面积 mm2
+    lambda_m = 14.8129 / area  # 导线比载 N/(m.mm)
+    # 取400m代表档距下
+    sigma_m = 28517 / area  # 架线时，初伸长未释放前的最低点水平应力。单位N/mm2
+    span_count = 3  # 几个档距
+    # n个档距,n-1个直线塔
+    h_array = [0, 0, 0]
+    l_array = [400, 400, 400]
+    t_array = [15, 15, 15]
+    lambda_array = [lambda_m, lambda_m, lambda_m]
+    loop_count = 1
+    sigma_0 = sigma_m * 0.8
+    while True:
+        sigma_0 = sigma_0 + 0.001
+        sigma_array = [sigma_0, 0, 0]
+        b_i = 0
+        delta_l_i_array = []
+        for i in range(span_count - 1):
+            h_i = h_array[i]
+            l_i = l_array[i]
+            lambda_i = lambda_array[i]
+            t_i = t_array[i]
+            sigma_i = sigma_array[i]
+            _delta_l_i = delta_li(
+                h_i,
+                l_i,
+                lambda_i,
+                alpha,
+                elastic,
+                t_e,
+                t_i,
+                sigma_i,
+                lambda_m,
+                t_m,
+                sigma_m,
+            )
+            delta_l_i_array.append(_delta_l_i)
+            b_i += _delta_l_i
+            length_i = string_length
+            g_i = string_g
+            h_i1 = h_array[i + 1]
+            l_i1 = l_array[i + 1]
+            lambda_i1 = lambda_array[i + 1]
+            sigma_i1 = fun_sigma_i1(
+                area,
+                sigma_i,
+                b_i,
+                length_i,
+                g_i,
+                h_i,
+                l_i,
+                lambda_i,
+                h_i1,
+                l_i1,
+                lambda_i1,
+            )
+            sigma_array[i + 1] = sigma_i1
+        # print("第{loop_count}轮求解。".format(loop_count=loop_count))
+        # print(b_i)
+        loop_count += 1
+        if math.fabs(b_i) < 1e-5:
+            print("迭代{loop_count}次找到解。".format(loop_count=loop_count))
+            print("悬垂串偏移累加bi为{b_i}".format(b_i=b_i))
+            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=delta_l_i_array[i]))
+            verify(
+                area,
+                h_array,
+                l_array,
+                string_length,
+                string_g,
+                sigma_array,
+                delta_l_i_array,
+                lambda_array,
+            )
+            break
+        if loop_count >= loop_end:
+            print("!!!未找到解。")
+            print(sigma_array)
+            print(b_i)
+            break
+
+
+# 检验等式。
+def verify(
+    area: float,
+    h_array: [float],
+    l_array: [float],
+    string_length: [float],
+    string_g: [float],
+    sigma_array: [float],
+    delta_l_i_array: [float],
+    lambda_array: [float],
+):
+    # 用新版大手册p329页(5-61)最第一个公式校验
+    for i in range(len(delta_l_i_array)):
+        sigma_i = sigma_array[i]
+        sigma_i1 = sigma_array[i + 1]
+        left_equ = sigma_array[i + 1]
+        _delta_l_i = delta_l_i_array[i]
+        lambda_i = lambda_array[i]
+        lambda_i1 = lambda_array[i + 1]
+        h_i = h_array[i]
+        h_i1 = h_array[i + 1]
+        l_i = l_array[i]
+        l_i1 = l_array[i + 1]
+        beta_i = math.atan(h_i / l_i)
+        beta_i1 = math.atan(h_i1 / l_i1)
+        w_i = (
+            lambda_i * l_i / 2 / math.cos(beta_i)
+            + sigma_i * h_i / l_i
+            + (lambda_i1 * l_i1 / 2 / math.cos(beta_i1) - sigma_i1 * h_i1 / l_i1)
+        )
+        right_equ = sigma_i + delta_l_i_array[i] / math.sqrt(
+            string_length ** 2 - delta_l_i_array[i] ** 2
+        ) * (string_g / 2 / area + w_i)
+        if math.fabs(right_equ - left_equ) > 1e-4:
+            print("!!!等式不满足")
+            return
+    print("等式满足。")
+
+
+cal_loop()
 
 
 print("Finished.")