#!/usr/bin/env python3 """Generate the stress-dependent elasticity bending benchmark deck.""" from __future__ import annotations import math from dataclasses import dataclass from pathlib import Path LENGTH = 0.10 HEIGHT = 0.01 WIDTH = 1.0 NX = 20 NY = 1 NZ = 10 E_TENSION = 3.0e8 E_COMPRESSION = 7.0e8 E_NOMINAL = 5.0e8 POISSON = 0.30 DENSITY = 1.0 TRANSITION_PRESSURE = 1.0e3 BENDING_MOMENT = -5.0 / 3.0 STATIC_INITIAL_INCREMENT = 0.05 STATIC_TOTAL_TIME = 1.0 STATIC_MIN_INCREMENT = 1.0e-4 STATIC_MAX_INCREMENT = 0.05 SET_LINE_WIDTH = 12 Point = tuple[float, float, float] @dataclass class Mesh: nodes: dict[int, Point] elements: list[tuple[int, ...]] fixed_nodes: list[int] right_face_loads: dict[int, float] def node_id(i: int, j: int, k: int) -> int: return 1 + i * (NY + 1) * (NZ + 1) + j * (NZ + 1) + k def node_point(i: int, j: int, k: int) -> Point: x = LENGTH * float(i) / float(NX) y = WIDTH * float(j) / float(NY) z = -0.5 * HEIGHT + HEIGHT * float(k) / float(NZ) if abs(x) < 1.0e-14: x = 0.0 if abs(y) < 1.0e-14: y = 0.0 if abs(z) < 1.0e-14: z = 0.0 return (x, y, z) def generate_nodes() -> dict[int, Point]: nodes: dict[int, Point] = {} for i in range(NX + 1): for j in range(NY + 1): for k in range(NZ + 1): nodes[node_id(i, j, k)] = node_point(i, j, k) return nodes def generate_elements() -> list[tuple[int, ...]]: elements: list[tuple[int, ...]] = [] for i in range(NX): for j in range(NY): for k in range(NZ): elements.append( ( node_id(i, j, k), node_id(i + 1, j, k), node_id(i + 1, j + 1, k), node_id(i, j + 1, k), node_id(i, j, k + 1), node_id(i + 1, j, k + 1), node_id(i + 1, j + 1, k + 1), node_id(i, j + 1, k + 1), ) ) return elements def right_face_loads(nodes: dict[int, Point]) -> dict[int, float]: inertia = WIDTH * HEIGHT**3 / 12.0 coeff = BENDING_MOMENT / inertia gp = (-1.0 / math.sqrt(3.0), 1.0 / math.sqrt(3.0)) loads: dict[int, float] = {} for j in range(NY): for k in range(NZ): face_nodes = ( node_id(NX, j, k), node_id(NX, j + 1, k), node_id(NX, j + 1, k + 1), node_id(NX, j, k + 1), ) dy = WIDTH / float(NY) dz = HEIGHT / float(NZ) jac = 0.25 * dy * dz for eta in gp: for zeta in gp: shape = ( 0.25 * (1.0 - eta) * (1.0 - zeta), 0.25 * (1.0 + eta) * (1.0 - zeta), 0.25 * (1.0 + eta) * (1.0 + zeta), 0.25 * (1.0 - eta) * (1.0 + zeta), ) z = sum(shape[a] * nodes[face_nodes[a]][2] for a in range(4)) traction_x = coeff * z for a, nid in enumerate(face_nodes): loads[nid] = loads.get(nid, 0.0) + shape[a] * traction_x * jac return {nid: value for nid, value in sorted(loads.items()) if abs(value) > 1.0e-12} def generate_mesh() -> Mesh: nodes = generate_nodes() fixed = [nid for nid, xyz in nodes.items() if abs(xyz[0]) < 1.0e-14] return Mesh( nodes=nodes, elements=generate_elements(), fixed_nodes=sorted(fixed), right_face_loads=right_face_loads(nodes), ) def format_float(value: float) -> str: if abs(value) < 1.0e-14: value = 0.0 return f"{value:.10E}" def write_set(lines: list[str], values: list[int]) -> None: for start in range(0, len(values), SET_LINE_WIDTH): chunk = values[start : start + SET_LINE_WIDTH] lines.append(", ".join(str(item) for item in chunk)) def analytical_neutral_axis() -> float: root_c = math.sqrt(E_COMPRESSION) root_t = math.sqrt(E_TENSION) return 0.5 * HEIGHT * (root_c - root_t) / (root_c + root_t) def write_deck(path: Path, mesh: Mesh) -> None: total_fx = sum(mesh.right_face_loads.values()) total_my = sum(mesh.nodes[nid][2] * load for nid, load in mesh.right_face_loads.items()) inertia = WIDTH * HEIGHT**3 / 12.0 lines: list[str] = [ "*HEADING", "FemLite Modeling Stress Dependent Elasticity benchmark", "** Reference: models.sme.stress_dependent_elasticity.pdf", "** 2D reference geometry is represented as a unit-thickness 3D solid beam.", f"** LENGTH_M={format_float(LENGTH)} HEIGHT_M={format_float(HEIGHT)} WIDTH_M={format_float(WIDTH)}", f"** NX={NX} NY={NY} NZ={NZ}", f"** E_TENSION_PA={format_float(E_TENSION)}", f"** E_COMPRESSION_PA={format_float(E_COMPRESSION)}", f"** TRANSITION_PRESSURE_PA={format_float(TRANSITION_PRESSURE)}", f"** BENDING_MOMENT_NM={format_float(BENDING_MOMENT)}", f"** SECTION_INERTIA_M4={format_float(inertia)}", f"** EXPECTED_NEUTRAL_AXIS_ABS_M={format_float(analytical_neutral_axis())}", f"** TOTAL_FX={format_float(total_fx)} TOTAL_MY={format_float(total_my)}", "*NODE", ] for nid, (x, y, z) in mesh.nodes.items(): lines.append(f"{nid}, {format_float(x)}, {format_float(y)}, {format_float(z)}") lines.append("*ELEMENT, TYPE=C3D8, ELSET=BEAM") for eid, conn in enumerate(mesh.elements, start=1): lines.append(f"{eid}, " + ", ".join(str(nid) for nid in conn)) lines.append("*NSET, NSET=FIXED_LEFT") write_set(lines, mesh.fixed_nodes) lines.extend( [ "*MATERIAL, NAME=SDE_MATERIAL", "*DENSITY", format_float(DENSITY), "*ELASTIC", f"{format_float(E_NOMINAL)}, {format_float(POISSON)}", "*STRESS DEPENDENT ELASTICITY", f"{format_float(E_TENSION)}, {format_float(E_COMPRESSION)}, {format_float(TRANSITION_PRESSURE)}", "*SOLID SECTION, ELSET=BEAM, MATERIAL=SDE_MATERIAL", "*BOUNDARY", "FIXED_LEFT, 1, 3, 0.0", "*STEP", "*STATIC", ( f"{format_float(STATIC_INITIAL_INCREMENT)}, {format_float(STATIC_TOTAL_TIME)}, " f"{format_float(STATIC_MIN_INCREMENT)}, {format_float(STATIC_MAX_INCREMENT)}" ), "*CLOAD", ] ) for nid, load in mesh.right_face_loads.items(): lines.append(f"{nid}, 1, {format_float(load)}") lines.append("*END STEP") path.write_text("\n".join(lines) + "\n", encoding="ascii") def main() -> int: here = Path(__file__).resolve().parent write_deck(here / "stress_dependent_elasticity.inp", generate_mesh()) return 0 if __name__ == "__main__": raise SystemExit(main())