模型参数和空腔参数计算

函数描述

计算模型参数和空腔参数。

参数

$\pi$ ：圆周率。
$L_{\text{mm}}$ ：模型总长度（mm）。
$\text{Top0}$ ：顶点位置的无量纲量。
$R_{\text{nmm}}$ ：空化器半径（mm）。
$N_{\text{con}}$ ：模型节数。
$\text{ConeLen}$ ：每节的长度（mm）。
$\text{BaseDiam}$ ：每节的末端直径（mm）。
$\Gamma$ ：攻角（度）。
$\Psi_0$ ：俯仰角（度）。
$\Gamma_{\text{dive}}$ ：潜水时的攻角（度）。
$\Psi_{0\text{dive}}$ ：潜水时的俯仰角（度）。
$\text{FlagDive}$ ：是否为潜水模式。
$\beta$ ：空化器角度（度）。
$\delta$ ：空化器倾角（度）。
$D_{\text{nmm}}$ ：空化器直径（mm）。
$H_0$ ：初始水头（m）。
$P_c$ ：初始压力（Pa）。
$V_0$ ：初始速度（m/s）。
$X_{\text{fin}}$ ：终点位置（m）。
$X_{\text{film}}$ ：拍摄起始点（m）。
$X_{\text{beg}}$ ：观察开始位置（m）。
$X_{\text{end}}$ ：观察结束位置（m）。
$L_h$ ：腔体长度（mm）。
$D_{Lh}$ ：腔体左端直径（mm）。
$D_{Rh}$ ：腔体右端直径（mm）。

返回值

$\Gamma_{\text{rad}}$ ：攻角的弧度值。
$\Psi_{0\text{rad}}$ ：初始俯仰角的弧度值。
$\sin(\Gamma)$ ：攻角的正弦值。
$\cos(\Gamma)$ ：攻角的余弦值。
$\beta_{\text{rad}}$ ：空化器角度的弧度值。
$\delta_{\text{rad}}$ ：空化器倾角的弧度值。
$\sin(\delta)$ ：空化器倾角的正弦值。
$\cos(\delta)$ ：空化器倾角的余弦值。
$\sin(\Psi_0)$ ：初始俯仰角的正弦值。
$\cos(\Psi_0)$ ：初始俯仰角的余弦值。
$L_{\text{mm}}$ ：模型总长度（mm）。
$L_m$ ：模型总长度（m）。
$\text{Rmstr}$ ：模型半径数组（无量纲）。
$\text{Xmstr}$ ：模型半径分布的x坐标。
$\text{Sm}$ ：模型半径分布的横截面积。
$gX_{\text{fin}}$ ：终点位置与模型长度的比值。
$gX_{\text{film}}$ ：拍摄起始点与模型长度的比值。
$gX_{\text{beg}}$ ：观察开始位置与模型长度的比值。
$gX_{\text{end}}$ ：观察结束位置与模型长度的比值。
$\text{Basa}$ ：观察范围的长度。
$X_{\text{agr}}$ ：轴对称空腔前缘的无量纲长度。
$R_{\text{agr}}$ ：轴对称空腔前缘的无量纲半径。
$S_{\text{agr}}$ ：轴对称空腔前缘的无量纲面积。
$X_{c\text{beg}}$ ：轴对称空腔前缘的起始点位置。
$R_{c\text{beg}}$ ：轴对称空腔前缘的起始点半径。
$A$ ：经验常数。
$AK1$ ：空腔形状计算中的常数。
$w2$ ：空腔形状计算中的中间变量。
$\kappa$ ：空腔形状计算中的经验常数。
$R_{c0}$ ：轴对称空腔中段的无量纲半径。
$L_{c0}$ ：轴对称空腔的无量纲长度。

计算公式

1. 初始化变量

