Electrical Engineering

Code Examples

Circuit Analysis Tools

import numpy as np
from dataclasses import dataclass
from typing import List, Tuple
import cmath

@dataclass
class Component:
    value: float
    unit: str

@dataclass
class Resistor(Component):
    def impedance(self, frequency: float = 0) -> complex:
        return self.value

@dataclass
class Capacitor(Component):
    def impedance(self, frequency: float) -> complex:
        if frequency == 0:
            return complex(float('inf'))
        return -1j / (2 * np.pi * frequency * self.value)

@dataclass
class Inductor(Component):
    def impedance(self, frequency: float) -> complex:
        if frequency == 0:
            return 0
        return 1j * 2 * np.pi * frequency * self.value

def nodal_analysis(
    conductances: np.ndarray,
    current_sources: np.ndarray
) -> np.ndarray:
    """Solve nodal analysis using modified nodal analysis."""
    return np.linalg.solve(conductances, current_sources)

def thevenin_equivalent(
    V_th: float,
    R_th: float,
    R_load: float
) -> Tuple[float, float, float]:
    """Calculate Thevenin equivalent circuit parameters."""
    V_load = V_th * R_load / (R_th + R_load)
    P_load = V_load**2 / R_load
    return V_load, P_load, V_load / R_load

def power_factor_correction(
    apparent_power: float,
    current_power_factor: float,
    target_power_factor: float
) -> Tuple[float, float]:
    """Calculate required capacitor for power factor correction."""
    theta1 = np.arccos(current_power_factor)
    theta2 = np.arccos(target_power_factor)
    Q1 = apparent_power * np.sin(theta1)
    Q2 = apparent_power * np.sin(theta2)
    Qc = Q1 - Q2
    return Qc, Qc / (2 * np.pi * 60)

# Example: Power factor correction
S = 100e3  # VA
pf_current = 0.8
pf_target = 0.95
Qc, C = power_factor_correction(S, pf_current, pf_target)
print(f"Required reactive power compensation: {Qc/1000:.1f} kVAR")
print(f"Required capacitance: {C*1e6:.1f} µF")

Semiconductor Calculations

from dataclasses import dataclass

@dataclass
class MOSFETParameters:
    Vds_max: float  # V
    Id_max: float  # A
    Rds_on: float  # ohms
    Vgs_th: float  # V
    Qg: float  # nC
    trr: float  # ns

@dataclass
class DiodeParameters:
    Vr_max: float  # V
    If_max: float  # A
    Vf: float  # V
    trr: float  # ns
    Ir: float  # µA

def mosfet_conduction_loss(
    Id: float,
    Rds_on: float,
    D: float
) -> float:
    """Calculate MOSFET conduction loss."""
    return Id**2 * Rds_on * D

def mosfet_switching_loss(
    Vds: float,
    Ids: float,
    tr: float,
    tf: float,
    fs: float
) -> float:
    """Calculate MOSFET switching loss."""
    return 0.5 * Vds * Ids * (tr + tf) * fs

def diode_reverse_recovery_loss(
    Irr: float,
    trr: float,
    Vr: float,
    fs: float
) -> float:
    """Calculate diode reverse recovery loss."""
    return 0.5 * Vr * Irr * trr * fs

def calculate_ripple_current(
    Vin: float,
    Vout: float,
    L: float,
    fs: float,
    D: float
) -> float:
    """Calculate inductor ripple current for buck converter."""
    return (Vin - Vout) * D / (L * fs)

def buck_converter_design(
    Vin: float,
    Vout: float,
    Io: float,
    fs: float,
    ripple_percent: float = 0.3
) -> dict:
    """Design basic buck converter parameters."""
    D = Vout / Vin
    Iripple_max = Io * ripple_percent
    L = (Vin - Vout) * D / (Iripple_max * fs)
    Ic = Iripple_max / 2
    return {
        "duty_cycle": D,
        "inductance_mH": L * 1000,
        "ripple_current": Iripple_max,
        "capacitor_ripple": Ic
    }

