gyz/obsidian_backup
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

vault backup: 2026-01-08 15:16:18

Browse Source
This commit is contained in:
yize 2026-01-08 15:16:18 +08:00
parent 7d12a4abc0
commit 03778fa3f9
2 changed files with 687 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

677
copilot-conversations/20260107_103211__[[Blade]]详细展示公式推导过程.md
View File

@ -451,8 +451,7 @@ $\mathbf{M}(q,t)\ddot{\mathbf{q}} = \mathbf{F}(\dot{q},q,t)$
...
TmpVec1 = RtHSdat%FSAero(:,K,J)*p%DRNodes(J) - ... ! Distributed aerodynamic force
TmpVec3 = RtHSdat%MMAero(:,K,J)*p%DRNodes(J) ! Distributed aerodynamic moment
```
* `RtHSdat%FSTipDrag(:,K)` 是叶尖阻力 $\boldsymbol{F}_{TipDragB1}^{S1}(BldFlexL)$。
``` * `RtHSdat%FSTipDrag(:,K)` 是叶尖阻力 $\boldsymbol{F}_{TipDragB1}^{S1}(BldFlexL)$。
* `RtHSdat%FSAero(:,K,J)*p%DRNodes(J)` 是叶片元素 $J$ 上的气动力 $\boldsymbol{F}_{AeroB1}^{S1}(r) \, dr$。
* `RtHSdat%MMAero(:,K,J)*p%DRNodes(J)` 是叶片元素 $J$ 上的气动扭矩 $\boldsymbol{M}_{AeroB1}^{M1}(r) \, dr$。
* 这些力/扭矩随后通过点积 `DOT_PRODUCT( RtHSdat%PLinVelES(...), TmpVec1 )` 和 `DOT_PRODUCT( RtHSdat%PAngVelEM(...), TmpVec3 )` 被投影到偏速度和偏角速度方向上，并累加到 `AugMat(..., p%NAug)`，对应于 [[Blade]] 公式 (26)。
@ -633,8 +632,7 @@ $\boldsymbol{\alpha} = \sum_i \boldsymbol{\omega}_i \ddot{q}_i + \sum_i \frac{d\
RtHSdat%PAngVelEH(DOF_Teet,1,:) = CROSS_PRODUCT( RtHSdat%AngVelEH, RtHSdat%PAngVelEH(DOF_Teet,0,:) )
...
ENDIF
```
这部分计算了轮毂偏角速度的一阶导数。对于旋转的参考系，偏角速度的导数通常涉及当前角速度与偏角速度的叉积（例如，科里奥利效应）。
``` 这部分计算了轮毂偏角速度的一阶导数。对于旋转的参考系，偏角速度的导数通常涉及当前角速度与偏角速度的叉积（例如，科里奥利效应）。
* **`RtHSdat%AngAccEHt` (轮毂角加速度中与 $\ddot{q}$ 无关的部分):**
```fortran
RtHSdat%AngAccEHt = AngAccELt
@ -796,4 +794,673 @@ $\boldsymbol{r} = \boldsymbol{r}(q_1, q_2, \ldots, q_n, t)$
4. **支持运动学计算:** 准确的位置信息是计算速度和加速度（包括偏速度和偏角速度）的基础，这些运动学量在 `CalculateAngularPosVelPAcc` 和 `CalculateLinearVelPAcc` 中被进一步计算。
通过这些详细的位置计算，`CalculatePositions` 确保了风力机叶片在复杂三维运动和柔性变形下的几何构型被准确地捕捉，为后续的动力学方程构建提供了坚实的基础。
[Timestamp: 2026/01/07 14:29:57]
[Timestamp: 2026/01/07 14:29:57]
**user**: [[Blade]][[Coeff]]结合理论和代码，解释叶片部分是如何计算的
[Timestamp: 2026/01/07 16:47:41]
**ai**: `Coeff` 子程序在风力机动力学仿真中扮演着**初始化和预计算**关键参数的角色。它在仿真开始时被调用，根据用户输入的几何、质量、刚度、阻尼等数据，计算出各种系数，这些系数随后在整个仿真过程中被其他子程序（如 `CalculatePositions`, `CalculateAngularPosVelPAcc`, `CalculateForcesMoments`, `FillAugMat` 等）使用。
本解释将聚焦于 `Coeff` 中与叶片相关的计算部分，并将其与 [[Blade]] 笔记中的理论公式进行对照。
### `Coeff` 子程序中的叶片部分计算
`Coeff` 子程序中与叶片相关的计算主要集中在几个方面：气动中心位置、叶片质量属性、广义质量、广义刚度、固有频率、广义阻尼以及扭转形状函数和轴向缩短系数的预计算。
#### 1. 气动中心位置 (`p%rSAerCenn1`, `p%rSAerCenn2`)
* **理论依据:** [[Blade]] 公式 (24) 中提到气动俯仰力矩 $M_{AeroB1}^{M1}(r)$ 可以包含由气动偏移引起的力矩。这意味着需要知道气动力作用点（气动中心）相对于叶片参考点的位置。
* **代码作用:**
```fortran
DO K = 1,p%NumBl ! Loop through the blades
DO J = 1,p%BldNodes ! Loop through the blade nodes / elements
TmpDist = ( 0.25 - p%PitchAxis(K,J) )*p%Chord(J) ! Distance along the chordline from point S (25% chord) to the aerodynamic center of the blade element J--positive towards the trailing edge.
TmpDistj1 = TmpDist*p%SAeroTwst(J) ! Distance along the j1-axis from point S (25% chord) to the aerodynamic center of the blade element J
TmpDistj2 = TmpDist*p%CAeroTwst(J) ! Distance along the j2-axis from point S (25% chord) to the aerodynamic center of the blade element J
p%rSAerCenn1(K,J) = TmpDistj1*p%CThetaS(K,J) - TmpDistj2*p%SThetaS(K,J)
p%rSAerCenn2(K,J) = TmpDistj1*p%SThetaS(K,J) + TmpDistj2*p%CThetaS(K,J)
ENDDO
ENDDO
```
这部分代码计算了每个叶片元素的气动中心相对于叶片参考点 S（通常是 25% 弦长处）在叶片局部坐标系 `n1` 和 `n2` 方向上的分量 `p%rSAerCenn1` 和 `p%rSAerCenn2`。
* `p%PitchAxis(K,J)`: 叶片 $K$ 元素 $J$ 的桨距轴位置（相对于弦长）。
* `p%Chord(J)`: 叶片元素 $J$ 的弦长。
* `TmpDist`: 气动中心与参考点 S 沿弦长的距离。
* `p%SAeroTwst(J)`, `p%CAeroTwst(J)`: 气动扭转的正弦和余弦值，用于将沿弦长的距离分解到叶片局部 `j1` 和 `j2` 轴。
* `p%CThetaS(K,J)`, `p%SThetaS(K,J)`: 叶片局部坐标系与气动坐标系之间的转换因子。
* **作用:** 这些预计算的距离在 `CalculateForcesMoments` 子程序中用于计算气动俯仰力矩的力臂。
#### 2. 叶片质量属性 (`p%BldMass`, `p%FirstMom`, `p%SecondMom`, `p%BldCG`)
* **理论依据:** [[Blade]] 公式 (2) 和 (3) 定义了叶片分布式质量 $\mu^{B1}(r)$ 和叶尖质量 $m^{B1Tip}$。这些是计算叶片总质量、质心和转动惯量的基础。
* **代码作用:**
```fortran
p%BldMass (K) = p%TipMass(K)
p%FirstMom (K) = p%TipMass(K)*p%BldFlexL
p%SecondMom(K) = p%TipMass(K)*p%BldFlexL*p%BldFlexL
...
p%BElmntMass(J,K) = p%MassB(K,J)*p%DRNodes(J)
...
p%BldMass (K) = p%BldMass (K) + p%BElmntMass(J,K)
p%FirstMom (K) = p%FirstMom (K) + p%BElmntMass(J,K)*p%RNodes(J)
p%SecondMom(K) = p%SecondMom(K) + p%BElmntMass(J,K)*p%RNodes(J)*p%RNodes(J)
...
p%BldCG (K) = p%FirstMom (K) / p%BldMass (K)
```
这部分代码通过对叶片元素质量和叶尖质量进行积分（或求和），计算了每个叶片的总质量 `p%BldMass`、一阶质量矩 `p%FirstMom`、二阶质量矩 `p%SecondMom` 以及质心位置 `p%BldCG`。
* `p%MassB(K,J)`: 叶片 $K$ 元素 $J$ 的单位长度质量。
* `p%DRNodes(J)`: 叶片元素 $J$ 的长度。
* `p%RNodes(J)`: 叶片元素 $J$ 的径向位置。
* **作用:** 这些质量属性是计算广义惯性力、广义重力以及整个风力机系统总质量和质心的基础。
#### 3. 广义质量 (`MBF`, `MBE`)
* **理论依据:** [[Blade]] 公式 (16) 和 (17) 定义了广义质量 $m_{ij}^{\prime B1F}$ 和 $m_{11}^{\prime B1E}$，它们通过对叶片分布式质量和模态形状函数进行积分得到。
* **代码作用:**
```fortran
MBF(K,1,1) = p%TipMass(K)
MBF(K,2,2) = p%TipMass(K)
MBE(K,1,1) = p%TipMass(K)
...
Shape1 = SHP( p%RNodesNorm(J), p%BldFlexL, p%BldFl1Sh(:,K), 0, ErrStat, ErrMsg )
Shape2 = SHP( p%RNodesNorm(J), p%BldFlexL, p%BldFl2Sh(:,K), 0, ErrStat, ErrMsg )
MBF (K,1,1) = MBF (K,1,1) + p%BElmntMass(J,K)*Shape1*Shape1
MBF (K,2,2) = MBF (K,2,2) + p%BElmntMass(J,K)*Shape2*Shape2
Shape = SHP( p%RNodesNorm(J), p%BldFlexL, p%BldEdgSh(:,K), 0, ErrStat, ErrMsg )
MBE (K,1,1) = MBE (K,1,1) + p%BElmntMass(J,K)*Shape *Shape
```
这部分代码计算了叶片挥舞方向 (`MBF`) 和摆振方向 (`MBE`) 的广义质量。
* `SHP(..., 0, ...)`: 这是一个函数，用于获取模态形状函数 $\phi(r)$ 的零阶导数（即形状函数本身）。
* `p%BldFl1Sh(:,K)`, `p%BldFl2Sh(:,K)`, `p%BldEdgSh(:,K)`: 分别是叶片 $K$ 的第一阶挥舞模态、第二阶挥舞模态和第一阶摆振模态的形状函数数据。
* **作用:** 这些广义质量是计算叶片固有频率 (公式 14, 15) 和广义惯性力 (公式 5) 的关键参数。
#### 4. 广义刚度 (`p%KBF`, `p%KBE`, `KBFCent`, `KBECent`)
* **理论依据:** [[Blade]] 公式 (9) 和 (11) 定义了未考虑离心刚化效应时的广义刚度 ${k'}_{ij}^{B1F}$ 和 ${k'}_{11}^{B1E}$。代码中还计算了离心刚化效应引起的刚度项。
* **代码作用:**
```fortran
ElmntStff = p%StiffBF(K,J)*p%DRNodes(J)
Shape1 = SHP( p%RNodesNorm(J), p%BldFlexL, p%BldFl1Sh(:,K), 2, ErrStat, ErrMsg )
Shape2 = SHP( p%RNodesNorm(J), p%BldFlexL, p%BldFl2Sh(:,K), 2, ErrStat, ErrMsg )
p%KBF (K,1,1) = p%KBF (K,1,1) + ElmntStff*Shape1*Shape1
p%KBF (K,1,2) = p%KBF (K,1,2) + ElmntStff*Shape1*Shape2
p%KBF (K,2,1) = p%KBF (K,2,1) + ElmntStff*Shape2*Shape1
p%KBF (K,2,2) = p%KBF (K,2,2) + ElmntStff*Shape2*Shape2
...
ElmntStff = FMomAbvNd(K,J)*p%DRNodes(J)*p%RotSpeed**2
Shape1 = SHP( p%RNodesNorm(J), p%BldFlexL, p%BldFl1Sh(:,K), 1, ErrStat, ErrMsg )
KBFCent(K,1,1) = KBFCent(K,1,1) + ElmntStff*Shape1*Shape1
```
这部分代码计算了叶片挥舞方向 (`p%KBF`) 和摆振方向 (`p%KBE`) 的广义刚度，包括结构刚度项和离心刚化项 (`KBFCent`, `KBECent`)。
* `SHP(..., 2, ...)`: 获取模态形状函数的二阶导数（曲率），对应于 [[Blade]] 公式 (9) 和 (11) 中的 $\frac{d^2 \phi}{dr^2}$。
* `p%StiffBF(K,J)`: 叶片 $K$ 元素 $J$ 的挥舞刚度 $EI^{B1F}(r)$。
* `FMomAbvNd(K,J)*p%DRNodes(J)*p%RotSpeed**2`: 离心刚化效应项，与叶片上方质量的一阶矩和转速平方相关。
* `SHP(..., 1, ...)`: 获取模态形状函数的一阶导数，用于离心刚化项。
* **作用:** 这些广义刚度是计算广义弹性力 (公式 8, 19) 和固有频率 (公式 14, 15) 的关键参数。
#### 5. 固有频率 (`p%FreqBF`, `p%FreqBE`)
* **理论依据:** [[Blade]] 公式 (14) 和 (15) 定义了未考虑离心刚化效应时的固有频率 $f_i^{\prime B1F}$ 和 $f_i^{\prime B1E}$。
* **代码作用:**
```fortran
p%FreqBF(K,I,1) = Inv2Pi*SQRT( p%KBF(K,I,I) /( MBF(K,I,I) - p%TipMass(K) ) )
p%FreqBF(K,I,2) = Inv2Pi*SQRT( p%KBF(K,I,I) / MBF(K,I,I) )
p%FreqBF(K,I,3) = Inv2Pi*SQRT( ( p%KBF(K,I,I) + KBFCent(K,I,I) )/ MBF(K,I,I) )
```
这部分代码计算了叶片在不同条件下（是否考虑叶尖质量、是否考虑离心刚化）的固有频率。
* `Inv2Pi`: $1/(2\pi)$。
* **作用:** 这些固有频率是计算广义阻尼力 (公式 13, 20) 的关键参数。
#### 6. 广义阻尼 (`p%CBF`, `p%CBE`)
* **理论依据:** [[Blade]] 公式 (13) 定义了广义阻尼力，其中阻尼系数与结构阻尼比 $\zeta$、广义刚度 $k'$ 和固有频率 $f'$ 相关。
* **代码作用:**
```fortran
p%CBF(K,I,L) = ( 0.01*p%BldFDamp(K,L) )*p%KBF(K,I,L)/( Pi*p%FreqBF(K,L,1) )
p%CBE (K,1,1) = ( 0.01*p%BldEDamp(K,1) )*p%KBE(K,1,1)/( Pi*p%FreqBE(K,1,1) )
``` 这部分代码根据瑞利阻尼假设，计算了叶片挥舞方向 (`p%CBF`) 和摆振方向 (`p%CBE`) 的广义阻尼系数。
* `p%BldFDamp(K,L)`: 叶片 $K$ 的挥舞阻尼比 $\zeta$。
* `Pi`: $\pi$。
* **作用:** 这些广义阻尼系数是计算广义阻尼力 (公式 13, 20) 的关键参数。
#### 7. 扭转形状函数和轴向缩短系数 (`p%TwistedSF`, `p%AxRedBld`)
* **理论依据:** 这些系数直接用于 `CalculatePositions` 子程序中计算叶片柔性点的位移，如前所述。它们描述了叶片柔性变形的几何特性。
* **代码作用:**
```fortran
! Calculate the 2nd derivatives of the twisted shape functions:
Shape = SHP( p%RNodesNorm(J), p%BldFlexL, p%BldFl1Sh(:,K), 2, ErrStat, ErrMsg )
p%TwistedSF(K,1,1,J,2) = Shape*p%CThetaS(K,J)
...
! Integrate to find the 1st derivatives of the twisted shape functions:
TwstdSF ( I,L, 1) = p%TwistedSF(K,I,L,J,2)*0.5*p%DRNodes(J)
p%TwistedSF (K,I,L,J,1) = TwstdSF ( I,L, 1)
...
! Integrate to find the twisted shape functions themselves (i.e., their zeroeth derivative):
TwstdSF ( I,L, 0) = p%TwistedSF(K,I,L,J,1)*0.5*p%DRNodes(J)
p%TwistedSF (K,I,L,J,0) = TwstdSF ( I,L, 0)
...
! Integrate to find the blade axial reduction shape functions:
AxRdBld ( I,L ) = 0.5*p%DRNodes(J)*( &
p%TwistedSF(K,1,I,L,1)*p%TwistedSF(K,1,L,J,1) &
+ p%TwistedSF(K,2,I,L,1)*p%TwistedSF(K,2,L,J,1) )
p%AxRedBld (K,I,L,J) = AxRdBld(I,L)
```
这部分代码通过对模态形状函数进行积分和组合，预计算了叶片上每个节点/元素在不同阶导数下的**扭转形状函数 `p%TwistedSF`** 和**轴向缩短系数 `p%AxRedBld`**。
* `SHP` 函数用于获取模态形状函数及其导数。
* `p%CThetaS`, `p%SThetaS`: 叶片局部坐标系与气动坐标系之间的转换因子。
* **作用:** 这些系数在 `CalculatePositions` 中用于计算叶片柔性点的精确位置，包括弯曲和扭转引起的位移以及轴向缩短效应。
### 总结
`Coeff` 子程序是风力机动力学模型中的“大脑”，它在仿真开始前，根据用户提供的原始输入数据，执行大量的预计算和集成操作。对于叶片部分，它：
1. **计算几何和质量属性:** 确定气动中心位置、叶片总质量、质心等。
2. **计算模态动力学参数:** 基于模态形状函数，通过积分计算广义质量、广义刚度（包括离心刚化）、固有频率和广义阻尼。
3. **预计算运动学辅助参数:** 计算扭转形状函数及其导数，以及轴向缩短系数，这些是描述叶片柔性变形几何的关键。
这些预计算的系数 (`p` 结构体中的数据) 随后被其他运行时子程序高效地调用，以执行实时的运动学、力和力矩计算，并最终构建系统的运动方程。这大大提高了仿真效率，并确保了模型中物理参数的一致性和准确性。
[Timestamp: 2026/01/08 09:46:42]
**user**:
```pub fn shp_array(fract: f64, // Fractional distance along the beam
flexl: f64, // Length of the flexible beam
mod_shp_ary: &Array1<f64>, // Array holding mode shape coefficients
deriv: usize // Derivative order (0, 1, or 2)
) -> f64 { // Return type is f64 without error handling
// Handle invalid deriv values by returning 0.0 if deriv is out of bounds
if deriv > 2 {
return 0.0;
}
// Handle invalid fract values by returning 0.0 if fract is out of bounds
if fract < 0.0 || fract > 1.0 {
return 0.0;
}
// Initialize the coefficients for the derivatives
let mut switch = [0; 3];
switch[deriv] = 1;
let mut shp = 0.0;
// Loop through all elements of mod_shp_ary
for (i, &mod_shp_val) in mod_shp_ary.iter().enumerate() {
let j = i + 2; // Fortran uses 1-based indexing, so adjust to 0-based for Rust
let coef_tmp = switch[0] + switch[1] * j as i32 + switch[2] * (i as i32 + 1) * (j as i32);
// Compute the SHP value
if j == 2 && deriv == 2 {
shp = mod_shp_val * coef_tmp as f64 / (flexl.powi(deriv as i32));
} else {
shp += mod_shp_val * coef_tmp as f64 * fract.powi((j - deriv) as i32) / (flexl.powi(deriv as i32));
}
}
shp // Return the calculated SHP value
}
bld_fl1_sh_2: -17.87632584
bld_fl1_sh_3: 40.75086281
bld_fl1_sh_4: -32.57060113
bld_fl1_sh_5: 12.03110336
bld_fl1_sh_6: -1.3350392
根据代码和系数参数，解释如何计算的模态形状函数的二阶导数
[Timestamp: 2026/01/08 10:29:43]
```
**ai**: 提供的 Rust 代码 `shp_array` 函数用于计算模态形状函数（mode shape function）及其导数。在风力机动力学模型中，模态形状函数 $\phi(r)$ 描述了柔性部件（如叶片或塔架）在特定模态下沿其长度的变形模式。
`shp_array` 函数的输入参数包括：
* `fract`: 沿梁的无量纲距离（0.0 到 1.0），表示在哪个位置计算形状函数。
* `flexl`: 柔性梁的实际长度。
* `mod_shp_ary`: 包含模态形状系数的数组。
* `deriv`: 导数阶数（0 表示形状函数本身，1 表示一阶导数，2 表示二阶导数）。
我们关注的是如何计算**模态形状函数的二阶导数**，即当 `deriv = 2` 时。
### 模态形状函数的数学表示
在 OpenFAST (ElastoDyn) 中，模态形状函数通常被表示为多项式形式，例如：
$\phi(x) = C_2 x^2 + C_3 x^3 + C_4 x^4 + C_5 x^5 + C_6 x^6$
其中 $x$ 是沿梁的无量纲距离（`fract`），$C_j$ 是模态形状系数（对应 `mod_shp_ary` 中的值）。
为了在实际长度 $L$ (`flexl`) 上使用，通常会进行归一化，即 $r = x \cdot L$。
所以，形状函数可以写成：
$\phi(r) = \sum_{j=2}^{6} C_j \left(\frac{r}{L}\right)^j$
### `shp_array` 函数计算二阶导数的逻辑 (`deriv = 2`)
当 `deriv = 2` 时，`switch` 数组将是 `[0, 0, 1]`。
让我们推导形状函数 $\phi(r)$ 的二阶导数：
$\frac{d\phi}{dr} = \sum_{j=2}^{6} C_j \frac{j}{L} \left(\frac{r}{L}\right)^{j-1}$
$\frac{d^2\phi}{dr^2} = \sum_{j=2}^{6} C_j \frac{j(j-1)}{L^2} \left(\frac{r}{L}\right)^{j-2}$
现在，我们对照 `shp_array` 函数中的循环逻辑：
```rust
// Loop through all elements of mod_shp_ary
for (i, &mod_shp_val) in mod_shp_ary.iter().enumerate() {
let j = i + 2; // Fortran uses 1-based indexing, so adjust to 0-based for Rust
let coef_tmp = switch[0] + switch[1] * j as i32 + switch[2] * (i as i32 + 1) * (j as i32);
// Compute the SHP value
if j == 2 && deriv == 2 {
shp = mod_shp_val * coef_tmp as f64 / (flexl.powi(deriv as i32));
} else {
shp += mod_shp_val * coef_tmp as f64 * fract.powi((j - deriv) as i32) / (flexl.powi(deriv as i32));
}
}
```
1. **`j = i + 2`**: 这个 `j` 对应于多项式项 $x^j$ 中的指数。由于 `mod_shp_ary` 的索引 `i` 从 0 开始，而多项式从 $x^2$ 开始，所以 `j` 从 2 开始。
* `i = 0` -> `j = 2` (对应 $C_2$)
* `i = 1` -> `j = 3` (对应 $C_3$)
* ...
* `i = 4` -> `j = 6` (对应 $C_6$)
2. **`coef_tmp` 的计算**: 当 `deriv = 2` 时，`switch = [0, 0, 1]`，所以 `coef_tmp` 简化为 `(i as i32 + 1) * (j as i32)`。
* `i = 0, j = 2`: `coef_tmp = (0+1)*(2) = 2`。
* `i = 1, j = 3`: `coef_tmp = (1+1)*(3) = 6`。
* `i = 2, j = 4`: `coef_tmp = (2+1)*(4) = 12`。
* `i = 3, j = 5`: `coef_tmp = (3+1)*(5) = 20`。
* `i = 4, j = 6`: `coef_tmp = (4+1)*(6) = 30`。
这些 `coef_tmp` 值实际上是 $j(j-1)$。
* $j=2 \implies 2(2-1) = 2$
* $j=3 \implies 3(3-1) = 6$
* $j=4 \implies 4(4-1) = 12$
* $j=5 \implies 5(5-1) = 20$
* $j=6 \implies 6(6-1) = 30$
这与我们推导的二阶导数公式中的 $j(j-1)$ 项完全一致。
3. **`flexl.powi(deriv as i32)`**: 当 `deriv = 2` 时，这一项是 `flexl.powi(2)`，即 $L^2$。这也与推导公式中的 $L^2$ 项一致。
4. **`fract.powi((j - deriv) as i32)`**: 当 `deriv = 2` 时，这一项是 `fract.powi((j - 2) as i32)`，即 $x^{j-2}$。这也与推导公式中的 $(r/L)^{j-2}$ 项一致（因为 `fract` 就是 $r/L$）。
5. **特殊情况 `if j == 2 && deriv == 2`**:
当 $j=2$ 且 `deriv=2` 时，多项式项是 $C_2 x^2$。其二阶导数是 $C_2 \frac{2}{L^2}$。
在代码中：
`shp = mod_shp_val * coef_tmp as f64 / (flexl.powi(deriv as i32));`
`mod_shp_val` 是 $C_2$，`coef_tmp` 是 2，`flexl.powi(deriv as i32)` 是 $L^2$。
所以 `shp` 变为 $C_2 \cdot 2 / L^2$，这正是 $C_2 x^2$ 的二阶导数。
注意，此时 `fract.powi((j - deriv) as i32)` 会是 `fract.powi(0)`，即 1。所以 `else` 分支对于 $j=2$ 的项也是正确的。这个 `if` 语句可能是一个优化或者为了避免 `fract.powi(0)` 的潜在浮点问题，但从数学上讲，两种方式都应该得到相同的结果。
### 结合系数参数进行计算示例
假设 `flexl` 是叶片柔性段的长度，`fract` 是沿叶片径向的无量纲位置。
给定的模态形状系数 `bld_fl1_sh` 对应于 `mod_shp_ary`：
* `mod_shp_ary[0]` = `bld_fl1_sh_2` = -17.87632584 (对应 $C_2$)
* `mod_shp_ary[1]` = `bld_fl1_sh_3` = 40.75086281 (对应 $C_3$)
* `mod_shp_ary[2]` = `bld_fl1_sh_4` = -32.57060113 (对应 $C_4$)
* `mod_shp_ary[3]` = `bld_fl1_sh_5` = 12.03110336 (对应 $C_5$)
* `mod_shp_ary[4]` = `bld_fl1_sh_6` = -1.3350392 (对应 $C_6$)
假设 `flexl = 10.0` 米，`fract = 0.5` (即在叶片柔性段的中间位置 $r = 5.0$ 米)，`deriv = 2`。
计算过程如下：
1. **初始化 `shp = 0.0`**
2. **第一次迭代 (i=0, j=2):**
* `mod_shp_val` = `bld_fl1_sh_2` = -17.87632584
* `coef_tmp` = $2(2-1) = 2$
* `j == 2 && deriv == 2` 为真。
* `shp` = -17.87632584 * 2 / (10.0^2) = -17.87632584 * 2 / 100.0 = -0.3575265168
3. **第二次迭代 (i=1, j=3):**
* `mod_shp_val` = `bld_fl1_sh_3` = 40.75086281
* `coef_tmp` = $3(3-1) = 6$
* `j == 2 && deriv == 2` 为假。
* `shp` += 40.75086281 * 6 * (0.5^(3-2)) / (10.0^2)
* `shp` += 40.75086281 * 6 * 0.5 / 100.0 = 40.75086281 * 3 / 100.0 = 1.2225258843
* `shp` = -0.3575265168 + 1.2225258843 = 0.8649993675
4. **第三次迭代 (i=2, j=4):**
* `mod_shp_val` = `bld_fl1_sh_4` = -32.57060113
* `coef_tmp` = $4(4-1) = 12$
* `shp` += -32.57060113 * 12 * (0.5^(4-2)) / (10.0^2)
* `shp` += -32.57060113 * 12 * 0.25 / 100.0 = -32.57060113 * 3 / 100.0 = -0.9771180339
* `shp` = 0.8649993675 - 0.9771180339 = -0.1121186664
5. **第四次迭代 (i=3, j=5):**
* `mod_shp_val` = `bld_fl1_sh_5` = 12.03110336
* `coef_tmp` = $5(5-1) = 20$
* `shp` += 12.03110336 * 20 * (0.5^(5-2)) / (10.0^2)
* `shp` += 12.03110336 * 20 * 0.125 / 100.0 = 12.03110336 * 2.5 / 100.0 = 0.300777584
* `shp` = -0.1121186664 + 0.300777584 = 0.1886589176
6. **第五次迭代 (i=4, j=6):**
* `mod_shp_val` = `bld_fl1_sh_6` = -1.3350392
* `coef_tmp` = $6(6-1) = 30$
* `shp` += -1.3350392 * 30 * (0.5^(6-2)) / (10.0^2)
* `shp` += -1.3350392 * 30 * 0.0625 / 100.0 = -1.3350392 * 1.875 / 100.0 = -0.025031985
* `shp` = 0.1886589176 - 0.025031985 = 0.1636269326
最终，在 `fract = 0.5` 处，模态形状函数的二阶导数约为 **0.1636269326**。
### 与 [[Blade]] 笔记的联系
在 [[Blade]] 笔记中，模态形状函数的二阶导数在计算**广义刚度**时被广泛使用。例如，公式 (9) 和 (11) 中：
$$
{k'}_{ij}^{B1F} = \sqrt{FlStTunr^{B1}(i) \, FlStTunr^{B1}(j)} \int_{0}^{BldFlexL} EI^{B1F}(r) \frac{d^2 \phi_i^{B1F}(r)}{dr^2} \frac{d^2 \phi_j^{B1F}(r)}{dr^2} dr
$$
这里的 $\frac{d^2 \phi_i^{B1F}(r)}{dr^2}$ 正是通过 `shp_array` 函数，将 `deriv` 设置为 2 来计算的。`Coeff` 子程序会遍历叶片上的所有节点，在每个节点处调用 `shp_array` 来获取模态形状函数的二阶导数，然后将这些值与叶片刚度 $EI^{B1F}(r)$ 相乘并进行数值积分，从而得到广义刚度。
因此，`shp_array` 函数是风力机柔性体动力学建模中一个核心的数学工具，它将抽象的模态形状函数定义转化为具体的数值计算，为广义刚度、广义质量等关键参数的计算提供了基础。
[Timestamp: 2026/01/08 10:30:08]
**user**: 展开形状函数的推导公式每一项，以多项式的形式解释，不要用连加符号
[Timestamp: 2026/01/08 10:36:21]
**ai**: 好的，我将根据提供的 `shp_array` Rust 代码和模态形状系数，以多项式形式展开模态形状函数的二阶导数，不使用连加符号。
### 模态形状函数的多项式形式
首先，我们假设模态形状函数 $\phi(x)$ 的基本多项式形式为：
$\phi(x) = C_2 x^2 + C_3 x^3 + C_4 x^4 + C_5 x^5 + C_6 x^6$
其中 $x$ 是沿梁的无量纲距离 `fract`，其范围是 。
系数 $C_j$ 对应于 `mod_shp_ary` 中的值：
* $C_2 = \text{bld\_fl1\_sh\_2} = -17.87632584$
* $C_3 = \text{bld\_fl1\_sh\_3} = 40.75086281$
* $C_4 = \text{bld\_fl1\_sh\_4} = -32.57060113$
* $C_5 = \text{bld\_fl1\_sh\_5} = 12.03110336$
* $C_6 = \text{bld\_fl1\_sh\_6} = -1.3350392$
### 模态形状函数的一阶导数
对 $\phi(x)$ 求关于 $x$ 的一阶导数：
$\frac{d\phi}{dx} = \frac{d}{dx}(C_2 x^2 + C_3 x^3 + C_4 x^4 + C_5 x^5 + C_6 x^6)$
$\frac{d\phi}{dx} = 2 C_2 x^1 + 3 C_3 x^2 + 4 C_4 x^3 + 5 C_5 x^4 + 6 C_6 x^5$
### 模态形状函数的二阶导数
对 $\frac{d\phi}{dx}$ 求关于 $x$ 的一阶导数，即 $\phi(x)$ 的二阶导数：
$\frac{d^2\phi}{dx^2} = \frac{d}{dx}(2 C_2 x^1 + 3 C_3 x^2 + 4 C_4 x^3 + 5 C_5 x^4 + 6 C_6 x^5)$
$\frac{d^2\phi}{dx^2} = 2 \cdot 1 \cdot C_2 x^0 + 3 \cdot 2 \cdot C_3 x^1 + 4 \cdot 3 \cdot C_4 x^2 + 5 \cdot 4 \cdot C_5 x^3 + 6 \cdot 5 \cdot C_6 x^4$
$\frac{d^2\phi}{dx^2} = 2 C_2 + 6 C_3 x + 12 C_4 x^2 + 20 C_5 x^3 + 30 C_6 x^4$
### 考虑实际长度 `flexl`
在 `shp_array` 函数中，导数是相对于实际长度 `flexl` 进行归一化的。如果 $\phi(r)$ 是关于实际距离 $r$ 的函数，且 $x = r / \text{flexl}$，那么：
$\frac{d\phi}{dr} = \frac{d\phi}{dx} \frac{dx}{dr} = \frac{d\phi}{dx} \frac{1}{\text{flexl}}$
$\frac{d^2\phi}{dr^2} = \frac{d}{dr}\left(\frac{d\phi}{dx} \frac{1}{\text{flexl}}\right) = \frac{1}{\text{flexl}} \frac{d}{dr}\left(\frac{d\phi}{dx}\right) = \frac{1}{\text{flexl}} \frac{d}{dx}\left(\frac{d\phi}{dx}\right) \frac{dx}{dr} = \frac{1}{\text{flexl}^2} \frac{d^2\phi}{dx^2}$
所以，模态形状函数关于实际长度 $r$ 的二阶导数 $\frac{d^2\phi}{dr^2}$ 的多项式形式为：
$\frac{d^2\phi}{dr^2} = \frac{1}{\text{flexl}^2} (2 C_2 + 6 C_3 x + 12 C_4 x^2 + 20 C_5 x^3 + 30 C_6 x^4)$
将 `fract` 代替 $x$，并代入具体的系数：
$\frac{d^2\phi}{dr^2} = \frac{1}{\text{flexl}^2} \left( 2 \cdot (-17.87632584) \right.$
$\quad + 6 \cdot (40.75086281) \cdot \text{fract}$
$\quad + 12 \cdot (-32.57060113) \cdot \text{fract}^2$
$\quad + 20 \cdot (12.03110336) \cdot \text{fract}^3$
$\quad \left. + 30 \cdot (-1.3350392) \cdot \text{fract}^4 \right)$
展开每一项：
$\frac{d^2\phi}{dr^2} = \frac{1}{\text{flexl}^2} \left( -35.75265168 \right.$
$\quad + 244.50517686 \cdot \text{fract}$
$\quad - 390.84721356 \cdot \text{fract}^2$
$\quad + 240.62206720 \cdot \text{fract}^3$
$\quad \left. - 40.05117600 \cdot \text{fract}^4 \right)$
### 与 `shp_array` 代码的对应关系
我们来验证这个展开式与 `shp_array` 代码的逻辑是否一致：
在 `shp_array` 函数中，当 `deriv = 2` 时：
* `coef_tmp` 的计算结果是 $j(j-1)$。
* `mod_shp_val` 是 $C_j$。
* `fract.powi((j - deriv) as i32)` 是 $x^{j-2}$。
* `flexl.powi(deriv as i32)` 是 $\text{flexl}^2$。
所以，`shp` 的累加项是：
`mod_shp_val * coef_tmp * fract.powi(j - 2) / flexl.powi(2)`
这正是 $C_j \cdot j(j-1) \cdot x^{j-2} / \text{flexl}^2$。
将 `mod_shp_ary` 中的每个系数代入，并按照 `j` 的顺序展开：
* **对于 $C_2$ (i=0, j=2):**
$C_2 \cdot 2(2-1) \cdot \text{fract}^{2-2} / \text{flexl}^2 = C_2 \cdot 2 \cdot \text{fract}^0 / \text{flexl}^2 = 2 C_2 / \text{flexl}^2$
$= 2 \cdot (-17.87632584) / \text{flexl}^2 = -35.75265168 / \text{flexl}^2$
* **对于 $C_3$ (i=1, j=3):**
$C_3 \cdot 3(3-1) \cdot \text{fract}^{3-2} / \text{flexl}^2 = C_3 \cdot 6 \cdot \text{fract}^1 / \text{flexl}^2$
$= 6 \cdot (40.75086281) \cdot \text{fract} / \text{flexl}^2 = 244.50517686 \cdot \text{fract} / \text{flexl}^2$
* **对于 $C_4$ (i=2, j=4):**
$C_4 \cdot 4(4-1) \cdot \text{fract}^{4-2} / \text{flexl}^2 = C_4 \cdot 12 \cdot \text{fract}^2 / \text{flexl}^2$
$= 12 \cdot (-32.57060113) \cdot \text{fract}^2 / \text{flexl}^2 = -390.84721356 \cdot \text{fract}^2 / \text{flexl}^2$
* **对于 $C_5$ (i=3, j=5):**
$C_5 \cdot 5(5-1) \cdot \text{fract}^{5-2} / \text{flexl}^2 = C_5 \cdot 20 \cdot \text{fract}^3 / \text{flexl}^2$
$= 20 \cdot (12.03110336) \cdot \text{fract}^3 / \text{flexl}^2 = 240.62206720 \cdot \text{fract}^3 / \text{flexl}^2$
* **对于 $C_6$ (i=4, j=6):**
$C_6 \cdot 6(6-1) \cdot \text{fract}^{6-2} / \text{flexl}^2 = C_6 \cdot 30 \cdot \text{fract}^4 / \text{flexl}^2$
$= 30 \cdot (-1.3350392) \cdot \text{fract}^4 / \text{flexl}^2 = -40.05117600 \cdot \text{fract}^4 / \text{flexl}^2$
将这些项相加，就得到了模态形状函数二阶导数的完整多项式形式，与我们之前推导的完全一致。
**结论：**
模态形状函数的二阶导数 $\frac{d^2\phi}{dr^2}$ 可以表示为以下多项式形式：
$\frac{d^2\phi}{dr^2} = \frac{1}{\text{flexl}^2} \left( (-35.75265168) \right.$
$\quad + (244.50517686) \cdot \text{fract}$
$\quad + (-390.84721356) \cdot \text{fract}^2$
$\quad + (240.62206720) \cdot \text{fract}^3$
$\quad \left. + (-40.05117600) \cdot \text{fract}^4 \right)$
其中：
* `flexl` 是叶片的柔性长度。
* `fract` 是沿叶片径向的无量纲距离（0 到 1）。
* 括号内的数值是模态形状系数 $C_j$ 乘以对应的导数因子 $j(j-1)$。
这个展开式清晰地展示了 `shp_array` 函数在 `deriv = 2` 时如何根据输入的模态形状系数和位置，计算出模态形状函数的二阶导数。
[Timestamp: 2026/01/08 10:36:43]
**user**: bld_fl1_sh_2: -17.87632584
bld_fl1_sh_3: 40.75086281
bld_fl1_sh_4: -32.57060113
bld_fl1_sh_5: 12.03110336
bld_fl1_sh_6: -1.3350392
bld_fl2_sh_2: -61.72252055
bld_fl2_sh_3: 150.47443903
bld_fl2_sh_4: -123.2723888
bld_fl2_sh_5: 40.42018428
bld_fl2_sh_6: -4.89971395
bld_edg_sh_2: -22.64325886
bld_edg_sh_3: 53.64951962
bld_edg_sh_4: -44.37014633
bld_edg_sh_5: 15.82350193
bld_edg_sh_6: -1.45961636
三条形状如何画出来看
[Timestamp: 2026/01/08 11:08:55]
**ai**: 好的，为了绘制这三条模态形状函数，我们需要使用 `shp_array` 函数来计算它们在叶片不同径向位置上的值。
模态形状函数的基本多项式形式为：
$\phi(x) = C_2 x^2 + C_3 x^3 + C_4 x^4 + C_5 x^5 + C_6 x^6$
其中 $x$ 是无量纲距离 `fract` (从 0 到 1)。
为了绘制这些形状，我们需要：
1. 定义一个 `shp_array` 函数的实现（这里我们使用之前提供的 Rust 代码的逻辑）。
2. 为每个模态形状函数提供其对应的系数数组。
3. 选择一个 `flexl` 值（叶片柔性段的长度）。
4. 在 `fract` 范围 内取一系列点。
5. 对于每个 `fract` 值，调用 `shp_array` 函数（`deriv = 0`，因为我们要绘制形状本身，而不是其导数）。
6. 将结果绘制出来。
### 1. `shp_array` 函数的逻辑（用于 `deriv = 0`）
当 `deriv = 0` 时，`switch` 数组将是 `[1, 0, 0]`。
`coef_tmp` 的计算简化为 `switch[0]`，即 1。
`flexl.powi(deriv as i32)` 简化为 `flexl.powi(0)`，即 1。
`fract.powi((j - deriv) as i32)` 简化为 `fract.powi(j as i32)`，即 $x^j$。
所以，`shp` 的累加项是：
`mod_shp_val * 1 * fract.powi(j) / 1`
这正是 $C_j \cdot x^j$。
因此，`shp_array(fract, flexl, mod_shp_ary, 0)` 将计算：
$\phi(x) = C_2 x^2 + C_3 x^3 + C_4 x^4 + C_5 x^5 + C_6 x^6$
### 2. 模态形状系数
我们有三组系数：
**a) 第一阶挥舞模态 (bld\_fl1\_sh):**
* $C_2 = -17.87632584$
* $C_3 = 40.75086281$
* $C_4 = -32.57060113$
* $C_5 = 12.03110336$
* $C_6 = -1.3350392$
**b) 第二阶挥舞模态 (bld\_fl2\_sh):**
* $C_2 = -61.72252055$
* $C_3 = 150.47443903$
* $C_4 = -123.2723888$
* $C_5 = 40.42018428$
* $C_6 = -4.89971395$
**c) 第一阶摆振模态 (bld\_edg\_sh):**
* $C_2 = -22.64325886$
* $C_3 = 53.64951962$
* $C_4 = -44.37014633$
* $C_5 = 15.82350193$
* $C_6 = -1.45961636$
### 3. 绘制方法
为了绘制这些形状，你可以使用任何支持科学绘图的编程语言或工具，例如 Python (matplotlib/numpy)、MATLAB、R、Julia 等。
以下是使用 Python 的示例代码和步骤：
**步骤:**
1. **定义 `shp_array` 函数（Python 实现）:**
```python
import numpy as np
import matplotlib.pyplot as plt
def shp_array_python(fract, flexl, mod_shp_ary, deriv):
if deriv > 2 or fract < 0.0 or fract > 1.0:
return 0.0
switch = [0, 0, 0]
switch[deriv] = 1
shp = 0.0
for i, mod_shp_val in enumerate(mod_shp_ary):
j = i + 2 # Corresponds to x^j in the polynomial
coef_tmp = switch[0] + switch[1] * j + switch[2] * (i + 1) * j
if j == 2 and deriv == 2:
# Special case for x^2 term's second derivative
shp_term = mod_shp_val * coef_tmp / (flexl**deriv)
else:
# General case for any derivative
shp_term = mod_shp_val * coef_tmp * (fract**(j - deriv)) / (flexl**deriv)
shp += shp_term
return shp
```
2. **定义模态形状系数数组:**
```python
# 假设 flexl = 1.0 (无量纲化，因为形状函数本身就是无量纲的，通常在绘图时将flexl设为1)
# 如果需要绘制实际物理长度上的形状，则flexl应为实际叶片柔性段长度，例如 60 米。
# 这里我们先绘制无量纲形状，所以 flexl=1.0，fract 对应 r/L
flexl_val = 1.0
# 第一阶挥舞模态 (bld_fl1_sh)
bld_fl1_sh = np.array([
-17.87632584, # C2
40.75086281, # C3
-32.57060113, # C4
12.03110336, # C5
-1.3350392 # C6
])
# 第二阶挥舞模态 (bld_fl2_sh)
bld_fl2_sh = np.array([
-61.72252055,
150.47443903,
-123.2723888,
40.42018428,
-4.89971395
])
# 第一阶摆振模态 (bld_edg_sh)
bld_edg_sh = np.array([
-22.64325886,
53.64951962,
-44.37014633,
15.82350193,
-1.45961636
])
```
3. **生成 `fract` 值范围:**
```python
fract_values = np.linspace(0.0, 1.0, 100) # 从 0 到 1 取 100 个点
```
4. **计算每个模态形状函数的值:**
```python
# 计算第一阶挥舞模态形状
fl1_shape = [shp_array_python(f, flexl_val, bld_fl1_sh, 0) for f in fract_values]
# 计算第二阶挥舞模态形状
fl2_shape = [shp_array_python(f, flexl_val, bld_fl2_sh, 0) for f in fract_values]
# 计算第一阶摆振模态形状
edg_shape = [shp_array_python(f, flexl_val, bld_edg_sh, 0) for f in fract_values]
```
5. **绘制图形:**
```python
plt.figure(figsize=(10, 6))
plt.plot(fract_values * flexl_val, fl1_shape, label='First Flapwise Mode')
plt.plot(fract_values * flexl_val, fl2_shape, label='Second Flapwise Mode')
plt.plot(fract_values * flexl_val, edg_shape, label='First Edgewise Mode')
plt.title('Blade Mode Shapes')
plt.xlabel('Fractional Blade Length (r/L)')
plt.ylabel('Mode Shape Amplitude')
plt.grid(True)
plt.legend()
plt.show()
```
### 解释绘制出的形状
绘制出的图形将展示这三种模态形状函数沿叶片长度的变形模式：
* **第一阶挥舞模态 (First Flapwise Mode):**
通常表现为叶片在挥舞方向（垂直于旋转平面）的第一次弯曲。形状会从叶根（`fract=0`）处的零位移开始，逐渐增加到最大位移，然后可能在叶尖附近再次减小（取决于边界条件和模态阶数）。对于风力机叶片，通常是单弯曲形状，叶尖位移最大。
* **第二阶挥舞模态 (Second Flapwise Mode):**
表现为叶片在挥舞方向的第二次弯曲。与第一阶模态不同，第二阶模态通常会有一个或多个“节点”（位移为零的点）沿叶片长度方向。这意味着叶片会形成 S 形或更复杂的弯曲模式，在叶尖处可能再次达到一个峰值。
* **第一阶摆振模态 (First Edgewise Mode):**
表现为叶片在摆振方向（平行于旋转平面）的第一次弯曲。与挥舞模态类似，它通常也是单弯曲形状，叶尖位移最大。由于摆振方向的刚度通常远大于挥舞方向，所以相同幅度的广义坐标下，摆振模态的物理位移可能较小，或者其固有频率较高。
通过可视化这些形状，你可以直观地理解在这些特定模态下，叶片是如何变形的，这对于理解叶片的动力学响应和设计优化至关重要。
[Timestamp: 2026/01/08 11:09:10]

30
多体+耦合求解器/多体理论框架.canvas → 多体+耦合求解器/多体理论框架及ED求解方法.canvas
View File

@ -9,7 +9,7 @@
{"id":"7351d2bbb065d539","type":"text","text":"动力学 ","x":-210,"y":110,"width":250,"height":60},
{"id":"da500b2b12ed0901","type":"text","text":"填充augmat矩阵","x":290,"y":-30,"width":250,"height":60},
{"id":"20ce8d75f0f35588","type":"text","text":"解出来q_dot ---u","x":580,"y":-30,"width":250,"height":60},
{"id":"6094c53caf966263","type":"text","text":"由F + F^* 的形式转换到 [C(q,t)]，{-f(qd,q,t)}形式 ","x":-165,"y":-40,"width":340,"height":80},
{"id":"6094c53caf966263","type":"text","text":"由F + F* 的形式转换到 [C(q,t)]，{-f(qd,q,t)}形式 ","x":-165,"y":-40,"width":340,"height":80},
{"id":"c20eeff7484d8a39","type":"text","text":"叠加法","x":-275,"y":560,"width":250,"height":60},
{"id":"a729b7930412f0b1","type":"text","text":"需要保持边界条件一致","x":60,"y":560,"width":250,"height":60},
{"id":"d405163cb9ecd804","type":"text","text":"叶片多段拆分，小段做模态叠加？","x":60,"y":670,"width":250,"height":60},
@ -19,20 +19,20 @@
{"id":"ae48e80ccd92bffa","type":"text","text":"连续体振动","x":60,"y":960,"width":250,"height":60},
{"id":"ed5a265dc4b72aaa","type":"text","text":"连续体动力学","x":420,"y":960,"width":250,"height":60},
{"id":"fc13b731983ac384","type":"text","text":"浮动坐标系","x":-340,"y":1181,"width":250,"height":60},
{"id":"df8e8a93ea4af203","x":984,"y":-235,"width":250,"height":60,"type":"text","text":"叶片"},
{"id":"7dc483819d8b527b","x":1280,"y":-235,"width":250,"height":60,"type":"text","text":"轮毂"},
{"id":"c02c22667637367f","x":1580,"y":-235,"width":250,"height":60,"type":"text","text":"机舱"},
{"id":"623ac90ce5bad160","x":1580,"y":-60,"width":250,"height":60,"type":"text","text":"塔架"},
{"id":"0324f23e7dc78d68","x":1580,"y":55,"width":250,"height":60,"type":"text","text":"机舱"},
{"id":"ba5c15a27611709c","x":1580,"y":-150,"width":250,"height":60,"type":"text","text":"偏航轴承"},
{"id":"6c3a6982a53e7df9","x":984,"y":177,"width":250,"height":60,"type":"text","text":"刚体部件："},
{"id":"f3c36900dd3ed9d1","x":1280,"y":177,"width":250,"height":60,"type":"text","text":"刚体的广义主动力、惯性力公式"},
{"id":"b624e8c6302b9a1c","x":984,"y":310,"width":250,"height":60,"type":"text","text":"叶片、塔架"},
{"id":"1054909d642ce071","x":1280,"y":310,"width":250,"height":60,"type":"text","text":"广义惯性力：质点广义惯性力公式 积分"},
{"id":"1e1a1a0d67920443","x":1280,"y":420,"width":250,"height":60,"type":"text","text":"广义主动力：由势能dV/dq_r"},
{"id":"092cf6719d47d01d","x":1280,"y":530,"width":250,"height":60,"type":"text","text":"弹性恢复力、阻尼、重力、气动力"},
{"id":"32b762bd2a4b0d66","x":984,"y":640,"width":250,"height":60,"type":"text","text":"传动链、偏航"},
{"id":"14a4450243ca9953","x":1620,"y":530,"width":250,"height":60,"type":"text","text":"原理呢？"}
{"id":"df8e8a93ea4af203","type":"text","text":"叶片","x":984,"y":-235,"width":250,"height":60},
{"id":"7dc483819d8b527b","type":"text","text":"轮毂","x":1280,"y":-235,"width":250,"height":60},
{"id":"c02c22667637367f","type":"text","text":"机舱","x":1580,"y":-235,"width":250,"height":60},
{"id":"623ac90ce5bad160","type":"text","text":"塔架","x":1580,"y":-60,"width":250,"height":60},
{"id":"0324f23e7dc78d68","type":"text","text":"机舱","x":1580,"y":55,"width":250,"height":60},
{"id":"ba5c15a27611709c","type":"text","text":"偏航轴承","x":1580,"y":-150,"width":250,"height":60},
{"id":"6c3a6982a53e7df9","type":"text","text":"刚体部件：","x":984,"y":177,"width":250,"height":60},
{"id":"f3c36900dd3ed9d1","type":"text","text":"刚体的广义主动力、惯性力公式","x":1280,"y":177,"width":250,"height":60},
{"id":"b624e8c6302b9a1c","type":"text","text":"叶片、塔架","x":984,"y":310,"width":250,"height":60},
{"id":"1054909d642ce071","type":"text","text":"广义惯性力：质点广义惯性力公式 积分","x":1280,"y":310,"width":250,"height":60},
{"id":"1e1a1a0d67920443","type":"text","text":"广义主动力：由势能dV/dq_r","x":1280,"y":420,"width":250,"height":60},
{"id":"092cf6719d47d01d","type":"text","text":"弹性恢复力、阻尼、重力、气动力","x":1280,"y":530,"width":250,"height":60},
{"id":"32b762bd2a4b0d66","type":"text","text":"传动链、偏航","x":984,"y":640,"width":250,"height":60},
{"id":"14a4450243ca9953","type":"text","text":"原理呢？","x":1620,"y":530,"width":250,"height":60}
],
"edges":[
{"id":"647c1b45edc92b02","fromNode":"9461f7dd96103316","fromSide":"bottom","toNode":"0c8534c8ba68c9a6","toSide":"top"},