CalcTurnModel 函数的数学公式表示

函数描述

CalcTurnModel 函数用于计算模型轮廓围绕质心旋转后的坐标。该函数通过旋转公式计算每个点的旋转后坐标。

参数说明

  • XcX_c：质心的x坐标。
  • Ψ\Psi：旋转角度（弧度）。
  • X0,modX_{0,\text{mod}}：模型轮廓的初始x坐标数组。
  • Y0,modY_{0,\text{mod}}：模型轮廓的初始y坐标数组。
  • X0,ribX_{0,\text{rib}}：模型肋骨的初始x坐标数组。
  • Y0,ribY_{0,\text{rib}}：模型肋骨的初始y坐标数组。
  • NconN_{\text{con}}：模型锥段数量。

数学公式表示

1. 初始化参数

  • 质心的x坐标XcX_c：
    Xc=self.Xc X_c = \text{self.Xc}
  • 旋转角度Ψ\Psi（弧度）：
    Ψ=self.Psi \Psi = \text{self.Psi}
  • 模型轮廓的初始x坐标数组X0,modX_{0,\text{mod}}：
    X0,mod=self.X0mod X_{0,\text{mod}} = \text{self.X0mod}
  • 模型轮廓的初始y坐标数组Y0,modY_{0,\text{mod}}：
    Y0,mod=self.Y0mod Y_{0,\text{mod}} = \text{self.Y0mod}
  • 模型肋骨的初始x坐标数组X0,ribX_{0,\text{rib}}：
    X0,rib=self.X0rib X_{0,\text{rib}} = \text{self.X0rib}
  • 模型肋骨的初始y坐标数组Y0,ribY_{0,\text{rib}}：
    Y0,rib=self.Y0rib Y_{0,\text{rib}} = \text{self.Y0rib}
  • 模型锥段数量NconN_{\text{con}}：
    Ncon=self.Ncon N_{\text{con}} = \text{self.Ncon}

2. 初始化旋转后的坐标数组

  • 初始化旋转后的模型轮廓坐标数组XmodX_{\text{mod}}和YmodY_{\text{mod}}：
    Xmod=np.zeros(2⋅Ncon+4) X_{\text{mod}} = \text{np.zeros}(2 \cdot N_{\text{con}} + 4)
    Ymod=np.zeros(2⋅Ncon+4) Y_{\text{mod}} = \text{np.zeros}(2 \cdot N_{\text{con}} + 4)
  • 初始化旋转后的模型肋骨坐标数组XribX_{\text{rib}}和YribY_{\text{rib}}：
    Xrib=np.zeros(2⋅(Ncon−1)) X_{\text{rib}} = \text{np.zeros}(2 \cdot (N_{\text{con}} - 1))
    Yrib=np.zeros(2⋅(Ncon−1)) Y_{\text{rib}} = \text{np.zeros}(2 \cdot (N_{\text{con}} - 1))

3. 计算模型轮廓的旋转

  • 对于每个点ii（从 0 到2⋅Ncon+32 \cdot N_{\text{con}} + 3）：
    Xmod[i]=Xc−(Xc−X0,mod[i])⋅cos⁡(Ψ)+Y0,mod[i]⋅sin⁡(Ψ) X_{\text{mod}}[i] = X_c - (X_c - X_{0,\text{mod}}[i]) \cdot \cos(\Psi) + Y_{0,\text{mod}}[i] \cdot \sin(\Psi)
    Ymod[i]=(Xc−X0,mod[i])⋅sin⁡(Ψ)+Y0,mod[i]⋅cos⁡(Ψ) Y_{\text{mod}}[i] = (X_c - X_{0,\text{mod}}[i]) \cdot \sin(\Psi) + Y_{0,\text{mod}}[i] \cdot \cos(\Psi)

