Statistical analysis and visualization are essential tools in civil engineering for ensuring the quality and consistency of construction materials. By examining properties such as **compressive strength**, you can verify whether a batch of concrete meets design requirements and identify any inconsistencies that may affect structural performance. Visualizing the distribution of test results, such as with a histogram, makes it easier to spot trends or outliers, supporting effective quality assurance and compliance with standards. This approach not only aids in technical assessment but also helps communicate findings clearly to stakeholders in a project.


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

class TestTask(unittest.TestCase):
    def setUp(self):
        self.strengths = [28.5, 30.2, 31.0, 29.7, 32.5, 27.9, 30.8, 28.9, 31.4, 29.3]
        self.required_strength = 30.0
        self.expected_mean = sum(self.strengths) / len(self.strengths)
        self.expected_std = (sum([(x - self.expected_mean) ** 2 for x in self.strengths]) / len(self.strengths)) ** 0.5

    def test_mean_printed(self):
        import user_code
        importlib.reload(user_code)
        captured = io.StringIO()
        sys.stdout = captured
        user_code.analyze_concrete_strength(self.strengths, self.required_strength)
        sys.stdout = sys.__stdout__
        out = captured.getvalue()
        _dynamic_test(
            self,
            "mean compressive strength" in out.lower(),
            "Mean compressive strength is printed",
            "Mean compressive strength is not printed",
        )
        _dynamic_test(
            self,
            str(round(self.expected_mean, 2))[:4] in out,
            "Printed mean value is approximately correct",
            f"Expected mean {self.expected_mean}, got output {out}",
        )

    def test_std_printed(self):
        import user_code
        importlib.reload(user_code)
        captured = io.StringIO()
        sys.stdout = captured
        user_code.analyze_concrete_strength(self.strengths, self.required_strength)
        sys.stdout = sys.__stdout__
        out = captured.getvalue()
        _dynamic_test(
            self,
            "standard deviation" in out.lower(),
            "Standard deviation is printed",
            "Standard deviation is not printed",
        )
        _dynamic_test(
            self,
            str(round(self.expected_std, 2))[:4] in out,
            "Printed standard deviation value is approximately correct",
            f"Expected std {self.expected_std}, got output {out}",
        )

    def test_histogram_plotted(self):
        import user_code
        importlib.reload(user_code)
        # Patch plt.show to test if it is called
        called = {'show': False}
        original_show = plt.show
        def fake_show(*args, **kwargs):
            called['show'] = True
        plt.show = fake_show
        try:
            user_code.analyze_concrete_strength(self.strengths, self.required_strength)
        finally:
            plt.show = original_show
        _dynamic_test(
            self,
            called['show'],
            "Histogram is plotted with plt.show()",
            "plt.show() was not called; histogram was not shown."
        )

    def test_compliance_message(self):
        import user_code
        importlib.reload(user_code)
        captured = io.StringIO()
        sys.stdout = captured
        user_code.analyze_concrete_strength(self.strengths, self.required_strength)
        sys.stdout = sys.__stdout__
        out = captured.getvalue().lower()
        if self.expected_mean >= self.required_strength:
            _dynamic_test(
                self,
                "meets the design requirement" in out,
                "Compliance message for meeting requirement is printed",
                "Compliance message for meeting requirement not found in output",
            )
        else:
            _dynamic_test(
                self,
                "does not meet the design requirement" in out,
                "Compliance message for not meeting requirement is printed",
                "Compliance message for not meeting requirement not found in output",
            )

    def test_noncompliance_message(self):
        import user_code
        importlib.reload(user_code)
        # Lower the strengths to force non-compliance
        low_strengths = [20.0, 21.0, 22.0, 20.5, 21.5, 22.5, 21.2, 20.8, 22.1, 21.7]
        required_strength = 25.0
        captured = io.StringIO()
        sys.stdout = captured
        user_code.analyze_concrete_strength(low_strengths, required_strength)
        sys.stdout = sys.__stdout__
        out = captured.getvalue().lower()
        _dynamic_test(
            self,
            "does not meet the design requirement" in out,
            "Non-compliance message is printed when mean is below requirement",
            "Non-compliance message not found in output",
        )

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: Concrete Mix Analysis

Løsning