qf-solver 0.2.0a0__py3-none-any.whl

mitc4/__init__.py

@@ -0,0 +1,19 @@
+"""MITC4 flat-shell finite element package."""
+
+from mitc4.benchmarks import CantileverPlateBenchmark, ScordelisLoBenchmark, ShearLockingStudy
+from mitc4.element import MITC4Element, Q4FullShearElement
+from mitc4.material import ShellMaterial
+from mitc4.model import ShellModel
+from mitc4.verification import MechanicalVerifier, VerificationResult
+
+__all__ = [
+    "CantileverPlateBenchmark",
+    "MITC4Element",
+    "MechanicalVerifier",
+    "Q4FullShearElement",
+    "ScordelisLoBenchmark",
+    "ShearLockingStudy",
+    "ShellMaterial",
+    "ShellModel",
+    "VerificationResult",
+]

mitc4/benchmarks.py

@@ -0,0 +1,183 @@
+"""Benchmark problems and shear-locking studies."""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from pathlib import Path
+
+import numpy as np
+
+from mitc4.constants import DOF_PER_NODE, UY, UZ
+from mitc4.element import MITC4Element, Q4FullShearElement
+from mitc4.material import ShellMaterial
+from mitc4.mesh import MeshFactory
+from mitc4.model import ShellModel
+from mitc4.visualization import DeformationPlotter
+
+
+@dataclass(frozen=True)
+class BenchmarkResult:
+    name: str
+    values: dict[str, float]
+
+
+class ScordelisLoBenchmark:
+    reference_w = -0.3024
+
+    def __init__(self, nx: int = 24, ny: int = 24):
+        self.nx = nx
+        self.ny = ny
+
+    def run(self, *, show: bool = False, png: Path | None = None, scale: float = 20.0) -> BenchmarkResult:
+        E = 4.32e8
+        nu = 0.0
+        t = 0.25
+        R = 25.0
+        L = 50.0
+        angle = math.radians(80.0)
+        qz = -90.0
+
+        mesh = MeshFactory.scordelis_lo(self.nx, self.ny)
+        model = ShellModel(mesh.nodes, mesh.quads, ShellMaterial(E=E, nu=nu, t=t))
+        area_element = (L / self.nx) * (R * angle / self.ny)
+        for conn in mesh.quads:
+            for node in conn:
+                model.add_nodal_load(int(node), UZ, qz * area_element / 4.0)
+
+        for i, p in enumerate(mesh.nodes):
+            if abs(p[0]) < 1.0e-10 or abs(p[0] - L) < 1.0e-10:
+                model.add_fixed_dof(i, UY)
+                model.add_fixed_dof(i, UZ)
+
+        model.add_fixed_dof(0, 0)
+        model.add_fixed_dof(0, 5)
+        U = model.solve()
+
+        mid_x = self.nx // 2
+        node_a = mid_x * (self.ny + 1) + 0
+        node_b = mid_x * (self.ny + 1) + self.ny
+        w_a = float(U[node_a * DOF_PER_NODE + UZ])
+        w_b = float(U[node_b * DOF_PER_NODE + UZ])
+        error = abs((w_a - self.reference_w) / self.reference_w) * 100.0
+        symmetry_error = abs(w_a - w_b) / abs(self.reference_w) * 100.0
+
+        if show or png is not None:
+            DeformationPlotter(scale=scale).plot(
+                mesh.nodes,
+                mesh.quads,
+                U,
+                title=f"Scordelis-Lo roof {self.nx}x{self.ny} - error {error:.2f}%",
+                png=png,
+                show=show,
+            )
+
+        return BenchmarkResult(
+            "Scordelis-Lo",
+            {
+                "w_edge_center": w_a,
+                "w_opposite_edge_center": w_b,
+                "reference": self.reference_w,
+                "error_percent": error,
+                "symmetry_error_percent": symmetry_error,
+                "num_nodes": float(mesh.nodes.shape[0]),
+                "num_elements": float(mesh.quads.shape[0]),
+            },
+        )
+
+
+class CantileverPlateBenchmark:
+    def __init__(
+        self,
+        nx: int = 16,
+        ny: int = 4,
+        *,
+        length: float = 1.0,
+        width: float = 0.2,
+        thickness: float = 0.01,
+        force: float = -1000.0,
+        E: float = 210.0e9,
+        nu: float = 0.3,
+        element_type: type[MITC4Element] = MITC4Element,
+    ):
+        self.nx = nx
+        self.ny = ny
+        self.length = length
+        self.width = width
+        self.thickness = thickness
+        self.force = force
+        self.E = E
+        self.nu = nu
+        self.element_type = element_type
+
+    def run(self, *, show: bool = False, png: Path | None = None, scale: float | None = None) -> BenchmarkResult:
+        mesh = MeshFactory.rectangular_plate(self.nx, self.ny, self.length, self.width)
+        material = ShellMaterial(E=self.E, nu=self.nu, t=self.thickness)
+        model = ShellModel(mesh.nodes, mesh.quads, material, element_type=self.element_type)
+
+        tip_nodes = np.where(np.isclose(mesh.nodes[:, 0], self.length))[0]
+        for node in tip_nodes:
+            model.add_nodal_load(int(node), UZ, self.force / len(tip_nodes))
+
+        root_nodes = np.where(np.isclose(mesh.nodes[:, 0], 0.0))[0]
+        for node in root_nodes:
+            model.fix_node(int(node))
+
+        U = model.solve()
+        tip_w = float(np.mean(U[tip_nodes * DOF_PER_NODE + UZ]))
+        D = self.E * self.thickness**3 / (12.0 * (1.0 - self.nu**2))
+        reference = self.force * self.length**3 / (3.0 * D * self.width)
+        error = abs((tip_w - reference) / reference) * 100.0
+
+        if scale is None:
+            scale = 0.15 * self.length / max(abs(tip_w), 1.0e-30)
+        if show or png is not None:
+            DeformationPlotter(scale=scale).plot(
+                mesh.nodes,
+                mesh.quads,
+                U,
+                title=f"Cantilever plate {self.nx}x{self.ny} - {self.element_type.name}",
+                png=png,
+                show=show,
+            )
+
+        return BenchmarkResult(
+            "Cantilever plate",
+            {
+                "tip_w": tip_w,
+                "reference": reference,
+                "error_percent": error,
+                "ratio_to_reference": tip_w / reference,
+                "num_nodes": float(mesh.nodes.shape[0]),
+                "num_elements": float(mesh.quads.shape[0]),
+            },
+        )
+
+
+class ShearLockingStudy:
+    """Compare MITC shear interpolation with full Q4 shear interpolation."""
+
+    def __init__(self, nx: int = 8, ny: int = 2, thicknesses: tuple[float, ...] = (1.0e-2, 1.0e-3, 1.0e-4)):
+        self.nx = nx
+        self.ny = ny
+        self.thicknesses = thicknesses
+
+    def run(self) -> BenchmarkResult:
+        values: dict[str, float] = {}
+        mitc_ratios = []
+        full_ratios = []
+        for t in self.thicknesses:
+            mitc = CantileverPlateBenchmark(self.nx, self.ny, thickness=t, element_type=MITC4Element).run()
+            full = CantileverPlateBenchmark(self.nx, self.ny, thickness=t, element_type=Q4FullShearElement).run()
+            mitc_ratio = mitc.values["ratio_to_reference"]
+            full_ratio = full.values["ratio_to_reference"]
+            mitc_ratios.append(mitc_ratio)
+            full_ratios.append(full_ratio)
+            values[f"mitc_ratio_t_{t:.0e}"] = mitc_ratio
+            values[f"full_ratio_t_{t:.0e}"] = full_ratio
+
+        values["mitc_ratio_spread"] = max(mitc_ratios) - min(mitc_ratios)
+        values["full_thin_ratio"] = full_ratios[-1]
+        values["locking_contrast"] = mitc_ratios[-1] / max(full_ratios[-1], 1.0e-30)
+        return BenchmarkResult("Shear locking study", values)
+