攻角的弧度值：
$\Gamma_{\text{rad}} = \begin{cases} \frac{\pi \times \Gamma_{\text{dive}}}{180}, & \text{if } \text{FlagDive} \\ \frac{\pi \times \Gamma}{180}, & \text{otherwise} \end{cases}$
初始俯仰角的弧度值：
$\Psi_{0\text{rad}} = \begin{cases} \frac{\pi \times \Psi_{0\text{dive}}}{180}, & \text{if } \text{FlagDive} \\ \frac{\pi \times \Psi_0}{180}, & \text{otherwise} \end{cases}$
攻角的正弦和余弦值：
$\sin(\Gamma) = \sin(\Gamma_{\text{rad}})$
$\cos(\Gamma) = \cos(\Gamma_{\text{rad}})$
空化器角度的弧度值：
$\beta_{\text{rad}} = \frac{\pi \times \beta}{180}$
空化器倾角的弧度值：
$\delta_{\text{rad}} = \frac{\pi \times \delta}{180}$
空化器倾角的正弦和余弦值：
$\sin(\delta) = \sin(\delta_{\text{rad}})$
$\cos(\delta) = \cos(\delta_{\text{rad}})$
初始俯仰角的正弦和余弦值：
$\sin(\Psi_0) = \sin(\Psi_{0\text{rad}})$
$\cos(\Psi_0) = \cos(\Psi_{0\text{rad}})$

2. 模型总长度

模型总长度（mm）：
$L_{\text{mm}} = \sum_{i=1}^{N_{\text{con}}} \text{ConeLen}[i]$
模型总长度（m）：
$L_m = \frac{L_{\text{mm}}}{1000}$

3. 计算阻力系数

调用 DragCone 函数计算阻力系数 $C_{x0}$ 。

4. 计算初始水头和空化数

初始水头：
$\text{Head0} = 500 \times V_0^2$
初始空化数：
$SG0 = \frac{19.61 \times (10 + H_0) - \frac{P_c}{500}}{V_0^2}$

5. 计算其他参数

水中马赫数：
$\text{Mach} = \frac{V_0}{1460}$
弗劳德数：
$Fr = \left\lfloor \frac{V_0}{\sqrt{9.81 \times \frac{D_{\text{nmm}}}{1000}}} \right\rfloor$
初始弗劳德数平方：
$Fr2 = \frac{V_0^2}{9.81 \times L_m}$
空化器半径（mm）：
$R_{\text{nmm}} = \frac{D_{\text{nmm}}}{2}$
无量纲半径：
$R_n = \frac{R_{\text{nmm}}}{L_{\text{mm}}}$
顶点的无量纲位置：
$\text{Top0} = \begin{cases} 0, & \text{if } \beta = 180 \\ \frac{R_n}{\tan(\beta_{\text{rad}} / 2)}, & \text{otherwise} \end{cases}$

6. 计算模型几何参数

模型各节的切线斜率：
$\text{RibTan}[0] = 0.5 \times \frac{\text{BaseDiam}[0] - D_{\text{nmm}}}{\text{ConeLen}[0]}$
$\text{RibTan}[i] = 0.5 \times \frac{\text{BaseDiam}[i] - \text{BaseDiam}[i-1]}{\text{ConeLen}[i]}, \quad \text{for } i = 1, 2, \ldots, N_{\text{con}} - 1$
模型各节的切线角度：
$\text{RibAng}[i] = \arctan(\text{RibTan}[i]), \quad \text{for } i = 0, 1, \ldots, N_{\text{con}} - 1$
模型各节的无量纲长度：
$\text{Part}[0] = \frac{\text{ConeLen}[0]}{L_{\text{mm}}}$
$\text{Part}[i] = \text{Part}[i-1] + \frac{\text{ConeLen}[i]}{L_{\text{mm}}}, \quad \text{for } i = 1, 2, \ldots, N_{\text{con}} - 1$
模型各节末端的无量纲半径：
$\text{BaseR}[i] = 0.5 \times \frac{\text{BaseDiam}[i]}{L_{\text{mm}}}, \quad \text{for } i = 0, 1, \ldots, N_{\text{con}} - 1$

7. 计算模型轮廓点

