507 Ways to Move Series Part 23: Vibration, Noise & Failure Analysis

1. Sources of Gear Vibration

1.1 Transmission Error

Transmission error (TE) is the fundamental source of gear vibration. It is defined as the difference between the actual angular position of the output gear and the position it would occupy if the gear pair were geometrically perfect. In other words, if you expect the output shaft to rotate exactly 1/3 of a revolution for every full revolution of a 3:1 gear pair, transmission error is the micro-deviation from that ideal ratio.

Sources of transmission error include:

• Tooth deflection under load: Teeth bend elastically, changing the effective geometry. This is the dominant source in well-made gears.
• Profile errors: Manufacturing deviations from the theoretical involute curve.
• Pitch errors: Uneven tooth spacing around the gear circumference.
• Runout: Eccentricity of the gear relative to the shaft axis, producing a once-per-revolution modulation.
• Tooth surface roughness: Microscopic irregularities cause high-frequency vibration components.

1.2 Tooth Stiffness Variation

As teeth engage and disengage, the number of tooth pairs sharing the load changes. For a spur gear with contact ratio 1.6, the load alternates between being shared by one pair and two pairs. This produces a periodic stiffness variation at the mesh frequency that excites vibration even in geometrically perfect gears.

1.3 Mesh Frequency & Harmonics

def mesh_frequency(rpm, num_teeth):
    """
    Calculate gear mesh frequency and its harmonics.

    Args:
        rpm: shaft rotational speed
        num_teeth: number of teeth on the gear

    Returns:
        Dictionary with mesh frequency and key harmonics
    """
    f_mesh = rpm * num_teeth / 60  # Hz

    return {
        'shaft_frequency_hz': rpm / 60,
        'mesh_frequency_hz': f_mesh,
        '2x_mesh_hz': 2 * f_mesh,
        '3x_mesh_hz': 3 * f_mesh,
        '4x_mesh_hz': 4 * f_mesh,
        'sideband_spacing_hz': rpm / 60,  # sidebands spaced at shaft frequency
    }

# Example: 1500 RPM pinion with 23 teeth
result = mesh_frequency(1500, 23)
print("Gear Mesh Frequency Analysis:")
for key, val in result.items():
    print(f"  {key}: {val:.1f} Hz")

print(f"\nExpected gear whine pitch: {result['mesh_frequency_hz']:.0f} Hz")
print(f"  (Musical note: approximately "
      f"{'below audible' if result['mesh_frequency_hz'] < 20 else ''}"
      f"{'audible' if 20 <= result['mesh_frequency_hz'] <= 20000 else ''})")

2. Gear Noise

2.1 Whine, Rattle & Hum

Gear noise manifests in three distinct forms, each with different causes and solutions:

In automotive transmissions, gear rattle is a major NVH (Noise, Vibration, Harshness) concern. Unloaded idler gears oscillate within their backlash gap due to torsional vibrations from the engine. Modern solutions include dual-mass flywheels (DMFs) to filter engine torsional pulses before they reach the gearbox, and drag torque devices on idler gears to prevent free oscillation.

2.2 NVH Measurement

Noise measurement in gear systems requires specialized techniques:

• Sound pressure level (SPL): Measured in dB(A) at a standard distance (typically 1 meter from the housing surface). Industrial gearboxes typically range from 75-95 dB(A).
• Sound intensity mapping: Using probe arrays to create spatial maps of noise emission, identifying which housing panels radiate the most sound.
• Order tracking: Synchronizing vibration measurement with shaft rotation to separate speed-dependent (gear) noise from speed-independent (structural) noise.
• Transfer path analysis (TPA): Tracing the vibration path from the gear mesh through shafts, bearings, and housing to identify amplification points.

3. Vibration Measurement & Analysis

3.1 Sensors & Instruments

3.2 Spectrum Analysis (FFT)

The Fast Fourier Transform (FFT) converts time-domain vibration data into a frequency-domain spectrum, revealing the individual frequency components that make up the overall vibration signal:

import math

