Comparing efficiencies of thermodynamic cycles is key for engineering decisions. This challenge will help you automate analysis and visualization.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import sys

class TestTask(unittest.TestCase):
    def setUp(self):
        import user_code
        importlib.reload(user_code)
        self.user_code = user_code

    def test_average_efficiency_calculation(self):
        import user_code
        importlib.reload(user_code)
        # Patch plt.show to prevent GUI
        plt.show = lambda *args, **kwargs: None
        # Run and capture average
        cycle_names = ['Otto', 'Diesel', 'Brayton', 'Rankine']
        efficiencies = [30, 35, 40, 42]
        # Temporarily patch plt to capture axhline
        original_axhline = plt.axhline
        self.avg_value = None
        def fake_axhline(y, *args, **kwargs):
            self.avg_value = y
            return original_axhline(y, *args, **kwargs)
        plt.axhline = fake_axhline
        self.user_code.analyze_and_plot_efficiency(cycle_names, efficiencies)
        plt.axhline = original_axhline
        expected_avg = sum(efficiencies) / len(efficiencies)
        _dynamic_test(
            self,
            self.avg_value is not None and abs(self.avg_value - expected_avg) < 1e-6,
            f"Correct average efficiency calculated ({expected_avg}) and used for axhline",
            f"Average efficiency not correctly used in axhline: expected {expected_avg}, got {self.avg_value}",
        )

    def test_bar_chart_cycle_names_and_efficiencies(self):
        import user_code
        importlib.reload(user_code)
        plt.show = lambda *args, **kwargs: None
        cycle_names = ['Otto', 'Diesel', 'Brayton', 'Rankine']
        efficiencies = [30, 35, 40, 42]
        fig = plt.figure()
        ax = fig.add_subplot(111)
        original_bar = plt.bar
        bars_data = {}
        def fake_bar(x, height, *args, **kwargs):
            bars_data['x'] = x
            bars_data['height'] = height
            return original_bar(x, height, *args, **kwargs)
        plt.bar = fake_bar
        user_code.analyze_and_plot_efficiency(cycle_names, efficiencies)
        plt.bar = original_bar
        _dynamic_test(
            self,
            'x' in bars_data and 'height' in bars_data and list(bars_data['x']) == cycle_names and list(bars_data['height']) == efficiencies,
            "Bar chart displays all cycle names with correct efficiencies",
            f"Bar chart does not display correct cycles or efficiencies: got {bars_data}",
        )

    def test_axis_labels(self):
        import user_code
        importlib.reload(user_code)
        plt.show = lambda *args, **kwargs: None
        cycle_names = ['Otto', 'Diesel', 'Brayton', 'Rankine']
        efficiencies = [30, 35, 40, 42]
        fig = plt.figure()
        ax = fig.add_subplot(111)
        original_xlabel = plt.xlabel
        original_ylabel = plt.ylabel
        xlabel_val = {}
        ylabel_val = {}
        def fake_xlabel(val, *args, **kwargs):
            xlabel_val['value'] = val
            return original_xlabel(val, *args, **kwargs)
        def fake_ylabel(val, *args, **kwargs):
            ylabel_val['value'] = val
            return original_ylabel(val, *args, **kwargs)
        plt.xlabel = fake_xlabel
        plt.ylabel = fake_ylabel
        user_code.analyze_and_plot_efficiency(cycle_names, efficiencies)
        plt.xlabel = original_xlabel
        plt.ylabel = original_ylabel
        _dynamic_test(
            self,
            xlabel_val.get('value','') == 'Thermodynamic Cycle',
            "X-axis label is correct",
            f"X-axis label incorrect: got {xlabel_val.get('value','')}",
        )
        _dynamic_test(
            self,
            ylabel_val.get('value','') == 'Efficiency (%)',
            "Y-axis label is correct",
            f"Y-axis label incorrect: got {ylabel_val.get('value','')}",
        )

    def test_legend_contains_average(self):
        import user_code
        importlib.reload(user_code)
        plt.show = lambda *args, **kwargs: None
        cycle_names = ['Otto', 'Diesel', 'Brayton', 'Rankine']
        efficiencies = [30, 35, 40, 42]
        legend_label = {}
        original_legend = plt.legend
        def fake_legend(*args, **kwargs):
            handles, labels = plt.gca().get_legend_handles_labels()
            legend_label['labels'] = labels
            return original_legend(*args, **kwargs)
        plt.legend = fake_legend
        user_code.analyze_and_plot_efficiency(cycle_names, efficiencies)
        plt.legend = original_legend
        found = False
        if 'labels' in legend_label:
            for label in legend_label['labels']:
                if 'average efficiency' in label.lower():
                    found = True
        _dynamic_test(
            self,
            found,
            "Legend includes the average efficiency value",
            f"Legend does not include an average efficiency label: {legend_label.get('labels', [])}",
        )

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 mechanical engineers to solve real-world engineering problems, automate calculations, analyze data, and visualize results. This course blends mechanical engineering concepts with practical Python programming, focusing on applications such as statics, dynamics, thermodynamics, and data analysis.

Learn to use Python for solving statics problems, automating engineering calculations, and visualizing forces and moments.

Apply Python to model, simulate, and analyze dynamic mechanical systems, including motion, vibration, and system response.

Use Python to analyze thermodynamic processes, automate calculations, and visualize engineering data.

Challenge: Analyze and Plot Efficiency Data

解答