模型轮廓点的坐标：
$\text{X0mod}[0] = -\text{Top0} \times \cos(\delta)$
$\text{Y0mod}[0] = \text{Top0} \times \sin(\delta)$
$\text{X0mod}[1] = R_n \times \sin(\delta)$
$\text{Y0mod}[1] = R_n \times \cos(\delta)$
$\text{X0mod}[2N_{\text{con}} + 2] = -\text{X0mod}[1]$
$\text{Y0mod}[2N_{\text{con}} + 2] = -\text{Y0mod}[1]$
$\text{X0mod}[2N_{\text{con}} + 3] = \text{X0mod}[0]$
$\text{Y0mod}[2N_{\text{con}} + 3] = \text{Y0mod}[0]$
$\text{X0mod}[i] = \text{Part}[i-2], \quad \text{for } i = 2, 3, \ldots, N_{\text{con}} + 1$
$\text{Y0mod}[i] = \text{BaseR}[i-2], \quad \text{for } i = 2, 3, \ldots, N_{\text{con}} + 1$
$\text{X0mod}[2N_{\text{con}} + 4 - i] = \text{Part}[i-2], \quad \text{for } i = 2, 3, \ldots, N_{\text{con}} + 1$
$\text{Y0mod}[2N_{\text{con}} + 4 - i] = -\text{BaseR}[i-2], \quad \text{for } i = 2, 3, \ldots, N_{\text{con}} + 1$

8. 计算模型肋骨轮廓点

模型肋骨轮廓点的坐标：
$\text{X0rib}[2i] = \text{Part}[i], \quad \text{for } i = 0, 1, \ldots, N_{\text{con}} - 2$
$\text{Y0rib}[2i] = \text{BaseR}[i], \quad \text{for } i = 0, 1, \ldots, N_{\text{con}} - 2$
$\text{X0rib}[2i + 1] = \text{Part}[i], \quad \text{for } i = 0, 1, \ldots, N_{\text{con}} - 2$
$\text{Y0rib}[2i + 1] = -\text{BaseR}[i], \quad \text{for } i = 0, 1, \ldots, N_{\text{con}} - 2$

9. 计算腔体轮廓点

腔体轮廓点的坐标：
$\text{X0cham}[0] = 1 - \frac{L_h}{L_{\text{mm}}}$
$\text{Y0cham}[0] = 0.5 \times \frac{D_{Lh}}{L_{\text{mm}}}$
$\text{X0cham}[1] = 1$
$\text{Y0cham}[1] = 0.5 \times \frac{D_{Rh}}{L_{\text{mm}}}$
$\text{X0cham}[2] = 1$
$\text{Y0cham}[2] = -\text{Y0cham}[1]$
$\text{X0cham}[3] = \text{X0cham}[0]$
$\text{Y0cham}[3] = -\text{Y0cham}[0]$
$\text{X0cham}[4] = \text{X0cham}[0]$
$\text{Y0cham}[4] = \text{Y0cham}[0]$

10. 计算模型半径分布

调用 [ModelRadii] 函数【高速入水】模型半径计算 | 雯雯のblog计算模型半径分布 $\text{Rmstr}$ 。
模型半径分布的x坐标：
$\text{Xmstr}[i] = 0.005 \times (i - 1), \quad \text{for } i = 1, 2, \ldots, 201$
模型半径分布的横截面积：
$\text{Sm}[i] = \pi \times (\text{Rmstr}[i] \times R_{\text{nmm}})^2 / 1000000, \quad \text{for } i = 1, 2, \ldots, 201$

11. 计算其他参数

终点位置与模型长度的比值：
$gX_{\text{fin}} = \frac{X_{\text{fin}}}{L_m}$
拍摄起始点与模型长度的比值：
$gX_{\text{film}} = \frac{X_{\text{film}}}{L_m}$
观察开始位置与模型长度的比值：
$gX_{\text{beg}} = \frac{X_{\text{beg}}}{L_m}$
观察结束位置与模型长度的比值：
$gX_{\text{end}} = \frac{X_{\text{end}}}{L_m}$
观察范围的长度：
$\text{Basa} = gX_{\text{end}} - gX_{\text{beg}}$

12. 计算空腔形状参数

