Clear visualization of **aggregate grading curves** is essential for making informed **mix design decisions** in civil engineering. By plotting **percent passing** against **sieve sizes** on a logarithmic scale, you can easily compare aggregate samples, check specification compliance, and optimize material blends for concrete or asphalt mixes. This approach enhances your ability to interpret and communicate material characteristics effectively, supporting better engineering outcomes.


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 user_code

class TestTask(unittest.TestCase):
    def setUp(self):
        self.sieve_sizes = [50, 37.5, 25, 19, 12.5, 9.5, 4.75, 2.36, 1.18, 0.6, 0.3, 0.15]
        self.percent_passing = [100, 98, 85, 70, 60, 55, 40, 30, 20, 10, 5, 2]

    def _get_plot_elements(self):
        plt.close('all')
        importlib.reload(user_code)
        fig = plt.gcf()
        ax = plt.gca()
        return fig, ax

    def test_semilogx_used(self):
        plt.close('all')
        # Patch plt.semilogx to set a flag
        import builtins
        called = {'flag': False}
        orig_semilogx = plt.semilogx
        def fake_semilogx(*args, **kwargs):
            called['flag'] = True
            return orig_semilogx(*args, **kwargs)
        plt.semilogx = fake_semilogx
        importlib.reload(user_code)
        plt.semilogx = orig_semilogx
        _dynamic_test(self, called['flag'], "semilogx is used for plotting", "semilogx was not used for plotting")

    def test_xaxis_label(self):
        fig, ax = self._get_plot_elements()
        label = ax.get_xlabel()
        _dynamic_test(self, label == "Sieve Size (mm)", "x-axis label is correct", f"x-axis label is '{label}', expected 'Sieve Size (mm)'")

    def test_yaxis_label(self):
        fig, ax = self._get_plot_elements()
        label = ax.get_ylabel()
        _dynamic_test(self, label == "Percent Passing (%)", "y-axis label is correct", f"y-axis label is '{label}', expected 'Percent Passing (%)'")

    def test_plot_title(self):
        fig, ax = self._get_plot_elements()
        title = ax.get_title()
        _dynamic_test(self, title == "Aggregate Grading Curve", "Plot title is correct", f"Plot title is '{title}', expected 'Aggregate Grading Curve'")

    def test_xaxis_inverted(self):
        fig, ax = self._get_plot_elements()
        xmin, xmax = ax.get_xlim()
        _dynamic_test(self, xmin > xmax, "x-axis is inverted (larger sieve sizes on the left)", "x-axis is not inverted (larger sieve sizes should be on the left)")

    def test_grid_displayed(self):
        fig, ax = self._get_plot_elements()
        grid_lines = ax.get_xgridlines() + ax.get_ygridlines()
        grid_visible = any(line.get_visible() for line in grid_lines)
        _dynamic_test(self, grid_visible, "Grid is displayed on the plot", "Grid is not displayed on the plot")

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 civil engineers to solve real-world engineering problems, automate calculations, and analyze data. This course blends practical coding with civil engineering scenarios, focusing on structural analysis, materials, and project management.

Learn how Python can be used to automate and solve common structural analysis problems in civil engineering, including beam calculations, load analysis, and visualization of structural responses.

Apply Python to analyze and visualize data related to construction materials, quality control, and site measurements, supporting better engineering decisions.

Use Python to automate project management tasks, optimize resource allocation, and support decision-making in civil engineering projects.

Challenge: Aggregate Grading Curve Plot

解答