# Example: Buck converter
design = buck_converter_design(12, 5, 2, 100e3)
print(f"Duty cycle: {design['duty_cycle']:.3f}")
print(f"Required inductance: {design['inductance_mH']:.2f} mH")
print(f"Ripple current: {design['ripple_current']:.3f} A")

PCB Design Calculations

def trace_current_capacity(
    width: float,  # mils
    thickness: float,  # oz/ft²
    temp_rise: float  # °C
) -> float:
    """Calculate PCB trace current carrying capacity using IPC-2221."""
    if temp_rise <= 10:
        return 0.048 * width**0.44 * thickness**0.725
    else:
        return 0.024 * width**0.44 * thickness**0.725 * (temp_rise / 10)**0.44

def microstrip_impedance(
    w: float,  # mm
    h: float,  # mm
    Er: float  # dielectric constant
) -> float:
    """Calculate microstrip trace impedance."""
    if w / h <= 1:
        return (87 / (Er + 1.41)**0.5) * np.log(5.98 * h / (0.8 * w + t))
    else:
        return (87 / (Er + 1.41)**0.5) * np.log(5.98 * h / (0.8 * w + t))

def via_inductance(
    length: float,  # mm
    diameter: float  # mm
) -> float:
    """Estimate via inductance."""
    return 0.2 * length * np.log(4 * length / diameter)

def decoupling_capacitor_selection(
    Cload: float,
    Vsupply: float,
    allowed_ripple: float,
    target_impedance: float,
    frequency: float
) -> float:
    """Calculate required decoupling capacitance."""
    C = Cload * allowed_ripple / Vsupply
    Z = 1 / (2 * np.pi * frequency * C)
    return max(C, Vsupply / (target_impedance * 2 * np.pi * frequency * Vsupply))

# Example: PCB trace sizing
trace_width = 50  # mils
copper_thickness = 1  # oz
temp_rise = 20  # °C
current = trace_current_capacity(trace_width, copper_thickness, temp_rise)
print(f"Current capacity: {current:.2f} A")

Power System Calculations

def three_phase_power(
    Vll: float,  # line-to-line voltage
    I: float,
    pf: float
) -> float:
    """Calculate three-phase power."""
    return np.sqrt(3) * Vll * I * pf

def short_circuit_current(
    S_sc: float,  # MVA
    V: float,  # kV
    Z_percent: float
) -> float:
    """Calculate short-circuit current."""
    return (S_sc * 1000) / (np.sqrt(3) * V * Z_percent / 100)

def voltage_drop_calculation(
    I: float,
    R: float,
    X: float,
    pf: float
) -> float:
    """Calculate voltage drop in percent."""
    return I * (R * pf + X * np.sin(np.arccos(pf))) / 10

def cable_sizing_current(
    I_load: float,
    derating_factor: float = 0.8,
    correction_factor: float = 1.0
) -> float:
    """Calculate required cable ampacity."""
    return I_load / (derating_factor * correction_factor)

def transformer_sizing(
    S_kVA: float,
    efficiency: float = 0.97,
    load_factor: float = 0.8
) -> float:
    """Calculate transformer kVA rating."""
    return S_kVA / (efficiency * load_factor)

# Example: Power distribution
load_current = 150  # A
voltage = 480  # V
pf = 0.85
power = three_phase_power(voltage, load_current, pf)
print(f"Three-phase power: {power/1000:.1f} kW")

Best Practices

• Use proper grounding techniques to minimize noise and ensure safety
• Include appropriate margins in component ratings for reliability
• Perform thermal analysis for power electronic components
• Consider EMI/EMC requirements early in the design process
• Use decoupling capacitors near IC power pins for noise suppression
• Follow IPC standards for PCB design and manufacturing
• Calculate worst-case conditions including temperature extremes
• Include proper fusing and overcurrent protection in designs
• Use appropriate wire gauges based on current carrying requirements
• Document schematics with clear component values and tolerances