结构健康监测仿真-主题009-结构疲劳与寿命预测

kkchenkx

36人浏览 · 2026-04-26 22:00:35

kkchenkx · 2026-04-26 22:00:35 发布

结构疲劳与寿命预测

1. 疲劳损伤累积模型

1.1 疲劳损伤的基本概念

疲劳是指材料或结构在循环载荷作用下，由于微观缺陷的逐渐发展而导致的失效现象。疲劳损伤累积是一个复杂的过程，涉及材料的微观结构变化、应力应变场的演化以及环境因素的影响。

疲劳损伤的主要特点：

发生在循环载荷作用下
通常在远低于材料屈服强度的应力水平下发生
是一个逐渐累积的过程
最终可能导致结构的突然失效

1.2 疲劳损伤累积模型

1.2.1 Miner线性累积损伤法则

Miner线性累积损伤法则是最常用的疲劳损伤累积模型，它假设损伤是线性累积的，与载荷顺序无关。

数学表达式：
$\sum_{i=1}^{k} \frac{n_i}{N_i} = D$

其中， n_i 是在应力水平 S_i 下的循环次数， N_i 是对应应力水平下的疲劳寿命， D 是损伤累积值。当 D = 1 时，材料或结构发生疲劳失效。

优点：

计算简单
应用广泛

缺点：

忽略了载荷顺序的影响
忽略了过载对疲劳寿命的有益作用
假设损伤线性累积，与实际情况有差异

1.2.2 Corten-Dolan模型

Corten-Dolan模型考虑了载荷顺序的影响，特别是过载对后续疲劳寿命的延长作用。

数学表达式：
$\sum_{i=1}^{k} \left( \frac{n_i}{N_i} \right)^{m}$

其中， m 是材料常数，通常取1.5-2.0。

1.2.3 损伤力学模型

损伤力学模型基于连续介质损伤力学理论，通过引入损伤变量来描述材料的损伤状态。

常用的损伤演化方程：
$\frac{dD}{dN} = C(1-D)^k \left( \frac{\sigma}{\sigma_0} \right)^m$

其中， D 是损伤变量， C, k, m 是材料常数， \sigma 是应力幅， \sigma_0 是参考应力。

1.3 疲劳损伤累积的Python实现

import numpy as np
import matplotlib.pyplot as plt

class FatigueDamageModel:
    def __init__(self, model_type='miner'):
        self.model_type = model_type
        self.damage = 0.0
    
    def calculate_damage(self, stress_levels, cycles):
        """计算疲劳损伤累积
        
        Args:
            stress_levels: 应力水平数组
            cycles: 对应应力水平下的循环次数数组
        
        Returns:
            damage: 累积损伤值
        """
        if self.model_type == 'miner':
            return self._miner_rule(stress_levels, cycles)
        elif self.model_type == 'corten-dolan':
            return self._corten_dolan_rule(stress_levels, cycles)
        elif self.model_type == 'damage-mechanics':
            return self._damage_mechanics_model(stress_levels, cycles)
        else:
            raise ValueError("Unknown model type")
    
    def _miner_rule(self, stress_levels, cycles):
        """Miner线性累积损伤法则"""
        damage = 0.0
        for stress, n in zip(stress_levels, cycles):
            N = self._s_n_curve(stress)
            damage += n / N
        return damage
    
    def _corten_dolan_rule(self, stress_levels, cycles):
        """Corten-Dolan模型"""
        damage = 0.0
        m = 1.5  # 材料常数
        for stress, n in zip(stress_levels, cycles):
            N = self._s_n_curve(stress)
            damage += (n / N) ** m
        return damage
    
    def _damage_mechanics_model(self, stress_levels, cycles):
        """损伤力学模型"""
        D = 0.0
        C = 1e-12  # 材料常数
        k = 2.0    # 材料常数
        m = 4.0    # 材料常数
        sigma0 = 100e6  # 参考应力
        
        for stress, n in zip(stress_levels, cycles):
            for i in range(n):
                dD = C * (1 - D) ** k * (stress / sigma0) ** m
                D += dD
                if D >= 1.0:
                    return D
        return D
    
    def _s_n_curve(self, stress):
        """S-N曲线，返回对应应力水平下的疲劳寿命"""
        # 示例S-N曲线参数
        sigma_f = 500e6  # 疲劳强度系数
        b = -0.12        # 疲劳强度指数
        N = (stress / sigma_f) ** (1 / b)
        return N

