As you have seen in previous chapters, **RLC circuits** are fundamental in electrical engineering for modeling transient and steady-state behaviors in response to various inputs. In a series RLC circuit, the **resistor** (`R`), **inductor** (`L`), and **capacitor** (`C`) are connected in series, and their combined response to an applied voltage can be described by a **second-order differential equation**. When a step input voltage is applied, the resulting voltage across the capacitor exhibits characteristic transient behavior, which can be **underdamped**, **critically damped**, or **overdamped** depending on the circuit parameters. 

Numerical simulation using Python's `scipy.integrate.odeint` allows you to solve such differential equations efficiently, providing insight into how the circuit responds over time. By simulating the voltage across the capacitor, you can visualize and analyze the **damping behavior**, which is crucial for understanding and designing real-world circuits.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import numpy as np
from scipy.integrate import odeint

class TestTask(unittest.TestCase):
    def test_rlc_circuit_derivatives(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'rlc_circuit', None)
        _dynamic_test(
            self,
            callable(func),
            "Function 'rlc_circuit' is defined.",
            "Function 'rlc_circuit' is not defined."
        )
        # Test that the function returns correct derivatives for a known state
        R, L, C, V_in = 50, 0.2, 20e-6, 10
        y = [0.001, 0.02]  # q=0.001 C, i=0.02 A
        t = 0.01
        result = func(y, t, R, L, C, V_in)
        _dynamic_test(
            self,
            isinstance(result, (list, tuple)) and len(result) == 2,
            "'rlc_circuit' returns a pair of derivatives.",
            f"'rlc_circuit' should return two derivatives, got: {result}"
        )
        dqdt_expected = 0.02
        didt_expected = (10 - 50*0.02 - 0.001/20e-6)/0.2
        _dynamic_test(
            self,
            np.isclose(result[0], dqdt_expected, atol=1e-5),
            "First derivative (dq/dt) is correct.",
            f"Expected dq/dt={dqdt_expected}, got {result[0]}"
        )
        _dynamic_test(
            self,
            np.isclose(result[1], didt_expected, atol=1e-2),
            "Second derivative (di/dt) is correct.",
            f"Expected di/dt={didt_expected}, got {result[1]}"
        )

    def test_voltage_rises_above_zero(self):
        import user_code
        importlib.reload(user_code)
        voltage_capacitor = getattr(user_code, 'voltage_capacitor', None)
        _dynamic_test(
            self,
            voltage_capacitor is not None and np.max(voltage_capacitor) > 0.5,
            "Voltage across capacitor rises above zero.",
            "Voltage across capacitor does not rise above zero."
        )

    def test_underdamped_peak(self):
        import user_code
        importlib.reload(user_code)
        voltage_capacitor = getattr(user_code, 'voltage_capacitor', None)
        V_in = getattr(user_code, 'V_in', None)
        _dynamic_test(
            self,
            voltage_capacitor is not None and V_in is not None,
            "Voltage and input voltage are available.",
            "Could not access voltage_capacitor or V_in."
        )
        max_voltage = np.max(voltage_capacitor)
        _dynamic_test(
            self,
            max_voltage > V_in,
            "Peak voltage exceeds steady-state value (underdamped behavior).",
            f"Peak voltage {max_voltage} does not exceed input {V_in}."
        )

    def test_voltage_settles_to_input(self):
        import user_code
        importlib.reload(user_code)
        voltage_capacitor = getattr(user_code, 'voltage_capacitor', None)
        V_in = getattr(user_code, 'V_in', None)
        _dynamic_test(
            self,
            voltage_capacitor is not None and V_in is not None,
            "Voltage and input voltage are available.",
            "Could not access voltage_capacitor or V_in."
        )
        final_voltage = np.mean(voltage_capacitor[-50:])
        _dynamic_test(
            self,
            np.isclose(final_voltage, V_in, atol=0.2),
            "Voltage settles to the input voltage as time increases.",
            f"Final voltage {final_voltage} does not settle to input {V_in}."
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

Explore how Python empowers electrical engineers to analyze circuits, process signals, and model systems. This course blends practical coding with real-world electrical engineering scenarios, using Python and its scientific libraries to solve authentic engineering problems.

Learn how Python can be used to analyze electrical circuits, calculate parameters, and visualize circuit behavior.

Discover how Python can be used to analyze, visualize, and process electrical signals relevant to engineering applications.

Use Python to model, simulate, and visualize electrical systems and their dynamic behavior.

Challenge: Simulate a Damped RLC Circuit

Oplossing