200 lines
6.2 KiB
Python
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()
|