# 示例：使用Miner法则计算损伤
if __name__ == "__main__":
    # 定义应力水平和循环次数
    stress_levels = [200e6, 180e6, 220e6]
    cycles = [10000, 20000, 5000]
    
    # 创建疲劳损伤模型
    miner_model = FatigueDamageModel(model_type='miner')
    corten_model = FatigueDamageModel(model_type='corten-dolan')
    damage_model = FatigueDamageModel(model_type='damage-mechanics')
    
    # 计算损伤
    damage_miner = miner_model.calculate_damage(stress_levels, cycles)
    damage_corten = corten_model.calculate_damage(stress_levels, cycles)
    damage_mechanics = damage_model.calculate_damage(stress_levels, cycles)
    
    print(f"Miner法则损伤: {damage_miner:.4f}")
    print(f"Corten-Dolan模型损伤: {damage_corten:.4f}")
    print(f"损伤力学模型损伤: {damage_mechanics:.4f}")
    
    # 绘制损伤累积曲线
    plt.figure(figsize=(10, 6))
    
    # 计算不同循环次数下的损伤
    total_cycles = []
    damage_miner_list = []
    damage_corten_list = []
    
    current_cycles = 0
    for stress, n in zip(stress_levels, cycles):
        for i in range(n):
            current_cycles += 1
            total_cycles.append(current_cycles)
            
            # 计算累积损伤
            partial_stress = [stress]
            partial_cycles = [i+1]
            if stress == stress_levels[0]:
                damage_miner_list.append(miner_model.calculate_damage(partial_stress, partial_cycles))
                damage_corten_list.append(corten_model.calculate_damage(partial_stress, partial_cycles))
            else:
                # 累积之前的损伤
                prev_stress = stress_levels[:stress_levels.index(stress)]
                prev_cycles = cycles[:stress_levels.index(stress)]
                prev_damage_miner = miner_model.calculate_damage(prev_stress, prev_cycles)
                prev_damage_corten = corten_model.calculate_damage(prev_stress, prev_cycles)
                
                current_damage_miner = prev_damage_miner + miner_model.calculate_damage(partial_stress, partial_cycles)
                current_damage_corten = prev_damage_corten + corten_model.calculate_damage(partial_stress, partial_cycles)
                
                damage_miner_list.append(current_damage_miner)
                damage_corten_list.append(current_damage_corten)
    
    plt.plot(total_cycles, damage_miner_list, label='Miner法则')
    plt.plot(total_cycles, damage_corten_list, label='Corten-Dolan模型')
    plt.axhline(y=1.0, color='r', linestyle='--', label='失效阈值')
    plt.xlabel('循环次数')
    plt.ylabel('累积损伤')
    plt.title('不同损伤累积模型的比较')
    plt.legend()
    plt.grid(True)
    plt.savefig('损伤累积曲线.png')
    plt.show()

2. 应力寿命方法

2.1 应力寿命方法的基本原理

应力寿命方法（S-N曲线法）是最传统的疲劳寿命预测方法，它通过材料的S-N曲线来预测结构在循环应力作用下的寿命。

S-N曲线是描述应力幅（或最大应力）与疲劳寿命之间关系的曲线，通常在双对数坐标系中呈线性关系。

2.2 S-N曲线的数学表达式

在双对数坐标系中，S-N曲线可以表示为：
$\log N = a - b \log S$

或
$\sigma_f)^{1/b}$

其中，

N 是疲劳寿命（循环次数）
S 是应力幅
\sigma_f 是疲劳强度系数
b 是疲劳强度指数
a 是常数

2.3 影响S-N曲线的因素

材料特性：不同材料的S-N曲线差异很大
应力比：应力比 R = \sigma_{min}/\sigma_{max} 对S-N曲线有显著影响
加载频率：加载频率影响材料的疲劳寿命
环境因素：温度、腐蚀等环境因素会降低材料的疲劳寿命
表面状态：表面粗糙度、残余应力等影响疲劳寿命

2.4 应力寿命方法的应用步骤

确定载荷谱：分析结构所承受的循环载荷
选择S-N曲线：根据材料类型和应力比选择合适的S-N曲线
计算损伤累积：使用Miner法则或其他损伤累积模型计算损伤
预测疲劳寿命：根据损伤累积率预测结构的疲劳寿命

