#!/usr/bin/env python3 """Generate the NAFEMS LE10 thick-plate solid benchmark deck for FemLite.""" from __future__ import annotations import math from dataclasses import dataclass from pathlib import Path from typing import Dict, Iterable, List, Sequence, Tuple INNER_A = 2.0 INNER_B = 1.0 OUTER_A = 3.25 OUTER_B = 2.75 THICKNESS = 0.6 YOUNG_MODULUS = 2.10e11 POISSON_RATIO = 0.30 DENSITY = 7850.0 TOP_PRESSURE = 1.0e6 N_RADIAL = 4 N_THETA = 16 N_Z = 2 RADIAL_BIAS = 1.25 SET_LINE_WIDTH = 12 STATIC_INITIAL_INCREMENT = 1.0 STATIC_TOTAL_TIME = 1.0 STATIC_MIN_INCREMENT = 0.1 STATIC_MAX_INCREMENT = 1.0 Point3 = Tuple[float, float, float] Element = Tuple[int, ...] Logical = Tuple[int, int, int] @dataclass class Mesh: nodes: Dict[int, Point3] node_logic: Dict[int, Logical] elements: List[Element] d_node: int d_probe_element: int top_loads: Dict[int, float] top_area: float def biased_radial_fraction(i2: int) -> float: eta = float(i2) / float(2 * N_RADIAL) return eta**RADIAL_BIAS def point_from_logic(i2: int, j2: int, k2: int) -> Point3: theta = 0.5 * math.pi * float(j2) / float(2 * N_THETA) radial = biased_radial_fraction(i2) xi = math.cos(theta) yi = math.sin(theta) inner = (INNER_A * xi, INNER_B * yi) outer = (OUTER_A * xi, OUTER_B * yi) x = inner[0] + radial * (outer[0] - inner[0]) y = inner[1] + radial * (outer[1] - inner[1]) z = THICKNESS * float(k2) / float(2 * N_Z) if abs(x) < 1.0e-12: x = 0.0 if abs(y) < 1.0e-12: y = 0.0 if abs(z) < 1.0e-12: z = 0.0 if abs(z - THICKNESS) < 1.0e-12: z = THICKNESS return (x, y, z) def add_node( nodes: Dict[int, Point3], node_logic: Dict[int, Logical], lookup: Dict[Logical, int], logic: Logical, ) -> int: existing = lookup.get(logic) if existing is not None: return existing node_id = len(nodes) + 1 lookup[logic] = node_id nodes[node_id] = point_from_logic(*logic) node_logic[node_id] = logic return node_id def element_nodes( nodes: Dict[int, Point3], node_logic: Dict[int, Logical], lookup: Dict[Logical, int], i: int, j: int, k: int, ) -> Element: i0 = 2 * i i1 = 2 * (i + 1) im = i0 + 1 j0 = 2 * j j1 = 2 * (j + 1) jm = j0 + 1 k0 = 2 * k k1 = 2 * (k + 1) km = k0 + 1 logic_nodes = ( (i0, j0, k0), (i1, j0, k0), (i1, j1, k0), (i0, j1, k0), (i0, j0, k1), (i1, j0, k1), (i1, j1, k1), (i0, j1, k1), (im, j0, k0), (i1, jm, k0), (im, j1, k0), (i0, jm, k0), (im, j0, k1), (i1, jm, k1), (im, j1, k1), (i0, jm, k1), (i0, j0, km), (i1, j0, km), (i1, j1, km), (i0, j1, km), ) return tuple(add_node(nodes, node_logic, lookup, logic) for logic in logic_nodes) def shape_quad8(r: float, s: float) -> Tuple[List[float], List[float], List[float]]: n = [ 0.25 * (1.0 - r) * (1.0 - s) * (-r - s - 1.0), 0.25 * (1.0 + r) * (1.0 - s) * (r - s - 1.0), 0.25 * (1.0 + r) * (1.0 + s) * (r + s - 1.0), 0.25 * (1.0 - r) * (1.0 + s) * (-r + s - 1.0), 0.5 * (1.0 - r * r) * (1.0 - s), 0.5 * (1.0 + r) * (1.0 - s * s), 0.5 * (1.0 - r * r) * (1.0 + s), 0.5 * (1.0 - r) * (1.0 - s * s), ] dndr = [ 0.25 * (1.0 - s) * (2.0 * r + s), 0.25 * (1.0 - s) * (2.0 * r - s), 0.25 * (1.0 + s) * (2.0 * r + s), 0.25 * (1.0 + s) * (2.0 * r - s), -r * (1.0 - s), 0.5 * (1.0 - s * s), -r * (1.0 + s), -0.5 * (1.0 - s * s), ] dnds = [ 0.25 * (1.0 - r) * (r + 2.0 * s), 0.25 * (1.0 + r) * (-r + 2.0 * s), 0.25 * (1.0 + r) * (r + 2.0 * s), 0.25 * (1.0 - r) * (-r + 2.0 * s), -0.5 * (1.0 - r * r), -(1.0 + r) * s, 0.5 * (1.0 - r * r), -(1.0 - r) * s, ] return n, dndr, dnds def cross(a: Point3, b: Point3) -> Point3: return ( a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0], ) def norm(v: Point3) -> float: return math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]) def top_face_pressure_loads(nodes: Dict[int, Point3], elements: Sequence[Element]) -> Tuple[Dict[int, float], float]: gp = [-math.sqrt(3.0 / 5.0), 0.0, math.sqrt(3.0 / 5.0)] gw = [5.0 / 9.0, 8.0 / 9.0, 5.0 / 9.0] loads = {node_id: 0.0 for node_id in nodes} area = 0.0 for elem in elements[(N_Z - 1) * N_THETA * N_RADIAL :]: face_nodes = [elem[index] for index in (4, 5, 6, 7, 12, 13, 14, 15)] coords = [nodes[node_id] for node_id in face_nodes] for r, wr in zip(gp, gw): for s, ws in zip(gp, gw): n, dndr, dnds = shape_quad8(r, s) tangent_r = ( sum(dndr[a] * coords[a][0] for a in range(8)), sum(dndr[a] * coords[a][1] for a in range(8)), sum(dndr[a] * coords[a][2] for a in range(8)), ) tangent_s = ( sum(dnds[a] * coords[a][0] for a in range(8)), sum(dnds[a] * coords[a][1] for a in range(8)), sum(dnds[a] * coords[a][2] for a in range(8)), ) jac = norm(cross(tangent_r, tangent_s)) weight = wr * ws area += jac * weight for a, node_id in enumerate(face_nodes): loads[node_id] -= TOP_PRESSURE * n[a] * jac * weight return loads, area def build_mesh() -> Mesh: nodes: Dict[int, Point3] = {} node_logic: Dict[int, Logical] = {} lookup: Dict[Logical, int] = {} elements: List[Element] = [] d_probe_element = 0 for k in range(N_Z): for j in range(N_THETA): for i in range(N_RADIAL): if i == 0 and j == 0 and k == N_Z - 1: d_probe_element = len(elements) + 1 elements.append(element_nodes(nodes, node_logic, lookup, i, j, k)) d_node = lookup[(0, 0, 2 * N_Z)] top_loads, top_area = top_face_pressure_loads(nodes, elements) return Mesh( nodes=nodes, node_logic=node_logic, elements=elements, d_node=d_node, d_probe_element=d_probe_element, top_loads=top_loads, top_area=top_area, ) def nodes_matching(mesh: Mesh, predicate) -> List[int]: return sorted(node_id for node_id, logic in mesh.node_logic.items() if predicate(logic)) def write_id_set(handle, ids: Sequence[int]) -> None: for index in range(0, len(ids), SET_LINE_WIDTH): handle.write(", ".join(str(item) for item in ids[index : index + SET_LINE_WIDTH])) handle.write("\n") def nonzero_loads(loads: Dict[int, float]) -> List[Tuple[int, float]]: return [(node_id, value) for node_id, value in sorted(loads.items()) if abs(value) > 1.0e-8] def write_inp(path: Path, mesh: Mesh) -> None: x_sym = nodes_matching(mesh, lambda logic: logic[1] == 2 * N_THETA) y_sym = nodes_matching(mesh, lambda logic: logic[1] == 0) outer_surface = nodes_matching(mesh, lambda logic: logic[0] == 2 * N_RADIAL) outer_midplane = nodes_matching( mesh, lambda logic: logic[0] == 2 * N_RADIAL and logic[2] == N_Z, ) loads = nonzero_loads(mesh.top_loads) total_load = sum(value for _, value in loads) exact_area = 0.25 * math.pi * (OUTER_A * OUTER_B - INNER_A * INNER_B) with path.open("w", encoding="ascii", newline="\n") as handle: handle.write("*HEADING\n") handle.write("FemLite NAFEMS LE10 thick plate pressure benchmark\n") handle.write( f"** inner_ellipse=({INNER_A:.10E},{INNER_B:.10E}), " f"outer_ellipse=({OUTER_A:.10E},{OUTER_B:.10E}), " f"thickness={THICKNESS:.10E}\n" ) handle.write( f"** top_pressure={TOP_PRESSURE:.10E}, integrated_top_area={mesh.top_area:.10E}, " f"exact_top_area={exact_area:.10E}, total_Fz={total_load:.10E}\n" ) handle.write( f"** D_NODE={mesh.d_node}, D_PROBE_ELEMENT={mesh.d_probe_element}, " "D_COORD=(2.0,0.0,0.6), NAFEMS_s22_D=-5.38E6\n" ) handle.write("*NODE\n") for node_id in sorted(mesh.nodes): x, y, z = mesh.nodes[node_id] handle.write(f"{node_id}, {x:.10E}, {y:.10E}, {z:.10E}\n") handle.write("*ELEMENT, TYPE=C3D20, ELSET=THICK_PLATE\n") for elem_id, elem in enumerate(mesh.elements, start=1): handle.write(f"{elem_id}, " + ", ".join(str(node_id) for node_id in elem) + "\n") handle.write("*ELSET, ELSET=D_PROBE\n") handle.write(f"{mesh.d_probe_element}\n") handle.write("*NSET, NSET=ALL_NODES, GENERATE\n") handle.write(f"1, {len(mesh.nodes)}, 1\n") handle.write("*NSET, NSET=X_SYM\n") write_id_set(handle, x_sym) handle.write("*NSET, NSET=Y_SYM\n") write_id_set(handle, y_sym) handle.write("*NSET, NSET=OUTER_SURFACE\n") write_id_set(handle, outer_surface) handle.write("*NSET, NSET=OUTER_MIDPLANE_Z\n") write_id_set(handle, outer_midplane) handle.write("*NSET, NSET=D_POINT\n") handle.write(f"{mesh.d_node}\n") handle.write("*MATERIAL, NAME=STEEL\n") handle.write("*DENSITY\n") handle.write(f"{DENSITY:.10E}\n") handle.write("*ELASTIC\n") handle.write(f"{YOUNG_MODULUS:.10E}, {POISSON_RATIO:.10E}\n") handle.write("*SOLID SECTION, ELSET=THICK_PLATE, MATERIAL=STEEL\n") handle.write("*BOUNDARY\n") handle.write("X_SYM, 1, 1, 0.0\n") handle.write("Y_SYM, 2, 2, 0.0\n") handle.write("OUTER_SURFACE, 1, 2, 0.0\n") handle.write("OUTER_MIDPLANE_Z, 3, 3, 0.0\n") handle.write("*CLOAD\n") for node_id, value in loads: handle.write(f"{node_id}, 3, {value:.10E}\n") handle.write("*STEP\n") handle.write("*STATIC\n") handle.write( f"{STATIC_INITIAL_INCREMENT:.10E}, {STATIC_TOTAL_TIME:.10E}, " f"{STATIC_MIN_INCREMENT:.10E}, {STATIC_MAX_INCREMENT:.10E}\n" ) handle.write("*END STEP\n") def main() -> None: output_dir = Path(__file__).resolve().parent write_inp(output_dir / "thick_plate_le10.inp", build_mesh()) if __name__ == "__main__": main()