数据驱动的湍流建模

湍流是流体动力学中最具挑战性的问题之一，其多尺度、高度非线性特性使得传统建模方法面临根本性的困难。机器学习为湍流建模提供了新的范式转变：从物理直觉驱动转向数据驱动，在保持物理一致性的同时显著提升预测精度。

1. 湍流基础理论回顾

1.1 Reynolds分解

湍流由大量不同尺度的涡旋组成。Reynolds分解将瞬时量分解为时均值和脉动量：

$$u_i(\mathbf{x},t)={\bar{u}}_i(\mathbf{x})+u_i^{\prime }(\mathbf{x},t)$$

其中 ${\bar{u}}_i=\frac{1}{T}{\int }_0^T{u}_{i}dt$ 是时间平均。

1.2 Reynolds平均N-S方程（RANS）

对N-S方程做Reynolds平均，得到RANS方程：

$$\frac{\partial {\bar{u}}_i}{\partial t}+{\bar{u}}_j\frac{\partial {\bar{u}}_i}{\partial x_j}=-\frac{1}{\rho }\frac{\partial \bar{p}}{\partial x_i}+\nu \frac{{\partial }^2{\bar{u}}_i}{\partial x_j^2}-\frac{\partial {\tau }_{ij}}{\partial x_j}$$

Reynolds应力：

$${\tau }_{ij}=-\overline{u_i^{\prime }{u}_j^{\prime }}$$

1.3 湍流闭合问题

RANS方程引入了未知的Reynolds应力项，这构成了著名的湍流闭合问题。传统方法使用Boussinesq假设：

$$-\overline{u_i^{\prime }{u}_j^{\prime }}={\nu }_t\left(\frac{\partial {\bar{u}}_i}{\partial x_j}+\frac{\partial {\bar{u}}_j}{\partial x_i}\right)-\frac{2}{3}k{\delta }_{ij}$$

其中 ${\nu }_t$ 是涡粘系数，$k=\frac{1}{2}\overline{u_i^{\prime }{u}_i^{\prime }}$ 是湍动能。

1.4 大涡模拟（LES）

LES仅解析大尺度涡旋，小尺度涡旋通过亚网格模型（SGS）建模：

$$\frac{\partial {\bar{u}}_i}{\partial t}+{\bar{u}}_j\frac{\partial {\bar{u}}_i}{\partial x_j}=-\frac{1}{\rho }\frac{\partial \bar{p}}{\partial x_i}-\frac{\partial {\tau }_{ij}^{SGS}}{\partial x_j}$$

亚网格应力 ${\tau }_{ij}^{SGS}=\overline{u_i{u}_j}-{\bar{u}}_i{\bar{u}}_j$ 通过SGS模型闭合。

2. 数据驱动RANS增强

2.1 数据驱动方法动机

RANS模型在复杂湍流（如分离流、旋涡流动）中预测精度有限。数据驱动方法可以：

1. 学习物理模型未捕获的非线性关系
2. 自适应调整模型参数
3. 处理模型不确定性

2.2 模型参数标定

最简单的数据驱动方法是对RANS模型的参数进行标定：

参数	物理意义	典型值
$C_{\mu }$	涡粘系数	0.09
$C_{ϵ1}$	耗散率方程常数	1.44
$C_{ϵ2}$	耗散率方程常数	1.92
${\sigma }_k$	湍动能Prandtl数	1.0
${\sigma }_{ϵ}$	耗散率Prandtl数	1.3

优化方法：

def calibrate_rans_parameters(velocity_data, target_stress):
    """标定RANS参数"""
    params = nn.Parameter(torch.tensor([0.09, 1.44, 1.92, 1.0, 1.3]))
    
    optimizer = torch.optim.Adam([params], lr=0.01)
    
    for iteration in range(1000):
        # 使用当前参数计算RANS预测
        rans_stress = compute_rans_stress(velocity_data, params)
        
        # 损失：与DNS/LES数据的差异
        loss = MSE(rans_stress, target_stress)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
    return params

2.3 机器学习增强RANS

超越参数标定，直接学习Reynolds应力的修正项：

$${\tau }_{ij}={\tau }_{ij}^{RANS}+\Delta {\tau }_{ij}(\mathbf{x},\mathbf{u};\theta )$$

神经网络架构：