2.5 应力寿命方法的Python实现

import numpy as np
import matplotlib.pyplot as plt

class SNCurve:
    def __init__(self, sigma_f, b, sigma_endurance=None):
        """初始化S-N曲线参数
        
        Args:
            sigma_f: 疲劳强度系数
            b: 疲劳强度指数
            sigma_endurance: 疲劳极限（可选）
        """
        self.sigma_f = sigma_f
        self.b = b
        self.sigma_endurance = sigma_endurance
    
    def get_life(self, stress):
        """根据应力水平计算疲劳寿命
        
        Args:
            stress: 应力幅
        
        Returns:
            life: 疲劳寿命（循环次数）
        """
        if self.sigma_endurance and stress <= self.sigma_endurance:
            return float('inf')  # 无限寿命
        return (stress / self.sigma_f) ** (1 / self.b)
    
    def plot_sn_curve(self, stress_range=None):
        """绘制S-N曲线
        
        Args:
            stress_range: 应力范围（可选）
        """
        if stress_range is None:
            stress_range = [self.sigma_f * 0.1, self.sigma_f]
        
        stresses = np.logspace(np.log10(stress_range[0]), np.log10(stress_range[1]), 100)
        lives = [self.get_life(s) for s in stresses]
        
        plt.figure(figsize=(10, 6))
        plt.loglog(stresses, lives, 'b-', linewidth=2)
        
        if self.sigma_endurance:
            plt.axvline(x=self.sigma_endurance, color='r', linestyle='--', label='疲劳极限')
        
        plt.xlabel('应力幅 (Pa)')
        plt.ylabel('疲劳寿命 (循环次数)')
        plt.title('S-N曲线')
        plt.grid(True, which='both', linestyle='--')
        plt.legend()
        plt.savefig('S-N曲线.png')
        plt.show()

class StressLifeMethod:
    def __init__(self, sn_curve):
        """初始化应力寿命方法
        
        Args:
            sn_curve: S-N曲线对象
        """
        self.sn_curve = sn_curve
    
    def predict_life(self, load_spectrum):
        """根据载荷谱预测疲劳寿命
        
        Args:
            load_spectrum: 载荷谱，格式为[(应力幅1, 循环次数1), (应力幅2, 循环次数2), ...]
        
        Returns:
            life: 预测的疲劳寿命
        """
        total_damage = 0.0
        for stress, cycles in load_spectrum:
            life = self.sn_curve.get_life(stress)
            if life == float('inf'):
                continue
            damage = cycles / life
            total_damage += damage
        
        if total_damage == 0:
            return float('inf')
        
        # 预测寿命 = 1 / (总损伤率)
        return 1 / (total_damage / sum([c for _, c in load_spectrum]))
    
    def calculate_damage(self, load_spectrum):
        """计算载荷谱引起的损伤
        
        Args:
            load_spectrum: 载荷谱
        
        Returns:
            damage: 累积损伤
        """
        total_damage = 0.0
        for stress, cycles in load_spectrum:
            life = self.sn_curve.get_life(stress)
            if life == float('inf'):
                continue
            damage = cycles / life
            total_damage += damage
        return total_damage

# 示例：使用应力寿命方法预测疲劳寿命
if __name__ == "__main__":
    # 定义S-N曲线参数（45号钢）
    sigma_f = 500e6  # 疲劳强度系数
    b = -0.12        # 疲劳强度指数
    sigma_endurance = 200e6  # 疲劳极限
    
    # 创建S-N曲线
    sn_curve = SNCurve(sigma_f, b, sigma_endurance)
    
    # 绘制S-N曲线
    sn_curve.plot_sn_curve()
    
    # 创建应力寿命方法
    sl_method = StressLifeMethod(sn_curve)
    
    # 定义载荷谱
    load_spectrum = [
        (250e6, 1000),  # 应力幅250MPa，1000次循环
        (220e6, 5000),  # 应力幅220MPa，5000次循环
        (200e6, 10000), # 应力幅200MPa，10000次循环
        (180e6, 50000)  # 应力幅180MPa，50000次循环
    ]
    
    # 预测疲劳寿命
    predicted_life = sl_method.predict_life(load_spectrum)
    print(f"预测疲劳寿命: {predicted_life:.0f} 次循环")
    
    # 计算损伤
    damage = sl_method.calculate_damage(load_spectrum)
    print(f"累积损伤: {damage:.4f}")
    
    # 绘制损伤贡献
    stresses = [s for s, _ in load_spectrum]
    cycles = [c for _, c in load_spectrum]
    damages = [c / sn_curve.get_life(s) if sn_curve.get_life(s) != float('inf') else 0 for s, c in load_spectrum]
    
    plt.figure(figsize=(10, 6))
    plt.bar(range(len(stresses)), damages, tick_label=[f"{s/1e6:.0f}MPa" for s in stresses])
    plt.xlabel('应力幅')
    plt.ylabel('损伤贡献')
    plt.title('不同应力水平的损伤贡献')
    plt.grid(True, axis='y')
    plt.savefig('损伤贡献.png')
    plt.show()