轴对称空腔前缘的无量纲长度：
$X_{\text{agr}} = 2.0$
轴对称空腔前缘的无量纲半径：
$R_{\text{agr}} = (1.0 + 3.0 \times X_{\text{agr}})^{\frac{1}{3}}$
轴对称空腔前缘的无量纲面积：
$S_{\text{agr}} = \pi \times (R_n \times R_{\text{agr}})^2$

13. 计算轴对称空腔前缘的起始点位置和半径

轴对称空腔前缘的起始点位置和半径：
$X_{c\text{beg}}[0] = 0.0$
$R_{c\text{beg}}[0] = R_n$
$X_{c\text{beg}}[i] = X_{c\text{beg}}[i-1] + \frac{R_n \times X_{\text{agr}}}{3.0}, \quad \text{for } i = 1, 2, 3$
$R_{c\text{beg}}[i] = R_n \times \left(1.0 + 3.0 \times \frac{X_{c\text{beg}}[i]}{R_n}\right)^{\frac{1}{3}}, \quad \text{for } i = 1, 2, 3$

14. 计算经验常数和空腔形状参数

经验常数：
$A = 2.0$
空腔形状计算中的常数：
$AK1 = \frac{4.0 \times \pi}{A^2}$
空腔形状计算中的中间变量：
$w2 = R_n \times A \times \sqrt{C_{x0}}$
空腔形状计算中的经验常数：
$\kappa = 0.93$

15. 计算轴对称空腔中段的无量纲半径和长度

轴对称空腔中段的无量纲半径：
$R_{c0} = \sqrt{\frac{C_{x0} \times (1.0 + SG0)}{\kappa \times SG0}}$
轴对称空腔的无量纲长度：
$L_{c0} = 2.0 \times \left(X_{\text{agr}} + \frac{A \times \sqrt{C_{x0}}}{SG0}\right)$

16. 调用其他函数

调用 MaxLoad 函数【高速入水】入水最大力系数估算 | 雯雯のblog计算最大力系数。

Python代码