4. 计算模型肋骨的旋转

  • 对于每个点ii（从 0 到2⋅(Ncon−1)−12 \cdot (N_{\text{con}} - 1) - 1）：
    Xrib[i]=Xc−(Xc−X0,rib[i])⋅cos⁡(Ψ)+Y0,rib[i]⋅sin⁡(Ψ) X_{\text{rib}}[i] = X_c - (X_c - X_{0,\text{rib}}[i]) \cdot \cos(\Psi) + Y_{0,\text{rib}}[i] \cdot \sin(\Psi)
    Yrib[i]=(Xc−X0,rib[i])⋅sin⁡(Ψ)+Y0,rib[i]⋅cos⁡(Ψ) Y_{\text{rib}}[i] = (X_c - X_{0,\text{rib}}[i]) \cdot \sin(\Psi) + Y_{0,\text{rib}}[i] \cdot \cos(\Psi)

5. 返回结果

  • 旋转后的模型轮廓坐标数组XmodX_{\text{mod}}和YmodY_{\text{mod}}。
  • 旋转后的模型肋骨坐标数组XribX_{\text{rib}}和YribY_{\text{rib}}。

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
def CalcTurnModel(self):
    # Xc, Psi, X0mod, Y0mod, X0rib, Y0rib, Ncon
    """
    计算模型轮廓围绕质心旋转后的坐标。

    参数:
    Xc (float): 质心的x坐标。
    Psi (float): 旋转角度（弧度）。
    X0mod (numpy.ndarray): 模型轮廓的初始x坐标数组。
    Y0mod (numpy.ndarray): 模型轮廓的初始y坐标数组。
    X0rib (numpy.ndarray): 模型肋骨的初始x坐标数组。
    Y0rib (numpy.ndarray): 模型肋骨的初始y坐标数组。
    Ncon (int): 模型锥段数量。
    返回:
    Xmod (numpy.ndarray): 旋转后的模型轮廓x坐标数组。
    Ymod (numpy.ndarray): 旋转后的模型轮廓y坐标数组。
    Xrib (numpy.ndarray): 旋转后的模型肋骨x坐标数组。
    Yrib (numpy.ndarray): 旋转后的模型肋骨y坐标数组。
    """
    # Xc (float): 质心的x坐标。
    Xc = self.Xc
    # Psi (float): 旋转角度（弧度）。
    Psi = self.Psi
    # X0mod (numpy.ndarray): 模型轮廓的初始x坐标数组。
    X0mod = self.X0mod
    # Y0mod (numpy.ndarray): 模型轮廓的初始y坐标数组。
    Y0mod = self.Y0mod
    # X0rib (numpy.ndarray): 模型肋骨的初始x坐标数组。
    X0rib = self.X0rib
    # Y0rib (numpy.ndarray): 模型肋骨的初始y坐标数组。
    Y0rib = self.Y0rib
    # Ncon (int): 模型锥段数量。
    Ncon = self.Ncon

    # 初始化旋转后的模型轮廓坐标
    Xmod = np.zeros(2 * Ncon + 4)
    Ymod = np.zeros(2 * Ncon + 4)

    # 初始化旋转后的模型肋骨坐标
    Xrib = np.zeros(2 * (Ncon - 1))
    Yrib = np.zeros(2 * (Ncon - 1))

    # 计算模型轮廓的旋转
    for i in range(2 * Ncon + 4):
        Xmod[i] = Xc - (Xc - X0mod[i]) * np.cos(Psi) + Y0mod[i] * np.sin(Psi)
        Ymod[i] = (Xc - X0mod[i]) * np.sin(Psi) + Y0mod[i] * np.cos(Psi)

    # 计算模型肋骨的旋转
    for i in range(2 * (Ncon - 1)):
        Xrib[i] = Xc - (Xc - X0rib[i]) * np.cos(Psi) + Y0rib[i] * np.sin(Psi)
        Yrib[i] = (Xc - X0rib[i]) * np.sin(Psi) + Y0rib[i] * np.cos(Psi)

    # 返回:
    # Xmod (numpy.ndarray): 旋转后的模型轮廓x坐标数组。(CalcTurnModel)
    self.Xmod = Xmod
    # Ymod (numpy.ndarray): 旋转后的模型轮廓y坐标数组。(CalcTurnModel)
    self.Ymod = Ymod
    # Xrib (numpy.ndarray): 旋转后的模型肋骨x坐标数组。(CalcTurnModel)
    self.Xrib = Xrib
    # Yrib (numpy.ndarray): 旋转后的模型肋骨y坐标数组。(CalcTurnModel)
    self.Yrib = Yrib