ANYsolver 0.1.0__py3-none-any.whl

anysolver/s4_validity.py

@@ -0,0 +1,326 @@
+"""S4 shell validity metrics and local report generation."""
+
+from __future__ import annotations
+
+import json
+import platform
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, Iterable, List, Mapping, Sequence, Tuple
+
+import numpy as np
+
+from .assembly import solve_linear
+from .boundary import FixedSupport, LoadCase
+from .elements import ShellElement
+from .fe_core import FEModel
+from .mesh_gen import generate_simple_panel_mesh
+from .shell_benchmarks import run_simple_supported_shell_benchmark
+
+
+DEFAULT_S4_VALIDITY_PATH = Path("reports/s4_validity/s4_validity_report.json")
+
+E_STEEL = 210.0e9
+NU_STEEL = 0.3
+
+
+@dataclass(frozen=True)
+class S4Metric:
+    """One scalar S4 validity metric."""
+
+    name: str
+    value: float
+    unit: str = ""
+    metadata: Mapping[str, Any] | None = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "name": self.name,
+            "value": float(self.value),
+            "unit": self.unit,
+            "metadata": dict(self.metadata or {}),
+        }
+
+
+def _git_sha() -> str | None:
+    try:
+        result = subprocess.run(["git", "rev-parse", "HEAD"], text=True, capture_output=True, check=False)
+    except Exception:
+        return None
+    return result.stdout.strip() if result.returncode == 0 and result.stdout.strip() else None
+
+
+def _single_s4_model(coords: Sequence[Sequence[float]], thickness: float = 0.01) -> FEModel:
+    model = FEModel("single_s4")
+    model.add_material("steel", E_STEEL, NU_STEEL)
+    for node_id, coord in enumerate(coords, start=1):
+        model.add_node(node_id, float(coord[0]), float(coord[1]), float(coord[2]))
+    model.add_element(1, ShellElement(1, [1, 2, 3, 4], "steel", thickness))
+    return model
+
+
+def reference_s4_geometries() -> Dict[str, Tuple[Tuple[float, float, float], ...]]:
+    """Representative S4 geometries used by validity metrics."""
+    return {
+        "square": ((0.0, 0.0, 0.0), (1.0, 0.0, 0.0), (1.0, 1.0, 0.0), (0.0, 1.0, 0.0)),
+        "parallelogram": ((0.0, 0.0, 0.0), (1.2, 0.0, 0.0), (1.55, 0.9, 0.0), (0.35, 0.9, 0.0)),
+        "skew": ((0.0, 0.0, 0.0), (1.35, 0.08, 0.0), (1.08, 0.95, 0.0), (-0.18, 1.12, 0.0)),
+        "mild_warp": ((0.0, 0.0, 0.0), (1.0, 0.0, 0.015), (1.0, 1.0, -0.012), (0.0, 1.0, 0.008)),
+    }
+
+
+def free_element_mode_metric(coords: Sequence[Sequence[float]]) -> Dict[str, Any]:
+    """Return free S4 eigenvalue/null-mode diagnostics."""
+    model = _single_s4_model(coords)
+    element = model.mesh.get_element(1)
+    K = element.compute_stiffness_matrix(model.mesh, model.get_material("steel"))
+    eig = np.linalg.eigvalsh(0.5 * (K + K.T))
+    max_eig = max(float(np.max(np.abs(eig))), 1.0)
+    threshold = 1.0e-9 * max_eig
+    return {
+        "zero_mode_count": int(np.sum(np.abs(eig) < threshold)),
+        "threshold": float(threshold),
+        "min_eigenvalue": float(np.min(eig)),
+        "max_eigenvalue": float(np.max(eig)),
+        "relative_negative_eigenvalue": float(min(np.min(eig), 0.0) / max_eig),
+    }
+
+
+def _membrane_displacement(model: FEModel, eps_x: float, eps_y: float, gamma_xy: float) -> np.ndarray:
+    element = model.mesh.get_element(1)
+    coords = element.get_node_coordinates(model.mesh)
+    u = np.zeros(element.total_dofs, dtype=float)
+    for local_node_index, coord in enumerate(coords):
+        x, y, _z = coord
+        base = local_node_index * 6
+        u[base + 0] = eps_x * x
+        u[base + 1] = eps_y * y + gamma_xy * x
+    return u
+
+
+def membrane_patch_metric(coords: Sequence[Sequence[float]]) -> Dict[str, Any]:
+    """Constant membrane strain patch error on one S4 element.
+
+    The element's default stress output is expressed in the per-integration-point
+    local shell frame (local x follows the xi tangent), which rotates relative to
+    the global axes on distorted geometry.  The patch comparison therefore uses
+    the ``return_global=True`` surface stresses so that exact constant-strain
+    reproduction is measured frame-consistently.
+    """
+    model = _single_s4_model(coords)
+    element = model.mesh.get_element(1)
+    material = model.get_material("steel")
+    eps_x, eps_y, gamma_xy = 1.2e-4, -0.4e-4, 0.7e-4
+    u = _membrane_displacement(model, eps_x, eps_y, gamma_xy)
+    stresses = element.compute_stresses(model.mesh, u, material, return_global=True)
+    E = material.elastic_modulus
+    nu = material.poisson_ratio
+    expected = {
+        "membrane_xx": ("xx", E / (1.0 - nu**2) * (eps_x + nu * eps_y)),
+        "membrane_yy": ("yy", E / (1.0 - nu**2) * (eps_y + nu * eps_x)),
+        "membrane_xy": ("xy", E / (2.0 * (1.0 + nu)) * gamma_xy),
+    }
+    errors = {}
+    spreads = {}
+    for key, (component, target) in expected.items():
+        top = np.asarray(stresses[f"global_{component}_top"], dtype=float)
+        bottom = np.asarray(stresses[f"global_{component}_bot"], dtype=float)
+        values = 0.5 * (top + bottom)
+        errors[key] = float(np.max(np.abs(values - target)) / max(abs(float(target)), 1.0))
+        spreads[key] = float((np.max(values) - np.min(values)) / max(abs(float(target)), 1.0))
+    return {"relative_errors": errors, "relative_spreads": spreads, "stress_frame": "global"}
+
+
+def bending_patch_metric(coords: Sequence[Sequence[float]]) -> Dict[str, Any]:
+    """Constant curvature patch error on one S4 element."""
+    model = _single_s4_model(coords)
+    element = model.mesh.get_element(1)
+    material = model.get_material("steel")
+    kappa_x = 1.1e-3
+    coords_array = element.get_node_coordinates(model.mesh)
+    u = np.zeros(element.total_dofs, dtype=float)
+    for local_node_index, coord in enumerate(coords_array):
+        x = coord[0]
+        u[local_node_index * 6 + 4] = kappa_x * x
+    stresses = element.compute_stresses(model.mesh, u, material, return_global=True)
+    expected = material.elastic_modulus * element.thickness / (2.0 * (1.0 - material.poisson_ratio**2)) * kappa_x
+    top = np.asarray(stresses["global_xx_top"], dtype=float)
+    bottom = np.asarray(stresses["global_xx_bot"], dtype=float)
+    values = 0.5 * (top - bottom)
+    return {
+        "relative_error": float(np.max(np.abs(values - expected)) / max(abs(expected), 1.0)),
+        "relative_spread": float((np.max(values) - np.min(values)) / max(abs(expected), 1.0)),
+        "stress_frame": "global",
+    }
+
+
+def shear_patch_metric(coords: Sequence[Sequence[float]]) -> Dict[str, Any]:
+    """Constant transverse shear patch on one S4 element.
+
+    Compared in the local shell frame.  MITC4 assumed transverse shear keeps a
+    small interpolation residual on distorted (non-affine) geometry; that is
+    expected element behavior rather than a stress-frame artifact.
+    """
+    model = _single_s4_model(coords)
+    element = model.mesh.get_element(1)
+    material = model.get_material("steel")
+    gamma_xz = 2.0e-4
+    coords_array = element.get_node_coordinates(model.mesh)
+    u = np.zeros(element.total_dofs, dtype=float)
+    for local_node_index, coord in enumerate(coords_array):
+        x = coord[0]
+        u[local_node_index * 6 + 2] = gamma_xz * x
+    stresses = element.compute_stresses(model.mesh, u, material)
+    expected = material.shear_modulus * (5.0 / 6.0) * gamma_xz
+    values = np.asarray(stresses["shear_xz"], dtype=float)
+    return {
+        "relative_error": float(np.max(np.abs(values - expected)) / max(abs(expected), 1.0)),
+        "relative_spread": float((np.max(values) - np.min(values)) / max(abs(expected), 1.0)),
+        "target_shear_pa": float(expected),
+    }
+
+
+def thin_plate_locking_sweep(
+    thicknesses: Sequence[float] = (0.01, 0.003, 0.001),
+    length: float = 1.0,
+    width: float = 0.1,
+    num_divisions: int = 10,
+) -> Tuple[Dict[str, Any], ...]:
+    """Cantilever strip sweep against beam bending reference."""
+    rows: List[Dict[str, Any]] = []
+    for thickness in thicknesses:
+        model = FEModel(name="s4_locking_strip")
+        model.add_material("steel", E_STEEL, NU_STEEL)
+        nid = {}
+        node_id = 1
+        for i in range(num_divisions + 1):
+            for j in range(2):
+                model.add_node(node_id, length * i / num_divisions, width * j, 0.0)
+                nid[(i, j)] = node_id
+                node_id += 1
+        for i in range(num_divisions):
+            model.add_element(
+                i + 1,
+                ShellElement(i + 1, [nid[(i, 0)], nid[(i + 1, 0)], nid[(i + 1, 1)], nid[(i, 1)]], "steel", thickness),
+            )
+        model.add_boundary_condition(FixedSupport("fixed", [nid[(0, 0)], nid[(0, 1)]]))
+        load_case = LoadCase("tip")
+        load_case.add_nodal_load(nid[(num_divisions, 0)], [0.0, 0.0, 0.5, 0.0, 0.0, 0.0])
+        load_case.add_nodal_load(nid[(num_divisions, 1)], [0.0, 0.0, 0.5, 0.0, 0.0, 0.0])
+        displacements, solver_info = solve_linear(model, load_case)
+        w_tip = 0.5 * (
+            displacements[model.mesh.get_node(nid[(num_divisions, 0)]).dofs[2]]
+            + displacements[model.mesh.get_node(nid[(num_divisions, 1)]).dofs[2]]
+        )
+        reference = length**3 / (3.0 * E_STEEL * width * thickness**3 / 12.0)
+        rows.append(
+            {
+                "thickness": float(thickness),
+                "span_to_thickness": float(length / thickness),
+                "tip_displacement": float(w_tip),
+                "beam_reference_displacement": float(reference),
+                "ratio_to_reference": float(w_tip / reference),
+                "relative_error": float(abs(w_tip - reference) / max(abs(reference), 1.0e-30)),
+                "solver_status": str((solver_info.get("convergence_info") or {}).get("status", "unknown")),
+            }
+        )
+    return tuple(rows)
+
+
+def _s4_recovered_von_mises(division: int, thickness: float) -> float:
+    from .boundary import LoadCase
+    from .mesh_gen import generate_simple_panel_mesh
+    from .results import recover_nodal_stresses
+
+    model = generate_simple_panel_mesh(1.0, 1.0, thickness, num_divisions_x=int(division), num_divisions_y=int(division), use_8node_elements=False)
+    load_case = LoadCase("constant_surface_load")
+    for element_id in model.mesh.elements:
+        load_case.add_pressure_load(element_id, 1000.0)
+    displacements, _info = solve_linear(model, load_case)
+    return float(recover_nodal_stresses(model, displacements)["max_von_mises"])
+
+
+def s4_s8_comparison(divisions: Sequence[int] = (2, 4), thickness: float = 0.01) -> Tuple[Dict[str, Any], ...]:
+    """Compare S4 and S8 responses for matching simple supported panel sweeps.
+
+    ``s4_von_mises`` is the raw integration-point peak; ``s4_von_mises_recovered``
+    is the Gauss-to-node extrapolated, patch-averaged nodal peak.  Note that the
+    coarse-mesh S8 von Mises overshoots the converged value near the hard
+    simply-supported corners, so the S4/S8 stress ratio at coarse divisions is
+    not a pure S4 accuracy measure.
+    """
+    rows: List[Dict[str, Any]] = []
+    for division in divisions:
+        s4 = run_simple_supported_shell_benchmark(divisions_x=int(division), divisions_y=int(division), thickness=thickness, use_8node_elements=False)
+        s8 = run_simple_supported_shell_benchmark(divisions_x=int(division), divisions_y=int(division), thickness=thickness, use_8node_elements=True)
+        recovered = _s4_recovered_von_mises(int(division), thickness)
+        rows.append(
+            {
+                "division": int(division),
+                "s4_nodes": int(s4.node_count),
+                "s8_nodes": int(s8.node_count),
+                "s4_displacement": float(s4.max_out_of_plane_displacement),
+                "s8_displacement": float(s8.max_out_of_plane_displacement),
+                "displacement_ratio_s4_to_s8": float(s4.max_out_of_plane_displacement / max(s8.max_out_of_plane_displacement, 1.0e-30)),
+                "s4_von_mises": float(s4.max_von_mises_stress),
+                "s4_von_mises_recovered": float(recovered),
+                "s8_von_mises": float(s8.max_von_mises_stress),
+                "stress_ratio_s4_to_s8": float(s4.max_von_mises_stress / max(s8.max_von_mises_stress, 1.0e-30)),
+                "recovered_stress_ratio_s4_to_s8": float(recovered / max(s8.max_von_mises_stress, 1.0e-30)),
+                "s4_status": s4.solver_status,
+                "s8_status": s8.solver_status,
+            }
+        )
+    return tuple(rows)
+
+
+def generate_s4_validity_report() -> Dict[str, Any]:
+    """Generate a local S4 validity report."""
+    geometries = reference_s4_geometries()
+    geometry_metrics: Dict[str, Any] = {}
+    for name, coords in geometries.items():
+        metrics = {"free_modes": free_element_mode_metric(coords)}
+        if name != "mild_warp":
+            metrics["membrane_patch"] = membrane_patch_metric(coords)
+            metrics["bending_patch"] = bending_patch_metric(coords)
+            metrics["shear_patch"] = shear_patch_metric(coords)
+        else:
+            model = _single_s4_model(coords)
+            element = model.mesh.get_element(1)
+            K = element.compute_stiffness_matrix(model.mesh, model.get_material("steel"))
+            metrics["warped_quad"] = {
+                "stiffness_finite": bool(np.all(np.isfinite(K))),
+                "relative_symmetry_error": float(np.linalg.norm(K - K.T) / max(np.linalg.norm(K), 1.0)),
+            }
+        geometry_metrics[name] = metrics
+
+    return {
+        "schema_version": 1,
+        "generated_at": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+        "commit": _git_sha(),
+        "environment": {
+            "platform": platform.platform(),
+            "python": sys.version.split()[0],
+            "numpy": np.__version__,
+        },
+        "element": "S4",
+        "theory_notes": [
+            "S4 uses a Mindlin-Reissner shell with MITC-style assumed transverse shear for 4-node quadrilaterals.",
+            "Metrics are local regression evidence; external CalculiX/SESTRA comparisons remain a separate validation layer.",
+        ],
+        "geometry_metrics": geometry_metrics,
+        "thin_plate_locking_sweep": list(thin_plate_locking_sweep()),
+        "s4_s8_comparison": list(s4_s8_comparison()),
+    }
+
+
+def write_s4_validity_report(path: Path | str = DEFAULT_S4_VALIDITY_PATH) -> Dict[str, Any]:
+    """Write the S4 validity report as JSON."""
+    report = generate_s4_validity_report()
+    output = Path(path)
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    return report

