As you have seen, engineers often need to fit mathematical models to real-world data to better understand and predict system behavior. **Curve fitting** and **regression** are essential tools for this purpose, especially when the relationship between variables is not strictly linear. In the context of pump efficiency, the relationship between flow rate and efficiency is typically nonlinear and often well-approximated by a **quadratic function**. By fitting a quadratic curve to measured data, you can both visualize the trend and extract a predictive model for further analysis.


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

class TestTask(unittest.TestCase):
    def setUp(self):
        self.Q = [10, 20, 30, 40, 50, 60, 70]
        self.efficiency = [60, 68, 75, 80, 78, 72, 65]
        # Patch plt.show to avoid blocking
        self._original_show = plt.show
        plt.show = lambda *a, **k: None

    def tearDown(self):
        plt.show = self._original_show
        plt.clf()
        plt.close('all')

    def test_polyfit_coefficients(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        sys_stdout = sys.stdout
        sys.stdout = f
        user_code.fit_and_plot_pump_efficiency(self.Q, self.efficiency)
        sys.stdout = sys_stdout
        output = f.getvalue()
        # Check if output contains three float-like numbers (coefficients)
        coeffs = None
        try:
            coeffs = eval(output.strip())
        except Exception:
            pass
        _dynamic_test(
            self,
            isinstance(coeffs, (list, np.ndarray)) and len(coeffs) == 3,
            "Function prints three polynomial coefficients",
            f"Expected three coefficients, got: {output.strip()}"
        )

    def test_scatter_and_curve_on_plot(self):
        import user_code
        importlib.reload(user_code)
        # Clear plt before running
        plt.clf()
        plt.close('all')
        user_code.fit_and_plot_pump_efficiency(self.Q, self.efficiency)
        # There should be a scatter and a plot (line)
        found_scatter = False
        found_line = False
        ax = plt.gca()
        for artist in ax.get_children():
            if isinstance(artist, matplotlib.collections.PathCollection):
                found_scatter = True
            if isinstance(artist, matplotlib.lines.Line2D):
                # Exclude axes lines
                if artist.get_label() == "Fitted Quadratic Curve":
                    found_line = True
        _dynamic_test(
            self,
            found_scatter,
            "Scatter plot for measured data is present",
            "Scatter plot for measured data is missing"
        )
        _dynamic_test(
            self,
            found_line,
            "Fitted quadratic curve is plotted",
            "Fitted quadratic curve is missing"
        )

    def test_polyfit_degree(self):
        import user_code
        importlib.reload(user_code)
        # Patch np.polyfit to capture degree
        saved_polyfit = np.polyfit
        degree_used = {'val': None}
        def fake_polyfit(x, y, deg, *a, **k):
            degree_used['val'] = deg
            return saved_polyfit(x, y, deg, *a, **k)
        np.polyfit = fake_polyfit
        user_code.fit_and_plot_pump_efficiency(self.Q, self.efficiency)
        np.polyfit = saved_polyfit
        _dynamic_test(
            self,
            degree_used['val'] == 2,
            "np.polyfit is called with degree 2 (quadratic)",
            f"np.polyfit not called with degree 2, got: {degree_used['val']}"
        )

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

A practical course designed for engineers who want to leverage Python to solve real-world engineering problems. Explore data analysis, mathematical modeling, and simulation using Python's powerful libraries and tools, all through engaging, hands-on examples and challenges.

Learn how to use Python to analyze, summarize, and visualize engineering data. This section covers essential data handling and visualization techniques tailored for engineering applications.

Dive into mathematical modeling and simulation techniques for engineering systems using Python. Learn to model physical processes, solve equations, and simulate system behavior.

Apply data science techniques to engineering problems, including classification, clustering, and predictive modeling using Python's scikit-learn and seaborn libraries.

Challenge: Fit a Model to Pump Efficiency Data

解答