thermal-analysis

What this skill does

# 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
```bash
pip install numpy scipy matplotlib pandas
```

### Optional Dependencies
```bash
# 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
```python
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
```python
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
```python
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 Foste