| |
| 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 / "task08_block_plate_init.cae" |
| GT_CAE = DESKTOP / "result" / "Task08_BlockPlate_GT.cae" |
| ODB = DESKTOP / "result" / "Task08_BlockPlate.odb" |
| METRICS = DESKTOP / "result" / "metrics.json" |
| CHECKER = DESKTOP / "__task08_abaqus_checker.py" |
| RESULT = DESKTOP / "__task08_abaqus_result.txt" |
| DETAIL = DESKTOP / "__task08_abaqus_detail.txt" |
| EVIDENCE = DESKTOP / "__task08_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, "task08_block_plate_init.cae") |
| GT_CAE = os.path.join(DESKTOP, "result", "Task08_BlockPlate_GT.cae") |
| ODB_PATH = os.path.join(DESKTOP, "result", "Task08_BlockPlate.odb") |
| METRICS_PATH = os.path.join(DESKTOP, "result", "metrics.json") |
| RESULT_PATH = os.path.join(DESKTOP, "__task08_abaqus_result.txt") |
| DETAIL_PATH = os.path.join(DESKTOP, "__task08_abaqus_detail.txt") |
| EVIDENCE_PATH = os.path.join(DESKTOP, "__task08_abaqus_evidence.json") |
| JOB_NAME = "Task08_BlockPlate" |
| MODEL_NAME = "BlockPlate3D" |
| FLOAT = r"[-+]?(?:\d+(?:\.\d*)?|\.\d+)(?:[Ee][-+]?\d+)?" |
| DETAILS = [] |
| RECOMPUTED = {} |
| INIT_SIGNATURES = {} |
| CAE_SIGNATURES = {} |
| |
| |
| 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 bounds(nodes): |
| xyz = [tuple(float(value) for value in 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 mesh_signature(nodes, elements): |
| node_list = list(nodes) |
| node_coordinates = [ |
| tuple(round(float(value), 8) for value in 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)))) |
| node_signature = sorted(node_coordinates) |
| element_signature.sort() |
| return node_signature, element_signature |
| |
| |
| def node_region_signature(region): |
| return sorted( |
| ( |
| str(node.instanceName).upper(), |
| int(node.label), |
| tuple(round(float(value), 8) for value in node.coordinates), |
| ) |
| for node in region.nodes |
| ) |
| |
| |
| 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 check_base_model(model): |
| if set(model.parts.keys()) != {"Plate", "Block"}: |
| log("part names mismatch: %s" % list(model.parts.keys())) |
| return False |
| plate = model.parts["Plate"] |
| block = model.parts["Block"] |
| if not bounds_match(bounds(plate.nodes), ((0.0, 24.0), (0.0, 24.0), (0.0, 3.0))): |
| log("plate geometry mismatch: %s" % (bounds(plate.nodes),)) |
| return False |
| if not bounds_match(bounds(block.nodes), ((0.0, 8.0), (0.0, 8.0), (0.0, 8.0))): |
| log("block geometry mismatch: %s" % (bounds(block.nodes),)) |
| return False |
| if len(plate.nodes) != 162 or len(plate.elements) != 64: |
| log("plate mesh count mismatch: nodes=%s elements=%s" % (len(plate.nodes), len(plate.elements))) |
| return False |
| if len(block.nodes) != 125 or len(block.elements) != 64: |
| log("block mesh count mismatch: nodes=%s elements=%s" % (len(block.nodes), len(block.elements))) |
| return False |
| if len(plate.nodes) + len(block.nodes) > 1000: |
| log("Learning Edition node limit exceeded") |
| return False |
| element_types = set(str(element.type).upper() for part in (plate, block) for element in part.elements) |
| if element_types != {"C3D8R"}: |
| log("element types mismatch: %s" % sorted(element_types)) |
| return False |
| if set(model.sections.keys()) != {"SteelSection"}: |
| log("section repository mismatch") |
| return False |
| if str(model.sections["SteelSection"].material) != "Steel": |
| log("SteelSection material binding mismatch") |
| return False |
| if any( |
| len(part.sectionAssignments) != 1 |
| or str(part.sectionAssignments[0].sectionName) != "SteelSection" |
| for part in (plate, block) |
| ): |
| log("part 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 set(block.surfaces.keys()) != {"BLOCK_BOTTOM", "BLOCK_TOP"}: |
| log("block init surfaces mismatch") |
| return False |
| if set(block.sets.keys()) != {"BLOCK_ANCHOR", "BLOCK_GUIDE", "BLOCK_TOP_NODES"}: |
| log("block init node sets mismatch") |
| return False |
| try: |
| elastic = model.materials["Steel"].elastic.table[0] |
| except Exception: |
| log("Steel elastic material missing") |
| return False |
| if not close(elastic[0], 210000.0) or not close(elastic[1], 0.3): |
| log("Steel elastic values mismatch: %s" % (elastic,)) |
| return False |
| assembly = model.rootAssembly |
| if set(assembly.instances.keys()) != {"Plate-1", "Block-1"}: |
| log("assembly instance names mismatch: %s" % list(assembly.instances.keys())) |
| return False |
| if not bounds_match(bounds(assembly.instances["Plate-1"].nodes), ((0.0, 24.0), (0.0, 24.0), (0.0, 3.0))): |
| log("plate instance placement mismatch") |
| return False |
| if not bounds_match(bounds(assembly.instances["Block-1"].nodes), ((8.0, 16.0), (8.0, 16.0), (3.0, 11.0))): |
| log("block instance placement mismatch") |
| return False |
| return True |
| |
| |
| def check_init(): |
| 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 |
| for instance_name in ("Plate-1", "Block-1"): |
| instance = model.rootAssembly.instances[instance_name] |
| INIT_SIGNATURES[instance_name] = mesh_signature(instance.nodes, instance.elements) |
| return True |
| |
| |
| def write_input_and_check_cae(): |
| 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 |
| for instance_name in ("Plate-1", "Block-1"): |
| instance = assembly.instances[instance_name] |
| signature = mesh_signature(instance.nodes, instance.elements) |
| if signature != INIT_SIGNATURES.get(instance_name): |
| log("init/GT node-coordinate or element-connectivity signature mismatch: " + instance_name) |
| return False |
| CAE_SIGNATURES[instance_name] = signature |
| if set(model.steps.keys()) != {"Initial", "ContactStep"}: |
| log("analysis steps mismatch: %s" % list(model.steps.keys())) |
| return False |
| step = model.steps["ContactStep"] |
| if step.__class__.__name__ != "StaticStep" or str(step.nlgeom).upper() != "ON": |
| log("nonlinear StaticStep missing") |
| return False |
| if ( |
| not close(step.initialInc, 0.05) |
| or not close(step.minInc, 1.0e-6) |
| or not close(step.maxInc, 0.1) |
| or int(step.maxNumInc) != 200 |
| ): |
| log("step increment controls mismatch") |
| return False |
| if set(model.interactions.keys()) != {"BlockPlateContact"}: |
| log("contact interaction mismatch") |
| return False |
| interaction = model.interactions["BlockPlateContact"] |
| 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 "PLATE_TOP" not in repr(interaction.main).upper() or "BLOCK_BOTTOM" 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 set(model.loads.keys()) != {"BlockTopPressure"}: |
| log("pressure load repository mismatch") |
| return False |
| if "BLOCK_TOP" not in repr(model.loads["BlockTopPressure"].region).upper(): |
| log("pressure region mismatch") |
| return False |
| if set(model.boundaryConditions.keys()) != {"PlateBottomFixed", "BlockAnchorXY", "BlockGuideY"}: |
| log("boundary-condition repository mismatch") |
| return False |
| if set(assembly.sets.keys()) != {"PLATE_BOTTOM_NODES", "BLOCK_TOP_NODES"}: |
| 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 node_region_signature(assembly.sets["BLOCK_TOP_NODES"]) != node_region_signature( |
| assembly.instances["Block-1"].sets["BLOCK_TOP_NODES"] |
| ): |
| log("BLOCK_TOP_NODES members do not match Block-1.BLOCK_TOP_NODES") |
| 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=C3D8R", |
| "*SURFACE INTERACTION, NAME=FRICTIONLESSHARD", |
| "*FRICTION\n0.", |
| "*SURFACE BEHAVIOR, PRESSURE-OVERCLOSURE=HARD", |
| "*STEP, NAME=CONTACTSTEP, NLGEOM=YES, INC=200", |
| ) |
| for fragment in required_fragments: |
| if fragment not in text: |
| log("generated input missing semantic fragment: " + fragment) |
| 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") != [ |
| ("BLOCK-1.BLOCK_BOTTOM", "PLATE-1.PLATE_TOP") |
| ] |
| ): |
| log("contact-pair count mismatch") |
| return False |
| expected_boundaries = sorted([ |
| ("BLOCK-1.BLOCK_ANCHOR", "1", "1"), |
| ("BLOCK-1.BLOCK_ANCHOR", "2", "2"), |
| ("BLOCK-1.BLOCK_GUIDE", "2", "2"), |
| ("PLATE-1.PLATE_BOTTOM", "ENCASTRE"), |
| ]) |
| 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.05, 1.0, 1.0e-6, 0.1)) |
| ) |
| ): |
| log("generated input Static increment controls mismatch") |
| return False |
| if len(re.findall(r"(?m)^\*DSLOAD\b", text)) != 1 or re.search(r"(?m)^\*(?:CLOAD|DLOAD)\b", text): |
| log("unexpected load keyword count") |
| return False |
| pressure = re.search( |
| r"(?ms)^\*DSLOAD[^\n]*\n\s*BLOCK-1\.BLOCK_TOP\s*,\s*P\s*,\s*(" + FLOAT + r")", |
| text, |
| ) |
| if not pressure or not close(pressure.group(1), 2.0): |
| log("2 MPa pressure 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()) != {"ContactStep"}: |
| log("ODB step names mismatch") |
| return False |
| step = odb.steps["ContactStep"] |
| 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 load time") |
| return False |
| instances = odb.rootAssembly.instances |
| if set(instances.keys()) != {"PLATE-1", "BLOCK-1"}: |
| log("ODB instance names mismatch") |
| return False |
| if len(instances["PLATE-1"].nodes) != 162 or len(instances["PLATE-1"].elements) != 64: |
| log("ODB plate mesh mismatch") |
| return False |
| if len(instances["BLOCK-1"].nodes) != 125 or len(instances["BLOCK-1"].elements) != 64: |
| log("ODB block mesh mismatch") |
| return False |
| if not bounds_match(bounds(instances["PLATE-1"].nodes), ((0.0, 24.0), (0.0, 24.0), (0.0, 3.0))): |
| log("ODB plate bounds mismatch") |
| return False |
| if not bounds_match(bounds(instances["BLOCK-1"].nodes), ((8.0, 16.0), (8.0, 16.0), (3.0, 11.0))): |
| log("ODB block bounds mismatch") |
| return False |
| for cae_name, odb_name in (("Plate-1", "PLATE-1"), ("Block-1", "BLOCK-1")): |
| if mesh_signature(instances[odb_name].nodes, instances[odb_name].elements) != CAE_SIGNATURES.get(cae_name): |
| log("CAE/ODB node-coordinate or element-connectivity signature mismatch: " + cae_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 "BLOCK-1_BLOCK_BOTTOM" not in normalized or "PLATE-1_PLATE_TOP" 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) < 9: |
| log("insufficient active contact pressure values") |
| return False |
| opening_values = [scalar(value) for value in copen.values if finite(scalar(value))] |
| if not opening_values or min(opening_values) < -1.0e-5 or max(opening_values) > 0.01: |
| log("COPEN values are missing or inconsistent with closed contact") |
| return False |
| max_contact_pressure = max(positive_pressures) |
| block_top = odb.rootAssembly.nodeSets["BLOCK_TOP_NODES"] |
| displacement_values = frame.fieldOutputs["U"].getSubset(region=block_top).values |
| vertical_displacement = min(float(value.data[2]) for value in displacement_values) |
| plate_bottom = odb.rootAssembly.nodeSets["PLATE_BOTTOM_NODES"] |
| reaction_values = frame.fieldOutputs["RF"].getSubset(region=plate_bottom).values |
| reaction_force = abs(math.fsum(float(value.data[2]) for value in reaction_values)) |
| mises_values = [] |
| for value in frame.fieldOutputs["S"].values: |
| try: |
| mises_values.append(float(value.mises)) |
| except Exception: |
| pass |
| max_mises = max(mises_values or [0.0]) |
| expected_force = 2.0 * 8.0 * 8.0 |
| if not (1.5 < max_contact_pressure < 4.0): |
| log("contact pressure outside physical range") |
| return False |
| if not (-0.01 < vertical_displacement < -1.0e-6): |
| log("vertical displacement outside physical range") |
| return False |
| if not close(reaction_force, expected_force, rel=0.01, abs_tol=0.25): |
| log("reaction/load imbalance: reaction=%s expected=%s" % (reaction_force, expected_force)) |
| return False |
| if not (0.1 < max_mises < 20.0): |
| log("stress outside physical range") |
| return False |
| recomputed = { |
| "max_contact_pressure": max_contact_pressure, |
| "vertical_displacement": vertical_displacement, |
| "reaction_force": reaction_force, |
| "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("Task08_BlockPlate_GT.cae", gt_cae.name) |
| .replace("Task08_BlockPlate.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=90, |
| 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() |
|
|
