engineering-systems

Engineering Systems

Overview

This skill covers computational engineering: control systems design and analysis, signal processing, reliability engineering, mathematical optimization, and sensor data processing. Use it for engineering research problems involving dynamic systems, sensor streams, or system optimization.

When to Use This Skill

• Analyzing or designing control systems (PID, feedback loops)
• Processing sensor time series (filtering, calibration, anomaly detection)
• Running engineering optimization (LP, MIP, scheduling)
• Assessing system reliability or failure analysis
• Working with FEA simulation outputs

---

1. Control Systems

Transfer Functions and System Analysis

import control
import numpy as np
import matplotlib.pyplot as plt

# Define transfer function G(s) = 1 / (s² + 2s + 1)
G = control.tf([1], [1, 2, 1])
print(G)

# Step response
t, y = control.step_response(G)
rise_time = t[np.argmax(y >= 0.1 * y[-1])]  # 10% rise time (approx)
settling_idx = np.where(np.abs(y - y[-1]) > 0.02 * y[-1])[0]
settling_time = t[settling_idx[-1]] if len(settling_idx) > 0 else 0

print(f"Steady-state value: {y[-1]:.3f}")
print(f"Rise time (10%): {rise_time:.3f} s")
print(f"Settling time (2%): {settling_time:.3f} s")
print(f"Overshoot: {(y.max() - y[-1]) / y[-1] * 100:.1f}%")

# Bode plot: gain margin and phase margin
gm, pm, wcg, wcp = control.margin(G)
print(f"Gain margin: {20*np.log10(gm):.1f} dB  (should be > 6 dB for stability)")
print(f"Phase margin: {pm:.1f}°  (should be > 30° for robustness)")

# Poles and zeros (stability: all poles must have Re < 0 for stability)
poles = control.poles(G)
zeros = control.zeros(G)
stable = all(p.real < 0 for p in poles)
print(f"Poles: {poles}  |  Stable: {stable}")

PID Controller Design

# PID controller: C(s) = Kp + Ki/s + Kd*s
# Closed-loop system: T(s) = C(s)*G(s) / (1 + C(s)*G(s))

def tune_pid_ziegler_nichols(Ku: float, Tu: float) -> dict:
    """Ziegler-Nichols tuning from ultimate gain Ku and period Tu.
    Ku: ultimate gain (gain at stability boundary)
    Tu: ultimate period (oscillation period at Ku)
    """
    return {
        "P":   {"Kp": 0.5 * Ku,      "Ki": 0,                 "Kd": 0},
        "PI":  {"Kp": 0.45 * Ku,     "Ki": 0.54 * Ku / Tu,    "Kd": 0},
        "PID": {"Kp": 0.6 * Ku,      "Ki": 1.2 * Ku / Tu,     "Kd": 3 * Ku * Tu / 40},
    }

# Build and simulate closed-loop PID
def make_pid_controller(Kp, Ki, Kd):
    """Return PID transfer function."""
    # C(s) = Kd*s² + Kp*s + Ki) / s
    return control.tf([Kd, Kp, Ki], [1, 0])

G_plant = control.tf([1], [1, 3, 2])  # Example plant
params = tune_ziegler_nichols = {"Kp": 3.0, "Ki": 1.5, "Kd": 0.5}  # Example values
C = make_pid_controller(**params)
T_cl = control.feedback(C * G_plant, 1)  # Closed-loop
t_cl, y_cl = control.step_response(T_cl)