Applications: Thermal Analysis

Learning Objectives

By the end of this section, you will be able to:

1. Apply the heat equation to real-world engineering problems in electronics, buildings, and industrial systems
2. Design heat sinks using fin efficiency analysis and thermal resistance networks
3. Calculate heat loss through building walls and pipe insulation using R-values and U-values
4. Understand the concept of critical radius in cylindrical insulation
5. Interpret thermal images using Stefan-Boltzmann law and Gaussian heat distribution
6. Connect steady-state thermal analysis to machine learning applications like CNNs for thermal imaging
7. Implement finite difference methods for 2D thermal analysis in Python

The Big Picture: Heat Equation in Practice

"The laws of physics do not care about engineering conventions — they only care about energy balance."

The heat equation is not just a mathematical curiosity. It forms the foundation for some of the most critical engineering analyses performed today:

The Three Modes of Heat Transfer

Before diving into applications, let's review the three fundamental mechanisms by which heat moves:

1. Conduction

Heat transfer through a stationary medium via molecular vibrations. Governed by Fourier's Law:

The thermal conductivity $k$ varies enormously across materials:

2. Convection

Heat transfer between a surface and moving fluid. Described by Newton's Law of Cooling:

The convection coefficient $h$ depends on fluid motion:

3. Radiation

Heat transfer via electromagnetic waves (photons). Governed by the Stefan-Boltzmann Law:

where $\sigma = 5.67 \times 10^{-8}$ W/(m²·K&sup4;) and $\epsilon$ is emissivity (0-1).

Electronics Thermal Management

Modern processors pack billions of transistors into tiny areas, creating heat fluxes rivaling nuclear reactors. The thermal management challenge is extreme:

Thermal Resistance Networks

Just like electrical circuits, heat flow through a thermal system can be modeled as resistances in series and parallel:

For series resistances (layers in sequence):

The junction temperature is then:

Heat Sink Design and Fin Efficiency

Heat sinks extend surface area using fins to enhance convective cooling. But there's a catch: heat must conduct through the fin to reach the outer portions, and temperature drops along the way.

The Fin Equation

Consider a thin rectangular fin of length L extending from a base at temperature T_b. The governing equation (steady-state heat equation with convection loss) is:

where P is the fin perimeter and A_c is its cross-sectional area.

Fin Efficiency

The fin efficiency η compares actual heat transfer to the ideal case where the entire fin is at base temperature:

This efficiency decreases as fins get taller because heat cannot reach the tip effectively:

PCB Thermal Management

Printed circuit boards present a 2D thermal challenge. Multiple heat sources (CPU, GPU, voltage regulators) interact through the board material. The steady-state temperature distribution satisfies:

