Calculating work during gas expansion is a common thermodynamics problem. Automating this with Python streamlines engineering analysis. When an ideal gas expands isothermally, the work done can be determined using the formula:

`W = nRT * ln(Vf/Vi)`

where **W** is the work done, **n** is the amount of gas in moles, **R** is the universal gas constant, **T** is the absolute temperature, **Vi** is the initial volume, **Vf** is the final volume, and **ln** is the natural logarithm. By creating a Python function to perform this calculation, you can quickly analyze different scenarios and support engineering decision-making.


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_work_standard_case(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'isothermal_expansion_work', None)
        _dynamic_test(
            self,
            callable(func),
            "Function isothermal_expansion_work is defined",
            "Function isothermal_expansion_work is not defined"
        )
        if not callable(func):
            return
        result = func(1.0, 2.0, 1.0, 300)
        expected = 1.0 * 8.314 * 300 * math.log(2.0/1.0)
        _dynamic_test(
            self,
            abs(result - expected) < 1e-6,
            "Correct work for vi=1.0, vf=2.0, n=1.0, t=300",
            f"Expected {expected}, got {result}"
        )

    def test_work_different_values(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'isothermal_expansion_work', None)
        _dynamic_test(
            self,
            callable(func),
            "Function isothermal_expansion_work is defined",
            "Function isothermal_expansion_work is not defined"
        )
        if not callable(func):
            return
        result = func(2.0, 4.0, 0.5, 350)
        expected = 0.5 * 8.314 * 350 * math.log(4.0/2.0)
        _dynamic_test(
            self,
            abs(result - expected) < 1e-6,
            "Correct work for vi=2.0, vf=4.0, n=0.5, t=350",
            f"Expected {expected}, got {result}"
        )

    def test_equal_volumes(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'isothermal_expansion_work', None)
        _dynamic_test(
            self,
            callable(func),
            "Function isothermal_expansion_work is defined",
            "Function isothermal_expansion_work is not defined"
        )
        if not callable(func):
            return
        result = func(3.0, 3.0, 1.0, 300)
        _dynamic_test(
            self,
            abs(result) < 1e-10,
            "Returns zero when vi == vf",
            f"Expected 0 when vi == vf, got {result}"
        )

    def test_vf_less_than_vi(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'isothermal_expansion_work', None)
        _dynamic_test(
            self,
            callable(func),
            "Function isothermal_expansion_work is defined",
            "Function isothermal_expansion_work is not defined"
        )
        if not callable(func):
            return
        result = func(2.0, 1.0, 1.0, 300)
        expected = 1.0 * 8.314 * 300 * math.log(1.0/2.0)
        _dynamic_test(
            self,
            abs(result - expected) < 1e-6 and result < 0,
            "Returns correct negative work value when vf < vi",
            f"Expected {expected} (negative), got {result}"
        )

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: Gas Expansion Work Calculation

Oplossing

Challenge: Gas Expansion Work Calculation

Oplossing