初步完成了双回路公式

main.py

@@ -6,20 +6,26 @@ import timeit
 
 def egm():
     avr_n_sf = 0  # 考虑电压的影响计算的跳闸率
-    voltage_n = 3  # 工作电压分成多少份来计算
+    voltage_n = 1  # 工作电压分成多少份来计算
     ng = func_ng(20)
     h_whole = 140  # 杆塔全高
     insulator_c_len = 6.8  # 串子绝缘长度
     string_c_len = 9.2
     string_g_len = 0.5
-    dgc = -0.0  # 导地线水平距离
+    rc_x = -0.0  # 导地线水平距离
+    rs_x = 0
+    rg_x = 0
     vertical_dgc = 2.7  # 导地线挂点垂直距离
     h_g_avr_sag = 11.67 * 2 / 3
     h_c_avr_sag = 14.43 * 2 / 3
-    h_gav = h_whole - string_g_len - h_g_avr_sag  # 地线对地平均高
-    h_cav = h_whole - string_c_len - vertical_dgc - h_c_avr_sag  # 导线对地平均高
-    shield_angle = math.atan(dgc / (vertical_dgc + string_c_len)) * 180 / math.pi
+    rs_y = h_whole - string_g_len - h_g_avr_sag  # 地线对地平均高
+    rc_y = h_whole - string_c_len - vertical_dgc - h_c_avr_sag  # 导线对地平均高
+    rg_y = rc_y - 20
+    shield_angle = (
+        math.atan(rc_x / (vertical_dgc + string_c_len)) * 180 / math.pi
+    )  # 保护角
     print(f"保护角{shield_angle:.3f}°")
+    rg_type = "c"
     for u_bar in range(voltage_n):
         u_ph = (
             math.sqrt(2) * 750 * math.cos(2 * math.pi / voltage_n * u_bar) / 1.732
@@ -30,12 +36,12 @@ def egm():
         _min_i = i_min  # 尝试的最小电流
         _max_i = 200  # 尝试的最大电流
         cad = Draw()
-        cad.draw(i_min, u_ph, h_gav, h_cav, dgc, 2)
+        # cad.draw(i_min, u_ph, rs_x, rs_y, rc_x, rc_y, rg_x, rg_y, rg_type, 2)
         for i_bar in np.linspace(_min_i, _max_i, int((_max_i - _min_i) / 0.1)):  # 雷电流
-            # print(f"尝试计算电流为{i_bar:.2f}")
+            print(f"尝试计算电流为{i_bar:.2f}")
             rs = rs_fun(i_bar)
             rc = rc_fun(i_bar, u_ph)
-            rg = rg_fun(i_bar, h_cav)
+            rg = rg_fun(i_bar, rc_y, u_ph, typ=rg_type)
             #######
             # cccCount += 1
             # if cccCount % 30 == 0:
@@ -47,20 +53,28 @@ def egm():
             #     )
             #     core.gMSP.add_circle((dgc, h_cav), rc)
             #######
-            circle_intersection = solve_circle_intersection(rs, rc, h_gav, h_cav, dgc)
-            if not circle_intersection:  # if circle_intersection is []
-                # print("保护弧和暴露弧无交点，检查设置参数。程序退出。")
-                continue
-            circle_rc_line_intersection = solve_circle_line_intersection(
-                rc, rg, dgc, h_cav
+            rg_rc_circle_intersection = solve_circle_intersection(
+                rs, rc, rs_x, rs_y, rc_x, rc_y
             )
-            if not circle_rc_line_intersection:
+            if not rg_rc_circle_intersection:  # if circle_intersection is []
+                print("保护弧和暴露弧无交点，检查设置参数。程序退出。")
+                continue
+            circle_rc_line_or_rg_intersection = None
+            if rg_type == "g":
+                circle_rc_line_or_rg_intersection = solve_circle_line_intersection(
+                    rc, rg, rc_x, rc_y
+                )
+            elif rg_type == "c":
+                circle_rc_line_or_rg_intersection = solve_circle_intersection(
+                    rg, rc, rg_x, rg_y, rc_x, rc_y
+                )
+            if not circle_rc_line_or_rg_intersection:
                 continue
             min_distance_intersection = (
                 np.sum(
                     (
-                        np.array(circle_intersection)
-                        - np.array(circle_rc_line_intersection)
+                        np.array(rg_rc_circle_intersection)
+                        - np.array(circle_rc_line_or_rg_intersection)
                     )
                     ** 2
                 )
@@ -69,14 +83,24 @@ def egm():
             i_max = i_bar
             if min_distance_intersection < 0.1:
                 break
-            if circle_intersection[1] < circle_rc_line_intersection[1]:
-                circle_rs_line_intersection = solve_circle_line_intersection(
-                    rs, rg, 0, h_gav
-                )
+            # 判断是否以完全被保护
+            if rg_rc_circle_intersection[1] < circle_rc_line_or_rg_intersection[1]:
+                circle_rs_line_or_rg_intersection = None
+                if rg_type == "g":
+                    circle_rs_line_or_rg_intersection = solve_circle_line_intersection(
+                        rs, rg, rs_x, rs_y
+                    )
+                if rg_type == "c":
+                    circle_rs_line_or_rg_intersection = solve_circle_intersection(
+                        rs, rg, rs_x, rs_y, rg_x, rg_y
+                    )
                 # 判断与保护弧的交点是否在暴露弧外面
                 distance = (
                     np.sum(
-                        (np.array(circle_rs_line_intersection) - np.array([dgc, h_cav]))
+                        (
+                            np.array(circle_rs_line_or_rg_intersection)
+                            - np.array([rc_x, rc_y])
+                        )
                         ** 2
                     )
                     ** 0.5
@@ -84,8 +108,8 @@ def egm():
                 if distance > rc:
                     print("暴露弧已经完全被屏蔽")
                     break
-        cad.draw(i_min, u_ph, h_gav, h_cav, dgc, 2)
-        cad.draw(i_max, u_ph, h_gav, h_cav, dgc, 6)
+        cad.draw(i_min, u_ph, rs_x, rs_y, rc_x, rc_y, rg_x, rg_y, rg_type, 2)
+        cad.draw(i_max, u_ph, rs_x, rs_y, rc_x, rc_y, rg_x, rg_y, rg_type, 6)
         cad.save()
         # 判断是否导线已经被完全保护
         if abs(i_max - _max_i) < 1e-5:
@@ -99,13 +123,12 @@ def egm():
             return
         # 开始积分
         curt_segment_n = int((i_max - i_min) / curt_fineness)  # 分成多少份
-        calculus = 0
         i_curt_samples, d_curt = np.linspace(
             i_min, i_max, curt_segment_n + 1, retstep=True
         )
         bd_area_vec = np.vectorize(bd_area)
         cal_bd_np = bd_area_vec(
-            i_curt_samples, u_ph, dgc, h_gav, h_cav
+            i_curt_samples, u_ph, rc_x, rc_y, rs_x, rs_y, rg_x, rg_y, rg_type
         ) * thunder_density(i_curt_samples)
         calculus = np.sum(cal_bd_np[:-1] + cal_bd_np[1:]) / 2 * d_curt
         # for i_curt in i_curt_samples[:-1]: