CalcSteadyCavity 函数的数学公式表示

函数描述

CalcSteadyCavity 函数用于计算稳态空泡形状和间隙分布。该函数通过数值方法计算空泡轮廓，并根据模型的几何形状和初始条件，计算模型与空泡之间的间隙。

参数说明

  • HX0\text{HX0}：计算步长。
  • Scale\text{Scale}：缩放比例。
  • RnR_n：空化器半径。
  • XagrX_{\text{agr}}：空泡增长系数。
  • ONETHIRD\text{ONETHIRD}：1/3的值，用于计算。
  • SagrS_{\text{agr}}：空泡面积增长系数。
  • AK1A_{K1}：空泡面积系数。
  • w2w_2：空泡宽度系数。
  • SG0S_{G0}：初始空化数。
  • Lc0L_{c0}：空泡长度系数。
  • Cx0C_{x0}：轴向力系数。
  • ΔRad\Delta_{\text{Rad}}：偏航角（弧度）。
  • Ψ0,Rad\Psi_{0,\text{Rad}}：初始攻角（弧度）。
  • sin⁡(Ψ0)\sin(\Psi_0)：初始攻角的正弦值。
  • cos⁡(Ψ0)\cos(\Psi_0)：初始攻角的余弦值。
  • NconN_{\text{con}}：模型锥段数量。
  • Part\text{Part}：模型各锥段的相对位置。
  • BaseR\text{BaseR}：模型各锥段的半径。
  • LmmL_{\text{mm}}：模型长度（毫米）。
  • Ψ0\Psi_0：初始攻角（度）。

数学公式表示

1. 初始化参数

  • 缩放比例Scale\text{Scale}和计算步长HX0\text{HX0}：
    Scale=self.Scale \text{Scale} = \text{self.Scale}
    HX0=self.HX0 \text{HX0} = \text{self.HX0}

  • 空化器半径RnR_n：
    Rn=self.Rn R_n = \text{self.Rn}

  • 空泡增长系数XagrX_{\text{agr}}和 1/3 的值ONETHIRD\text{ONETHIRD}：
    Xagr=self.Xagr X_{\text{agr}} = \text{self.Xagr}
    ONETHIRD=self.ONETHIRD \text{ONETHIRD} = \text{self.ONETHIRD}

  • 空泡面积增长系数SagrS_{\text{agr}}和空泡面积系数AK1A_{K1}：
    Sagr=self.Sagr S_{\text{agr}} = \text{self.Sagr}
    AK1=self.AK1 A_{K1} = \text{self.AK1}

  • 空泡宽度系数w2w_2和初始空化数SG0S_{G0}：
    w2=self.w2 w_2 = \text{self.w2}
    SG0=self.SG0 S_{G0} = \text{self.SG0}

  • 轴向力系数Cx0C_{x0}和偏航角ΔRad\Delta_{\text{Rad}}：
    Cx0=self.Cx0 C_{x0} = \text{self.Cx0}
    ΔRad=self.DeltaRad \Delta_{\text{Rad}} = \text{self.DeltaRad}

  • 初始攻角Ψ0,Rad\Psi_{0,\text{Rad}}和其正弦、余弦值：
    Ψ0,Rad=self.Psi0Rad \Psi_{0,\text{Rad}} = \text{self.Psi0Rad}
    sin⁡(Ψ0)=self.SIN P \sin(\Psi_0) = \text{self.SIN P}
    cos⁡(Ψ0)=self.COS P \cos(\Psi_0) = \text{self.COS P}

  • 模型锥段数量NconN_{\text{con}}和各锥段的相对位置Part\text{Part}：
    Ncon=self.Ncon N_{\text{con}} = \text{self.Ncon}
    Part=self.Part \text{Part} = \text{self.Part}

  • 各锥段半径BaseR\text{BaseR}和模型长度LmmL_{\text{mm}}：
    BaseR=self.BaseR \text{BaseR} = \text{self.BaseR}
    Lmm=self.Lmm L_{\text{mm}} = \text{self.Lmm}

  • 初始攻角Ψ0\Psi_0和空泡长度系数Lc0L_{c0}：
    Ψ0=self.Psi0 \Psi_0 = \text{self.Psi0}
    Lc0=self.Lc0 L_{c0} = \text{self.Lc0}