mitc4/cli.py

@@ -0,0 +1,115 @@
+"""Command line interface for the MITC4 package."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+from typing import Sequence
+
+from mitc4.benchmarks import CantileverPlateBenchmark, ScordelisLoBenchmark, ShearLockingStudy
+from mitc4.verification import MechanicalVerifier, print_results_table
+from solveur.version import __version__
+
+
+def command_verify(args: argparse.Namespace) -> int:
+    results = MechanicalVerifier().run(include_benchmark=not args.quick, png=args.png)
+    print_results_table(results)
+    return 0 if all(result.passed for result in results) else 1
+
+
+def command_scordelis(args: argparse.Namespace) -> int:
+    result = ScordelisLoBenchmark(args.nx, args.ny).run(show=args.show, png=args.png, scale=args.scale)
+    values = result.values
+    print("\nScordelis-Lo roof")
+    print(f"mesh                 : {args.nx} x {args.ny}")
+    print(f"edge center Uz       : {values['w_edge_center']:.8e} m")
+    print(f"opposite edge Uz     : {values['w_opposite_edge_center']:.8e} m")
+    print(f"reference Uz         : {values['reference']:.8e} m")
+    print(f"relative error       : {values['error_percent']:.4f} %")
+    print(f"symmetry error       : {values['symmetry_error_percent']:.4f} %")
+    if args.png is not None:
+        print(f"figure saved         : {args.png}")
+    return 0 if values["error_percent"] < args.max_error else 1
+
+
+def command_cantilever(args: argparse.Namespace) -> int:
+    result = CantileverPlateBenchmark(
+        args.nx,
+        args.ny,
+        length=args.length,
+        width=args.width,
+        thickness=args.thickness,
+        force=args.force,
+        E=args.E,
+        nu=args.nu,
+    ).run(show=args.show, png=args.png, scale=args.scale)
+    values = result.values
+    print("\nCantilever plate")
+    print(f"mesh                 : {args.nx} x {args.ny}")
+    print(f"tip Uz               : {values['tip_w']:.8e} m")
+    print(f"EB/Kirchhoff check   : {values['reference']:.8e} m")
+    print(f"relative difference  : {values['error_percent']:.4f} %")
+    if args.png is not None:
+        print(f"figure saved         : {args.png}")
+    return 0
+
+
+def command_shear_study(args: argparse.Namespace) -> int:
+    result = ShearLockingStudy(args.nx, args.ny).run()
+    print("\nTransverse shear / shear-locking study")
+    for key, value in result.values.items():
+        print(f"{key:24s}: {value:.8e}")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(description="MITC4 flat-shell solver and verification suite.")
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    sub = parser.add_subparsers(dest="command")
+
+    verify = sub.add_parser("verify", help="run mechanical verification tests")
+    verify.add_argument("--quick", action="store_true", help="skip Scordelis-Lo benchmark")
+    verify.add_argument("--png", type=Path, default=Path("results/scordelis_verification.png"), help="benchmark figure path")
+    verify.set_defaults(func=command_verify)
+
+    scordelis = sub.add_parser("scordelis", help="solve the Scordelis-Lo roof benchmark")
+    scordelis.add_argument("--nx", type=int, default=24)
+    scordelis.add_argument("--ny", type=int, default=24)
+    scordelis.add_argument("--scale", type=float, default=20.0)
+    scordelis.add_argument("--show", action="store_true")
+    scordelis.add_argument("--png", type=Path, default=Path("results/scordelis.png"))
+    scordelis.add_argument("--max-error", type=float, default=1.5)
+    scordelis.set_defaults(func=command_scordelis)
+
+    cantilever = sub.add_parser("cantilever", help="solve a clamped rectangular plate")
+    cantilever.add_argument("--nx", type=int, default=16)
+    cantilever.add_argument("--ny", type=int, default=4)
+    cantilever.add_argument("--length", type=float, default=1.0)
+    cantilever.add_argument("--width", type=float, default=0.2)
+    cantilever.add_argument("--thickness", type=float, default=0.01)
+    cantilever.add_argument("--force", type=float, default=-1000.0)
+    cantilever.add_argument("--E", type=float, default=210.0e9)
+    cantilever.add_argument("--nu", type=float, default=0.3)
+    cantilever.add_argument("--scale", type=float, default=None)
+    cantilever.add_argument("--show", action="store_true")
+    cantilever.add_argument("--png", type=Path, default=Path("results/cantilever.png"))
+    cantilever.set_defaults(func=command_cantilever)
+
+    shear = sub.add_parser("shear-study", help="compare MITC and full Q4 transverse shear behavior")
+    shear.add_argument("--nx", type=int, default=8)
+    shear.add_argument("--ny", type=int, default=2)
+    shear.set_defaults(func=command_shear_study)
+
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    if args.command is None:
+        args = parser.parse_args(["verify"])
+    return args.func(args)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

mitc4/constants.py

@@ -0,0 +1,11 @@
+"""Shared constants for the MITC4 package."""
+
+DOF_PER_NODE = 6
+
+UX = 0
+UY = 1
+UZ = 2
+RX = 3
+RY = 4
+RZ = 5
+

mitc4/convergence.py

@@ -0,0 +1,282 @@
+"""Five-level structural convergence studies for the MITC4 element."""
+
+from __future__ import annotations
+
+import math
+from dataclasses import asdict, dataclass
+
+import numpy as np
+
+from mitc4.benchmarks import ScordelisLoBenchmark
+from mitc4.constants import DOF_PER_NODE, RX, RZ, UX, UY, UZ
+from mitc4.material import ShellMaterial
+from mitc4.model import ShellModel
+
+
+@dataclass(frozen=True)
+class ConvergencePoint:
+    mesh: tuple[int, int]
+    element_count: int
+    value: float
+    reference: float
+    relative_error: float
+    solver_method: str = "direct"
+    solver_iterations: int | None = None
+    solver_relative_residual: float | None = None
+
+    def to_dict(self) -> dict[str, object]:
+        return asdict(self)
+
+
+@dataclass(frozen=True)
+class StructuralConvergence:
+    identifier: str
+    points: tuple[ConvergencePoint, ...]
+    error_limit: float
+    status: str
+    final_increment: float
+    minimum_reference_error: float
+    review_status: str
+    recommendation: str
+
+    def to_dict(self) -> dict[str, object]:
+        return {
+            "study_id": self.identifier,
+            "status": self.status,
+            "error_limit": self.error_limit,
+            "points": [point.to_dict() for point in self.points],
+            "final_increment": self.final_increment,
+            "minimum_reference_error": self.minimum_reference_error,
+            "review_status": self.review_status,
+            "recommendation": self.recommendation,
+        }
+
+
+class Mitc4StructuralConvergence:
+    """Run Cook, Scordelis-Lo and pinched-cylinder h studies."""
+
+    def run(self, *, quick: bool = False) -> dict[str, StructuralConvergence]:
+        if quick:
+            return {}
+        return {
+            "cook": self._study(
+                "VNV-MITC4-COOK-001",
+                ((4, 4), (8, 8), (16, 16), (24, 24), (32, 32), (64, 64)),
+                0.05,
+                _cook_point,
+            ),
+            "scordelis": self._study(
+                "VNV-MITC4-SCORDELIS-001",
+                ((8, 8), (12, 12), (16, 16), (24, 24), (32, 32)),
+                0.02,
+                _scordelis_point,
+            ),
+            "pinched": self._study(
+                "VNV-MITC4-PINCHED-001",
+                ((8, 16), (12, 24), (16, 32), (24, 48), (32, 64)),
+                0.10,
+                _pinched_point,
+            ),
+        }
+
+    @staticmethod
+    def drilling_sensitivity(
+        scales: tuple[float, ...] = (1.0e-6, 1.0e-5, 1.0e-4, 1.0e-3, 1.0e-2),
+    ) -> dict[str, object]:
+        points = [
+            {"drilling_scale": scale, "tip_displacement": _cook_point(16, 16, scale).value}
+            for scale in scales
+        ]
+        baseline = next(point["tip_displacement"] for point in points if point["drilling_scale"] == 1.0e-4)
+        for point in points:
+            point["relative_change"] = abs(point["tip_displacement"] - baseline) / max(abs(baseline), 1.0e-30)
+        plateau = max(
+            point["relative_change"]
+            for point in points
+            if 1.0e-5 <= point["drilling_scale"] <= 1.0e-3
+        )
+        return {
+            "study_id": "VNV-MITC4-DRILLING-001",
+            "status": "PASS" if plateau <= 0.01 else "FAIL",
+            "plateau_relative_change": plateau,
+            "plateau_limit": 0.01,
+            "selected_scale": 1.0e-4,
+            "points": points,
+        }
+
+    @staticmethod
+    def _study(
+        identifier: str,
+        meshes: tuple[tuple[int, int], ...],
+        limit: float,
+        runner: object,
+    ) -> StructuralConvergence:
+        points = tuple(runner(*mesh) for mesh in meshes)
+        final_error = points[-1].relative_error
+        minimum_error = min(point.relative_error for point in points)
+        final_increment = abs(points[-1].value - points[-2].value) / max(abs(points[-1].value), 1.0e-30)
+        status = "PASS" if final_error <= limit and final_increment <= limit else "FAIL"
+        review_status = "WARNING" if final_error > minimum_error + 0.01 else "PASS"
+        recommendation = (
+            "The reference error rises after an earlier minimum; audit the Cook reference and boundary conditions "
+            "before claiming full static acceptance."
+            if review_status == "WARNING"
+            else "Reference-error trend is compatible with the current acceptance criterion."
+        )
+        return StructuralConvergence(
+            identifier,
+            points,
+            limit,
+            status,
+            final_increment,
+            minimum_error,
+            review_status,
+            recommendation,
+        )
+
+
+def cook_large_point(nx: int = 200, ny: int = 200) -> ConvergencePoint:
+    """Run an opt-in, memory-bounded Cook refinement point."""
+    return _cook_point(nx, ny, iterative=True)
+
+
+def _cook_point(
+    nx: int,
+    ny: int,
+    drilling_scale: float = 1.0e-4,
+    *,
+    iterative: bool = False,
+) -> ConvergencePoint:
+    scale = 0.01
+    corners = scale * np.asarray(
+        [[0.0, 0.0, 0.0], [48.0, 44.0, 0.0], [48.0, 60.0, 0.0], [0.0, 44.0, 0.0]]
+    )
+    nodes, quads, node = _bilinear_mesh(corners, nx, ny)
+    young, thickness, total_force = 1.0e6, 0.01, 100.0
+    model = ShellModel(
+        nodes,
+        quads,
+        ShellMaterial(E=young, nu=1.0 / 3.0, t=thickness, drilling_scale=drilling_scale),
+    )
+    edge_length = float(np.linalg.norm(corners[2] - corners[1]))
+    traction = total_force / edge_length
+    for j in range(ny):
+        first, second = node(nx, j), node(nx, j + 1)
+        segment = float(np.linalg.norm(nodes[second] - nodes[first]))
+        model.add_nodal_load(first, UY, 0.5 * traction * segment)
+        model.add_nodal_load(second, UY, 0.5 * traction * segment)
+    for j in range(ny + 1):
+        model.fix_node(node(0, j))
+    diagnostics: dict[str, float | int | str] = {}
+    if iterative:
+        displacement, diagnostics = model.solve_iterative()
+    else:
+        displacement = model.solve()
+    tip = node(nx, ny)
+    value = float(displacement[tip * DOF_PER_NODE + UY])
+    reference = 23.96 * total_force / (young * thickness)
+    return _point(
+        nx,
+        ny,
+        value,
+        reference,
+        solver_method=str(diagnostics.get("method", "direct")),
+        solver_iterations=int(diagnostics["iterations"]) if "iterations" in diagnostics else None,
+        solver_relative_residual=(
+            float(diagnostics["relative_residual"]) if "relative_residual" in diagnostics else None
+        ),
+    )
+
+
+def _scordelis_point(nx: int, ny: int) -> ConvergencePoint:
+    result = ScordelisLoBenchmark(nx, ny).run().values
+    value = 0.5 * (result["w_edge_center"] + result["w_opposite_edge_center"])
+    return _point(nx, ny, value, result["reference"])
+
+
+def _pinched_point(nx: int, ntheta: int) -> ConvergencePoint:
+    length, radius = 600.0, 300.0
+    nodes, quads, node = _periodic_cylinder(length, radius, nx, ntheta)
+    model = ShellModel(nodes, quads, ShellMaterial(E=3.0e6, nu=0.3, t=3.0))
+    for j in range(ntheta):
+        for i in (0, nx):
+            model.add_fixed_dof(node(i, j), UY)
+            model.add_fixed_dof(node(i, j), UZ)
+            model.add_fixed_dof(node(i, j), RX)
+    model.add_fixed_dof(node(0, 0), UX)
+    model.add_fixed_dof(node(0, 0), RZ)
+    load_a = node(nx // 2, 0)
+    load_b = node(nx // 2, ntheta // 2)
+    model.add_nodal_load(load_a, UY, -1.0)
+    model.add_nodal_load(load_b, UY, 1.0)
+    displacement = model.solve()
+    value = abs(float(displacement[load_a * DOF_PER_NODE + UY]))
+    return _point(nx, ntheta, value, 1.8248e-5)
+
+
+def _point(
+    nx: int,
+    ny: int,
+    value: float,
+    reference: float,
+    *,
+    solver_method: str = "direct",
+    solver_iterations: int | None = None,
+    solver_relative_residual: float | None = None,
+) -> ConvergencePoint:
+    return ConvergencePoint(
+        mesh=(nx, ny),
+        element_count=nx * ny,
+        value=value,
+        reference=reference,
+        relative_error=abs((value - reference) / reference),
+        solver_method=solver_method,
+        solver_iterations=solver_iterations,
+        solver_relative_residual=solver_relative_residual,
+    )
+
+
+def _bilinear_mesh(
+    corners: np.ndarray, nx: int, ny: int
+) -> tuple[np.ndarray, np.ndarray, object]:
+    nodes = []
+    for i in range(nx + 1):
+        xi = i / nx
+        for j in range(ny + 1):
+            eta = j / ny
+            nodes.append(
+                (1.0 - xi) * (1.0 - eta) * corners[0]
+                + xi * (1.0 - eta) * corners[1]
+                + xi * eta * corners[2]
+                + (1.0 - xi) * eta * corners[3]
+            )
+
+    def node(i: int, j: int) -> int:
+        return i * (ny + 1) + j
+
+    quads = [
+        [node(i, j), node(i + 1, j), node(i + 1, j + 1), node(i, j + 1)]
+        for i in range(nx)
+        for j in range(ny)
+    ]
+    return np.asarray(nodes), np.asarray(quads, dtype=int), node
+
+
+def _periodic_cylinder(
+    length: float, radius: float, nx: int, ntheta: int
+) -> tuple[np.ndarray, np.ndarray, object]:
+    nodes = [
+        [-0.5 * length + length * i / nx, radius * math.cos(2.0 * math.pi * j / ntheta), radius * math.sin(2.0 * math.pi * j / ntheta)]
+        for i in range(nx + 1)
+        for j in range(ntheta)
+    ]
+
+    def node(i: int, j: int) -> int:
+        return i * ntheta + (j % ntheta)
+
+    quads = [
+        [node(i, j), node(i + 1, j), node(i + 1, j + 1), node(i, j + 1)]
+        for i in range(nx)
+        for j in range(ntheta)
+    ]
+    return np.asarray(nodes), np.asarray(quads, dtype=int), node