def CalcParameters(self):
    #  PI, Lmm, Top0, Rnmm, Ncon, ConeLen, Gamma, Psi0, GammaDive, Psi0dive, FlagDive, Beta, Delta,
    #                         Dnmm, H0, Pc, V0, Xfin, Xfilm, Xbeg, Xend
    # 这个函数先改成及时调用修改的模式，因为涉及到调用其他函数修改
    """
    计算模型参数和空腔参数。
    # 导入变量
    # 圆周率喵
    PI = self.PI
    # Ncon (int): 模型节数。
    Ncon = self.Ncon
    # Gamma (float): 攻角（度）。
    Gamma = self.Gamma
    # Psi0 (float): 俯仰角（度）。
    Psi0 = self.Psi0
    # GammaDive (float): 潜水时的攻角（度）。
    GammaDive = self.GammaDive
    # Psi0dive (float): 潜水时的俯仰角（度）。
    Psi0dive = self.Psi0dive
    # FlagDive (bool): 是否为潜水模式。
    FlagDive = self.FlagDive
    # Beta (float): 空化器角度（度）。
    Beta = self.Beta
    # Delta (float): 空化器倾角（度）。
    Delta = self.Delta
    # Dnmm (float): 空化器直径（mm）。
    Dnmm = self.Dnmm
    # H0 (float): 初始水头？不对，Head0是初始水头，这个从外部给定是个啥东东啊（m）。
    # 应该是模型在水中的初始深度，是一个直接的几何参数。
    H0 = self.H0
    # Pc (float): 初始压力（Pa）。
    Pc = self.Pc
    # V0 (float): 初始速度（m/s）。
    V0 = self.V0
    # Xfin (float): 终点位置（m）。
    Xfin = self.Xfin
    # Xfilm (float): 拍摄起始点（m）。
    Xfilm = self.Xfilm
    # Xbeg (float): 观察开始位置（m）。
    Xbeg = self.Xbeg
    # Xend (float): 观察结束位置（m）。
    Xend = self.Xend
    # 每一节长度，单位毫米
    ConeLen = self.ConeLen
    # 每一节末端直径
    BaseDiam = self.BaseDiam
    # 模型腔体长度，单位毫米
    Lh = self.Lh
    # 模型腔体左端直径，单位毫米
    DLh = self.DLh
    # 模型腔体右端直径
    DRh = self.DRh

    返回:
    # 攻角（Gamma）的弧度值，用于描述模型的俯仰角度
    self.GammaRad = GammaRad
    # 初始俯仰角（Psi0）的弧度值，用于描述模型的初始姿态
    self.Psi0Rad = Psi0Rad
    # 攻角（Gamma）的正弦值，用于计算相关动力学参数
    self.SIN_G = SIN_G
    # 攻角（Gamma）的余弦值，用于计算相关动力学参数
    self.COS_G = COS_G
    # 空化器角度（Beta）的弧度值，用于描述空化器的几何特性
    self.BetaRad = BetaRad
    # 空化器倾角（Delta）的弧度值，用于描述空化器的几何特性
    self.DeltaRad = DeltaRad
    # 空化器倾角（Delta）的正弦值，用于计算相关动力学参数
    self.SIN_D = SIN_D
    # 空化器倾角（Delta）的余弦值，用于计算相关动力学参数
    self.COS_D = COS_D
    # 初始俯仰角（Psi0）的正弦值，用于计算相关动力学参数
    self.SIN_P = SIN_P
    # 初始俯仰角（Psi0）的余弦值，用于计算相关动力学参数
    self.COS_P = COS_P
    # 模型总长度（毫米）
    self.Lmm = Lmm
    # 模型总长度（米）
    self.Lm = Lm
            # 模型半径分布的x坐标，用于描述模型的半径变化
    self.Xmstr = Xmstr
    # 模型半径分布的横截面积，用于描述模型的几何特性
    self.Sm = Sm
    # 终点位置与模型长度的比值，用于描述模型的运动范围
    self.gXfin = gXfin
    # 拍摄起始点与模型长度的比值，用于描述模型的运动范围
    self.gXfilm = gXfilm
    # 观察开始位置与模型长度的比值，用于描述模型的运动范围
    self.gXbeg = gXbeg
    # 观察结束位置与模型长度的比值，用于描述模型的运动范围
    self.gXend = gXend
    # 观察范围的长度，用于描述模型的运动范围
    self.Basa = Basa
    # 轴对称空腔前缘的无量纲长度，用于描述空腔形状
    self.Xagr = Xagr
    # 轴对称空腔前缘的无量纲半径，用于描述空腔形状
    self.Ragr = Ragr
    # 轴对称空腔前缘的无量纲面积，用于描述空腔形状
    self.Sagr = Sagr
    # 轴对称空腔前缘的起始点位置，用于描述空腔形状
    self.XcBeg = XcBeg
    # 轴对称空腔前缘的起始点半径，用于描述空腔形状
    self.RcBeg = RcBeg
    # 经验常数，用于描述空腔形状
    self.AA = AA
    # 空腔形状计算中的常数，用于描述空腔形状
    self.AK1 = AK1
    # 空腔形状计算中的中间变量，用于描述空腔形状
    self.w2 = w2
    # 空腔形状计算中的经验常数，用于描述空腔形状
    self.Kappa = Kappa
    # 轴对称空腔中段的无量纲半径，用于描述空腔形状
    self.Rc0 = Rc0
    # 轴对称空腔的无量纲长度，用于描述空腔形状
    self.Lc0 = Lc0
    """
    # 导入变量
    # 圆周率喵
    PI = self.PI
    # Ncon (int): 模型节数。
    Ncon = self.Ncon
    # Gamma (float): 攻角（度）。
    Gamma = self.Gamma
    # Psi0 (float): 俯仰角（度）。
    Psi0 = self.Psi0
    # GammaDive (float): 潜水时的攻角（度）。
    GammaDive = self.GammaDive
    # Psi0dive (float): 潜水时的俯仰角（度）。
    Psi0dive = self.Psi0dive
    # FlagDive (bool): 是否为潜水模式。
    FlagDive = self.FlagDive
    # Beta (float): 空化器角度（度）。
    Beta = self.Beta
    # Delta (float): 空化器倾角（度）。
    Delta = self.Delta
    # Dnmm (float): 空化器直径（mm）。
    Dnmm = self.Dnmm
    # H0 (float): 初始水头？不对，Head0是初始水头，这个从外部给定是个啥东东啊（m）。
    # 应该是模型在水中的初始深度，是一个直接的几何参数。
    H0 = self.H0
    # Pc (float): 初始压力（Pa）。
    Pc = self.Pc
    # V0 (float): 初始速度（m/s）。
    V0 = self.V0
    # Xfin (float): 终点位置（m）。
    Xfin = self.Xfin
    # Xfilm (float): 拍摄起始点（m）。
    Xfilm = self.Xfilm
    # Xbeg (float): 观察开始位置（m）。
    Xbeg = self.Xbeg
    # Xend (float): 观察结束位置（m）。
    Xend = self.Xend
    # 每一节长度，单位毫米
    ConeLen = self.ConeLen
    # 每一节末端直径
    BaseDiam = self.BaseDiam
    # 模型腔体长度，单位毫米
    Lh = self.Lh
    # 模型腔体左端直径，单位毫米
    DLh = self.DLh
    # 模型腔体右端直径
    DRh = self.DRh

    # 初始化变量
    GammaRad = np.radians(GammaDive if FlagDive else Gamma)
    Psi0Rad = np.radians(Psi0dive if FlagDive else Psi0)
    SIN_G = np.sin(GammaRad)
    COS_G = np.cos(GammaRad)
    BetaRad = np.radians(Beta)
    DeltaRad = np.radians(Delta)
    SIN_D = np.sin(DeltaRad)
    COS_D = np.cos(DeltaRad)
    SIN_P = np.sin(Psi0Rad)
    COS_P = np.cos(Psi0Rad)

    Lmm = sum(ConeLen)  # 模型总长度（mm）
    Lm = Lmm / 1000.0  # 模型长度（m）

    # 在调用新函数前先进行数据调度同步
    # 攻角（Gamma）的弧度值，用于描述模型的俯仰角度
    self.GammaRad = GammaRad
    # 初始俯仰角（Psi0）的弧度值，用于描述模型的初始姿态
    self.Psi0Rad = Psi0Rad
    # 攻角（Gamma）的正弦值，用于计算相关动力学参数
    self.SIN_G = SIN_G
    # 攻角（Gamma）的余弦值，用于计算相关动力学参数
    self.COS_G = COS_G
    # 空化器角度（Beta）的弧度值，用于描述空化器的几何特性
    self.BetaRad = BetaRad
    # 空化器倾角（Delta）的弧度值，用于描述空化器的几何特性
    self.DeltaRad = DeltaRad
    # 空化器倾角（Delta）的正弦值，用于计算相关动力学参数
    self.SIN_D = SIN_D
    # 空化器倾角（Delta）的余弦值，用于计算相关动力学参数
    self.COS_D = COS_D
    # 初始俯仰角（Psi0）的正弦值，用于计算相关动力学参数
    self.SIN_P = SIN_P
    # 初始俯仰角（Psi0）的余弦值，用于计算相关动力学参数
    self.COS_P = COS_P
    # 模型总长度（毫米）
    self.Lmm = Lmm
    # 模型总长度（米）
    self.Lm = Lm

    # 调用 DragCone 函数计算阻力系数
    self.DragCone()

    # 重新引入更新的参量
    Cx0 = self.Cx0

    # 继续计算
    # 初始水头
    Head0 = 500 * V0 ** 2
    # 初始空化数
    SG0 = (19.61 * (10 + H0) - Pc / 500) / V0 ** 2
    # 水中马赫数
    Mach = V0 / 1460
    # 弗劳德数
    Fr = int(V0 / np.sqrt(9.81 * Dnmm / 1000))
    # 初始弗劳德数平方
    Fr2 = V0 ** 2 / (9.81 * Lm)
    # 空化器半径（mm）
    Rnmm = Dnmm / 2.0
    # 无量纲半径
    Rn = Rnmm / Lmm
    # 模型顶点无量纲位置
    Top0 = 0.0 if Beta == 180.0 else Rn / np.tan(BetaRad / 2.0)

    RibTan = np.zeros(Ncon)
    RibAng = np.zeros(Ncon)
    Part = np.zeros(Ncon)
    BaseR = np.zeros(Ncon)
    X0mod = np.zeros(2 * Ncon + 4)
    Y0mod = np.zeros(2 * Ncon + 4)
    X0rib = np.zeros(2 * (Ncon - 1))
    Y0rib = np.zeros(2 * (Ncon - 1))
    X0cham = np.zeros(5)
    Y0cham = np.zeros(5)
    Xmstr = np.zeros(201)
    Sm = np.zeros(201)

    RibTan[0] = 0.5 * (BaseDiam[0] - Dnmm) / ConeLen[0]
    RibAng[0] = np.arctan(RibTan[0])
    for i in range(1, Ncon):
        RibTan[i] = 0.5 * (BaseDiam[i] - BaseDiam[i - 1]) / ConeLen[i]
        RibAng[i] = np.arctan(RibTan[i])

    Part[0] = ConeLen[0] / Lmm
    for i in range(1, Ncon):
        Part[i] = Part[i - 1] + ConeLen[i] / Lmm

    for i in range(Ncon):
        BaseR[i] = 0.5 * BaseDiam[i] / Lmm

    X0mod[0] = -Top0 * COS_D
    Y0mod[0] = Top0 * SIN_D
    X0mod[1] = Rn * SIN_D
    Y0mod[1] = Rn * COS_D
    X0mod[2 * Ncon + 2] = -X0mod[1]
    Y0mod[2 * Ncon + 2] = -Y0mod[1]
    X0mod[2 * Ncon + 3] = X0mod[0]
    Y0mod[2 * Ncon + 3] = Y0mod[0]
    for i in range(2, Ncon + 2):
        X0mod[i] = Part[i - 2]
        Y0mod[i] = BaseR[i - 2]
        X0mod[2 * Ncon + 4 - i] = Part[i - 2]
        Y0mod[2 * Ncon + 4 - i] = -BaseR[i - 2]

    for i in range(Ncon - 1):
        X0rib[2 * i] = Part[i]
        Y0rib[2 * i] = BaseR[i]
        X0rib[2 * i + 1] = Part[i]
        Y0rib[2 * i + 1] = -BaseR[i]

    X0cham[0] = 1.0 - Lh / Lmm
    Y0cham[0] = 0.5 * DLh / Lmm
    X0cham[1] = 1.0
    Y0cham[1] = 0.5 * DRh / Lmm
    X0cham[2] = 1.0
    Y0cham[2] = -Y0cham[1]
    X0cham[3] = X0cham[0]
    Y0cham[3] = -Y0cham[0]
    X0cham[4] = X0cham[0]
    Y0cham[4] = Y0cham[0]

    Sn = np.pi * Dnmm ** 2 / 4000000  # 空化器面积（m²）

    # 在函数调用前再次及时更新参数
    # 初始水头（会在CalcParameters定义） Head0 = 5D02 * V0**2
    # 这部分是速度部分的水头，感觉是分两部分了(CalcParameters)
    self.Head0 = Head0
    # 初始空化数
    self.SG0 = SG0
    # 水中马赫数
    self.Mach = Mach
    # # 弗劳德数(用于显示)
    self.Fr = Fr
    # 初始弗劳德数的平方，给DerivDyn的
    self.Fr2 = Fr2
    # 空化器半径mm
    self.Rnmm = Rnmm
    # 空化器的无量纲半径
    self.Rn = Rn
    # 顶点的无量纲位置(CalcParameters)
    self.Top0 = Top0
    # 模型各节的切线斜率，用于描述模型的几何形状
    self.RibTan = RibTan
    # 模型各节的切线角度（弧度），用于描述模型的几何形状
    self.RibAng = RibAng
    # 模型各节的无量纲长度，用于描述模型的几何分布
    self.Part = Part
    # 模型各节末端的无量纲半径，用于描述模型的几何形状
    self.BaseR = BaseR
    # 模型轮廓点的x坐标，用于绘制模型的几何轮廓
    self.X0mod = X0mod
    # 模型轮廓点的y坐标，用于绘制模型的几何轮廓
    self.Y0mod = Y0mod
    # 模型肋骨轮廓点的x坐标，用于绘制模型的肋骨几何轮廓
    self.X0rib = X0rib
    # 模型肋骨轮廓点的y坐标，用于绘制模型的肋骨几何轮廓
    self.Y0rib = Y0rib
    # 腔体轮廓点的x坐标，用于描述腔体的几何形状
    self.X0cham = X0cham
    # 腔体轮廓点的y坐标，用于描述腔体的几何形状
    self.Y0cham = Y0cham
    # 空化器面积
    self.Sn = Sn

    # 调用其他函数

    # 调用 ModelRadii 函数计算模型半径
    self.ModelRadii()

    # 返回无量纲半径，更新
    Rmstr = self.Rmstr

    for i in range(1, 201):
        Xmstr[i] = 0.005 * (i - 1)
        Sm[i] = np.pi * (Rmstr[i] * Rnmm) ** 2 / 1000000

    gXfin = Xfin / Lm
    gXfilm = Xfilm / Lm
    gXbeg = Xbeg / Lm
    gXend = Xend / Lm
    Basa = gXend - gXbeg

    Xagr = 2.0
    Ragr = (1.0 + 3.0 * Xagr) ** (1 / 3)
    Sagr = np.pi * (Rn * Ragr) ** 2

    XcBeg = np.zeros(4)
    RcBeg = np.zeros(4)
    XcBeg[0] = 0.0
    RcBeg[0] = Rn
    for i in range(1, 4):
        XcBeg[i] = XcBeg[i - 1] + Rn * Xagr / 3.0
        RcBeg[i] = Rn * (1.0 + 3.0 * XcBeg[i] / Rn) ** (1 / 3)

    AA = 2.0
    AK1 = 4.0 * np.pi / AA ** 2
    w2 = Rn * AA * np.sqrt(Cx0)
    Kappa = 0.93

    Rc0 = np.sqrt(Cx0 * (1.0 + SG0) / (Kappa * SG0))
    Lc0 = 2.0 * (Xagr + AA * np.sqrt(Cx0) / SG0)

    # 再次更新一次参数
    # 模型半径分布的x坐标，用于描述模型的半径变化
    self.Xmstr = Xmstr
    # 模型半径分布的横截面积，用于描述模型的几何特性
    self.Sm = Sm
    # 终点位置与模型长度的比值，用于描述模型的运动范围
    self.gXfin = gXfin
    # 拍摄起始点与模型长度的比值，用于描述模型的运动范围
    self.gXfilm = gXfilm
    # 观察开始位置与模型长度的比值，用于描述模型的运动范围
    self.gXbeg = gXbeg
    # 观察结束位置与模型长度的比值，用于描述模型的运动范围
    self.gXend = gXend
    # 观察范围的长度，用于描述模型的运动范围
    self.Basa = Basa
    # 轴对称空腔前缘的无量纲长度，用于描述空腔形状
    self.Xagr = Xagr
    # 轴对称空腔前缘的无量纲半径，用于描述空腔形状
    self.Ragr = Ragr
    # 轴对称空腔前缘的无量纲面积，用于描述空腔形状
    self.Sagr = Sagr
    # 轴对称空腔前缘的起始点位置，用于描述空腔形状
    self.XcBeg = XcBeg
    # 轴对称空腔前缘的起始点半径，用于描述空腔形状
    self.RcBeg = RcBeg
    # 经验常数，用于描述空腔形状
    self.AA = AA
    # 空腔形状计算中的常数，用于描述空腔形状
    self.AK1 = AK1
    # 空腔形状计算中的中间变量，用于描述空腔形状
    self.w2 = w2
    # 空腔形状计算中的经验常数，用于描述空腔形状
    self.Kappa = Kappa
    # 轴对称空腔中段的无量纲半径，用于描述空腔形状
    self.Rc0 = Rc0
    # 轴对称空腔的无量纲长度，用于描述空腔形状
    self.Lc0 = Lc0

    # 调用 MaxLoad 函数计算最大力系数
    self.MaxLoad()