2. 计算空泡轮廓

  • 根据缩放比例和步长计算视图中的步数NviewN_{\text{view}}：
    Nview={⌊1.4⋅ScaleHX0⌋+2if Scale≥0.72⌊1.4HX0⌋+2otherwise N_{\text{view}} = \begin{cases} \left\lfloor \frac{1.4 \cdot \text{Scale}}{\text{HX0}} \right\rfloor + 2 & \text{if } \text{Scale} \geq 0.72 \\ \left\lfloor \frac{1.4}{\text{HX0}} \right\rfloor + 2 & \text{otherwise} \end{cases}

  • 初始化空泡轮廓的 x 坐标数组XprX_{\text{pr}}和半径数组RprR_{\text{pr}}：
    Xpr[0]=0.0 X_{\text{pr}}[0] = 0.0
    Rpr[0]=Rn R_{\text{pr}}[0] = R_n

  • 计算轴对称空泡的主要部分：
    for i=1 to Nview−1: \text{for } i = 1 \text{ to } N_{\text{view}} - 1:
    Xpr[i]=(i−1)⋅HX0 X_{\text{pr}}[i] = (i - 1) \cdot \text{HX0}
    if Xpr[i]≤Rn⋅Xagr: \text{if } X_{\text{pr}}[i] \leq R_n \cdot X_{\text{agr}}:
    S=π⋅(Rn⋅(1+3⋅Xpr[i]Rn)ONETHIRD)2 S = \pi \cdot \left( R_n \cdot \left(1 + 3 \cdot \frac{X_{\text{pr}}[i]}{R_n} \right)^{\text{ONETHIRD}} \right)^2
    else: \text{else}:
    work=Xpr[i]−Rn⋅Xagr2 \text{work} = \frac{X_{\text{pr}}[i] - R_n \cdot X_{\text{agr}}}{2}
    S=Sagr+AK1⋅work⋅(w2−work⋅SG0) S = S_{\text{agr}} + A_{K1} \cdot \text{work} \cdot (w_2 - \text{work} \cdot S_{G0})
    if S≥0: \text{if } S \geq 0:
    Rpr[i]=Sπ R_{\text{pr}}[i] = \sqrt{\frac{S}{\pi}}
    Ipr=i I_{\text{pr}} = i

3. 计算实际空泡轮廓和间隙

  • 计算流向坐标系中的升力系数CyC_y：
    Cy=−0.5⋅Cx0⋅sin⁡(2⋅(ΔRad+Ψ0,Rad)) C_y = -0.5 \cdot C_{x0} \cdot \sin(2 \cdot (\Delta_{\text{Rad}} + \Psi_{0,\text{Rad}}))

  • 计算空泡轴的弯曲和实际空泡轮廓：
    for i=1 to Nview−1: \text{for } i = 1 \text{ to } N_{\text{view}} - 1:
    hfi=−Cy⋅Rn⋅(0.46−SG0+2⋅Xpr[i]Lc0⋅Rn) h_{\text{fi}} = -C_y \cdot R_n \cdot \left(0.46 - S_{G0} + 2 \cdot \frac{X_{\text{pr}}[i]}{L_{c0} \cdot R_n}\right)
    Ypr2[i]=Rpr[i]+hfi Y_{\text{pr2}}[i] = R_{\text{pr}}[i] + h_{\text{fi}}
    Ypr1[i]=−Rpr[i]+hfi Y_{\text{pr1}}[i] = -R_{\text{pr}}[i] + h_{\text{fi}}

  • 计算模型轮廓和间隙：
    if Xpr[i]≤Part[0]+5×10−4: \text{if } X_{\text{pr}}[i] \leq \text{Part}[0] + 5 \times 10^{-4}:
    Ymod2[i]=Rn+Xpr[i]⋅BaseR[0]−RnPart[0] Y_{\text{mod2}}[i] = R_n + X_{\text{pr}}[i] \cdot \frac{\text{BaseR}[0] - R_n}{\text{Part}[0]}
    Ymod1[i]=−Ymod2[i] Y_{\text{mod1}}[i] = -Y_{\text{mod2}}[i]
    if Ψ0≠0: \text{if } \Psi_0 \neq 0:
    Ymod2[i]=−Xpr[i]⋅sin⁡(Ψ0)+Ymod2[i]⋅cos⁡(Ψ0) Y_{\text{mod2}}[i] = -X_{\text{pr}}[i] \cdot \sin(\Psi_0) + Y_{\text{mod2}}[i] \cdot \cos(\Psi_0)
    Ymod1[i]=−Xpr[i]⋅sin⁡(Ψ0)+Ymod1[i]⋅cos⁡(Ψ0) Y_{\text{mod1}}[i] = -X_{\text{pr}}[i] \cdot \sin(\Psi_0) + Y_{\text{mod1}}[i] \cdot \cos(\Psi_0)
    H2[i]=(Ypr2[i]−Ymod2[i])⋅Lmm H_2[i] = (Y_{\text{pr2}}[i] - Y_{\text{mod2}}[i]) \cdot L_{\text{mm}}
    H1[i]=(−Ypr1[i]+Ymod1[i])⋅Lmm H_1[i] = (-Y_{\text{pr1}}[i] + Y_{\text{mod1}}[i]) \cdot L_{\text{mm}}
    else: \text{else}:
    for j=1 to Ncon−1: \text{for } j = 1 \text{ to } N_{\text{con}} - 1:
    if Xpr[i]≤Part[j]+5×10−4: \text{if } X_{\text{pr}}[i] \leq \text{Part}[j] + 5 \times 10^{-4}:
    Ymod2[i]=BaseR[j−1]+(Xpr[i]−Part[j−1])⋅BaseR[j]−BaseR[j−1]Part[j]−Part[j−1] Y_{\text{mod2}}[i] = \text{BaseR}[j-1] + (X_{\text{pr}}[i] - \text{Part}[j-1]) \cdot \frac{\text{BaseR}[j] - \text{BaseR}[j-1]}{\text{Part}[j] - \text{Part}[j-1]}
    Ymod1[i]=−Ymod2[i] Y_{\text{mod1}}[i] = -Y_{\text{mod2}}[i]
    if Ψ0≠0: \text{if } \Psi_0 \neq 0:
    Ymod2[i]=−Xpr[i]⋅sin⁡(Ψ0)+Ymod2[i]⋅cos⁡(Ψ0) Y_{\text{mod2}}[i] = -X_{\text{pr}}[i] \cdot \sin(\Psi_0) + Y_{\text{mod2}}[i] \cdot \cos(\Psi_0)
    Ymod1[i]=−Xpr[i]⋅sin⁡(Ψ0)+Ymod1[i]⋅cos⁡(Ψ0) Y_{\text{mod1}}[i] = -X_{\text{pr}}[i] \cdot \sin(\Psi_0) + Y_{\text{mod1}}[i] \cdot \cos(\Psi_0)
    H2[i]=(Ypr2[i]−Ymod2[i])⋅Lmm H_2[i] = (Y_{\text{pr2}}[i] - Y_{\text{mod2}}[i]) \cdot L_{\text{mm}}
    H1[i]=(−Ypr1[i]+Ymod1[i])⋅Lmm H_1[i] = (-Y_{\text{pr1}}[i] + Y_{\text{mod1}}[i]) \cdot L_{\text{mm}}

4. 计算模型后部的间隙

  • 如果空泡轮廓的最后一个有效点Xpr[Ipr]X_{\text{pr}}[I_{\text{pr}}]大于 1.0005：
    H2t=Ypr2[−1]−Ymod2[−1] H_{2t} = Y_{\text{pr2}}[-1] - Y_{\text{mod2}}[-1]
    H1t=−Ypr1[−1]+Ymod1[−1] H_{1t} = -Y_{\text{pr1}}[-1] + Y_{\text{mod1}}[-1]

python 代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
def CalcSteadyCavity(self):
    # HX0, Scale, Rn, Xagr, ONETHIRD, Sagr, AK1, w2, SG0, Lc0, Cx0, DeltaRad
    # Psi0Rad, SIN_P, COS_P, Ncon, Part, BaseR, Lmm, Psi0
    """
    计算稳态空泡形状和间隙分布。

    参数:
    HX0: 计算步长。
    Scale: 缩放比例。
    Rn: 空化器半径。
    Xagr: 空泡增长系数。
    ONETHIRD: 1/3的值，用于计算。
    Sagr: 空泡面积增长系数。
    AK1: 空泡面积系数。
    w2: 空泡宽度系数。
    SG0: 初始空化数。
    Lc0: 空泡长度系数。
    Cx0: 轴向力系数。
    DeltaRad: 偏航角（弧度）。
    Psi0Rad: 初始攻角（弧度）。
    SIN_P: 初始攻角的正弦值。
    COS_P: 初始攻角的余弦值。
    Ncon: 模型锥段数量。
    Part: 模型各锥段的相对位置。
    BaseR: 模型各锥段的半径。
    Lmm: 模型长度（毫米）。
    Psi0: 初始攻角（度）。
    """
    # 缩放比例
    Scale = self.Scale
    # 计算步长，这里HX0就是可视化界面中的HX/L
    HX0 = self.HX0
    # 空化器半径
    Rn = self.Rn
    # 轴对称空腔前缘的无量纲长度，用于描述空腔形状，空泡增长系数。
    Xagr = self.Xagr
    # 1/3的值
    ONETHIRD = self.ONETHIRD
    # 轴对称空腔前缘的无量纲面积，用于描述空腔形状，空泡面积增长系数
    Sagr = self.Sagr
    # 空腔形状计算中的常数，用于描述空腔形状
    AK1 = self.AK1
    # 空腔形状计算中的中间变量，用于描述空腔形状
    w2 = self.w2
    # 初始空化数
    SG0 = self.SG0
    # 轴向力系数
    Cx0 = self.Cx0
    # 偏航角（弧度）
    DeltaRad = self.DeltaRad
    # 初始攻角
    Psi0Rad = self.Psi0Rad
    # 初始攻角正弦
    SIN_P = self.SIN_P
    # 初始攻角余弦
    COS_P = self.COS_P
    # 模型锥段数量
    Ncon = self.Ncon
    # 模型各锥段的相对位置。
    Part = self.Part
    # 各锥段半径
    BaseR = self.BaseR
    # 模型长度毫米
    Lmm = self.Lmm
    # 初始攻角
    Psi0 = self.Psi0
    # 空泡长度系数
    Lc0 = self.Lc0

    # 分配内存
    if Scale >= 0.72:
        Nview = int(1.4 * Scale / HX0) + 2  # 根据缩放比例和步长计算视图中的步数
    else:
        Nview = int(1.4 / HX0) + 2

    # 初始化空泡轮廓的x坐标数组
    self.Xpr = np.zeros(Nview)
    # 初始化空泡轮廓的半径数组
    self.Rpr = np.zeros(Nview)
    # 初始化空泡轮廓的下边界y坐标数组
    self.Ypr1 = np.zeros(Nview)
    # 初始化空泡轮廓的上边界y坐标数组
    self.Ypr2 = np.zeros(Nview)
    # 初始化下间隙数组
    self.H1 = np.zeros(Nview)
    # 初始化上间隙数组
    self.H2 = np.zeros(Nview)
    # 初始化模型轮廓的下边界y坐标数组
    self.Ymod1 = np.zeros(Nview)
    # 初始化模型轮廓的上边界y坐标数组
    self.Ymod2 = np.zeros(Nview)

    Nmod = int(1 / HX0) + 1  # 计算模型上的步数
    self.Ymod1 = np.zeros(Nmod)  # 初始化模型轮廓的下边界y坐标数组
    self.Ymod2 = np.zeros(Nmod)  # 初始化模型轮廓的上边界y坐标数组

    # 初始化常量值
    self.Xpr[0] = 0.0
    self.Rpr[0] = Rn
    self.Ymod2[0] = Rn
    self.Ymod1[0] = -Rn
    self.Ypr2[0] = Rn
    self.Ypr1[0] = -Rn
    self.H1[0] = 0.0
    self.H2[0] = 0.0

    # 计算轴对称空泡的主要部分
    for i in range(1, Nview):
        self.Xpr[i] = (i - 1) * HX0  # 计算当前步长的x坐标
        if self.Xpr[i] <= Rn * Xagr:
            # 如果在空泡增长区域内，使用幂律关系计算空泡面积
            S = np.pi * (Rn * (1 + 3 * self.Xpr[i] / Rn)**ONETHIRD)**2
        else:
            # 如果超出空泡增长区域，使用线性关系计算空泡面积
            work = (self.Xpr[i] - Rn * Xagr) / 2
            S = Sagr + AK1 * work * (w2 - work * SG0)
        if S >= 0:
            self.Rpr[i] = np.sqrt(S / np.pi)  # 计算空泡半径
            self.Ipr = i  # 记录最后一个有效空泡轮廓的索引

    # 计算实际空泡轮廓和间隙
    Cy = -0.5 * Cx0 * np.sin(2 * (DeltaRad + Psi0Rad))  # 流向坐标系中的升力系数
    for i in range(1, Nview):
        # 计算空泡轴的弯曲，由于空化器上的侧向力
        hfi = -Cy * Rn * (0.46 - SG0 + 2 * self.Xpr[i] / (Lc0 * Rn))
        # 计算实际空泡轮廓（不考虑空化器的垂直位移）
        self.Ypr2[i] = self.Rpr[i] + hfi
        self.Ypr1[i] = -self.Rpr[i] + hfi

        if self.Xpr[i] <= Part[0] + 5e-4:
            # 如果在模型的第一个锥段内
            self.Ymod2[i] = Rn + self.Xpr[i] * (BaseR[0] - Rn) / Part[0]
            self.Ymod1[i] = -self.Ymod2[i]
            if Psi0 != 0:
                # 如果有初始攻角，旋转模型轮廓
                self.Ymod2[i] = -self.Xpr[i] * SIN_P + self.Ymod2[i] * COS_P
                self.Ymod1[i] = -self.Xpr[i] * SIN_P + self.Ymod1[i] * COS_P
            self.H2[i] = (self.Ypr2[i] - self.Ymod2[i]) * Lmm  # 计算上间隙
            self.H1[i] = (-self.Ypr1[i] + self.Ymod1[i]) * Lmm  # 计算下间隙
        else:
            for j in range(1, Ncon):
                if self.Xpr[i] <= Part[j] + 5e-4:
                    # 如果在模型的其他锥段内
                    self.Ymod2[i] = BaseR[j-1] + (self.Xpr[i] - Part[j-1]) * (BaseR[j] - BaseR[j-1]) / (Part[j] - Part[j-1])
                    self.Ymod1[i] = -self.Ymod2[i]
                    if Psi0 != 0:
                        # 如果有初始攻角，旋转模型轮廓
                        self.Ymod2[i] = -self.Xpr[i] * SIN_P + self.Ymod2[i] * COS_P
                        self.Ymod1[i] = -self.Xpr[i] * SIN_P + self.Ymod1[i] * COS_P
                    self.H2[i] = (self.Ypr2[i] - self.Ymod2[i]) * Lmm  # 计算上间隙
                    self.H1[i] = (-self.Ypr1[i] + self.Ymod1[i]) * Lmm  # 计算下间隙
                    break
    # 绘制稳态空泡形状
    # self.plot_steady_cavity()

    # 释放数组(没必要啊)
    # self.Xpr = None
    # self.Rpr = None
    # self.Ypr1 = None
    # self.Ypr2 = None
    # self.H1 = None
    # self.H2 = None
    # self.Ymod1 = None
    # self.Ymod2 = None
    # 计算模型后部的间隙
    if self.Xpr[self.Ipr] >= 1.0005:
        self.H2t = self.Ypr2[-1] - self.Ymod2[-1]  # 模型后部的上间隙
        self.H1t = -self.Ypr1[-1] + self.Ymod1[-1]  # 模型后部的下间隙