thermal-analysis

Thermal Analysis Skill

Electronic system thermal modeling and analysis for reliable component operation.

Purpose

This skill provides comprehensive capabilities for thermal analysis of electronic systems, from component-level junction temperature calculations to system-level thermal management design. It supports heat sink selection, thermal interface material evaluation, and safe operating area verification.

Capabilities

Junction-to-Ambient Thermal Resistance

• Thermal resistance network modeling
• Junction-to-case (theta_jc) calculations
• Case-to-sink (theta_cs) with TIM analysis
• Sink-to-ambient (theta_sa) characterization
• Total thermal path analysis

Heat Sink Selection and Optimization

• Natural convection heat sink sizing
• Forced convection performance estimation
• Fin optimization for given constraints
• Heat sink comparison and selection
• Custom heat sink specification
• Mounting and interface considerations

Forced Convection Analysis

• Fan airflow requirements calculation
• Pressure drop through enclosures
• Flow impedance matching
• Thermal resistance vs airflow curves
• Fan operating point determination

PCB Thermal Analysis

• Copper spreading resistance calculation
• Via thermal conductivity
• Multi-layer board thermal modeling
• Hot spot identification
• Thermal relief pad analysis

Thermal Interface Material Selection

• TIM thermal conductivity requirements
• Contact resistance estimation
• Phase change vs thermal grease vs gap pads
• Bond line thickness effects
• Long-term reliability considerations

Transient Thermal Analysis

• Thermal time constant determination
• Pulse power handling
• Foster and Cauer RC network models
• Transient thermal impedance curves
• Peak temperature prediction

Safe Operating Area Verification

• SOA curve interpretation
• DC and pulsed operation limits
• Secondary breakdown considerations
• Thermal runaway detection
• Derating for reliability

Derating Curve Application

• Temperature-based power derating
• Maximum junction temperature limits
• Reliability vs performance tradeoffs
• Component-specific derating guidelines

CFD Simulation Setup Guidance

• Boundary condition definition
• Mesh requirements for electronics
• Turbulence model selection
• Radiation modeling considerations
• Results validation approaches

Prerequisites

Installation

pip install numpy scipy matplotlib pandas

Optional Dependencies

# For advanced thermal modeling
pip install CoolProp  # Fluid properties

# For optimization
pip install scipy

# For visualization
pip install plotly

Usage Patterns

Thermal Resistance Network Analysis

import numpy as np
from dataclasses import dataclass
from typing import List, Optional

@dataclass
class ThermalComponent:
    """Represents a thermal resistance element"""
    name: str
    theta: float  # Thermal resistance (C/W)
    power: float = 0.0  # Power dissipation (W)

class ThermalNetwork:
    """1D thermal resistance network for electronics"""

    def __init__(self):
        self.components: List[ThermalComponent] = []
        self.ambient_temp = 25.0  # Celsius

    def add_resistance(self, name: str, theta: float, power: float = 0.0):
        self.components.append(ThermalComponent(name, theta, power))

    def calculate_temperatures(self, total_power: float) -> dict:
        """Calculate temperature at each node"""
        temperatures = {'ambient': self.ambient_temp}
        current_temp = self.ambient_temp

        # Work from ambient back to junction
        for comp in reversed(self.components):
            delta_t = total_power * comp.theta
            current_temp += delta_t
            temperatures[comp.name] = current_temp

        return temperatures

    def total_thermal_resistance(self) -> float:
        return sum(c.theta for c in self.components)

    def max_power_for_tj(self, tj_max: float) -> float:
        """Calculate max power for given junction temperature"""
        theta_ja = self.total_thermal_resistance()
        return (tj_max - self.ambient_temp) / theta_ja

# Example: MOSFET thermal analysis
network = ThermalNetwork()
network.ambient_temp = 40.0  # Elevated ambient

# Add thermal path components
network.add_resistance('theta_jc', 0.5)   # Junction to case
network.add_resistance('theta_cs', 0.2)   # Case to sink (TIM)
network.add_resistance('theta_sa', 2.0)   # Sink to ambient