3. 应变寿命方法

3.1 应变寿命方法的基本原理

应变寿命方法（ε-N曲线法）是基于材料的应变-寿命关系来预测疲劳寿命的方法，特别适用于低周疲劳（循环次数小于10^4）和塑性变形显著的情况。

应变寿命方法的核心是Manson-Coffin方程，它将总应变幅分解为弹性应变幅和塑性应变幅两部分。

3.2 Manson-Coffin方程

Manson-Coffin方程的数学表达式：
$\Delta\varepsilon_t / 2 = \Delta\varepsilon_e / 2 + \Delta\varepsilon_p / 2 = (\sigma_f' / E)(2N_f)^b + (\varepsilon_f')(2N_f)^c$

其中，

\Delta\varepsilon_t 是总应变幅
\Delta\varepsilon_e 是弹性应变幅
\Delta\varepsilon_p 是塑性应变幅
\sigma_f’ 是疲劳强度系数
\varepsilon_f’ 是疲劳延性系数
b 是疲劳强度指数
c 是疲劳延性指数
E 是弹性模量
N_f 是疲劳寿命

3.3 应变寿命方法的应用步骤

确定应变-寿命曲线：通过试验获得材料的ε-N曲线参数
计算应变幅：根据载荷条件计算结构中的应变幅
预测疲劳寿命：使用Manson-Coffin方程预测疲劳寿命
考虑均值效应：对于有平均应变的情况，需要修正寿命预测

3.4 应变寿命方法的Python实现

import numpy as np
import matplotlib.pyplot as plt

class StrainLifeCurve:
    def __init__(self, sigma_f_prime, epsilon_f_prime, b, c, E):
        """初始化应变-寿命曲线参数
        
        Args:
            sigma_f_prime: 疲劳强度系数
            epsilon_f_prime: 疲劳延性系数
            b: 疲劳强度指数
            c: 疲劳延性指数
            E: 弹性模量
        """
        self.sigma_f_prime = sigma_f_prime
        self.epsilon_f_prime = epsilon_f_prime
        self.b = b
        self.c = c
        self.E = E
    
    def get_life(self, total_strain):
        """根据总应变幅计算疲劳寿命
        
        Args:
            total_strain: 总应变幅
        
        Returns:
            life: 疲劳寿命（循环次数）
        """
        # 使用二分法求解Manson-Coffin方程
        def f(N):
            elastic_strain = (self.sigma_f_prime / self.E) * (2 * N) ** self.b
            plastic_strain = self.epsilon_f_prime * (2 * N) ** self.c
            return (elastic_strain + plastic_strain) - total_strain
        
        # 二分法求解
        left = 1
        right = 1e7
        
        while right - left > 1:
            mid = (left + right) // 2
            if f(mid) > 0:
                left = mid
            else:
                right = mid
        
        return right
    
    def plot_strain_life_curve(self, strain_range=None):
        """绘制应变-寿命曲线
        
        Args:
            strain_range: 应变范围（可选）
        """
        if strain_range is None:
            strain_range = [1e-4, 1e-1]
        
        strains = np.logspace(np.log10(strain_range[0]), np.log10(strain_range[1]), 100)
        lives = [self.get_life(s) for s in strains]
        
        # 计算弹性应变和塑性应变
        elastic_strains = [(self.sigma_f_prime / self.E) * (2 * N) ** self.b for N in lives]
        plastic_strains = [self.epsilon_f_prime * (2 * N) ** self.c for N in lives]
        
        plt.figure(figsize=(10, 6))
        plt.loglog(lives, strains, 'b-', linewidth=2, label='总应变')
        plt.loglog(lives, elastic_strains, 'r--', linewidth=1.5, label='弹性应变')
        plt.loglog(lives, plastic_strains, 'g--', linewidth=1.5, label='塑性应变')
        
        plt.xlabel('疲劳寿命 (循环次数)')
        plt.ylabel('应变幅')
        plt.title('应变-寿命曲线')
        plt.grid(True, which='both', linestyle='--')
        plt.legend()
        plt.savefig('应变-寿命曲线.png')
        plt.show()

