Blame for task/software-selection/cli/abaqus/task-18/eval.py

# -*- coding: utf-8 -*-
from __future__ import annotations

import subprocess
import sys
from pathlib import Path


DESKTOP = Path(r"C:\Users\user\Desktop")
ABAQUS = Path(r"C:\SIMULIA\Commands\abaqus.bat")
INIT_CAE = DESKTOP / "task18_punch_plate_init.cae"
GT_CAE = DESKTOP / "result" / "Task18_PunchPlate_GT.cae"
ODB = DESKTOP / "result" / "Task18_PunchPlate.odb"
METRICS = DESKTOP / "result" / "metrics.json"
CHECKER = DESKTOP / "__task18_abaqus_checker.py"
RESULT = DESKTOP / "__task18_abaqus_result.txt"
DETAIL = DESKTOP / "__task18_abaqus_detail.txt"
EVIDENCE = DESKTOP / "__task18_abaqus_evidence.json"


CHECKER_SOURCE = r'''# -*- coding: utf-8 -*-
from __future__ import print_function

import json
import math
import os
import re
import traceback

from abaqus import mdb, openMdb
from abaqusConstants import OFF
from caeModules import *
from odbAccess import openOdb


DESKTOP = r"C:\Users\user\Desktop"
INIT_CAE = os.path.join(DESKTOP, "task18_punch_plate_init.cae")
GT_CAE = os.path.join(DESKTOP, "result", "Task18_PunchPlate_GT.cae")
ODB_PATH = os.path.join(DESKTOP, "result", "Task18_PunchPlate.odb")
METRICS_PATH = os.path.join(DESKTOP, "result", "metrics.json")
RESULT_PATH = os.path.join(DESKTOP, "__task18_abaqus_result.txt")
DETAIL_PATH = os.path.join(DESKTOP, "__task18_abaqus_detail.txt")
EVIDENCE_PATH = os.path.join(DESKTOP, "__task18_abaqus_evidence.json")
JOB_NAME = "Task18_PunchPlate"
MODEL_NAME = "PunchPlate2D"
FLOAT = r"[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[Ee][-+]?\d+)?"
DETAILS = []
RECOMPUTED = {}
INIT_PLATE_SIGNATURE = None
INIT_PUNCH_EDGE_SIGNATURE = None
CAE_PLATE_SIGNATURE = None


def log(message):
    DETAILS.append(str(message))


def finite(value):
    try:
        return math.isfinite(float(value))
    except Exception:
        return False


def close(actual, expected, rel=1.0e-6, abs_tol=1.0e-9):
    try:
        actual = float(actual)
        expected = float(expected)
        return math.isfinite(actual) and abs(actual - expected) <= max(abs_tol, rel * abs(expected))
    except Exception:
        return False


def point3(values):
    result = [float(value) for value in values]
    while len(result) < 3:
        result.append(0.0)
    return tuple(result[:3])


def node_bounds(nodes):
    xyz = [point3(node.coordinates) for node in nodes]
    if not xyz:
        return None
    return tuple((min(point[i] for point in xyz), max(point[i] for point in xyz)) for i in range(3))


def bounds_match(observed, expected, tolerance=1.0e-6):
    if observed is None:
        return False
    return all(
        abs(observed[axis][end] - expected[axis][end]) <= tolerance
        for axis in range(3)
        for end in range(2)
    )


def vertex_coordinates(vertices):
    return sorted(tuple(round(value, 6) for value in point3(vertex.pointOn[0])) for vertex in vertices)


def analytical_edge_signature(edges):
    return sorted(tuple(round(value, 6) for value in point3(edge.pointOn[0])) for edge in edges)


def mesh_signature(nodes, elements):
    node_list = list(nodes)
    node_coordinates = [
        tuple(round(value, 8) for value in point3(node.coordinates))
        for node in node_list
    ]
    coordinates_by_label = {
        int(node.label): coordinates for node, coordinates in zip(node_list, node_coordinates)
    }
    element_list = list(elements)
    connectivity_is_indexed = any(
        int(value) == 0
        for element in element_list
        for value in element.connectivity
    )
    element_signature = []
    for element in element_list:
        if connectivity_is_indexed:
            connected = [node_coordinates[int(value)] for value in element.connectivity]
        else:
            connected = [coordinates_by_label[int(value)] for value in element.connectivity]
        element_signature.append((str(element.type).upper(), tuple(sorted(connected))))
    return sorted(node_coordinates), sorted(element_signature)


def node_region_signature(region):
    return sorted(
        (
            str(node.instanceName).upper(),
            int(node.label),
            tuple(round(value, 8) for value in point3(node.coordinates)),
        )
        for node in region.nodes
    )


def reference_point_signature(region):
    return sorted(repr(point) for point in region.referencePoints)


def keyword_data(text, keyword):
    result = []
    collecting = False
    for raw_line in text.splitlines():
        line = raw_line.strip()
        if line.startswith("**"):
            continue
        if line.startswith("*"):
            collecting = line.split(",", 1)[0].strip() == keyword
            continue
        if collecting and line:
            result.append(tuple(item.strip() for item in line.split(",")))
    return result


def named_keyword_data(text, keyword, name):
    headers = []
    result = []
    collecting = False
    expected_name = "NAME=" + name
    for raw_line in text.splitlines():
        line = raw_line.strip()
        if line.startswith("**"):
            continue
        if line.startswith("*"):
            fields = [item.strip() for item in line.split(",")]
            collecting = (
                fields[0] == keyword
                and expected_name in [item.replace(" ", "") for item in fields[1:]]
            )
            if collecting:
                headers.append(line)
            continue
        if collecting and line:
            result.append(tuple(item.strip() for item in line.split(",")))
    return headers, result


def check_base_model(model):
    if set(model.parts.keys()) != {"Plate", "Punch"}:
        log("part names mismatch: %s" % list(model.parts.keys()))
        return False
    plate = model.parts["Plate"]
    punch = model.parts["Punch"]
    if not bounds_match(node_bounds(plate.nodes), ((-20.0, 20.0), (-12.0, 0.0), (0.0, 0.0))):
        log("plate geometry mismatch: %s" % (node_bounds(plate.nodes),))
        return False
    if len(plate.nodes) != 533 or len(plate.elements) != 480:
        log("plate mesh count mismatch: nodes=%s elements=%s" % (len(plate.nodes), len(plate.elements)))
        return False
    if len(plate.nodes) + 1 > 1000:
        log("Learning Edition node limit exceeded")
        return False
    if set(str(element.type).upper() for element in plate.elements) != {"CPE4R"}:
        log("plate must use CPE4R plane-strain elements")
        return False
    if set(model.sections.keys()) != {"PlateSection"}:
        log("section repository mismatch")
        return False
    if str(model.sections["PlateSection"].material) != "EngineeringPolymer":
        log("PlateSection material binding mismatch")
        return False
    if len(plate.sectionAssignments) != 1 or str(plate.sectionAssignments[0].sectionName) != "PlateSection":
        log("plate section assignment mismatch")
        return False
    if set(plate.surfaces.keys()) != {"PLATE_TOP"} or set(plate.sets.keys()) != {"PLATE_BOTTOM"}:
        log("plate init surfaces/sets mismatch")
        return False
    if len(punch.nodes) or len(punch.elements) or len(punch.edges) != 2 or len(punch.referencePoints) != 1:
        log("analytical rigid punch topology mismatch")
        return False
    expected_vertices = [(-5.0, 0.0, 0.0), (0.0, -5.0, 0.0), (5.0, 0.0, 0.0)]
    if vertex_coordinates(punch.vertices) != expected_vertices:
        log("punch radius/geometry mismatch: %s" % (vertex_coordinates(punch.vertices),))
        return False
    expected_edge_signature = [(-4.619398, -1.913417, 0.0), (1.913417, -4.619398, 0.0)]
    if analytical_edge_signature(punch.edges) != expected_edge_signature:
        log("punch analytical edge geometry mismatch: %s" % (analytical_edge_signature(punch.edges),))
        return False
    if set(punch.surfaces.keys()) != {"PUNCH_CONTACT"} or set(punch.sets.keys()) != {"PUNCH_RP"}:
        log("punch init surface/reference-point set mismatch")
        return False
    try:
        elastic = model.materials["EngineeringPolymer"].elastic.table[0]
    except Exception:
        log("EngineeringPolymer elastic material missing")
        return False
    if not close(elastic[0], 2100.0) or not close(elastic[1], 0.35):
        log("EngineeringPolymer elastic values mismatch: %s" % (elastic,))
        return False
    assembly = model.rootAssembly
    if set(assembly.instances.keys()) != {"Plate-1", "Punch-1"}:
        log("assembly instance names mismatch: %s" % list(assembly.instances.keys()))
        return False
    if not bounds_match(node_bounds(assembly.instances["Plate-1"].nodes), ((-20.0, 20.0), (-12.0, 0.0), (0.0, 0.0))):
        log("plate instance placement mismatch")
        return False
    expected_instance_vertices = [(-5.0, 5.0, 0.0), (0.0, 0.0, 0.0), (5.0, 5.0, 0.0)]
    if vertex_coordinates(assembly.instances["Punch-1"].vertices) != expected_instance_vertices:
        log("punch instance placement mismatch")
        return False
    return True


def check_init():
    global INIT_PLATE_SIGNATURE, INIT_PUNCH_EDGE_SIGNATURE
    openMdb(pathName=INIT_CAE)
    if MODEL_NAME not in mdb.models:
        log("init model missing")
        return False
    model = mdb.models[MODEL_NAME]
    if not check_base_model(model):
        log("init base model invalid")
        return False
    if set(model.steps.keys()) != {"Initial"}:
        log("init must contain only Initial step")
        return False
    if (
        model.interactions.keys()
        or model.loads.keys()
        or model.boundaryConditions.keys()
        or model.rootAssembly.sets.keys()
        or mdb.jobs.keys()
    ):
        log("init is already completed")
        return False
    plate = model.rootAssembly.instances["Plate-1"]
    INIT_PLATE_SIGNATURE = mesh_signature(plate.nodes, plate.elements)
    INIT_PUNCH_EDGE_SIGNATURE = analytical_edge_signature(model.parts["Punch"].edges)
    return True


def write_input_and_check_cae():
    global CAE_PLATE_SIGNATURE
    openMdb(pathName=GT_CAE)
    if MODEL_NAME not in mdb.models:
        log("GT model missing")
        return False
    model = mdb.models[MODEL_NAME]
    if not check_base_model(model):
        return False
    assembly = model.rootAssembly
    CAE_PLATE_SIGNATURE = mesh_signature(
        assembly.instances["Plate-1"].nodes,
        assembly.instances["Plate-1"].elements,
    )
    if CAE_PLATE_SIGNATURE != INIT_PLATE_SIGNATURE:
        log("init/GT plate node-coordinate or element-connectivity signature mismatch")
        return False
    if analytical_edge_signature(model.parts["Punch"].edges) != INIT_PUNCH_EDGE_SIGNATURE:
        log("init/GT analytical punch edge signature mismatch")
        return False
    if set(model.steps.keys()) != {"Initial", "IndentationStep"}:
        log("analysis steps mismatch: %s" % list(model.steps.keys()))
        return False
    step = model.steps["IndentationStep"]
    if step.__class__.__name__ != "StaticStep" or str(step.nlgeom).upper() != "ON":
        log("nonlinear StaticStep missing")
        return False
    if (
        not close(step.initialInc, 0.01)
        or not close(step.minInc, 1.0e-6)
        or not close(step.maxInc, 0.05)
        or int(step.maxNumInc) != 300
    ):
        log("step increment controls mismatch")
        return False
    if set(model.interactions.keys()) != {"PunchPlateContact"}:
        log("contact interaction mismatch")
        return False
    interaction = model.interactions["PunchPlateContact"]
    if (
        interaction.__class__.__name__ != "SurfaceToSurfaceStd"
        or str(interaction.sliding).upper() != "FINITE"
        or bool(interaction.suppressed)
    ):
        log("surface-to-surface finite-sliding contact missing")
        return False
    if "PUNCH_CONTACT" not in repr(interaction.main).upper() or "PLATE_TOP" not in repr(interaction.secondary).upper():
        log("contact surfaces mismatch")
        return False
    try:
        prop = model.interactionProperties["FrictionlessHard"]
        if str(prop.normalBehavior.pressureOverclosure).upper() != "HARD":
            raise ValueError("normal behavior")
        if str(prop.normalBehavior.allowSeparation).upper() != "ON":
            raise ValueError("separation behavior")
        if str(prop.tangentialBehavior.formulation).upper() != "FRICTIONLESS":
            raise ValueError("tangential behavior")
    except Exception:
        log("hard frictionless contact property missing")
        return False
    if model.loads.keys():
        log("unexpected external load repository")
        return False
    if set(model.boundaryConditions.keys()) != {"PlateBottomFixed", "PunchMotion"}:
        log("boundary-condition repository mismatch")
        return False
    if set(assembly.sets.keys()) != {"PLATE_BOTTOM_NODES", "PUNCH_RP_NODE"}:
        log("result-extraction assembly sets mismatch")
        return False
    if node_region_signature(assembly.sets["PLATE_BOTTOM_NODES"]) != node_region_signature(
        assembly.instances["Plate-1"].sets["PLATE_BOTTOM"]
    ):
        log("PLATE_BOTTOM_NODES members do not match Plate-1.PLATE_BOTTOM")
        return False
    if reference_point_signature(assembly.sets["PUNCH_RP_NODE"]) != reference_point_signature(
        assembly.instances["Punch-1"].sets["PUNCH_RP"]
    ):
        log("PUNCH_RP_NODE members do not match Punch-1.PUNCH_RP")
        return False
    if (
        set(mdb.jobs.keys()) != {JOB_NAME}
        or mdb.jobs[JOB_NAME].model != MODEL_NAME
        or int(mdb.jobs[JOB_NAME].numCpus) != 1
    ):
        log("job/model association mismatch")
        return False
    os.chdir(DESKTOP)
    mdb.jobs[JOB_NAME].writeInput(consistencyChecking=OFF)
    input_path = os.path.join(DESKTOP, JOB_NAME + ".inp")
    text = open(input_path, "r").read().upper()
    required_fragments = (
        "*ELEMENT, TYPE=CPE4R",
        "*RIGID BODY, REF NODE=PUNCH-1-REFPT_, ANALYTICAL SURFACE=PUNCH_CONTACT",
        "*SURFACE INTERACTION, NAME=FRICTIONLESSHARD",
        "*FRICTION\n0.",
        "*SURFACE BEHAVIOR, PRESSURE-OVERCLOSURE=HARD",
        "*STEP, NAME=INDENTATIONSTEP, NLGEOM=YES, INC=300",
    )
    for fragment in required_fragments:
        if fragment not in text:
            log("generated input missing semantic fragment: " + fragment)
            return False
    surface_headers, surface_data = named_keyword_data(text, "*SURFACE", "PUNCH_CONTACT")
    expected_surface_header = "*SURFACE, TYPE=SEGMENTS, NAME=PUNCH_CONTACT"
    if surface_headers != [expected_surface_header] or len(surface_data) != 3:
        log("PUNCH_CONTACT must be one analytical TYPE=SEGMENTS surface")
        return False
    if (
        surface_data[0][0] != "START"
        or surface_data[1][0] != "CIRCL"
        or surface_data[2][0] != "CIRCL"
        or len(surface_data[0]) != 3
        or len(surface_data[1]) != 5
        or len(surface_data[2]) != 5
    ):
        log("PUNCH_CONTACT must contain START followed by two CIRCL arcs and no LINE segments")
        return False
    try:
        start = tuple(float(value) for value in surface_data[0][1:])
        first_end = tuple(float(value) for value in surface_data[1][1:3])
        first_center = tuple(float(value) for value in surface_data[1][3:5])
        second_end = tuple(float(value) for value in surface_data[2][1:3])
        second_center = tuple(float(value) for value in surface_data[2][3:5])
    except Exception:
        log("PUNCH_CONTACT analytical segment coordinates are invalid")
        return False
    expected_points = (
        (start, (5.0, 0.0)),
        (first_end, (0.0, -5.0)),
        (first_center, (0.0, 0.0)),
        (second_end, (-5.0, 0.0)),
        (second_center, (0.0, 0.0)),
    )
    if any(not all(close(actual, wanted) for actual, wanted in zip(observed, expected)) for observed, expected in expected_points):
        log("PUNCH_CONTACT CIRCL endpoint or common-center geometry mismatch")
        return False
    arc_points = (start, first_end, second_end)
    if any(not close(math.hypot(point[0], point[1]), 5.0) for point in arc_points):
        log("PUNCH_CONTACT CIRCL radius must be 5")
        return False
    contact_lines = re.findall(r"(?m)^\*CONTACT PAIR[^\n]*", text)
    expected_contact = "*CONTACT PAIR, INTERACTION=FRICTIONLESSHARD, TYPE=SURFACE TO SURFACE"
    first_step = text.find("*STEP")
    contact_position = text.find(expected_contact)
    if (
        contact_lines != [expected_contact]
        or contact_position < 0
        or first_step < 0
        or contact_position >= first_step
        or keyword_data(text, "*CONTACT PAIR") != [
            ("PLATE-1.PLATE_TOP", "PUNCH-1.PUNCH_CONTACT")
        ]
    ):
        log("contact-pair count mismatch")
        return False
    expected_boundaries = sorted([
        ("PLATE-1.PLATE_BOTTOM", "ENCASTRE"),
        ("PUNCH-1.PUNCH_RP", "1", "1"),
        ("PUNCH-1.PUNCH_RP", "2", "2", "-0.1"),
        ("PUNCH-1.PUNCH_RP", "6", "6"),
    ])
    if sorted(keyword_data(text, "*BOUNDARY")) != expected_boundaries:
        log("generated input boundary-condition DOFs mismatch")
        return False
    static_data = keyword_data(text, "*STATIC")
    if (
        len(static_data) != 1
        or len(static_data[0]) != 4
        or not all(
            close(actual, expected)
            for actual, expected in zip(static_data[0], (0.01, 1.0, 1.0e-6, 0.05))
        )
    ):
        log("generated input Static increment controls mismatch")
        return False
    if re.search(r"(?m)^\*(?:CLOAD|DLOAD|DSLOAD)\b", text):
        log("unexpected force/pressure load keyword")
        return False
    displacement = re.search(
        r"(?m)^\s*PUNCH-1\.PUNCH_RP\s*,\s*2\s*,\s*2\s*,\s*(" + FLOAT + r")\s*$",
        text,
    )
    if not displacement or not close(displacement.group(1), -0.1):
        log("-0.1 mm punch displacement missing from generated input")
        return False
    return True


def field_by_prefix(frame, prefix):
    matches = [name for name in frame.fieldOutputs.keys() if str(name).strip().upper().startswith(prefix)]
    if len(matches) != 1:
        raise ValueError("field prefix %s matched %s" % (prefix, matches))
    return matches[0], frame.fieldOutputs[matches[0]]


def scalar(value):
    try:
        return float(value.data)
    except Exception:
        return float(value.data[0])


def check_odb_and_metrics():
    odb = openOdb(path=ODB_PATH, readOnly=True)
    try:
        status = str(odb.diagnosticData.jobStatus).upper()
        if status != "JOB_STATUS_COMPLETED_SUCCESSFULLY":
            log("ODB job status mismatch: " + status)
            return False
        if set(odb.steps.keys()) != {"IndentationStep"}:
            log("ODB step names mismatch")
            return False
        step = odb.steps["IndentationStep"]
        if len(step.frames) < 2:
            log("ODB has too few converged frames")
            return False
        frame = step.frames[-1]
        if not close(frame.frameValue, 1.0, rel=1.0e-5):
            log("analysis did not reach full step time")
            return False
        instances = odb.rootAssembly.instances
        if set(instances.keys()) != {"PLATE-1", "PUNCH-1"}:
            log("ODB instance names mismatch")
            return False
        plate = instances["PLATE-1"]
        punch = instances["PUNCH-1"]
        if len(plate.nodes) != 533 or len(plate.elements) != 480:
            log("ODB plate mesh mismatch")
            return False
        if not bounds_match(node_bounds(plate.nodes), ((-20.0, 20.0), (-12.0, 0.0), (0.0, 0.0))):
            log("ODB plate bounds mismatch")
            return False
        if mesh_signature(plate.nodes, plate.elements) != CAE_PLATE_SIGNATURE:
            log("CAE/ODB plate node-coordinate or element-connectivity signature mismatch")
            return False
        if len(punch.nodes) != 1 or len(punch.elements) != 0:
            log("ODB analytical rigid punch topology mismatch")
            return False
        punch_coordinate = point3(punch.nodes[0].coordinates)
        if any(abs(punch_coordinate[index] - (0.0, 5.0, 0.0)[index]) > 1.0e-6 for index in range(3)):
            log("ODB punch reference-point location mismatch: %s" % (punch_coordinate,))
            return False
        for set_name in ("PLATE_BOTTOM_NODES", "PUNCH_RP_NODE"):
            if set_name not in odb.rootAssembly.nodeSets:
                log("ODB node set missing: " + set_name)
                return False
        for field_name in ("U", "S", "RF"):
            if field_name not in frame.fieldOutputs:
                log("ODB field missing: " + field_name)
                return False
        cpress_name, cpress = field_by_prefix(frame, "CPRESS")
        copen_name, copen = field_by_prefix(frame, "COPEN")
        for field_name in (cpress_name, copen_name):
            normalized = str(field_name).upper()
            if "PLATE-1_PLATE_TOP" not in normalized or "PUNCH-1_PUNCH_CONTACT" not in normalized:
                log("contact output belongs to unexpected surfaces: " + normalized)
                return False
        pressure_values = [scalar(value) for value in cpress.values if finite(scalar(value))]
        positive_pressures = [value for value in pressure_values if value > 1.0e-8]
        if len(positive_pressures) < 2:
            log("insufficient active contact pressure values")
            return False
        opening_values = [
            scalar(value) for value in copen.values
            if finite(scalar(value)) and scalar(value) > -1.0e30
        ]
        if (
            len(opening_values) < 3
            or min(opening_values) < -0.02
            or max(opening_values) > 0.5
            or min(opening_values) > 0.0
        ):
            log("COPEN values are missing or inconsistent with punch contact")
            return False
        max_contact_pressure = max(positive_pressures)
        bottom = odb.rootAssembly.nodeSets["PLATE_BOTTOM_NODES"]
        punch_rp = odb.rootAssembly.nodeSets["PUNCH_RP_NODE"]
        bottom_reaction = math.fsum(
            float(value.data[1])
            for value in frame.fieldOutputs["RF"].getSubset(region=bottom).values
        )
        rp_reaction = math.fsum(
            float(value.data[1])
            for value in frame.fieldOutputs["RF"].getSubset(region=punch_rp).values
        )
        displacement_values = frame.fieldOutputs["U"].getSubset(region=punch_rp).values
        if len(displacement_values) != 1:
            log("punch reference-point displacement cardinality mismatch")
            return False
        punch_displacement = float(displacement_values[0].data[1])
        max_mises = max(
            [float(value.mises) for value in frame.fieldOutputs["S"].values if finite(value.mises)]
            or [0.0]
        )
        punch_reaction = abs(rp_reaction)
        if not (5.0 < max_contact_pressure < 500.0):
            log("contact pressure outside physical range")
            return False
        if not close(punch_displacement, -0.1, rel=1.0e-5, abs_tol=1.0e-6):
            log("ODB punch displacement mismatch: %s" % punch_displacement)
            return False
        if not (1.0 < punch_reaction < 1000.0):
            log("punch reaction outside physical range")
            return False
        if bottom_reaction * rp_reaction >= 0.0:
            log("bottom and punch raw reactions must have opposite signs")
            return False
        if not close(abs(bottom_reaction), abs(rp_reaction), rel=0.002, abs_tol=1.0):
            log("opposing reaction-force imbalance: bottom=%s punch=%s" % (bottom_reaction, punch_reaction))
            return False
        if not (1.0 < max_mises < 500.0):
            log("stress outside physical range")
            return False
        recomputed = {
            "max_contact_pressure": max_contact_pressure,
            "punch_vertical_displacement": punch_displacement,
            "punch_reaction_force": punch_reaction,
            "max_mises_stress": max_mises,
        }
        metrics = json.load(open(METRICS_PATH, "r"))
        if set(metrics.keys()) != set(recomputed.keys()):
            log("metrics fields mismatch")
            return False
        for name, expected in recomputed.items():
            if not finite(metrics[name]) or not close(metrics[name], expected, rel=2.0e-6, abs_tol=1.0e-10):
                log("metrics/ODB mismatch for %s" % name)
                return False
        RECOMPUTED.update(recomputed)
        return True
    finally:
        odb.close()


def main():
    ok = False
    try:
        ok = check_init() and write_input_and_check_cae() and check_odb_and_metrics()
    except Exception:
        log(traceback.format_exc())
        ok = False
    with open(RESULT_PATH, "w") as handle:
        handle.write("True\n" if ok else "False\n")
    with open(DETAIL_PATH, "w") as handle:
        handle.write("\n".join(DETAILS) + "\n")
    with open(EVIDENCE_PATH, "w") as handle:
        json.dump({"passed": ok, "recomputed_metrics": RECOMPUTED, "details": DETAILS}, handle, indent=2, sort_keys=True)


if __name__ == "__main__":
    main()
'''


