216 lines
6.8 KiB
Python
216 lines
6.8 KiB
Python
#!/usr/bin/env python3
|
|
"""Generate the stress-dependent elasticity bending benchmark deck."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import math
|
|
from dataclasses import dataclass
|
|
from pathlib import Path
|
|
|
|
|
|
LENGTH = 0.10
|
|
HEIGHT = 0.01
|
|
WIDTH = 1.0
|
|
NX = 20
|
|
NY = 1
|
|
NZ = 10
|
|
E_TENSION = 3.0e8
|
|
E_COMPRESSION = 7.0e8
|
|
E_NOMINAL = 5.0e8
|
|
POISSON = 0.30
|
|
DENSITY = 1.0
|
|
TRANSITION_PRESSURE = 1.0e3
|
|
BENDING_MOMENT = -5.0 / 3.0
|
|
STATIC_INITIAL_INCREMENT = 0.05
|
|
STATIC_TOTAL_TIME = 1.0
|
|
STATIC_MIN_INCREMENT = 1.0e-4
|
|
STATIC_MAX_INCREMENT = 0.05
|
|
SET_LINE_WIDTH = 12
|
|
|
|
|
|
Point = tuple[float, float, float]
|
|
|
|
|
|
@dataclass
|
|
class Mesh:
|
|
nodes: dict[int, Point]
|
|
elements: list[tuple[int, ...]]
|
|
fixed_nodes: list[int]
|
|
right_face_loads: dict[int, float]
|
|
|
|
|
|
def node_id(i: int, j: int, k: int) -> int:
|
|
return 1 + i * (NY + 1) * (NZ + 1) + j * (NZ + 1) + k
|
|
|
|
|
|
def node_point(i: int, j: int, k: int) -> Point:
|
|
x = LENGTH * float(i) / float(NX)
|
|
y = WIDTH * float(j) / float(NY)
|
|
z = -0.5 * HEIGHT + HEIGHT * float(k) / float(NZ)
|
|
if abs(x) < 1.0e-14:
|
|
x = 0.0
|
|
if abs(y) < 1.0e-14:
|
|
y = 0.0
|
|
if abs(z) < 1.0e-14:
|
|
z = 0.0
|
|
return (x, y, z)
|
|
|
|
|
|
def generate_nodes() -> dict[int, Point]:
|
|
nodes: dict[int, Point] = {}
|
|
for i in range(NX + 1):
|
|
for j in range(NY + 1):
|
|
for k in range(NZ + 1):
|
|
nodes[node_id(i, j, k)] = node_point(i, j, k)
|
|
return nodes
|
|
|
|
|
|
def generate_elements() -> list[tuple[int, ...]]:
|
|
elements: list[tuple[int, ...]] = []
|
|
for i in range(NX):
|
|
for j in range(NY):
|
|
for k in range(NZ):
|
|
elements.append(
|
|
(
|
|
node_id(i, j, k),
|
|
node_id(i + 1, j, k),
|
|
node_id(i + 1, j + 1, k),
|
|
node_id(i, j + 1, k),
|
|
node_id(i, j, k + 1),
|
|
node_id(i + 1, j, k + 1),
|
|
node_id(i + 1, j + 1, k + 1),
|
|
node_id(i, j + 1, k + 1),
|
|
)
|
|
)
|
|
return elements
|
|
|
|
|
|
def right_face_loads(nodes: dict[int, Point]) -> dict[int, float]:
|
|
inertia = WIDTH * HEIGHT**3 / 12.0
|
|
coeff = BENDING_MOMENT / inertia
|
|
gp = (-1.0 / math.sqrt(3.0), 1.0 / math.sqrt(3.0))
|
|
loads: dict[int, float] = {}
|
|
|
|
for j in range(NY):
|
|
for k in range(NZ):
|
|
face_nodes = (
|
|
node_id(NX, j, k),
|
|
node_id(NX, j + 1, k),
|
|
node_id(NX, j + 1, k + 1),
|
|
node_id(NX, j, k + 1),
|
|
)
|
|
dy = WIDTH / float(NY)
|
|
dz = HEIGHT / float(NZ)
|
|
jac = 0.25 * dy * dz
|
|
for eta in gp:
|
|
for zeta in gp:
|
|
shape = (
|
|
0.25 * (1.0 - eta) * (1.0 - zeta),
|
|
0.25 * (1.0 + eta) * (1.0 - zeta),
|
|
0.25 * (1.0 + eta) * (1.0 + zeta),
|
|
0.25 * (1.0 - eta) * (1.0 + zeta),
|
|
)
|
|
z = sum(shape[a] * nodes[face_nodes[a]][2] for a in range(4))
|
|
traction_x = coeff * z
|
|
for a, nid in enumerate(face_nodes):
|
|
loads[nid] = loads.get(nid, 0.0) + shape[a] * traction_x * jac
|
|
|
|
return {nid: value for nid, value in sorted(loads.items()) if abs(value) > 1.0e-12}
|
|
|
|
|
|
def generate_mesh() -> Mesh:
|
|
nodes = generate_nodes()
|
|
fixed = [nid for nid, xyz in nodes.items() if abs(xyz[0]) < 1.0e-14]
|
|
return Mesh(
|
|
nodes=nodes,
|
|
elements=generate_elements(),
|
|
fixed_nodes=sorted(fixed),
|
|
right_face_loads=right_face_loads(nodes),
|
|
)
|
|
|
|
|
|
def format_float(value: float) -> str:
|
|
if abs(value) < 1.0e-14:
|
|
value = 0.0
|
|
return f"{value:.10E}"
|
|
|
|
|
|
def write_set(lines: list[str], values: list[int]) -> None:
|
|
for start in range(0, len(values), SET_LINE_WIDTH):
|
|
chunk = values[start : start + SET_LINE_WIDTH]
|
|
lines.append(", ".join(str(item) for item in chunk))
|
|
|
|
|
|
def analytical_neutral_axis() -> float:
|
|
root_c = math.sqrt(E_COMPRESSION)
|
|
root_t = math.sqrt(E_TENSION)
|
|
return 0.5 * HEIGHT * (root_c - root_t) / (root_c + root_t)
|
|
|
|
|
|
def write_deck(path: Path, mesh: Mesh) -> None:
|
|
total_fx = sum(mesh.right_face_loads.values())
|
|
total_my = sum(mesh.nodes[nid][2] * load for nid, load in mesh.right_face_loads.items())
|
|
inertia = WIDTH * HEIGHT**3 / 12.0
|
|
lines: list[str] = [
|
|
"*HEADING",
|
|
"FemLite Modeling Stress Dependent Elasticity benchmark",
|
|
"** Reference: models.sme.stress_dependent_elasticity.pdf",
|
|
"** 2D reference geometry is represented as a unit-thickness 3D solid beam.",
|
|
f"** LENGTH_M={format_float(LENGTH)} HEIGHT_M={format_float(HEIGHT)} WIDTH_M={format_float(WIDTH)}",
|
|
f"** NX={NX} NY={NY} NZ={NZ}",
|
|
f"** E_TENSION_PA={format_float(E_TENSION)}",
|
|
f"** E_COMPRESSION_PA={format_float(E_COMPRESSION)}",
|
|
f"** TRANSITION_PRESSURE_PA={format_float(TRANSITION_PRESSURE)}",
|
|
f"** BENDING_MOMENT_NM={format_float(BENDING_MOMENT)}",
|
|
f"** SECTION_INERTIA_M4={format_float(inertia)}",
|
|
f"** EXPECTED_NEUTRAL_AXIS_ABS_M={format_float(analytical_neutral_axis())}",
|
|
f"** TOTAL_FX={format_float(total_fx)} TOTAL_MY={format_float(total_my)}",
|
|
"*NODE",
|
|
]
|
|
|
|
for nid, (x, y, z) in mesh.nodes.items():
|
|
lines.append(f"{nid}, {format_float(x)}, {format_float(y)}, {format_float(z)}")
|
|
|
|
lines.append("*ELEMENT, TYPE=C3D8, ELSET=BEAM")
|
|
for eid, conn in enumerate(mesh.elements, start=1):
|
|
lines.append(f"{eid}, " + ", ".join(str(nid) for nid in conn))
|
|
|
|
lines.append("*NSET, NSET=FIXED_LEFT")
|
|
write_set(lines, mesh.fixed_nodes)
|
|
lines.extend(
|
|
[
|
|
"*MATERIAL, NAME=SDE_MATERIAL",
|
|
"*DENSITY",
|
|
format_float(DENSITY),
|
|
"*ELASTIC",
|
|
f"{format_float(E_NOMINAL)}, {format_float(POISSON)}",
|
|
"*STRESS DEPENDENT ELASTICITY",
|
|
f"{format_float(E_TENSION)}, {format_float(E_COMPRESSION)}, {format_float(TRANSITION_PRESSURE)}",
|
|
"*SOLID SECTION, ELSET=BEAM, MATERIAL=SDE_MATERIAL",
|
|
"*BOUNDARY",
|
|
"FIXED_LEFT, 1, 3, 0.0",
|
|
"*STEP",
|
|
"*STATIC",
|
|
(
|
|
f"{format_float(STATIC_INITIAL_INCREMENT)}, {format_float(STATIC_TOTAL_TIME)}, "
|
|
f"{format_float(STATIC_MIN_INCREMENT)}, {format_float(STATIC_MAX_INCREMENT)}"
|
|
),
|
|
"*CLOAD",
|
|
]
|
|
)
|
|
|
|
for nid, load in mesh.right_face_loads.items():
|
|
lines.append(f"{nid}, 1, {format_float(load)}")
|
|
lines.append("*END STEP")
|
|
path.write_text("\n".join(lines) + "\n", encoding="ascii")
|
|
|
|
|
|
def main() -> int:
|
|
here = Path(__file__).resolve().parent
|
|
write_deck(here / "stress_dependent_elasticity.inp", generate_mesh())
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|