def simulate_gear_vibration(rpm, num_teeth, num_samples=4096,
                            sample_rate=10000, damage_tooth=None):
    """
    Simulate gear vibration signal with optional tooth damage.

    Args:
        rpm: shaft speed
        num_teeth: number of teeth
        num_samples: FFT length
        sample_rate: samples per second (Hz)
        damage_tooth: if set, simulates a damaged tooth

    Returns:
        Dictionary with time signal and frequency spectrum
    """
    f_shaft = rpm / 60
    f_mesh = f_shaft * num_teeth
    dt = 1.0 / sample_rate

    # Generate time vector
    time = [i * dt for i in range(num_samples)]

    # Build vibration signal
    signal = []
    for t in time:
        # Mesh frequency and harmonics (normal vibration)
        v = 1.0 * math.sin(2 * math.pi * f_mesh * t)
        v += 0.4 * math.sin(2 * math.pi * 2 * f_mesh * t)  # 2x mesh
        v += 0.15 * math.sin(2 * math.pi * 3 * f_mesh * t)  # 3x mesh

        # Add damage modulation if specified
        if damage_tooth is not None:
            # Amplitude modulation at shaft frequency
            modulation = 1 + 0.5 * math.sin(2 * math.pi * f_shaft * t)
            v *= modulation

        # Add random noise
        # Simple pseudo-random using sine of large number
        noise = 0.1 * math.sin(12345.6789 * t * 7919)
        v += noise

        signal.append(v)

    # Simple DFT magnitude (simplified -- real applications use FFT library)
    freq_resolution = sample_rate / num_samples
    frequencies = [i * freq_resolution for i in range(num_samples // 2)]

    print(f"Vibration Analysis Results:")
    print(f"  Shaft speed: {rpm} RPM ({f_shaft:.1f} Hz)")
    print(f"  Mesh frequency: {f_mesh:.1f} Hz")
    print(f"  2x mesh: {2*f_mesh:.1f} Hz")
    print(f"  3x mesh: {3*f_mesh:.1f} Hz")
    print(f"  Frequency resolution: {freq_resolution:.2f} Hz")

    if damage_tooth:
        print(f"\n  DAMAGE DETECTED: Sidebands expected at:")
        for n in range(1, 4):
            print(f"    {f_mesh:.1f} +/- {n}x{f_shaft:.1f} = "
                  f"{f_mesh - n*f_shaft:.1f} / {f_mesh + n*f_shaft:.1f} Hz")

    return {'time': time, 'signal': signal, 'frequencies': frequencies}

# Healthy gearbox
print("=== HEALTHY GEARBOX ===")
simulate_gear_vibration(1500, 23)

print("\n=== DAMAGED TOOTH ===")
simulate_gear_vibration(1500, 23, damage_tooth=True)

3.3 Natural Frequency & Resonance Avoidance

Every gear system has natural frequencies determined by its mass and stiffness distribution. When a mesh frequency harmonic coincides with a structural natural frequency, resonance amplifies vibration dramatically -- potentially by factors of 10x to 100x. Resonance avoidance is a critical aspect of gearbox design.

Methods for resonance avoidance include:

• Campbell diagram: Plot mesh frequency harmonics versus speed, overlaid with structural natural frequencies. Operating speed ranges must avoid intersection points.
• Stiffening the housing: Raising natural frequencies above the excitation range by adding ribs or increasing wall thickness.
• Damping treatments: Constrained-layer damping on housing panels, viscoelastic mounts, or tuned mass dampers for specific resonances.
• Tooth number selection: Choosing tooth numbers that place mesh frequencies away from structural resonances. Hunting tooth combinations (no common factors between pinion and gear tooth numbers) distribute wear evenly but don't inherently avoid resonance.

4. Gear Tooth Failure Modes

4.1 Bending Fatigue

Bending fatigue is the most common failure mode in well-designed gear systems. A crack initiates at the root fillet (the radius at the base of the tooth, which is the point of maximum tensile stress), propagates through the tooth root, and eventually causes complete tooth fracture.

• Initiation site: The root fillet on the tension side of the loaded tooth, typically at the 30-degree tangent point.
• Propagation: Crack grows under cyclic loading following Paris' law: da/dN = C * (delta_K)^m, where da/dN is crack growth rate and delta_K is stress intensity range.
• Fracture: When the remaining cross-section cannot support the load, catastrophic fracture occurs. Fracture surfaces show characteristic beach marks (fatigue progression lines) and a final overload zone.
• Prevention: Shot peening the root fillet (introduces compressive residual stress), generous root radius, case hardening, proper design stress below the endurance limit.

4.2 Pitting (Surface Contact Fatigue)

Pitting is surface fatigue caused by repeated Hertzian contact stress exceeding the material's surface endurance limit. Subsurface cracks initiate at the depth of maximum shear stress (approximately 0.4 times the contact half-width below the surface), propagate to the surface, and release small particles of material, leaving characteristic craters.

4.3 Scuffing & Scoring

Scuffing (also called scoring) is an adhesive wear failure caused by breakdown of the lubricant film between tooth surfaces. When metal-to-metal contact occurs at high sliding velocities, instantaneous welding and tearing of surface asperities produces characteristic radial scratches aligned with the sliding direction.

Scuffing risk factors:

• High sliding velocity (especially near tooth tips/roots where sliding is maximum)
• Inadequate lubricant viscosity or EP additive concentration
• High contact temperature (flash temperature theory by Blok)
• New gears during break-in (before surfaces conform)
• Sudden load increases or speed changes

4.4 Wear Modes

5. Gear Stress Analysis

5.1 Lewis Bending Stress Equation

Wilfred Lewis published his gear tooth bending stress equation in 1892, and it remains the foundation of modern gear rating. The Lewis equation treats the gear tooth as a cantilever beam loaded at the tip:

import math

def lewis_bending_stress(torque_nm, module, face_width,
                         num_teeth, lewis_form_factor):
    """
    Calculate Lewis bending stress at the gear tooth root.

    Lewis equation: sigma_b = Wt / (F * m * Y)

    Args:
        torque_nm: transmitted torque (N*m)
        module: gear module (mm)
        face_width: face width (mm)
        num_teeth: number of teeth
        lewis_form_factor: Lewis form factor Y (dimensionless)

    Returns:
        Dictionary with stress results
    """
    # Pitch radius
    r = num_teeth * module / 2  # mm

    # Tangential force
    Wt = torque_nm * 1000 / r  # N (torque in N*mm / radius in mm)

    # Lewis bending stress
    sigma_b = Wt / (face_width * module * lewis_form_factor)  # MPa

    return {
        'tangential_force_N': Wt,
        'bending_stress_MPa': sigma_b,
        'pitch_radius_mm': r
    }

# Lewis Form Factors (20-degree pressure angle, full-depth)
lewis_Y = {
    12: 0.245, 14: 0.276, 16: 0.296, 18: 0.309,
    20: 0.322, 25: 0.340, 30: 0.359, 35: 0.373,
    40: 0.389, 50: 0.408, 60: 0.422, 75: 0.435,
    100: 0.447, 150: 0.460, 200: 0.463, 300: 0.471,
}

print("Lewis Form Factors (20-deg PA, full-depth):")
print("-" * 40)
for z, Y in lewis_Y.items():
    print(f"  Z = {z:>3} teeth: Y = {Y:.3f}")

# Example calculation
print("\nExample: 100 Nm torque, module 3, face width 30mm, 25 teeth")
result = lewis_bending_stress(100, 3, 30, 25, lewis_Y[25])
for key, val in result.items():
    print(f"  {key}: {val:.2f}")

5.2 Hertzian Contact Stress (AGMA Rating)

While Lewis covers bending, the Hertzian contact stress equation governs surface durability (pitting resistance). The contact stress between two cylinders (approximating gear teeth) is:

import math

def hertzian_contact_stress(Wt, face_width, r1, r2,
                            E1=207000, E2=207000,
                            nu1=0.3, nu2=0.3,
                            pressure_angle_deg=20):
    """
    Calculate Hertzian contact stress between gear teeth.

    Args:
        Wt: tangential force (N)
        face_width: gear face width (mm)
        r1, r2: pitch radii (mm)
        E1, E2: elastic moduli (MPa)
        nu1, nu2: Poisson's ratios
        pressure_angle_deg: pressure angle (degrees)

    Returns:
        Dictionary with contact stress results
    """
    phi = math.radians(pressure_angle_deg)

    # Normal force
    Wn = Wt / math.cos(phi)

    # Equivalent radius of curvature at pitch point
    rho1 = r1 * math.sin(phi)  # radius of curvature, pinion
    rho2 = r2 * math.sin(phi)  # radius of curvature, gear
    rho_eq = (rho1 * rho2) / (rho1 + rho2)  # equivalent radius

    # Equivalent elastic modulus
    E_star = 1 / ((1 - nu1**2) / E1 + (1 - nu2**2) / E2)

    # Hertzian contact stress (cylinder on cylinder)
    sigma_H = math.sqrt(Wn * E_star / (2 * math.pi * face_width * rho_eq))

    # Contact half-width
    a = math.sqrt(2 * Wn * rho_eq / (math.pi * face_width * E_star))

    return {
        'normal_force_N': Wn,
        'equivalent_radius_mm': rho_eq,
        'contact_stress_MPa': sigma_H,
        'contact_half_width_mm': a,
        'max_subsurface_shear_depth_mm': 0.4 * a
    }

# Example: 20T/60T, module 4, 200 Nm torque
r1, r2 = 40, 120  # mm
Wt = 200 * 1000 / r1  # N
result = hertzian_contact_stress(Wt, 40, r1, r2)

print("Hertzian Contact Stress Analysis:")
for key, val in result.items():
    print(f"  {key}: {val:.2f}")

5.3 S-N Curves for Gear Steels

S-N (stress vs number of cycles to failure) curves define the fatigue strength of gear materials:

6. Condition Monitoring & Predictive Maintenance

6.1 Vibration Signature Analysis

Modern condition monitoring systems track vibration signatures over time, looking for changes that indicate developing faults:

6.2 Oil Analysis & Thermal Imaging

Complementary condition monitoring techniques strengthen the diagnostic picture:

• Oil analysis (ferrography): Examines wear particles in lubricant. Particle size, shape, material, and concentration indicate the type and severity of wear. Normal operation produces small (<5 micrometer) particles. Abnormal wear produces larger particles with characteristic shapes (cutting chips = abrasive wear, platelets = fatigue, spheres = rolling contact fatigue).
• Spectrometric oil analysis (SOAP): Detects dissolved metals in oil. Elevated iron indicates gear/shaft wear; elevated copper indicates bronze component wear; elevated silicon indicates dirt ingress.
• Thermal imaging (infrared): Identifies hot spots on gearbox housings that indicate localized friction, bearing problems, or cooling system failures. Temperature differentials of more than 10-15 degrees C across a housing surface warrant investigation.
• Acoustic emission (AE): Ultra-high-frequency stress waves from crack propagation and surface damage. AE monitoring can detect micro-cracking before it becomes visible in vibration spectra.

7. Case Studies

8. Python Gear Stress Calculator

"""
Comprehensive Gear Stress & Vibration Analysis Tool
====================================================
Combines Lewis bending, Hertzian contact, and vibration analysis.
"""
import math

class GearStressAnalyzer:
    """Complete gear stress and vibration analysis."""

    # Lewis form factors for 20-degree PA, full-depth teeth
    LEWIS_Y = {
        12: 0.245, 14: 0.276, 16: 0.296, 18: 0.309,
        20: 0.322, 22: 0.331, 24: 0.337, 25: 0.340,
        28: 0.353, 30: 0.359, 34: 0.371, 36: 0.377,
        40: 0.389, 45: 0.399, 50: 0.408, 60: 0.422,
        75: 0.435, 100: 0.447, 150: 0.460, 300: 0.471,
    }

    def __init__(self, module, z1, z2, face_width,
                 torque_nm, rpm_pinion, pressure_angle_deg=20):
        self.m = module
        self.z1 = z1
        self.z2 = z2
        self.b = face_width
        self.T = torque_nm
        self.rpm = rpm_pinion
        self.phi = math.radians(pressure_angle_deg)

        self.r1 = z1 * module / 2
        self.r2 = z2 * module / 2
        self.Wt = torque_nm * 1000 / self.r1  # tangential force, N

    def get_lewis_Y(self, z):
        """Interpolate Lewis form factor."""
        keys = sorted(self.LEWIS_Y.keys())
        if z in self.LEWIS_Y:
            return self.LEWIS_Y[z]
        for i in range(len(keys) - 1):
            if keys[i] < z < keys[i+1]:
                # Linear interpolation
                Y1, Y2 = self.LEWIS_Y[keys[i]], self.LEWIS_Y[keys[i+1]]
                frac = (z - keys[i]) / (keys[i+1] - keys[i])
                return Y1 + frac * (Y2 - Y1)
        return self.LEWIS_Y[keys[-1]]

    def lewis_stress(self):
        """Calculate Lewis bending stress for both gears."""
        Y1 = self.get_lewis_Y(self.z1)
        Y2 = self.get_lewis_Y(self.z2)

        sigma1 = self.Wt / (self.b * self.m * Y1)
        sigma2 = self.Wt / (self.b * self.m * Y2)

        return {
            'pinion_bending_MPa': sigma1,
            'gear_bending_MPa': sigma2,
            'pinion_Y': Y1,
            'gear_Y': Y2,
            'critical_gear': 'pinion' if sigma1 > sigma2 else 'gear'
        }

    def hertzian_stress(self, E=207000, nu=0.3):
        """Calculate Hertzian contact stress at pitch point."""
        Wn = self.Wt / math.cos(self.phi)
        rho1 = self.r1 * math.sin(self.phi)
        rho2 = self.r2 * math.sin(self.phi)
        rho_eq = (rho1 * rho2) / (rho1 + rho2)
        E_star = E / (2 * (1 - nu**2))

        sigma_H = math.sqrt(Wn * E_star / (2 * math.pi * self.b * rho_eq))

        return {
            'contact_stress_MPa': sigma_H,
            'equivalent_radius_mm': rho_eq,
            'normal_force_N': Wn
        }

    def mesh_frequencies(self):
        """Calculate mesh frequency and key harmonics."""
        f_shaft = self.rpm / 60
        f_mesh = f_shaft * self.z1

        return {
            'shaft_freq_Hz': f_shaft,
            'mesh_freq_Hz': f_mesh,
            'mesh_2x_Hz': 2 * f_mesh,
            'mesh_3x_Hz': 3 * f_mesh,
        }

    def full_report(self):
        """Generate comprehensive analysis report."""
        print("=" * 65)
        print("  GEAR STRESS & VIBRATION ANALYSIS REPORT")
        print("=" * 65)

        print(f"\n  INPUT PARAMETERS:")
        print(f"    Module: {self.m} mm | Teeth: {self.z1}T / {self.z2}T")
        print(f"    Face width: {self.b} mm | Torque: {self.T} Nm")
        print(f"    Pinion speed: {self.rpm} RPM")
        print(f"    Tangential force: {self.Wt:.1f} N")

        lewis = self.lewis_stress()
        print(f"\n  LEWIS BENDING STRESS:")
        print(f"    Pinion: {lewis['pinion_bending_MPa']:.1f} MPa (Y={lewis['pinion_Y']:.3f})")
        print(f"    Gear:   {lewis['gear_bending_MPa']:.1f} MPa (Y={lewis['gear_Y']:.3f})")
        print(f"    Critical: {lewis['critical_gear']}")

        hertz = self.hertzian_stress()
        print(f"\n  HERTZIAN CONTACT STRESS:")
        print(f"    Contact stress: {hertz['contact_stress_MPa']:.1f} MPa")
        print(f"    Normal force: {hertz['normal_force_N']:.1f} N")

        freq = self.mesh_frequencies()
        print(f"\n  VIBRATION FREQUENCIES:")
        print(f"    Shaft: {freq['shaft_freq_Hz']:.1f} Hz")
        print(f"    Mesh: {freq['mesh_freq_Hz']:.1f} Hz")
        print(f"    2x mesh: {freq['mesh_2x_Hz']:.1f} Hz")
        print(f"    3x mesh: {freq['mesh_3x_Hz']:.1f} Hz")

        print("=" * 65)

# Run analysis
analyzer = GearStressAnalyzer(
    module=3, z1=20, z2=60, face_width=40,
    torque_nm=150, rpm_pinion=1500
)
analyzer.full_report()

9. Exercises & Self-Assessment

Conclusion & Next Steps

In this article, we explored the critical diagnostic sciences of gear engineering:

• Transmission error is the root cause of gear vibration, arising from tooth deflection, profile errors, and pitch errors. Tooth stiffness variation produces periodic excitation at mesh frequency even in perfect gears.
• Gear noise manifests as whine (mesh frequency tonal), rattle (backlash impacts), and hum (bearing/shaft sources), each requiring different mitigation strategies.
• Failure modes include bending fatigue (root fillet cracks), pitting (surface contact fatigue), scuffing (lubricant film breakdown), and various wear mechanisms. Each produces characteristic fracture surfaces and vibration signatures.
• Lewis bending stress and Hertzian contact stress provide the quantitative foundation for gear rating per AGMA and ISO standards.
• Condition monitoring through vibration analysis, oil analysis, and thermal imaging enables predictive maintenance that prevents catastrophic failures and extends gearbox service life.