def is_nonempty(path: Path) -> bool:
    return path.is_file() and path.stat().st_size > 0


def discover_result_pair():
    root = DESKTOP / "result"
    if not root.is_dir():
        return None
    caes = sorted(path for path in root.glob("*.cae") if is_nonempty(path))
    odbs = sorted(path for path in root.glob("*.odb") if is_nonempty(path))
    if len(caes) != 1 or len(odbs) != 1:
        return None
    cae_stem = caes[0].stem.lower()
    odb_stem = odbs[0].stem.lower()
    if cae_stem not in {odb_stem, odb_stem + "_gt"}:
        return None
    return caes[0], odbs[0]


def evaluate() -> bool:
    pair = discover_result_pair()
    if pair is None:
        return False
    gt_cae, odb = pair
    required = (INIT_CAE, gt_cae, odb, METRICS)
    if not ABAQUS.is_file() or any(not is_nonempty(path) for path in required):
        return False
    for stale in (RESULT, DETAIL, EVIDENCE):
        try:
            stale.unlink()
        except FileNotFoundError:
            pass
    try:
        checker_source = (
            CHECKER_SOURCE
            .replace("Task18_PunchPlate_GT.cae", gt_cae.name)
            .replace("Task18_PunchPlate.odb", odb.name)
        )
        CHECKER.write_text(checker_source, encoding="utf-8")
        completed = subprocess.run(
            [str(ABAQUS), "cae", "noGUI=" + str(CHECKER)],
            cwd=str(DESKTOP),
            text=True,
            capture_output=True,
            timeout=120,
            shell=False,
        )
        if completed.returncode != 0 or not is_nonempty(RESULT):
            return False
        return RESULT.read_text(encoding="utf-8", errors="ignore") == "True\n"
    except Exception:
        return False


def main() -> None:
    passed = evaluate()
    if not passed and DETAIL.is_file():
        sys.stderr.write(DETAIL.read_text(encoding="utf-8", errors="replace"))
    print("True" if passed else "False")


if __name__ == "__main__":
    main()