where q'''(x,y) is the local heat generation rate (W/m³).

Thermal Vias

PCB FR-4 material is a poor thermal conductor (k ≈ 0.3 W/m·K). To improve heat spreading, designers add thermal vias — copper-plated holes that conduct heat vertically through the board.

Building Thermal Analysis

Buildings are complex thermal systems where the heat equation governs energy flow through walls, windows, and roofs. The goal is to minimize heating and cooling energy while maintaining comfort.

R-Values and U-Values

The R-value (thermal resistance) measures how well a material resists heat flow:

For multiple layers, R-values add in series:

The U-value (thermal transmittance) is the inverse of total R-value:

Temperature Profile Through a Wall

In steady state, the heat equation through a planar wall reduces to:

The temperature varies linearly through each homogeneous layer, with the slope proportional to heat flux divided by conductivity.

Pipe Insulation and Critical Radius

Heat flow through cylindrical geometries (pipes, wires) follows a different pattern than planar walls. The steady-state temperature distribution is:

The temperature profile is logarithmic, not linear! The thermal resistance of a cylindrical layer is:

The Critical Radius

Here's a counterintuitive result: for small-diameter pipes, adding insulation can actually increase heat loss! This happens because the outer surface area grows faster than the thermal resistance.

The critical radius is:

For r < r_crit, adding insulation increases heat loss. For r > r_crit, insulation reduces heat loss as expected.

Engine Thermal Management

Internal combustion engines present extreme thermal challenges. Combustion reaches 2000-2500°C, but cylinder walls must stay below ~200°C to prevent material failure and oil breakdown.

Heat Flow Path

Heat generated in the combustion chamber flows through several resistances:

1. Combustion gases → cylinder wall: Convection with h ≈ 200-500 W/(m²·K)
2. Through cylinder wall: Conduction through cast iron or aluminum
3. Cylinder wall → coolant: Forced convection with h ≈ 5,000-10,000 W/(m²·K)
4. Coolant → radiator tubes: Internal forced convection
5. Radiator tubes → air: External forced convection (fan + vehicle motion)

The Thermostat's Role

Engine efficiency depends on operating temperature. Cold engines run rich (more fuel) and have higher friction. The thermostat blocks coolant flow until the engine reaches optimal temperature (~90°C), then modulates flow to maintain it.

Thermal Imaging and the Stefan-Boltzmann Law

Thermal cameras detect infrared radiation emitted by objects according to the Stefan-Boltzmann law:

This fourth-power dependence makes thermal imaging highly sensitive: a 10% temperature increase (in Kelvin) results in ~46% more radiation.

Applications

Temperature Distribution

In many thermal imaging scenarios, heat sources create temperature distributions that follow the steady-state heat equation. Away from localized sources, the solution to ∇²T = 0 produces smooth temperature gradients that the heat kernel characterizes.

For a point heat source, the steady-state temperature in 2D decays as:

In 3D, it decays as 1/r (like gravity or electrostatics). The heat kernel solution gives Gaussian-like profiles for transient problems.

Machine Learning Connections

Thermal analysis intersects with machine learning in several important ways:

1. CNNs for Thermal Image Analysis

Convolutional neural networks excel at thermal image classification:

• Predictive maintenance: Detecting hot spots in electrical equipment before failure
• Medical diagnosis: Identifying inflammation patterns in thermography
• Building inspection: Automatic detection of insulation gaps and air leaks

2. Physics-Informed Neural Networks (PINNs)

PINNs solve PDEs by embedding the heat equation directly into the loss function:

where $\mathcal{L}_\text{physics} = \left\| \frac{\partial u}{\partial t} - \alpha \nabla^2 u \right\|^2$

3. Surrogate Models for Optimization

Full thermal simulations are computationally expensive. ML models trained on simulation data can provide rapid predictions for:

• Heat sink geometry optimization
• Thermal interface material selection
• Building energy modeling

Python Implementation

2D Finite Difference Solver

1import numpy as np
2import matplotlib.pyplot as plt
3
4def solve_2d_heat_equation(Lx, Ly, nx, ny, k, q_gen, T_boundary, tol=1e-6, max_iter=10000):
5    """
6    Solve steady-state 2D heat equation using finite differences.
7
8    The governing equation:
9    ∇²T = -q_gen/k
10
11    Discretized using central differences:
12    (T[i+1,j] - 2T[i,j] + T[i-1,j])/dx² +
13    (T[i,j+1] - 2T[i,j] + T[i,j-1])/dy² = -q_gen/k
14    """
15    dx = Lx / (nx - 1)
16    dy = Ly / (ny - 1)
17
18    # Initialize temperature field
19    T = np.ones((ny, nx)) * T_boundary
20
21    # Source term (heat generation)
22    source = q_gen / k
23
24    # Gauss-Seidel iteration
25    for iteration in range(max_iter):
26        T_old = T.copy()
27
28        # Update interior points
29        for i in range(1, ny - 1):
30            for j in range(1, nx - 1):
31                T[i, j] = (
32                    (T[i+1, j] + T[i-1, j]) / dx**2 +
33                    (T[i, j+1] + T[i, j-1]) / dy**2 +
34                    source[i, j]
35                ) / (2/dx**2 + 2/dy**2)
36
37        # Check convergence
38        max_change = np.max(np.abs(T - T_old))
39        if max_change < tol:
40            print(f"Converged in {iteration} iterations")
41            break
42
43    return T
44
45# Example: CPU die with non-uniform heat generation
46Lx, Ly = 0.01, 0.01  # 1cm x 1cm die
47nx, ny = 50, 50
48k = 150  # Silicon conductivity (W/m·K)
49T_boundary = 50  # °C (heat sink temperature)
50
51# Non-uniform heat generation (hot spots)
52q_gen = np.zeros((ny, nx))
53q_gen[15:25, 15:25] = 1e8  # Core (100 W/cm³)
54q_gen[30:40, 25:35] = 5e7  # Cache (50 W/cm³)
55
56# Solve
57T = solve_2d_heat_equation(Lx, Ly, nx, ny, k, q_gen, T_boundary)
58
59# Visualize
60x = np.linspace(0, Lx*1000, nx)  # Convert to mm
61y = np.linspace(0, Ly*1000, ny)
62X, Y = np.meshgrid(x, y)
63
64plt.figure(figsize=(10, 4))
65
66plt.subplot(1, 2, 1)
67plt.contourf(X, Y, q_gen/1e6, cmap='hot', levels=20)
68plt.colorbar(label='Heat Generation (MW/m³)')
69plt.xlabel('x (mm)')
70plt.ylabel('y (mm)')
71plt.title('Heat Source Distribution')
72
73plt.subplot(1, 2, 2)
74plt.contourf(X, Y, T, cmap='hot', levels=20)
75plt.colorbar(label='Temperature (°C)')
76plt.xlabel('x (mm)')
77plt.ylabel('y (mm)')
78plt.title(f'Temperature Distribution\nMax: {T.max():.1f}°C')
79
80plt.tight_layout()
81plt.show()

Thermal Resistance Network

1import numpy as np
2
3def thermal_resistance_network(layers, h_inside, h_outside, T_inside, T_outside, A):
4    """
5    Calculate heat transfer through a composite wall using
6    the thermal resistance network method.
7
8    R_total = 1/(h_in*A) + Σ(L_i/(k_i*A)) + 1/(h_out*A)
9    Q = ΔT / R_total
10    """
11    # Convection resistances
12    R_conv_in = 1 / (h_inside * A)
13    R_conv_out = 1 / (h_outside * A)
14
15    # Conduction resistances for each layer
16    R_cond = []
17    for layer in layers:
18        R = layer['thickness'] / (layer['k'] * A)
19        R_cond.append(R)
20
21    R_total = R_conv_in + sum(R_cond) + R_conv_out
22
23    # Heat transfer rate
24    Q = (T_inside - T_outside) / R_total
25
26    # Calculate interface temperatures
27    temperatures = [T_inside]
28    T_current = T_inside
29
30    # Temperature drop at inside surface
31    T_current -= Q * R_conv_in
32    temperatures.append(T_current)
33
34    # Temperature through each layer
35    for R in R_cond:
36        T_current -= Q * R
37        temperatures.append(T_current)
38
39    return {
40        'Q': Q,
41        'R_total': R_total,
42        'U_value': 1 / (R_total * A),  # Overall heat transfer coefficient
43        'temperatures': temperatures
44    }
45
46# Example: Building wall analysis
47A = 1.0  # m² (per unit area)
48h_inside = 10    # W/(m²·K) - natural convection
49h_outside = 25   # W/(m²·K) - wind convection
50
51layers = [
52    {'name': 'Drywall', 'thickness': 0.013, 'k': 0.16},
53    {'name': 'Insulation', 'thickness': 0.1, 'k': 0.04},
54    {'name': 'Plywood', 'thickness': 0.012, 'k': 0.12},
55    {'name': 'Brick', 'thickness': 0.1, 'k': 0.72},
56]
57
58T_inside = 21   # °C
59T_outside = -5  # °C
60
61result = thermal_resistance_network(layers, h_inside, h_outside, T_inside, T_outside, A)
62
63print("Thermal Resistance Network Analysis")
64print("=" * 50)
65print(f"Heat loss rate: {result['Q']:.2f} W/m²")
66print(f"Total R-value: {result['R_total']:.3f} m²·K/W")
67print(f"U-value: {result['U_value']:.3f} W/(m²·K)")
68print()
69print("Temperature Profile:")
70print(f"  Inside air: {result['temperatures'][0]:.1f}°C")
71print(f"  Inside surface: {result['temperatures'][1]:.1f}°C")
72for i, layer in enumerate(layers):
73    print(f"  After {layer['name']}: {result['temperatures'][i+2]:.1f}°C")

Fin Efficiency Analysis

1import numpy as np
2import matplotlib.pyplot as plt
3
4def fin_efficiency(h, k, P, A_c, L):
5    """
6    Calculate efficiency of a straight fin with adiabatic tip.
7
8    The fin parameter m = sqrt(hP/(kA_c)) characterizes the
9    balance between convective heat loss and conductive supply.
10
11    Fin efficiency η = tanh(mL)/(mL)
12
13    As L increases, η decreases because heat can't reach the tip.
14    """
15    m = np.sqrt(h * P / (k * A_c))
16    mL = m * L
17
18    # Prevent division by zero
19    if mL < 0.01:
20        return 1.0
21
22    eta = np.tanh(mL) / mL
23    return eta
24
25def optimize_heat_sink(base_area, n_fins, fin_thickness, fin_height, k, h):
26    """
27    Analyze a heat sink with n parallel rectangular fins.
28
29    Trade-offs:
30    - More fins → more surface area, but less spacing
31    - Taller fins → more area, but lower efficiency
32    - Thicker fins → better conduction, but less total fins
33    """
34    fin_spacing = (base_area / n_fins) - fin_thickness
35
36    if fin_spacing < 0.001:  # Minimum 1mm spacing
37        return None
38
39    # Fin geometry
40    P = 2 * (fin_thickness + base_area / n_fins)  # Perimeter
41    A_c = fin_thickness * (base_area / n_fins)    # Cross-section
42    A_fin = P * fin_height / 2                     # Surface area (one fin)
43
44    eta = fin_efficiency(h, k, P, A_c, fin_height)
45
46    # Total heat transfer
47    # Q = h * (A_base + n * η * A_fin) * ΔT
48    A_base = base_area - n_fins * fin_thickness * base_area / n_fins
49    A_effective = A_base + n_fins * eta * A_fin
50
51    return {
52        'efficiency': eta,
53        'A_effective': A_effective,
54        'spacing': fin_spacing * 1000,  # mm
55        'thermal_resistance': 1 / (h * A_effective)
56    }
57
58# Optimization study
59k_aluminum = 200  # W/(m·K)
60h_forced = 50     # W/(m²·K) - forced convection
61base_area = 0.01  # m² (10cm x 10cm base)
62
63print("Heat Sink Optimization Study")
64print("=" * 60)
65print(f"{'Fins':<8} {'Height(mm)':<12} {'η (%)':<10} {'Spacing(mm)':<12} {'R (K/W)':<10}")
66print("-" * 60)
67
68for n_fins in [10, 20, 30, 50]:
69    for height in [0.01, 0.02, 0.03, 0.05]:  # 10-50mm
70        result = optimize_heat_sink(
71            base_area, n_fins, 0.002, height, k_aluminum, h_forced
72        )
73        if result:
74            print(f"{n_fins:<8} {height*1000:<12.0f} {result['efficiency']*100:<10.1f} "
75                  f"{result['spacing']:<12.2f} {result['thermal_resistance']:<10.3f}")

Common Pitfalls

Test Your Understanding

Summary

We've seen how the heat equation becomes practical engineering formulas for thermal design. The key concepts bridge abstract mathematics to real-world applications.

Key Equations

Key Takeaways

1. Thermal resistance networks simplify complex systems into series and parallel combinations, analogous to electrical circuits
2. Fin efficiency decreases with height because heat cannot conduct to the outer portions; optimal design balances area versus efficiency
3. Cylindrical heat transfer has logarithmic temperature profiles and the counterintuitive critical radius effect
4. Biot number determines whether internal temperature gradients matter (Bi > 0.1) or can be ignored (Bi < 0.1)
5. Thermal imaging relies on the T&sup4; dependence of radiation, making it highly sensitive to temperature differences
6. Steady-state analysis (∇²T = -q/k) is often sufficient for design; transient analysis adds complexity but is needed for time-dependent problems
7. Machine learning complements traditional analysis through surrogate models, image classification, and physics-informed neural networks

Coming Next: In the next section, we'll explore how the heat equation applies to biological systems, from cell membrane diffusion to drug delivery and neural signal propagation.