331 lines
10 KiB
Python
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()
|