Files
FemLite/examples/stress_dependent_elasticity/generate_stress_dependent_elasticity.py
T

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())