class DataDrivenRANS(nn.Module):
    """数据驱动RANS增强模型"""
    def __init__(self, input_dim=10, hidden_dim=128, n_layers=4):
        super().__init__()
        
        self.encoder = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),
        )
        
        self.stress_predictor = nn.Sequential(
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, 6)  # 对称张量6个分量
        )
        
        # 物理约束层
        self.physical_constraints = PhysicalConstraintLayer()
    
    def forward(self, features):
        """
        features: [u, v, w, dU/dx, dU/dy, ..., y+, ...]
        """
        h = self.encoder(features)
        delta_tau = self.stress_predictor(h)
        
        # 加入物理约束
        tau = self.physical_constraints(delta_tau)
        
        return tau

2.4 物理知情损失函数

训练损失不仅包含数据拟合项，还包含物理约束项：

$$\mathcal{L}={\mathcal{L}}_{data}+{\lambda }_1{\mathcal{L}}_{physics}+{\lambda }_2{\mathcal{L}}_{regularization}$$

数据损失：

$${\mathcal{L}}_{data}=\frac{1}{N}\sum _{i=1}^N\Vert {\hat{\tau }}_{ij}({\mathbf{x}}_i)-{\tau }_{ij}^{DNS}({\mathbf{x}}_i){\Vert }^2$$

物理损失：

$${\mathcal{L}}_{physics}=\sum _i\left|\frac{\partial {\hat{\tau }}_{ij}}{\partial x_j}\right|\text{(平衡方程约束)}$$

3. 端到端湍流预测网络

3.1 TurbulenceNet架构

端到端方法直接从输入流场预测湍流量，避免传统建模框架：