anysolver/sesam_fem/__init__.py

@@ -0,0 +1,55 @@
+"""Pure-Python SESAM formatted FEM import/export support."""
+
+from .diagnostics import FemDiagnostic, SesamFemError
+from .document import (
+    FemBoundary,
+    FemCoordinate,
+    FemCoordinateTransform,
+    FemElement,
+    FemElementReference,
+    FemHeader,
+    FemLoadRecord,
+    FemMaterial,
+    FemNode,
+    FemSection,
+    FemUnitVector,
+    SesamFemDocument,
+    parse_sesam_fem_records,
+    read_sesam_fem_document,
+)
+from .exporter import SesamFemExportReport, export_sesam_fem, write_sesam_fem_document
+from .importer import SesamFemImportResult, build_fe_model_from_sesam_document, import_sesam_fem
+from .records import FemRawRecord, read_raw_records, strict_int
+from .schema import SESAM_ELEMENT_REGISTRY, SesamElementSpec
+from .validation import validate_sesam_fem_document
+
+__all__ = [
+    "FemBoundary",
+    "FemCoordinate",
+    "FemCoordinateTransform",
+    "FemDiagnostic",
+    "FemElement",
+    "FemElementReference",
+    "FemHeader",
+    "FemLoadRecord",
+    "FemMaterial",
+    "FemNode",
+    "FemRawRecord",
+    "FemSection",
+    "FemUnitVector",
+    "SESAM_ELEMENT_REGISTRY",
+    "SesamElementSpec",
+    "SesamFemDocument",
+    "SesamFemError",
+    "SesamFemExportReport",
+    "SesamFemImportResult",
+    "build_fe_model_from_sesam_document",
+    "export_sesam_fem",
+    "import_sesam_fem",
+    "parse_sesam_fem_records",
+    "read_raw_records",
+    "read_sesam_fem_document",
+    "strict_int",
+    "validate_sesam_fem_document",
+    "write_sesam_fem_document",
+]

