Files
FemLite/examples/thick_plate/generate_thick_plate_le10.py
T

331 lines
10 KiB
Python

#!/usr/bin/env python3
"""Generate the NAFEMS LE10 thick-plate solid benchmark deck for FemLite."""
from __future__ import annotations
import math
from dataclasses import dataclass
from pathlib import Path
from typing import Dict, Iterable, List, Sequence, Tuple
INNER_A = 2.0
INNER_B = 1.0
OUTER_A = 3.25
OUTER_B = 2.75
THICKNESS = 0.6
YOUNG_MODULUS = 2.10e11
POISSON_RATIO = 0.30
DENSITY = 7850.0
TOP_PRESSURE = 1.0e6
N_RADIAL = 4
N_THETA = 16
N_Z = 2
RADIAL_BIAS = 1.25
SET_LINE_WIDTH = 12
STATIC_INITIAL_INCREMENT = 1.0
STATIC_TOTAL_TIME = 1.0
STATIC_MIN_INCREMENT = 0.1
STATIC_MAX_INCREMENT = 1.0
Point3 = Tuple[float, float, float]
Element = Tuple[int, ...]
Logical = Tuple[int, int, int]
@dataclass
class Mesh:
nodes: Dict[int, Point3]
node_logic: Dict[int, Logical]
elements: List[Element]
d_node: int
d_probe_element: int
top_loads: Dict[int, float]
top_area: float
def biased_radial_fraction(i2: int) -> float:
eta = float(i2) / float(2 * N_RADIAL)
return eta**RADIAL_BIAS
def point_from_logic(i2: int, j2: int, k2: int) -> Point3:
theta = 0.5 * math.pi * float(j2) / float(2 * N_THETA)
radial = biased_radial_fraction(i2)
xi = math.cos(theta)
yi = math.sin(theta)
inner = (INNER_A * xi, INNER_B * yi)
outer = (OUTER_A * xi, OUTER_B * yi)
x = inner[0] + radial * (outer[0] - inner[0])
y = inner[1] + radial * (outer[1] - inner[1])
z = THICKNESS * float(k2) / float(2 * N_Z)
if abs(x) < 1.0e-12:
x = 0.0
if abs(y) < 1.0e-12:
y = 0.0
if abs(z) < 1.0e-12:
z = 0.0
if abs(z - THICKNESS) < 1.0e-12:
z = THICKNESS
return (x, y, z)
def add_node(
nodes: Dict[int, Point3],
node_logic: Dict[int, Logical],
lookup: Dict[Logical, int],
logic: Logical,
) -> int:
existing = lookup.get(logic)
if existing is not None:
return existing
node_id = len(nodes) + 1
lookup[logic] = node_id
nodes[node_id] = point_from_logic(*logic)
node_logic[node_id] = logic
return node_id
def element_nodes(
nodes: Dict[int, Point3],
node_logic: Dict[int, Logical],
lookup: Dict[Logical, int],
i: int,
j: int,
k: int,
) -> Element:
i0 = 2 * i
i1 = 2 * (i + 1)
im = i0 + 1
j0 = 2 * j
j1 = 2 * (j + 1)
jm = j0 + 1
k0 = 2 * k
k1 = 2 * (k + 1)
km = k0 + 1
logic_nodes = (
(i0, j0, k0),
(i1, j0, k0),
(i1, j1, k0),
(i0, j1, k0),
(i0, j0, k1),
(i1, j0, k1),
(i1, j1, k1),
(i0, j1, k1),
(im, j0, k0),
(i1, jm, k0),
(im, j1, k0),
(i0, jm, k0),
(im, j0, k1),
(i1, jm, k1),
(im, j1, k1),
(i0, jm, k1),
(i0, j0, km),
(i1, j0, km),
(i1, j1, km),
(i0, j1, km),
)
return tuple(add_node(nodes, node_logic, lookup, logic) for logic in logic_nodes)
def shape_quad8(r: float, s: float) -> Tuple[List[float], List[float], List[float]]:
n = [
0.25 * (1.0 - r) * (1.0 - s) * (-r - s - 1.0),
0.25 * (1.0 + r) * (1.0 - s) * (r - s - 1.0),
0.25 * (1.0 + r) * (1.0 + s) * (r + s - 1.0),
0.25 * (1.0 - r) * (1.0 + s) * (-r + s - 1.0),
0.5 * (1.0 - r * r) * (1.0 - s),
0.5 * (1.0 + r) * (1.0 - s * s),
0.5 * (1.0 - r * r) * (1.0 + s),
0.5 * (1.0 - r) * (1.0 - s * s),
]
dndr = [
0.25 * (1.0 - s) * (2.0 * r + s),
0.25 * (1.0 - s) * (2.0 * r - s),
0.25 * (1.0 + s) * (2.0 * r + s),
0.25 * (1.0 + s) * (2.0 * r - s),
-r * (1.0 - s),
0.5 * (1.0 - s * s),
-r * (1.0 + s),
-0.5 * (1.0 - s * s),
]
dnds = [
0.25 * (1.0 - r) * (r + 2.0 * s),
0.25 * (1.0 + r) * (-r + 2.0 * s),
0.25 * (1.0 + r) * (r + 2.0 * s),
0.25 * (1.0 - r) * (-r + 2.0 * s),
-0.5 * (1.0 - r * r),
-(1.0 + r) * s,
0.5 * (1.0 - r * r),
-(1.0 - r) * s,
]
return n, dndr, dnds
def cross(a: Point3, b: Point3) -> Point3:
return (
a[1] * b[2] - a[2] * b[1],
a[2] * b[0] - a[0] * b[2],
a[0] * b[1] - a[1] * b[0],
)
def norm(v: Point3) -> float:
return math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2])
def top_face_pressure_loads(nodes: Dict[int, Point3], elements: Sequence[Element]) -> Tuple[Dict[int, float], float]:
gp = [-math.sqrt(3.0 / 5.0), 0.0, math.sqrt(3.0 / 5.0)]
gw = [5.0 / 9.0, 8.0 / 9.0, 5.0 / 9.0]
loads = {node_id: 0.0 for node_id in nodes}
area = 0.0
for elem in elements[(N_Z - 1) * N_THETA * N_RADIAL :]:
face_nodes = [elem[index] for index in (4, 5, 6, 7, 12, 13, 14, 15)]
coords = [nodes[node_id] for node_id in face_nodes]
for r, wr in zip(gp, gw):
for s, ws in zip(gp, gw):
n, dndr, dnds = shape_quad8(r, s)
tangent_r = (
sum(dndr[a] * coords[a][0] for a in range(8)),
sum(dndr[a] * coords[a][1] for a in range(8)),
sum(dndr[a] * coords[a][2] for a in range(8)),
)
tangent_s = (
sum(dnds[a] * coords[a][0] for a in range(8)),
sum(dnds[a] * coords[a][1] for a in range(8)),
sum(dnds[a] * coords[a][2] for a in range(8)),
)
jac = norm(cross(tangent_r, tangent_s))
weight = wr * ws
area += jac * weight
for a, node_id in enumerate(face_nodes):
loads[node_id] -= TOP_PRESSURE * n[a] * jac * weight
return loads, area
def build_mesh() -> Mesh:
nodes: Dict[int, Point3] = {}
node_logic: Dict[int, Logical] = {}
lookup: Dict[Logical, int] = {}
elements: List[Element] = []
d_probe_element = 0
for k in range(N_Z):
for j in range(N_THETA):
for i in range(N_RADIAL):
if i == 0 and j == 0 and k == N_Z - 1:
d_probe_element = len(elements) + 1
elements.append(element_nodes(nodes, node_logic, lookup, i, j, k))
d_node = lookup[(0, 0, 2 * N_Z)]
top_loads, top_area = top_face_pressure_loads(nodes, elements)
return Mesh(
nodes=nodes,
node_logic=node_logic,
elements=elements,
d_node=d_node,
d_probe_element=d_probe_element,
top_loads=top_loads,
top_area=top_area,
)
def nodes_matching(mesh: Mesh, predicate) -> List[int]:
return sorted(node_id for node_id, logic in mesh.node_logic.items() if predicate(logic))
def write_id_set(handle, ids: Sequence[int]) -> None:
for index in range(0, len(ids), SET_LINE_WIDTH):
handle.write(", ".join(str(item) for item in ids[index : index + SET_LINE_WIDTH]))
handle.write("\n")
def nonzero_loads(loads: Dict[int, float]) -> List[Tuple[int, float]]:
return [(node_id, value) for node_id, value in sorted(loads.items()) if abs(value) > 1.0e-8]
def write_inp(path: Path, mesh: Mesh) -> None:
x_sym = nodes_matching(mesh, lambda logic: logic[1] == 2 * N_THETA)
y_sym = nodes_matching(mesh, lambda logic: logic[1] == 0)
outer_surface = nodes_matching(mesh, lambda logic: logic[0] == 2 * N_RADIAL)
outer_midplane = nodes_matching(
mesh,
lambda logic: logic[0] == 2 * N_RADIAL and logic[2] == N_Z,
)
loads = nonzero_loads(mesh.top_loads)
total_load = sum(value for _, value in loads)
exact_area = 0.25 * math.pi * (OUTER_A * OUTER_B - INNER_A * INNER_B)
with path.open("w", encoding="ascii", newline="\n") as handle:
handle.write("*HEADING\n")
handle.write("FemLite NAFEMS LE10 thick plate pressure benchmark\n")
handle.write(
f"** inner_ellipse=({INNER_A:.10E},{INNER_B:.10E}), "
f"outer_ellipse=({OUTER_A:.10E},{OUTER_B:.10E}), "
f"thickness={THICKNESS:.10E}\n"
)
handle.write(
f"** top_pressure={TOP_PRESSURE:.10E}, integrated_top_area={mesh.top_area:.10E}, "
f"exact_top_area={exact_area:.10E}, total_Fz={total_load:.10E}\n"
)
handle.write(
f"** D_NODE={mesh.d_node}, D_PROBE_ELEMENT={mesh.d_probe_element}, "
"D_COORD=(2.0,0.0,0.6), NAFEMS_s22_D=-5.38E6\n"
)
handle.write("*NODE\n")
for node_id in sorted(mesh.nodes):
x, y, z = mesh.nodes[node_id]
handle.write(f"{node_id}, {x:.10E}, {y:.10E}, {z:.10E}\n")
handle.write("*ELEMENT, TYPE=C3D20, ELSET=THICK_PLATE\n")
for elem_id, elem in enumerate(mesh.elements, start=1):
handle.write(f"{elem_id}, " + ", ".join(str(node_id) for node_id in elem) + "\n")
handle.write("*ELSET, ELSET=D_PROBE\n")
handle.write(f"{mesh.d_probe_element}\n")
handle.write("*NSET, NSET=ALL_NODES, GENERATE\n")
handle.write(f"1, {len(mesh.nodes)}, 1\n")
handle.write("*NSET, NSET=X_SYM\n")
write_id_set(handle, x_sym)
handle.write("*NSET, NSET=Y_SYM\n")
write_id_set(handle, y_sym)
handle.write("*NSET, NSET=OUTER_SURFACE\n")
write_id_set(handle, outer_surface)
handle.write("*NSET, NSET=OUTER_MIDPLANE_Z\n")
write_id_set(handle, outer_midplane)
handle.write("*NSET, NSET=D_POINT\n")
handle.write(f"{mesh.d_node}\n")
handle.write("*MATERIAL, NAME=STEEL\n")
handle.write("*DENSITY\n")
handle.write(f"{DENSITY:.10E}\n")
handle.write("*ELASTIC\n")
handle.write(f"{YOUNG_MODULUS:.10E}, {POISSON_RATIO:.10E}\n")
handle.write("*SOLID SECTION, ELSET=THICK_PLATE, MATERIAL=STEEL\n")
handle.write("*BOUNDARY\n")
handle.write("X_SYM, 1, 1, 0.0\n")
handle.write("Y_SYM, 2, 2, 0.0\n")
handle.write("OUTER_SURFACE, 1, 2, 0.0\n")
handle.write("OUTER_MIDPLANE_Z, 3, 3, 0.0\n")
handle.write("*CLOAD\n")
for node_id, value in loads:
handle.write(f"{node_id}, 3, {value:.10E}\n")
handle.write("*STEP\n")
handle.write("*STATIC\n")
handle.write(
f"{STATIC_INITIAL_INCREMENT:.10E}, {STATIC_TOTAL_TIME:.10E}, "
f"{STATIC_MIN_INCREMENT:.10E}, {STATIC_MAX_INCREMENT:.10E}\n"
)
handle.write("*END STEP\n")
def main() -> None:
output_dir = Path(__file__).resolve().parent
write_inp(output_dir / "thick_plate_le10.inp", build_mesh())
if __name__ == "__main__":
main()