class TurbulenceNet(nn.Module):
    """端到端湍流预测网络"""
    def __init__(self, in_channels=3, out_channels=6):
        super().__init__()
        
        # 编码器：多尺度特征提取
        self.encoder = nn.ModuleList([
            nn.Sequential(
                nn.Conv2d(in_channels if i==0 else 64*(2**(i-1)), 64*(2**i), 3, padding=1),
                nn.BatchNorm2d(64*(2**i)),
                nn.LeakyReLU(0.1),
            )
            for i in range(4)
        ])
        
        # 瓶颈层：全局信息融合
        self.bottleneck = SpatialAttentionBlock(256)
        
        # 解码器：多尺度输出
        self.decoder = nn.ModuleList([
            nn.Sequential(
                nn.ConvTranspose2d(256 // (2**i), 128 // (2**i), 4, stride=2, padding=1),
                nn.BatchNorm2d(128 // (2**i)),
                nn.ReLU(),
            )
            for i in range(3)
        ])
        
        # 输出层
        self.output = nn.Conv2d(64, out_channels, 3, padding=1)
    
    def forward(self, x):
        # 编码
        skips = []
        for layer in self.encoder:
            x = layer(x)
            skips.append(x)
            x = F.avg_pool2d(x, 2)
        
        # 瓶颈
        x = self.bottleneck(x)
        
        # 解码
        for i, layer in enumerate(self.decoder):
            x = layer(x)
            x = x + skips[-(i+2)]  # 跳跃连接
        
        return self.output(x)

3.2 训练策略

课程学习：

1. 阶段1：在层流/低Re数据上训练，学习基本物理
2. 阶段2：在中等湍流数据上训练
3. 阶段3：在高Re湍流数据上微调

多任务学习：

同时预测多个湍流量（应力、耗散率、湍动能），共享特征表示：

$${\mathcal{L}}_{multi-task}=\sum _k{w}_k{\mathcal{L}}_k$$

4. 亚网格建模（数据驱动LES）

4.1 传统SGS模型

Smagorinsky模型：

$${\tau }_{ij}^{SGS}=-2C_S{\Delta }^2|\bar{S}|{\bar{S}}_{ij}$$

其中 $|\bar{S}|=\sqrt{2{\bar{S}}_{ij}{\bar{S}}_{ij}}$，$\Delta$ 是网格尺度。

4.2 数据驱动SGS模型

class DataDrivenSGS(nn.Module):
    """数据驱动亚网格应力模型"""
    def __init__(self, input_channels=6):
        super().__init__()
        
        # 输入：过滤后的速度梯度张量分量
        self.net = nn.Sequential(
            nn.Conv2d(input_channels, 64, 3, padding=1),
            nn.ReLU(),
            nn.Conv2d(64, 64, 3, padding=1),
            nn.ReLU(),
            nn.Conv2d(64, 6, 3, padding=1),  # 输出6个SGS应力分量
        )
        
        # 涡粘约束：确保正定性
        self.viscosity_net = nn.Sequential(
            nn.Conv2d(input_channels, 32, 3, padding=1),
            nn.ReLU(),
            nn.Conv2d(32, 1, 3, padding=1),
            nn.Softplus()  # 确保正值
        )
    
    def forward(self, filtered_velocity, grid_spacing):
        """
        filtered_velocity: 过滤后的速度场
        grid_spacing: 网格间距
        """
        # 计算输入特征
        features = self.compute_velocity_gradients(filtered_velocity)
        
        # 预测SGS应力
        tau = self.net(features)
        
        # 加入涡粘约束
        nu_t = 0.1 * self.viscosity_net(features) * grid_spacing**2
        
        return tau, nu_t
    
    def compute_velocity_gradients(self, u):
        """计算速度梯度"""
        grad_u = torch.autograd.grad(u[:, 0], u, create_graph=True)[0]
        grad_v = torch.autograd.grad(u[:, 1], u, create_graph=True)[0]
        # ...
        return torch.cat([grad_u, grad_v], dim=1)

4.3 能量级串约束

湍流能量从大尺度向小尺度传递（Kolmogorov能谱）。SGS模型应保证这一物理特性：

$$\Pi =-{\tau }_{ij}^{SGS}{\bar{S}}_{ij}\ge 0$$

其中 $\Pi$ 是亚网格能量传输率。

约束损失：

$${\mathcal{L}}_{backscatter}=1(\Pi <0)\cdot |\Pi |$$

5. 迁移学习与跨Re数泛化

5.1 问题定义

湍流数据稀缺且获取成本高。迁移学习解决跨不同Reynolds数、几何的泛化问题：

• 源域：低Re层流/湍流（DNS/LES数据丰富）
• 目标域：高Re实际应用（数据稀缺）

5.2 领域自适应方法

class TurbulenceDomainAdaptation(nn.Module):
    def __init__(self, feature_dim=128):
        super().__init__()
        
        # 共享特征提取器
        self.shared_encoder = TurbulenceEncoder(feature_dim)
        
        # 源域/目标域特定编码
        self.domain_specific = nn.ModuleDict({
            'source': DomainSpecificEncoder(feature_dim),
            'target': DomainSpecificEncoder(feature_dim),
        })
        
        # 域判别器
        self.domain_discriminator = DomainClassifier(feature_dim)
    
    def forward(self, x, domain='source'):
        features = self.shared_encoder(x)
        domain_features = self.domain_specific[domain](features)
        tau = self.predict_stress(domain_features)
        return tau

5.3 物理约束的迁移学习

通过物理正则化强制跨域一致性：

$${\mathcal{L}}_{physics}=\sum _{d\in \{src,tgt\}}\sum _p\left|\frac{\partial {\tau }_{ij}^{(p)}}{\partial x_j}\right|$$

其中 $p$ 跨越不同域。

6. 不确定性与鲁棒性

6.1 认知不确定性

模型参数不确定性：

$${\tau }_{ij}={\tau }_{ij}(\cdot )+{\sigma }_{ij}(\cdot )\cdot ϵ,ϵ\sim \mathcal{N}(0,I)$$

class BayesianTurbulenceNet(nn.Module):
    def __init__(self):
        super().__init__()
        self.mean_net = TurbulenceNet()
        self.var_net = TurbulenceNet(output_channels=6)
    
    def forward(self, x):
        mean = self.mean_net(x)
        log_var = self.var_net(x)
        std = torch.exp(0.5 * log_var)
        
        # 采样（测试时多次前向传播）
        return mean + std * torch.randn_like(std)

6.2 Aleatoric不确定性

数据固有噪声，通过损失函数学习：

$$\mathcal{L}=\frac{1}{2{\sigma }^2}\Vert \hat{\tau }-{\tau }_{true}{\Vert }^2+\log {\sigma }^2$$

7. 前沿进展

7.1 Transformer for Turbulence

• Turbulenceformer：注意力机制捕获长程湍流相关性
• Physics-informed Attention：加入物理约束的注意力

7.2 Graph Neural Networks for Turbulence

• MeshTurbNet：非结构化网格上的湍流预测
• GNN-LES：图神经网络亚网格建模

7.3 Foundation Models for Turbulence

• TurbulenceFM：预训练的湍流基础模型
• Few-shot Turbulence：少样本湍流预测

参考文献