anysolver/sesam_fem/__main__.py

@@ -0,0 +1,80 @@
+"""Command line helpers for SESAM formatted FEM files."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+import sys
+
+from .diagnostics import SesamFemError
+from .document import read_sesam_fem_document
+from .exporter import write_sesam_fem_document
+from .importer import import_sesam_fem
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="python -m anysolver.sesam_fem")
+    parser.add_argument("--lenient", action="store_true", help="collect diagnostics instead of failing on errors")
+    parser.add_argument("--json", action="store_true", help="print machine-readable JSON")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    inspect_parser = sub.add_parser("inspect", help="show document summary")
+    inspect_parser.add_argument("input")
+
+    validate_parser = sub.add_parser("validate", help="validate a FEM file")
+    validate_parser.add_argument("input")
+
+    roundtrip_parser = sub.add_parser("roundtrip", help="canonicalize a FEM file")
+    roundtrip_parser.add_argument("input")
+    roundtrip_parser.add_argument("output")
+    roundtrip_parser.add_argument("--overwrite", action="store_true")
+
+    summary_parser = sub.add_parser("import-summary", help="read and optionally build a solver model")
+    summary_parser.add_argument("input")
+    summary_parser.add_argument("--summary-json", dest="summary_json")
+    summary_parser.add_argument("--no-build-model", action="store_true")
+
+    args = parser.parse_args(argv)
+    strict = not args.lenient
+    try:
+        if args.command == "inspect":
+            document = read_sesam_fem_document(args.input, strict=strict)
+            return _print(document.summary(), args.json)
+        if args.command == "validate":
+            document = read_sesam_fem_document(args.input, strict=strict)
+            payload = {"ok": not any(item.severity == "error" for item in document.diagnostics), "diagnostics": [item.as_dict() for item in document.diagnostics]}
+            return _print(payload, args.json)
+        if args.command == "roundtrip":
+            document = read_sesam_fem_document(args.input, strict=strict)
+            report = write_sesam_fem_document(document, args.output, overwrite=args.overwrite)
+            return _print({"output": str(report.path), "records_written": report.records_written, "bytes_written": report.bytes_written}, args.json)
+        if args.command == "import-summary":
+            result = import_sesam_fem(args.input, strict=strict, build_model=not args.no_build_model)
+            payload = result.document.summary()
+            payload["element_count_by_type"] = result.element_count_by_type
+            payload["model_built"] = result.model is not None
+            if args.summary_json:
+                Path(args.summary_json).write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")
+            return _print(payload, args.json)
+    except SesamFemError as exc:
+        payload = {"ok": False, "code": exc.code, "message": str(exc), "diagnostics": [item.as_dict() for item in exc.diagnostics]}
+        _print(payload, True)
+        return 2
+    return 1
+
+
+def _print(payload: object, as_json: bool) -> int:
+    if as_json:
+        print(json.dumps(payload, indent=2, sort_keys=True))
+    else:
+        if isinstance(payload, dict):
+            for key, value in payload.items():
+                print(f"{key}: {value}")
+        else:
+            print(payload)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

anysolver/sesam_fem/diagnostics.py

@@ -0,0 +1,65 @@
+"""Diagnostics and exceptions for SESAM formatted FEM support."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Iterable, Mapping, Optional, Tuple
+
+
+@dataclass(frozen=True)
+class FemDiagnostic:
+    """A structured SESAM FEM import/export diagnostic."""
+
+    code: str
+    message: str
+    severity: str = "error"
+    record_name: Optional[str] = None
+    line_start: Optional[int] = None
+    line_end: Optional[int] = None
+    context: Mapping[str, Any] | None = None
+
+    def as_dict(self) -> dict[str, Any]:
+        data: dict[str, Any] = {
+            "code": self.code,
+            "severity": self.severity,
+            "message": self.message,
+        }
+        if self.record_name is not None:
+            data["record_name"] = self.record_name
+        if self.line_start is not None:
+            data["line_start"] = self.line_start
+        if self.line_end is not None:
+            data["line_end"] = self.line_end
+        if self.context:
+            data["context"] = dict(self.context)
+        return data
+
+
+class SesamFemError(ValueError):
+    """Raised when a SESAM FEM file cannot be safely read or written."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        code: str = "FEM000",
+        diagnostics: Iterable[FemDiagnostic] | None = None,
+    ) -> None:
+        self.code = code
+        self.diagnostics: Tuple[FemDiagnostic, ...] = tuple(diagnostics or ())
+        super().__init__(f"{code}: {message}")
+
+
+def has_errors(diagnostics: Iterable[FemDiagnostic]) -> bool:
+    """Return True when the diagnostic collection contains errors."""
+
+    return any(item.severity.lower() == "error" for item in diagnostics)
+
+
+def raise_if_errors(diagnostics: Iterable[FemDiagnostic], message: str) -> None:
+    """Raise a SesamFemError when any diagnostic has error severity."""
+
+    items = tuple(diagnostics)
+    if has_errors(items):
+        first = next(item for item in items if item.severity.lower() == "error")
+        raise SesamFemError(message, code=first.code, diagnostics=items)