# Calculate temperatures
power = 50.0  # Watts
temps = network.calculate_temperatures(power)
print(f"Junction temperature: {temps['theta_jc']:.1f}C")
print(f"Case temperature: {temps['theta_cs']:.1f}C")
print(f"Sink temperature: {temps['theta_sa']:.1f}C")

# Maximum power calculation
tj_max = 150.0  # Maximum junction temp from datasheet
max_power = network.max_power_for_tj(tj_max)
print(f"Maximum power at Tambient={network.ambient_temp}C: {max_power:.1f}W")

Heat Sink Selection

import numpy as np

class HeatSinkCalculator:
    """Heat sink thermal calculations"""

    @staticmethod
    def natural_convection_theta(length_mm: float, width_mm: float,
                                  height_mm: float, num_fins: int,
                                  fin_thickness_mm: float = 1.5) -> float:
        """Estimate thermal resistance for extruded aluminum heat sink
        using natural convection correlation"""

        # Convert to meters
        L = length_mm / 1000
        W = width_mm / 1000
        H = height_mm / 1000
        t_fin = fin_thickness_mm / 1000

        # Base area
        A_base = L * W

        # Fin spacing
        s = (W - num_fins * t_fin) / (num_fins - 1) if num_fins > 1 else W

        # Fin surface area (both sides)
        A_fins = 2 * num_fins * L * H

        # Total surface area
        A_total = A_base + A_fins

        # Natural convection coefficient estimate (typical for vertical fins)
        h = 10  # W/(m^2*K) typical for natural convection

        # Fin efficiency (simplified)
        k_al = 200  # W/(m*K) for aluminum
        m = np.sqrt(2 * h / (k_al * t_fin))
        eta_fin = np.tanh(m * H) / (m * H)

        # Effective area
        A_eff = A_base + eta_fin * A_fins

        # Thermal resistance
        theta_sa = 1 / (h * A_eff)

        return theta_sa

    @staticmethod
    def forced_convection_theta(theta_natural: float, velocity_m_s: float) -> float:
        """Estimate forced convection thermal resistance
        based on natural convection value and air velocity"""

        # Empirical correlation: forced convection much better than natural
        # Typical improvement factor
        velocity_factor = np.sqrt(velocity_m_s / 0.25)  # Normalized to typical natural
        improvement = min(velocity_factor * 3, 10)  # Cap at 10x improvement

        return theta_natural / improvement

# Example: Select heat sink for 75W dissipation
calculator = HeatSinkCalculator()

# Heat sink candidates
candidates = [
    {'name': 'Small', 'L': 50, 'W': 50, 'H': 25, 'fins': 10},
    {'name': 'Medium', 'L': 75, 'W': 75, 'H': 35, 'fins': 15},
    {'name': 'Large', 'L': 100, 'W': 100, 'H': 50, 'fins': 20},
]

power = 75  # Watts
tj_max = 125
ta = 40
theta_jc = 0.3
theta_cs = 0.15

required_theta_sa = (tj_max - ta) / power - theta_jc - theta_cs
print(f"Required theta_sa: {required_theta_sa:.2f} C/W")

print("\nHeat sink comparison (natural convection):")
for hs in candidates:
    theta = calculator.natural_convection_theta(
        hs['L'], hs['W'], hs['H'], hs['fins']
    )
    tj = ta + power * (theta_jc + theta_cs + theta)
    status = "OK" if tj <= tj_max else "FAIL"
    print(f"{hs['name']}: theta_sa={theta:.2f} C/W, Tj={tj:.1f}C [{status}]")

Transient Thermal Analysis

import numpy as np
import matplotlib.pyplot as plt

class TransientThermal:
    """Transient thermal analysis using Foster RC network"""

    def __init__(self, tau_values: List[float], r_values: List[float]):
        """
        Initialize with Foster