class StrainLifeMethod:
    def __init__(self, strain_life_curve):
        """初始化应变寿命方法
        
        Args:
            strain_life_curve: 应变-寿命曲线对象
        """
        self.strain_life_curve = strain_life_curve
    
    def predict_life(self, strain_spectrum):
        """根据应变谱预测疲劳寿命
        
        Args:
            strain_spectrum: 应变谱，格式为[(应变幅1, 循环次数1), (应变幅2, 循环次数2), ...]
        
        Returns:
            life: 预测的疲劳寿命
        """
        total_damage = 0.0
        for strain, cycles in strain_spectrum:
            life = self.strain_life_curve.get_life(strain)
            damage = cycles / life
            total_damage += damage
        
        if total_damage == 0:
            return float('inf')
        
        # 预测寿命 = 1 / (总损伤率)
        return 1 / (total_damage / sum([c for _, c in strain_spectrum]))
    
    def calculate_damage(self, strain_spectrum):
        """计算应变谱引起的损伤
        
        Args:
            strain_spectrum: 应变谱
        
        Returns:
            damage: 累积损伤
        """
        total_damage = 0.0
        for strain, cycles in strain_spectrum:
            life = self.strain_life_curve.get_life(strain)
            damage = cycles / life
            total_damage += damage
        return total_damage

# 示例：使用应变寿命方法预测疲劳寿命
if __name__ == "__main__":
    # 定义应变-寿命曲线参数（45号钢）
    sigma_f_prime = 550e6  # 疲劳强度系数
    epsilon_f_prime = 0.5   # 疲劳延性系数
    b = -0.12              # 疲劳强度指数
    c = -0.5               # 疲劳延性指数
    E = 210e9              # 弹性模量
    
    # 创建应变-寿命曲线
    strain_life_curve = StrainLifeCurve(sigma_f_prime, epsilon_f_prime, b, c, E)
    
    # 绘制应变-寿命曲线
    strain_life_curve.plot_strain_life_curve()
    
    # 创建应变寿命方法
    sl_method = StrainLifeMethod(strain_life_curve)
    
    # 定义应变谱
    strain_spectrum = [
        (0.005, 100),    # 应变幅0.005，100次循环
        (0.003, 1000),   # 应变幅0.003，1000次循环
        (0.002, 5000),   # 应变幅0.002，5000次循环
        (0.001, 20000)   # 应变幅0.001，20000次循环
    ]
    
    # 预测疲劳寿命
    predicted_life = sl_method.predict_life(strain_spectrum)
    print(f"预测疲劳寿命: {predicted_life:.0f} 次循环")
    
    # 计算损伤
    damage = sl_method.calculate_damage(strain_spectrum)
    print(f"累积损伤: {damage:.4f}")
    
    # 绘制损伤贡献
    strains = [s for s, _ in strain_spectrum]
    cycles = [c for _, c in strain_spectrum]
    damages = [c / strain_life_curve.get_life(s) for s, c in strain_spectrum]
    
    plt.figure(figsize=(10, 6))
    plt.bar(range(len(strains)), damages, tick_label=[f"{s:.4f}" for s in strains])
    plt.xlabel('应变幅')
    plt.ylabel('损伤贡献')
    plt.title('不同应变水平的损伤贡献')
    plt.grid(True, axis='y')
    plt.savefig('应变损伤贡献.png')
    plt.show()

4. 疲劳寿命预测的工程应用

4.1 桥梁结构疲劳寿命预测

桥梁结构在车辆荷载作用下会产生循环应力，导致疲劳损伤。疲劳寿命预测对于桥梁的安全评估和维护计划制定至关重要。

