Files
FemLite/examples/Kirsch/generate_kirsch.py
T
2026-06-24 17:29:36 +08:00

200 lines
6.2 KiB
Python

#!/usr/bin/env python3
"""Generate FemLite Kirsch plate static input decks."""
from __future__ import annotations
import math
from dataclasses import dataclass
from pathlib import Path
from typing import Dict, List, Sequence, Tuple
OUTER_SIZE = 1.0
HOLE_RADIUS = 0.1
THICKNESS = 0.1
YOUNG_MODULUS = 2.1e11
POISSON_RATIO = 0.3
DENSITY = 1.0
EDGE_STRESS_X = 1.0e3
STATIC_INITIAL_INCREMENT = 1.0
STATIC_TOTAL_TIME = 1.0
STATIC_MIN_INCREMENT = 0.1
STATIC_MAX_INCREMENT = 1.0
N_RADIAL = 24
N_THETA = 40
RADIAL_BIAS = 1.8
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
radial_rows: List[List[int]]
def outer_radius(theta: float) -> float:
return OUTER_SIZE / max(math.cos(theta), math.sin(theta))
def build_mesh(element_type: str) -> Mesh:
nodes: Dict[int, Point3] = {}
radial_rows: List[List[int]] = []
node_id = 1
for j in range(N_THETA + 1):
theta = 0.5 * math.pi * float(j) / float(N_THETA)
radius_outer = outer_radius(theta)
row: List[int] = []
for i in range(N_RADIAL + 1):
eta = float(i) / float(N_RADIAL)
eta_biased = eta**RADIAL_BIAS
radius = HOLE_RADIUS + eta_biased * (radius_outer - HOLE_RADIUS)
x = radius * math.cos(theta)
y = radius * math.sin(theta)
if abs(x) < 1.0e-12:
x = 0.0
if abs(y) < 1.0e-12:
y = 0.0
if abs(x - OUTER_SIZE) < 1.0e-12:
x = OUTER_SIZE
if abs(y - OUTER_SIZE) < 1.0e-12:
y = OUTER_SIZE
row.append(node_id)
nodes[node_id] = (x, y, 0.0)
node_id += 1
radial_rows.append(row)
elements: List[Element] = []
for j in range(N_THETA):
for i in range(N_RADIAL):
n1 = radial_rows[j][i]
n2 = radial_rows[j][i + 1]
n3 = radial_rows[j + 1][i + 1]
n4 = radial_rows[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, radial_rows=radial_rows)
def ysym_nodes(mesh: Mesh) -> List[int]:
return list(mesh.radial_rows[0])
def xsym_nodes(mesh: Mesh) -> List[int]:
return list(mesh.radial_rows[-1])
def hole_nodes(mesh: Mesh) -> List[int]:
return [row[0] for row in mesh.radial_rows]
def right_edge_segments(mesh: Mesh) -> List[Tuple[int, int]]:
segments: List[Tuple[int, int]] = []
for j in range(N_THETA):
n1 = mesh.radial_rows[j][-1]
n2 = mesh.radial_rows[j + 1][-1]
x1 = mesh.nodes[n1][0]
x2 = mesh.nodes[n2][0]
if abs(x1 - OUTER_SIZE) < 1.0e-10 and abs(x2 - OUTER_SIZE) < 1.0e-10:
segments.append((n1, n2))
return segments
def right_edge_nodes(mesh: Mesh) -> List[int]:
ids = set()
for n1, n2 in right_edge_segments(mesh):
ids.add(n1)
ids.add(n2)
return sorted(ids)
def nodal_edge_loads(mesh: Mesh) -> Dict[int, float]:
loads = {nid: 0.0 for nid in mesh.nodes}
line_load = EDGE_STRESS_X * THICKNESS
for n1, n2 in right_edge_segments(mesh):
p1 = mesh.nodes[n1]
p2 = mesh.nodes[n2]
length = math.sqrt(sum((p2[i] - p1[i]) ** 2 for i in range(3)))
share = line_load * length * 0.5
loads[n1] += share
loads[n2] += share
return loads
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) -> None:
loads = nodal_edge_loads(mesh)
nonzero_loads = [(nid, value) for nid, value in sorted(loads.items()) if abs(value) > 0.0]
total_fx = sum(value for _, value in nonzero_loads)
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 Kirsch quarter plate {mesh.element_type} static\n")
f.write(
f"** quarter model: L={OUTER_SIZE:.10E}, a={HOLE_RADIUS:.10E}, "
f"thickness={THICKNESS:.10E}, sigma_x={EDGE_STRESS_X:.10E}, "
f"total_Fx={total_fx:.10E}\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=ALL_NODES, GENERATE\n")
f.write(f"1, {len(mesh.nodes)}, 1\n")
f.write("*NSET, NSET=XSYM\n")
write_id_set(f, xsym_nodes(mesh))
f.write("*NSET, NSET=YSYM\n")
write_id_set(f, ysym_nodes(mesh))
f.write("*NSET, NSET=HOLE_EDGE\n")
write_id_set(f, hole_nodes(mesh))
f.write("*NSET, NSET=RIGHT_EDGE\n")
write_id_set(f, right_edge_nodes(mesh))
f.write("*MATERIAL, NAME=STEEL\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=STEEL\n")
f.write(f"{THICKNESS:.10E}\n")
f.write("*BOUNDARY\n")
f.write("XSYM, 1, 1, 0.0\n")
f.write("YSYM, 2, 2, 0.0\n")
f.write("ALL_NODES, 3, 6, 0.0\n")
f.write("*CLOAD\n")
for nid, value in nonzero_loads:
f.write(f"{nid}, 1, {value:.10E}\n")
f.write("*STEP\n")
f.write("*STATIC\n")
f.write(
f"{STATIC_INITIAL_INCREMENT:.10E}, {STATIC_TOTAL_TIME:.10E}, "
f"{STATIC_MIN_INCREMENT:.10E}, {STATIC_MAX_INCREMENT:.10E}\n"
)
f.write("*END STEP\n")
def main() -> None:
output_dir = Path(__file__).resolve().parent
write_inp(output_dir / "krisch_tri.inp", build_mesh("S3"))
write_inp(output_dir / "kirsch_quad.inp", build_mesh("S4"))
if __name__ == "__main__":
main()