#!/usr/bin/env python3 """Generate FemLite shell tension 2D example input decks. The mesh backend is the Gmsh Python API. If gmsh is not available, the script uses a small deterministic structured fallback mesh with the same node ordering. """ from __future__ import annotations import argparse from dataclasses import dataclass from pathlib import Path from typing import Dict, List, Sequence, Tuple LENGTH = 0.20 WIDTH = 0.10 THICKNESS = 0.002 YOUNG_MODULUS = 70.0e9 POISSON_RATIO = 0.30 DENSITY = 2700.0 TOTAL_FORCE_Z = 1000.0 END_TIME = 0.10 TIME_STEP = 1.0e-6 DISPLACEMENT_RATE = 0.01 FINAL_DISPLACEMENT_Z = DISPLACEMENT_RATE * END_TIME NX = 8 NZ = 4 SET_LINE_WIDTH = 16 Point3 = Tuple[float, float, float] Element = Tuple[int, ...] @dataclass class Mesh: nodes: Dict[int, Point3] elements: List[Element] element_type: str def try_import_gmsh(): try: import gmsh # type: ignore except ImportError: return None return gmsh def build_gmsh_mesh(element_type: str) -> Mesh: gmsh = try_import_gmsh() if gmsh is None: raise RuntimeError("gmsh Python module is not available") wanted = 2 if element_type == "S3" else 3 gmsh.initialize() try: gmsh.model.add(f"tension2d_{element_type.lower()}") geo = gmsh.model.geo p1 = geo.addPoint(0.0, 0.0, 0.0) p2 = geo.addPoint(LENGTH, 0.0, 0.0) p3 = geo.addPoint(LENGTH, WIDTH, 0.0) p4 = geo.addPoint(0.0, WIDTH, 0.0) l1 = geo.addLine(p1, p2) l2 = geo.addLine(p2, p3) l3 = geo.addLine(p3, p4) l4 = geo.addLine(p4, p1) loop = geo.addCurveLoop([l1, l2, l3, l4]) surface = geo.addPlaneSurface([loop]) geo.mesh.setTransfiniteCurve(l1, NX + 1) geo.mesh.setTransfiniteCurve(l3, NX + 1) geo.mesh.setTransfiniteCurve(l2, NZ + 1) geo.mesh.setTransfiniteCurve(l4, NZ + 1) geo.mesh.setTransfiniteSurface(surface) if element_type == "S4": geo.mesh.setRecombine(2, surface) geo.synchronize() gmsh.model.mesh.generate(2) return collect_gmsh_mesh(gmsh, wanted, element_type) finally: gmsh.finalize() def collect_gmsh_mesh(gmsh, wanted: int, element_type: str) -> Mesh: node_tags, node_coords, _ = gmsh.model.mesh.getNodes() tag_to_id: Dict[int, int] = {} nodes: Dict[int, Point3] = {} for new_id, tag in enumerate(node_tags, start=1): tag_int = int(tag) tag_to_id[tag_int] = new_id i = 3 * (new_id - 1) x = float(node_coords[i]) z = float(node_coords[i + 1]) nodes[new_id] = (x, 0.0, z) elements: List[Element] = [] elem_types, _, elem_node_tags = gmsh.model.mesh.getElements(2) nen = 3 if wanted == 2 else 4 for etype, conn in zip(elem_types, elem_node_tags): if int(etype) != wanted: continue for i in range(0, len(conn), nen): elem = tuple(tag_to_id[int(tag)] for tag in conn[i : i + nen]) if element_type == "S3": elem = orient_tri(nodes, elem) else: elem = orient_quad(nodes, elem) elements.append(elem) if not elements: raise RuntimeError(f"gmsh did not generate {element_type} elements") return Mesh(nodes=nodes, elements=elements, element_type=element_type) def build_internal_mesh(element_type: str) -> Mesh: nodes: Dict[int, Point3] = {} node_grid: List[List[int]] = [] node_id = 1 for j in range(NZ + 1): z = WIDTH * float(j) / float(NZ) row: List[int] = [] for i in range(NX + 1): x = LENGTH * float(i) / float(NX) row.append(node_id) nodes[node_id] = (x, 0.0, z) node_id += 1 node_grid.append(row) elements: List[Element] = [] for j in range(NZ): for i in range(NX): n1 = node_grid[j][i] n2 = node_grid[j][i + 1] n3 = node_grid[j + 1][i + 1] n4 = node_grid[j + 1][i] if element_type == "S4": elements.append((n1, n2, n3, n4)) else: elements.append((n1, n2, n3)) elements.append((n1, n3, n4)) return Mesh(nodes=nodes, elements=elements, element_type=element_type) def orient_tri(nodes: Dict[int, Point3], elem: Sequence[int]) -> Element: area = signed_area_xz(nodes, elem) if area >= 0.0: return tuple(int(n) for n in elem) return (int(elem[0]), int(elem[2]), int(elem[1])) def orient_quad(nodes: Dict[int, Point3], elem: Sequence[int]) -> Element: area = signed_area_xz(nodes, elem) if area >= 0.0: return tuple(int(n) for n in elem) return (int(elem[0]), int(elem[3]), int(elem[2]), int(elem[1])) def signed_area_xz(nodes: Dict[int, Point3], elem: Sequence[int]) -> float: area2 = 0.0 for i, nid in enumerate(elem): x0, _, z0 = nodes[int(nid)] x1, _, z1 = nodes[int(elem[(i + 1) % len(elem)])] area2 += x0 * z1 - x1 * z0 return 0.5 * area2 def build_mesh(element_type: str, backend: str) -> Mesh: if backend == "gmsh": return build_gmsh_mesh(element_type) if backend == "auto" and try_import_gmsh() is not None: return build_gmsh_mesh(element_type) return build_internal_mesh(element_type) def bottom_nodes(mesh: Mesh) -> List[int]: return [nid for nid, xyz in sorted(mesh.nodes.items()) if abs(xyz[2]) < 1.0e-10] def top_nodes(mesh: Mesh) -> List[int]: return [nid for nid, xyz in sorted(mesh.nodes.items()) if abs(xyz[2] - WIDTH) < 1.0e-10] def write_id_set(f, ids: Sequence[int]) -> None: for i in range(0, len(ids), SET_LINE_WIDTH): f.write(", ".join(str(item) for item in ids[i : i + SET_LINE_WIDTH])) f.write("\n") def write_inp(path: Path, mesh: Mesh, load_case: str) -> None: bottoms = bottom_nodes(mesh) tops = top_nodes(mesh) if not bottoms or not tops: raise RuntimeError("failed to identify top or bottom edge node set") path.parent.mkdir(parents=True, exist_ok=True) with path.open("w", encoding="ascii", newline="\n") as f: f.write("*HEADING\n") f.write(f"FemLite shell tension 2D {mesh.element_type} {load_case}\n") f.write("*NODE\n") for nid in sorted(mesh.nodes): x, y, z = mesh.nodes[nid] f.write(f"{nid}, {x:.10E}, {y:.10E}, {z:.10E}\n") f.write(f"*ELEMENT, TYPE={mesh.element_type}, ELSET=PLATE\n") for eid, elem in enumerate(mesh.elements, start=1): f.write(f"{eid}, " + ", ".join(str(nid) for nid in elem) + "\n") f.write("*NSET, NSET=BOTTOM\n") write_id_set(f, bottoms) f.write("*NSET, NSET=TOP\n") write_id_set(f, tops) f.write("*MATERIAL, NAME=ALUMINUM\n") f.write("*DENSITY\n") f.write(f"{DENSITY:.10E}\n") f.write("*ELASTIC\n") f.write(f"{YOUNG_MODULUS:.10E}, {POISSON_RATIO:.10E}\n") f.write("*SHELL SECTION, ELSET=PLATE, MATERIAL=ALUMINUM\n") f.write(f"{THICKNESS:.10E}\n") f.write("*BOUNDARY\n") f.write("BOTTOM, 1, 6, 0.0\n") if load_case == "force": force_per_node = TOTAL_FORCE_Z / float(len(tops)) f.write("*CLOAD\n") for nid in tops: f.write(f"{nid}, 3, {force_per_node:.10E}\n") elif load_case == "displacement": f.write("*AMPLITUDE, NAME=UZ_RAMP\n") f.write(f"0.0, 0.0, {END_TIME:.10E}, 1.0\n") f.write("*BOUNDARY, AMPLITUDE=UZ_RAMP\n") f.write(f"TOP, 3, 3, {FINAL_DISPLACEMENT_Z:.10E}\n") else: raise ValueError(f"unknown load case: {load_case}") f.write("*STEP\n") f.write("*DYNAMIC\n") f.write(f"{TIME_STEP:.10E}, {END_TIME:.10E}\n") f.write("*END STEP\n") def write_all(output_dir: Path, backend: str) -> None: tri_mesh = build_mesh("S3", backend) quad_mesh = build_mesh("S4", backend) write_inp(output_dir / "tension1000tri.inp", tri_mesh, "force") write_inp(output_dir / "tension1000quad.inp", quad_mesh, "force") write_inp(output_dir / "disp0_0001tri.inp", tri_mesh, "displacement") write_inp(output_dir / "disp0_0001quad.inp", quad_mesh, "displacement") def main() -> None: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument( "--backend", choices=("auto", "gmsh", "internal"), default="auto", help="mesh backend; auto uses gmsh when installed and otherwise falls back to internal", ) parser.add_argument( "--output-dir", type=Path, default=Path(__file__).resolve().parent, help="directory for generated inp files", ) args = parser.parse_args() write_all(args.output_dir, args.backend) if __name__ == "__main__": main()