主要步骤：

荷载谱分析：收集和分析车辆荷载数据
应力分析：计算桥梁关键部位的应力响应
S-N曲线选择：根据桥梁材料选择合适的S-N曲线
损伤累积计算：使用Miner法则计算损伤
寿命预测：根据损伤累积率预测疲劳寿命

4.2 机械结构疲劳寿命预测

机械结构如发动机、齿轮、轴承等在工作过程中承受循环载荷，容易发生疲劳失效。

主要步骤：

工况分析：分析机械结构的工作工况和载荷条件
有限元分析：计算结构的应力应变分布
应变寿命分析：对于高应力区域使用应变寿命方法
疲劳寿命预测：综合考虑各种载荷条件预测寿命

4.3 航空结构疲劳寿命预测

航空结构对疲劳寿命要求极高，因为疲劳失效可能导致灾难性后果。

主要步骤：

飞行载荷谱分析：收集和分析飞行载荷数据
损伤容限分析：考虑初始缺陷和损伤扩展
疲劳寿命预测：综合考虑多种载荷条件
安全系数设置：设置适当的安全系数确保结构安全

5. 疲劳寿命预测的常见问题与解决方案

5.1 常见问题

载荷谱不确定性：实际载荷谱与设计载荷谱存在差异
材料性能分散性：材料性能存在个体差异
环境因素影响：温度、腐蚀等环境因素加速疲劳损伤
应力集中效应：结构中的应力集中加速疲劳失效
计算模型误差：有限元模型与实际结构存在差异

5.2 解决方案

载荷谱修正：通过实际监测数据修正载荷谱
统计分析：使用统计方法处理材料性能分散性
环境因素考虑：在寿命预测中考虑环境因素的影响
应力集中系数：使用应力集中系数修正局部应力
模型验证：通过试验验证计算模型的准确性

6. 疲劳寿命预测的未来发展

6.1 先进材料的疲劳寿命预测

随着新材料的不断发展，如复合材料、高温合金等，需要开发适用于这些材料的疲劳寿命预测方法。

6.2 多轴疲劳寿命预测

实际结构通常承受多轴载荷，需要开发多轴疲劳寿命预测模型。

6.3 智能疲劳监测与预测

结合传感器技术和人工智能，实现结构疲劳状态的实时监测和预测。

6.4 数字孪生技术在疲劳寿命预测中的应用

利用数字孪生技术，建立结构的数字模型，实时更新模型参数，提高疲劳寿命预测的准确性。

7. 总结与展望

结构疲劳与寿命预测是结构健康监测中的重要内容，对于确保结构的安全运行和合理维护至关重要。通过合理选择疲劳损伤累积模型和寿命预测方法，可以有效地预测结构的疲劳寿命，为结构的设计、维护和管理提供科学依据。

未来，随着计算机技术、传感器技术和人工智能的发展，疲劳寿命预测将向更加智能化、精准化的方向发展。同时，多物理场耦合、多尺度分析等方法的应用，将进一步提高疲劳寿命预测的准确性和可靠性。

通过不断改进疲劳寿命预测方法，我们可以更好地保障结构的安全运行，延长结构的使用寿命，减少维护成本，为工程结构的可持续发展做出贡献。

AtomGit开源社区

AtomGit 是由开放原子开源基金会联合 CSDN 等生态伙伴共同推出的新一代开源与人工智能协作平台。平台坚持“开放、中立、公益”的理念，把代码托管、模型共享、数据集托管、智能体开发体验和算力服务整合在一起，为开发者提供从开发、训练到部署的一站式体验。

更多推荐

扣子编程实战：3天零代码搭出企业级自动化系统

AtomGit开源社区

【负荷预测】基于LSTM-KAN的负荷预测研究（Python代码实现）

LSTM-KAN模型结合了LSTM和注意力机制的特点。LSTM是一种特殊的循环神经网络（RNN），通过引入记忆单元和门控机制（遗忘门、输入门、输出门），有效解决了传统RNN在处理长序列数据时存在的梯度消失或梯度爆炸问题，能够捕捉时间序列数据中的长期依赖关系。而注意力机制则能够模拟人类在处理信息时的注意力分配过程，通过为不同时间步的输入数据分配不同的权重，突出重要信息对预测结果的影响。