Simulating cooling curves is important for thermal management. This challenge will help you automate cooling analysis with Python. You will use Newton's law of cooling to model how the temperature of an object changes over time when placed in a cooler environment.


import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib
import math

class TestTask(unittest.TestCase):
    def test_length_of_output(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'cooling_curve', None)
        _dynamic_test(self, callable(func), "Function cooling_curve exists", "cooling_curve is not defined or not callable")
        if not callable(func):
            return
        T_initial = 100
        T_ambient = 25
        k = 0.05
        dt = 1
        duration = 10
        result = func(T_initial, T_ambient, k, dt, duration)
        expected_length = int(duration // dt) + 1
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) == expected_length,
            f"Returned list has correct length {expected_length}",
            f"Expected list of length {expected_length}, got {len(result) if isinstance(result, list) else type(result)}",
        )

    def test_first_value_is_initial(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'cooling_curve', None)
        _dynamic_test(self, callable(func), "Function cooling_curve exists", "cooling_curve is not defined or not callable")
        if not callable(func):
            return
        T_initial = 80
        T_ambient = 20
        k = 0.1
        dt = 0.5
        duration = 3
        result = func(T_initial, T_ambient, k, dt, duration)
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) > 0 and abs(result[0] - T_initial) < 1e-8,
            "First value equals initial temperature",
            f"Expected first value {T_initial}, got {result[0] if isinstance(result, list) and len(result)>0 else result}"
        )

    def test_final_value(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'cooling_curve', None)
        _dynamic_test(self, callable(func), "Function cooling_curve exists", "cooling_curve is not defined or not callable")
        if not callable(func):
            return
        T_initial = 50
        T_ambient = 10
        k = 0.2
        dt = 0.25
        duration = 1
        result = func(T_initial, T_ambient, k, dt, duration)
        n_steps = int(duration // dt) + 1
        t_final = (n_steps-1) * dt
        expected_final = T_ambient + (T_initial - T_ambient) * math.exp(-k * t_final)
        _dynamic_test(
            self,
            isinstance(result, list) and abs(result[-1] - expected_final) < 1e-8,
            "Final value matches analytical solution",
            f"Expected final value {expected_final}, got {result[-1] if isinstance(result, list) else result}"
        )

    def test_non_integer_dt_and_duration(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'cooling_curve', None)
        _dynamic_test(self, callable(func), "Function cooling_curve exists", "cooling_curve is not defined or not callable")
        if not callable(func):
            return
        T_initial = 30
        T_ambient = 15
        k = 0.3
        dt = 0.3
        duration = 1.2
        result = func(T_initial, T_ambient, k, dt, duration)
        n_steps = int(duration // dt) + 1
        _dynamic_test(
            self,
            isinstance(result, list) and len(result) == n_steps,
            f"Correct number of time steps for non-integer dt and duration ({n_steps})",
            f"Expected {n_steps} steps, got {len(result) if isinstance(result, list) else result}"
        )
        # Check a mid-point value
        t1 = 0.6
        expected1 = T_ambient + (T_initial - T_ambient) * math.exp(-k * t1)
        idx1 = int(t1 // dt)
        _dynamic_test(
            self,
            abs(result[idx1] - expected1) < 1e-8,
            f"Value at t={t1} matches analytical solution",
            f"Expected {expected1}, got {result[idx1]} at t={t1}"
        )

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: Cooling Curve Simulation

Løsning