thermal-analysis

name	thermal-analysis
description	Electronic system thermal modeling and analysis skill for junction temperature calculation, heat sink selection, thermal resistance networks, and safe operating area verification.
allowed-tools	Read, Grep, Write, Bash, Edit, Glob
category	Thermal Management
backlog-id	SK-025
metadata	{"author":"babysitter-sdk","version":"1.0.0"}
graph	{"domains":["domain:electrical-engineering"],"skillAreas":["skill-area:hardware-abstraction-layer","skill-area:device-drivers","skill-area:firmware-development"],"roles":["role:embedded-engineer","role:systems-integration-engineer"]}

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
         comp  (.components):
            delta_t = total_power * comp.theta
            current_temp += delta_t
            temperatures[comp.name] = current_temp

         temperatures

     () -> :
         (c.theta  c  .components)

     () -> :
        
        theta_ja = .total_thermal_resistance()
         (tj_max - .ambient_temp) / theta_ja


network = ThermalNetwork()
network.ambient_temp =   


network.add_resistance(, )   
network.add_resistance(, )   
network.add_resistance(, )   


power =   
temps = network.calculate_temperatures(power)
()
()
()


tj_max =   
max_power = network.max_power_for_tj(tj_max)
()

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 =  / (h * A_eff)

         theta_sa


     () -> :
        

        
        
        velocity_factor = np.sqrt(velocity_m_s / )  
        improvement = (velocity_factor * , )  

         theta_natural / improvement


calculator = HeatSinkCalculator()


candidates = [
    {: , : , : , : , : },
    {: , : , : , : , : },
    {: , : , : , : , : },
]

power =   
tj_max = 
ta = 
theta_jc = 
theta_cs = 

required_theta_sa = (tj_max - ta) / power - theta_jc - theta_cs
()

()
 hs  candidates:
    theta = calculator.natural_convection_theta(
        hs[], hs[], hs[], hs[]
    )
    tj = ta + power * (theta_jc + theta_cs + theta)
    status =   tj <= tj_max  
    ()

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 network parameters
        tau_values: Time constants in seconds
        r_values: Thermal resistance contributions in C/W
        """
        self.tau = np.array(tau_values)
        self.r = np.array(r_values)

    def thermal_impedance(self, time: float) -> float:
        """Calculate Zth(t) at given time"""
        zth = np.sum(self.r * (1 - np.exp(-time / self.tau)))
        return zth

    def temperature_rise(self, power: float, time: float) -> float:
        """Calculate temperature rise for constant power"""
        return power * self.thermal_impedance(time)

    def pulsed_power_analysis(self, power: float, t_on: float, t_off: float,
                              num_pulses: int) -> np.ndarray:
        """Analyze temperature for pulsed power"""
        dt = (t_on, t_off) / 
        total_time = num_pulses * (t_on + t_off)
        time = np.arange(, total_time, dt)

        temp_rise = np.zeros_like(time)

         i, t  (time):
            
             pulse  (num_pulses):
                pulse_start = pulse * (t_on + t_off)
                pulse_end = pulse_start + t_on

                 t > pulse_start:
                    
                    temp_rise[i] += power * .thermal_impedance(t - pulse_start)
                 t > pulse_end:
                    
                    temp_rise[i] -= power * .thermal_impedance(t - pulse_end)

         time, temp_rise



tau = [, , , ]  
r = [, , , ]    

thermal = TransientThermal(tau, r)


pulse_power =   
pulse_duration =   

temp_rise = thermal.temperature_rise(pulse_power, pulse_duration)
()


temp_steady = thermal.temperature_rise(pulse_power, )
()

Safe Operating Area Check

class SOAChecker:
    """Safe Operating Area verification"""

    def __init__(self, vds_max: float, id_max: float, pd_max: float,
                 tj_max: float, theta_jc: float):
        self.vds_max = vds_max
        self.id_max = id_max
        self.pd_max = pd_max
        self.tj_max = tj_max
        self.theta_jc = theta_jc

    def check_dc_operation(self, vds: float, id: float, tc: float) -> dict:
        """Check if operating point is within DC SOA"""
        power = vds * id
        tj = tc + power * self.theta_jc

        checks = {
            'vds_ok': vds <= self.vds_max,
            'id_ok': id <= self.id_max,
            'power_ok': power <= self.pd_max,
            'tj_ok': tj <= self.tj_max,
        }

        checks['all_ok'] = all(checks.values())
        checks['power'] = power
        checks['tj'] = tj

        return checks

    def max_current_at_voltage(self, vds: float, tc: ) -> :
        
        
        max_power_thermal = (.tj_max - tc) / .theta_jc
        max_power = (max_power_thermal, .pd_max)

        
        id_power = max_power / vds  vds >   .id_max

        
         (id_power, .id_max)


soa = SOAChecker(
    vds_max=,  
    id_max=,    
    pd_max=,   
    tj_max=,   
    theta_jc=  
)


result = soa.check_dc_operation(vds=, =, tc=)
()


vds_points = np.logspace(, , )  
id_curve = [soa.max_current_at_voltage(v, )  v  vds_points]
()

Usage Guidelines

When to Use This Skill

• Component thermal verification during design
• Heat sink selection and specification
• Thermal interface material selection
• PCB thermal management design
• Failure analysis of overheated components

Best Practices

1. Use manufacturer thermal data when available
2. Add margin to thermal calculations (typically 10-20%)
3. Consider worst-case ambient temperature
4. Account for aging of TIMs and fans
5. Verify calculations with thermal measurements
6. Document thermal assumptions in design reviews

Process Integration

• ee-switching-power-supply-design (thermal management)
• ee-motor-drive-design (power stage thermal)
• ee-hardware-validation (thermal characterization)
• ee-dfm-review (thermal design review)

Dependencies

• numpy: Numerical calculations
• scipy: Optimization for heat sink selection
• matplotlib: Thermal visualization

References

• Ellison, G. "Thermal Computations for Electronics"
• Sergent & Krum, "Thermal Management Handbook"
• Application Notes from Infineon, ON Semi, TI