Files
FemLite/examples/tension2D/generate_tension2d.py
shenw be02684827
FemLite CI / build-test (push) Has been cancelled
Release FemLite 0.3.0
2026-06-23 19:28:44 +08:00

268 lines
8.7 KiB
Python

#!/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()