In AC circuit analysis, **phasor representation** allows you to solve for voltages and currents using complex numbers. For a **series RLC circuit**, the total impedance `Z` is given by the formula:

`Z = R + j(ωL - 1/(ωC))`

where `R` is resistance, `L` is inductance, `C` is capacitance, `ω` (omega) is the angular frequency (`ω = 2πf`), and `j` is the imaginary unit. The **current amplitude** `I` in the circuit is found using Ohm's Law for AC: `I = V / |Z|`, where `V` is the voltage amplitude and `|Z|` is the magnitude of the impedance. The **phase angle** `θ` between the source voltage and the current is given by the argument (angle) of the impedance: `θ = arctan((ωL - 1/(ωC))/R)`.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import io
import math
import cmath
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_impedance_calculation(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.solve_series_rlc(100, 0.1, 10e-6, 50, 10)
        output = f.getvalue()
        # Calculate expected impedance
        R = 100
        L = 0.1
        C = 10e-6
        f_ = 50
        omega = 2 * math.pi * f_
        X_L = omega * L
        X_C = 1 / (omega * C)
        Z = complex(R, X_L - X_C)
        expected = f"Impedance: {Z}"
        _dynamic_test(
            self,
            normalize_text(expected) in normalize_text(output),
            f"Correct impedance calculated and printed: {Z}",
            f"Expected impedance output '{expected}', got '{output}'",
        )

    def test_current_amplitude(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.solve_series_rlc(100, 0.1, 10e-6, 50, 10)
        output = f.getvalue()
        # Calculate expected current amplitude
        R = 100
        L = 0.1
        C = 10e-6
        f_ = 50
        V_ampl = 10
        omega = 2 * math.pi * f_
        X_L = omega * L
        X_C = 1 / (omega * C)
        Z = complex(R, X_L - X_C)
        Z_magnitude = abs(Z)
        current_amplitude = V_ampl / Z_magnitude
        expected = f"Current amplitude: {current_amplitude}"
        _dynamic_test(
            self,
            normalize_text(expected) in normalize_text(output),
            f"Correct current amplitude calculated and printed: {current_amplitude}",
            f"Expected current amplitude output '{expected}', got '{output}'",
        )

    def test_phase_angle(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.solve_series_rlc(100, 0.1, 10e-6, 50, 10)
        output = f.getvalue()
        # Calculate expected phase angle
        R = 100
        L = 0.1
        C = 10e-6
        f_ = 50
        omega = 2 * math.pi * f_
        X_L = omega * L
        X_C = 1 / (omega * C)
        Z = complex(R, X_L - X_C)
        phase_angle_rad = cmath.phase(Z)
        phase_angle_deg = math.degrees(phase_angle_rad)
        expected = f"Phase angle (degrees): {phase_angle_deg}"
        _dynamic_test(
            self,
            normalize_text(expected) in normalize_text(output),
            f"Correct phase angle calculated and printed: {phase_angle_deg}",
            f"Expected phase angle output '{expected}', got '{output}'",
        )

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: Series RLC Circuit Solver

Løsning