ANYsolver 0.1.2__tar.gz → 0.1.3__tar.gz

{anysolver-0.1.2 → anysolver-0.1.3}/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## Unreleased
 
+## 0.1.3 - 2026-07-28
+
+- Complete the generated-geometry runtime bridge: apply configured shear force
+  and torsional moment, pass current-area follower pressure only to supported
+  nonlinear static/arc-length paths, retain the selected corotational
+  kinematics in arc length, and fail closed for incompatible follower paths.
+  Runtime prestress recovery now consumes matching committed nonlinear
+  histories and exposes Gauss-point membrane/bending resultants plus recovery
+  provenance.
+- Correct nonlinear display recovery so plastic-history von Mises values use
+  only the return-mapped shell in-plane or beam-fiber components, while purely
+  elastic nonlinear states retain their full equivalent stress. Preserve
+  combinations with elastically reconstructed transverse shear/torsion as a
+  separately labelled model-scope diagnostic.
+- Add the public `resolve_runtime_analysis()` contract so application GUIs can
+  reflect normalized nonlinear/material/control/kinematics selections without
+  importing private runtime helpers.
+
 ## 0.1.2 - 2026-07-28
 
 - Add opt-in executable CalculiX reference validation with isolated case runs,
@@ -34,8 +52,7 @@
   invalid-row fallback, add a safeguarded local consistency solve with
   fail-closed residual checks, and add constitutive and full-Newton
   parity/performance evidence.
-
-## 0.1.1 - 2026-07-25
+## 0.1.1 - 2026-07-25
 
 - Correct the layered-shell membrane/bending coupling tangent and keep the
   accelerated plastic shell path consistent with the scalar return mapping.

{anysolver-0.1.2 → anysolver-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ANYsolver
-Version: 0.1.2
+Version: 0.1.3
 Summary: Qualified beam and shell finite-element solver
 Author-email: Audun Arnesen Nyhus <audunarn@gmail.com>
 License-Expression: GPL-3.0-or-later
@@ -64,9 +64,27 @@ from anysolver import (
     run_generated_geometry_fem,
     solve_linear,
 )
-from anysolver.runtime import LightweightFEMConfig, run_production_fem
+from anysolver.runtime import (
+    LightweightFEMConfig,
+    resolve_runtime_analysis,
+    run_production_fem,
+)
 ```
 
+The runtime facade applies its normalized axial force, bending moment, shear
+force, torsional moment, and pressure inputs to the generated model. Set
+`LightweightFEMConfig.follower_pressure=True` only for nonlinear static or
+arc-length analysis using the `static only` or `nonlinear static` runtime
+path; incompatible linear, stepwise eigenvalue-buckling, transient, collision,
+and structured-capacity paths return an explicit `invalid_follower_pressure`
+status. Arc length retains the requested von Karman or corotational
+kinematics. Production runtime failures remain failures rather than being
+replaced by an estimator.
+
+Application integrations should use `resolve_runtime_analysis(config)` to
+reflect the solver's effective nonlinear/material/control/kinematics choices;
+the normalization helpers with leading underscores are implementation details.
+
 The generic `GeneratedGeometryFEM*` names are the preferred workflow API.
 Historical `AnyStructureFEM*` aliases remain available only for downstream
 compatibility. Material selection is centralized in
@@ -97,7 +115,7 @@ changes before making release claims.
 | Initial fields | Element-local shell membrane/bending stress or membrane/curvature prestrain, arbitrary configured beam-fiber stress/prestrain distributions, zero-external-load equilibration, admissibility checks, and provenance kept separate from geometric imperfections. |
 | Workflows | Normalized generated geometry to static/prestress/buckling; traceable static-to-buckling-to-imperfect nonlinear-capacity workflow. |
 | Interchange | Pure-Python SESAM formatted FEM record/document parsing, guarded round-trip writing, supported semantic import to `FEModel`, coordinate transforms, beam orientation, and SIF shell-stress reading by load case. |
-| Results | Result provenance; unified elastic or committed shell-layer/beam-fiber stress recovery; guarded Zienkiewicz-Zhu-style patch recovery for qualified shell neighborhoods; selected recovery; reaction filtering; validation diagnostics; deterministic baselines; benchmarks; and generated qualification reports. |
+| Results | Result provenance; unified elastic or committed shell-layer/beam-fiber stress recovery; Gauss-point membrane-force and bending-moment resultants for generated-geometry prestress; guarded Zienkiewicz-Zhu-style patch recovery for qualified shell neighborhoods; selected recovery; reaction filtering; validation diagnostics; deterministic baselines; benchmarks; and generated qualification reports. |
 | External verification | Reproducible CalculiX input generation plus opt-in isolated execution, FRD/DAT parsing, solver provenance, and tolerance-controlled analytical comparison. Deck-only reports remain explicitly `not_executed` and make no numerical-agreement claim. |
 
 Implemented does not automatically mean qualified for every geometry or load
@@ -139,6 +157,13 @@ Important limits:
 - material-history-aware recovery requires retained, matching committed
   nonlinear layer/fiber states; missing or invalid state is reported and the
   affected components fall back explicitly to elastic reconstruction;
+- with an active plastic constitutive history, `von_mises` covers the
+  return-mapped shell in-plane or beam-fiber stress components. Transverse
+  shell shear and beam shear/torsion remain elastic reconstructions and are
+  exposed separately through `mixed_reconstruction_von_mises`, rather than
+  being presented as a hardening-curve-consistent equivalent stress. A purely
+  elastic nonlinear state keeps the full mixed elastic value as its primary
+  equivalent stress;
 - the guarded patch-recovery fit is qualified only for locally planar,
   consistently oriented, homogeneous, full-integration Q4 or Q8 shell
   neighborhoods. Discontinuities remain separate, and the optional normalized

{anysolver-0.1.2 → anysolver-0.1.3}/README.md

@@ -29,12 +29,30 @@ from anysolver import (
     run_generated_geometry_fem,
     solve_linear,
 )
-from anysolver.runtime import LightweightFEMConfig, run_production_fem
-```
-
-The generic `GeneratedGeometryFEM*` names are the preferred workflow API.
-Historical `AnyStructureFEM*` aliases remain available only for downstream
-compatibility. Material selection is centralized in
+from anysolver.runtime import (
+    LightweightFEMConfig,
+    resolve_runtime_analysis,
+    run_production_fem,
+)
+```
+
+The runtime facade applies its normalized axial force, bending moment, shear
+force, torsional moment, and pressure inputs to the generated model. Set
+`LightweightFEMConfig.follower_pressure=True` only for nonlinear static or
+arc-length analysis using the `static only` or `nonlinear static` runtime
+path; incompatible linear, stepwise eigenvalue-buckling, transient, collision,
+and structured-capacity paths return an explicit `invalid_follower_pressure`
+status. Arc length retains the requested von Karman or corotational
+kinematics. Production runtime failures remain failures rather than being
+replaced by an estimator.
+
+Application integrations should use `resolve_runtime_analysis(config)` to
+reflect the solver's effective nonlinear/material/control/kinematics choices;
+the normalization helpers with leading underscores are implementation details.
+
+The generic `GeneratedGeometryFEM*` names are the preferred workflow API.
+Historical `AnyStructureFEM*` aliases remain available only for downstream
+compatibility. Material selection is centralized in
 `dnv_c208_steel_properties()` and `dnv_c208_steel_curve()`; the runtime facade
 uses the same canonical table and validation.
 
@@ -62,7 +80,7 @@ changes before making release claims.
 | Initial fields | Element-local shell membrane/bending stress or membrane/curvature prestrain, arbitrary configured beam-fiber stress/prestrain distributions, zero-external-load equilibration, admissibility checks, and provenance kept separate from geometric imperfections. |
 | Workflows | Normalized generated geometry to static/prestress/buckling; traceable static-to-buckling-to-imperfect nonlinear-capacity workflow. |
 | Interchange | Pure-Python SESAM formatted FEM record/document parsing, guarded round-trip writing, supported semantic import to `FEModel`, coordinate transforms, beam orientation, and SIF shell-stress reading by load case. |
-| Results | Result provenance; unified elastic or committed shell-layer/beam-fiber stress recovery; guarded Zienkiewicz-Zhu-style patch recovery for qualified shell neighborhoods; selected recovery; reaction filtering; validation diagnostics; deterministic baselines; benchmarks; and generated qualification reports. |
+| Results | Result provenance; unified elastic or committed shell-layer/beam-fiber stress recovery; Gauss-point membrane-force and bending-moment resultants for generated-geometry prestress; guarded Zienkiewicz-Zhu-style patch recovery for qualified shell neighborhoods; selected recovery; reaction filtering; validation diagnostics; deterministic baselines; benchmarks; and generated qualification reports. |
 | External verification | Reproducible CalculiX input generation plus opt-in isolated execution, FRD/DAT parsing, solver provenance, and tolerance-controlled analytical comparison. Deck-only reports remain explicitly `not_executed` and make no numerical-agreement claim. |
 
 Implemented does not automatically mean qualified for every geometry or load
@@ -101,9 +119,16 @@ Important limits:
   selected automatically for follower pressure, but its numerical
   frame-sensitivity evaluation is costlier than the rotated tangent used by
   default for ordinary corotational solves;
-- material-history-aware recovery requires retained, matching committed
-  nonlinear layer/fiber states; missing or invalid state is reported and the
-  affected components fall back explicitly to elastic reconstruction;
+- material-history-aware recovery requires retained, matching committed
+  nonlinear layer/fiber states; missing or invalid state is reported and the
+  affected components fall back explicitly to elastic reconstruction;
+- with an active plastic constitutive history, `von_mises` covers the
+  return-mapped shell in-plane or beam-fiber stress components. Transverse
+  shell shear and beam shear/torsion remain elastic reconstructions and are
+  exposed separately through `mixed_reconstruction_von_mises`, rather than
+  being presented as a hardening-curve-consistent equivalent stress. A purely
+  elastic nonlinear state keeps the full mixed elastic value as its primary
+  equivalent stress;
 - the guarded patch-recovery fit is qualified only for locally planar,
   consistently oriented, homogeneous, full-integration Q4 or Q8 shell
   neighborhoods. Discontinuities remain separate, and the optional normalized

{anysolver-0.1.2 → anysolver-0.1.3}/docs/ARCHITECTURE.md

@@ -177,12 +177,19 @@ persistent shell batches transport only ordinary constitutive history. This
 keeps field state and recovery exact while leaving the accelerated path
 unchanged for ordinary elements.
 
-Committed layered-shell and beam-fiber states are the preferred recovery
-source for nonlinear results. The unified recovery API ties those states to
-the matching displacement vector, records a component-level source and
-explicitly labels any elastic displacement-reconstruction fallback. In
-corotational analyses it uses the same objective pull-back and current element
-frame as force assembly.
+Committed layered-shell and beam-fiber states are the preferred recovery
+source for nonlinear results. The unified recovery API ties those states to
+the matching displacement vector, records a component-level source and
+explicitly labels any elastic displacement-reconstruction fallback. In
+corotational analyses it uses the same objective pull-back and current element
+frame as force assembly. With an active plastic constitutive history, the
+material-history `von_mises` field is formed only from components governed by
+the corresponding return map: shell in-plane layers or axial beam fibers. A
+separately labelled `mixed_reconstruction_von_mises` diagnostic combines those
+stresses with the matching elastic transverse-shear/torsion reconstruction
+without implying that the mixed value was return-mapped or bounded by the
+hardening curve. Committed states from purely elastic nonlinear analyses retain
+the full mixed elastic value as primary `von_mises`.
 
 The optional Zienkiewicz--Zhu-style shell patch fit is deliberately narrow. It
 is qualified only for locally planar, consistently oriented, materially and
@@ -199,7 +206,7 @@ substep. It does not remove nodes, DOFs, or MPCs and is not crack mechanics.
 | Module | Responsibility |
 | --- | --- |
 | `anystructure_fem_mode.py` | Solver-owned generated-geometry workflow: normalize geometry, idealize tagged members, build the FE model/load, solve static response, recover prestress, and solve buckling. The filename is retained for source compatibility. |
-| `runtime.py` | Headless lightweight facade for normalized flat-panel/cylinder geometry, meshing, production solves, kernel warm-up, and typed runtime contracts. |
+| `runtime.py` | Headless facade for normalized flat-panel/cylinder geometry, meshing, balanced generated axial/bending/shear/torsional loading, pressure/follower-pressure routing, production solves, kernel warm-up, and typed runtime contracts. |
 | `capacity_workflow.py` | Static solve -> prestress -> buckling -> stress-free imperfection -> nonlinear capacity. |
 | `sesam_fem/records.py` | Loss-aware sequential formatted-record parsing/writing. |
 | `sesam_fem/document.py` | Typed FEM document model, sections, transforms, loads, and preserved unknown records. |
@@ -207,10 +214,26 @@ substep. It does not remove nodes, DOFs, or MPCs and is not crack mechanics.
 | `sesam_fem/exporter.py` | Guarded document round-trip output; arbitrary `FEModel` semantic export is rejected. |
 | `sesam_fem/sif_importer.py` | Supported SIF result summaries and shell stress tensors with explicit load-case selection. |
 
-The generated-geometry mode does not infer arbitrary untagged surfaces into beams.
-Explicit line members are retained, while tagged member plates can be collapsed
-to equivalent beams. Disabling that idealization causes tagged member plates
-without matching beam members to fail closed, preventing double counting.
+The generated-geometry mode does not infer arbitrary untagged surfaces into beams.
+Explicit line members are retained, while tagged member plates can be collapsed
+to equivalent beams. Disabling that idealization causes tagged member plates
+without matching beam members to fail closed, preventing double counting.
+
+The runtime facade is a production adapter, not a substitute solver. It applies
+configured shear and torsion as balanced edge or ring loading and forwards
+current-area pressure only when the selected path is nonlinear static or arc
+length without a subsequent stepwise eigenvalue solve. Linear, stepwise
+eigenvalue-buckling, transient, collision, and structured-capacity follower
+requests fail with an explicit status. Arc length preserves the selected von
+Karman or corotational kinematics. Downstream clients must preserve a
+non-success status; they must not relabel a compact estimate as a successful
+production solve.
+
+Generated-geometry prestress recovery uses matching committed nonlinear states
+when they are available. Shell buckling states retain the legacy mean membrane
+resultants for compatibility and additionally carry membrane forces and bending
+moments at each Gauss point. Recovery source, history use, warnings, and any
+explicit elastic fallback are retained in result provenance.
 
 ### Public API boundaries
 
@@ -220,10 +243,13 @@ generated-geometry names `GeneratedGeometryFEMConfig`,
 `AnyStructureFEM*` names are compatibility aliases, not the preferred
 solver-owned vocabulary.
 
-`anysolver.runtime` defines an explicit `__all__` and typed
-`NormalizedGeometry`, `GeneratedGeometry`, and `StatusCallback` contracts.
-Downstream applications own state extraction, option mapping, UI, and plotting;
-they pass normalized data into this headless facade.
+`anysolver.runtime` defines an explicit `__all__` and typed
+`NormalizedGeometry`, `GeneratedGeometry`, `StatusCallback`, and
+`RuntimeAnalysisSelection` contracts. Downstream applications own state
+extraction, option mapping, UI, and plotting; they pass normalized data into
+this headless facade. They use `resolve_runtime_analysis()` to reflect effective
+solver selections instead of importing normalization helpers with leading
+underscores.
 
 `dnv_c208_steel_properties()` is the single property-table entry point used by
 both the root analysis APIs and the runtime facade. This prevents grade and

{anysolver-0.1.2 → anysolver-0.1.3}/docs/QUALITY_CONTROL.md

@@ -69,9 +69,16 @@ Checks on 2026-07-28 against the `0.1.2` release-candidate source:
   shell initial-field equilibration, and retained a maximum analytical/oracle
   tangent error of `1.34e-9`.
 
-This evidence qualifies the `0.1.2` source. Distribution metadata, archive
-contents, and isolated-wheel execution are checked separately when the release
-artifacts are built; publishing remains a distinct, manually approved action.
+This evidence qualified the then-current `0.1.2` source snapshot. Distribution
+metadata, archive contents, and isolated-wheel execution are checked separately
+when the release artifacts are built; publishing remains a distinct, manually
+approved action.
+
+The later generated-geometry runtime bridge follow-up (shear/torsion routing,
+follower-pressure guards, corotational arc length, and committed-history
+prestress resultants) is not represented by the numbered snapshot above until
+the release verification and distribution checks are rerun against the final
+source.
 
 ## Recorded 0.1.1 release evidence
 
@@ -216,7 +223,7 @@ deck-only artifact.
 | Nonlinear capacity | DNV curves, layered shell plasticity, beam fibers, von Karman/corotational paths, rotated/consistent corotational tangents, follower-pressure Newton and arc-length paths, load programs, displacement control, and imperfections. |
 | Transient/contact | Newmark/HHT-alpha, pressure patches, energy/impulse checks, shell/beam sphere contact, event subdivision, nonlinear impact, damage/erosion. |
 | Recovery/resources | Committed shell-layer/beam-fiber recovery, explicitly labelled elastic fallback, corotational objectivity, component provenance, guarded Q4/Q8 patch fits, discontinuity regions, selected components, deterministic threading, memory estimation/limits, and provenance. |
-| Workflows/interchange | Normalized generated geometry, capacity workflow, SESAM FEM round trip/import, transforms/orientation, and SIF load-case stress isolation. |
+| Workflows/interchange | Normalized generated geometry; balanced axial/bending/shear/torsional runtime loads; guarded follower-pressure routing; corotational arc length; committed-history prestress with Gauss-point resultants and provenance; capacity workflow; SESAM FEM round trip/import; transforms/orientation; and SIF load-case stress isolation. |
 | Release scope | Stable verification IDs, PASS/XFAIL separation, production capability matrix, limitations, and evidence manifest. |
 
 ## Interpreting results

{anysolver-0.1.2 → anysolver-0.1.3}/docs/THEORY.md

@@ -656,17 +656,24 @@ reported per element and per component, so a caller can distinguish
 `committed_shell_layer_state`, `committed_beam_fiber_state`, and explicitly
 labelled elastic fallback.
 
-For shells, committed return-mapped layer stresses are integrated with the
-same Gauss-Lobatto layer positions and weights used by the nonlinear
-formulation. The output includes membrane and bending stress measures, exact
-top/bottom layer values, and von Mises stress including the elastic transverse
-shear from the same solution. For fiber beams, the stored fiber coordinates,
-weights, and stations give axial force and biaxial bending resultants; the
-reported von Mises envelope also includes elastic shear and torsion. In
-corotational analyses, recovery uses the objective deformational pull-back,
-current coordinates, and current corotated frame. Material history can only be
-used when compatible committed states were retained; missing or invalid state
-is a visible elastic fallback, never a silent plastic-stress reconstruction.
+For shells, committed return-mapped layer stresses are integrated with the
+same Gauss-Lobatto layer positions and weights used by the nonlinear
+formulation. The output includes membrane and bending stress measures, exact
+top/bottom layer values, and an in-plane von Mises stress governed by the shell
+return map. For fiber beams, the stored fiber coordinates, weights, and
+stations give axial force and biaxial bending resultants; the material-history
+von Mises envelope is the uniaxial fiber-stress envelope when a plastic
+constitutive history is active. Transverse shell shear and beam shear/torsion
+are matching elastic reconstructions rather than return-mapped state variables.
+They remain available as individual components and in the explicitly labelled
+`mixed_reconstruction_von_mises` diagnostic, but are not folded into the
+hardening-curve-consistent `von_mises` field. A purely elastic nonlinear state
+instead retains the full mixed elastic equivalent stress as primary. In
+corotational analyses, recovery uses the objective deformational pull-back,
+current coordinates, and current corotated frame. Material history can only
+be used when compatible committed states were retained; missing or invalid
+state is a visible elastic fallback, never a silent plastic-stress
+reconstruction.
 
 Passing `PatchRecoveryConfig` enables a guarded linear least-squares,
 [Zienkiewicz-Zhu-style](https://doi.org/10.1002/nme.1620330702) shell surface
@@ -765,8 +772,21 @@ explicit backlog items, not current capabilities:
    midpoint/beam-axis penalty models as engineering approximations.
 5. Develop an equilibrated or compliance-weighted recovery estimator for
    adaptive refinement. The current guarded patch result and normalized
-   stress-L2 discrepancy intentionally make no energy-norm or guaranteed-error
-   claim.
+   stress-L2 discrepancy intentionally make no energy-norm or guaranteed-error
+   claim.
+6. Extend shell plasticity to transverse shear and beam-section plasticity to
+   shear/torsion interaction. Until then, large
+   `mixed_reconstruction_von_mises` values are model-scope warnings: the
+   underlying equilibrium used elastic shear/torsion and those components must
+   not be capped or described as plastically redistributed.
+7. Split shell patch-recovered nodal equivalent stress into the same
+   constitutive in-plane and explicitly mixed invariants used by element
+   recovery. The current patch tensor retains transverse shear and therefore
+   represents the mixed elastic/plastic diagnostic.
+8. Recover quadratic-beam shear and torsion at the same Gauss stations as each
+   fiber block before forming a mixed diagnostic. The current B3 diagnostic
+   combines station-dependent fiber stress with one element-level elastic
+   shear/torsion envelope; the constant-response B2 case is unaffected.
 
 ## Verification anchors
 

{anysolver-0.1.2 → anysolver-0.1.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ANYsolver"
-version = "0.1.2"
+version = "0.1.3"
 description = "Qualified beam and shell finite-element solver"
 readme = "README.md"
 requires-python = ">=3.11"

{anysolver-0.1.2 → anysolver-0.1.3}/src/ANYsolver.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ANYsolver
-Version: 0.1.2
+Version: 0.1.3
 Summary: Qualified beam and shell finite-element solver
 Author-email: Audun Arnesen Nyhus <audunarn@gmail.com>
 License-Expression: GPL-3.0-or-later
@@ -64,9 +64,27 @@ from anysolver import (
     run_generated_geometry_fem,
     solve_linear,
 )
-from anysolver.runtime import LightweightFEMConfig, run_production_fem
+from anysolver.runtime import (
+    LightweightFEMConfig,
+    resolve_runtime_analysis,
+    run_production_fem,
+)
 ```
 
+The runtime facade applies its normalized axial force, bending moment, shear
+force, torsional moment, and pressure inputs to the generated model. Set
+`LightweightFEMConfig.follower_pressure=True` only for nonlinear static or
+arc-length analysis using the `static only` or `nonlinear static` runtime
+path; incompatible linear, stepwise eigenvalue-buckling, transient, collision,
+and structured-capacity paths return an explicit `invalid_follower_pressure`
+status. Arc length retains the requested von Karman or corotational
+kinematics. Production runtime failures remain failures rather than being
+replaced by an estimator.
+
+Application integrations should use `resolve_runtime_analysis(config)` to
+reflect the solver's effective nonlinear/material/control/kinematics choices;
+the normalization helpers with leading underscores are implementation details.
+
 The generic `GeneratedGeometryFEM*` names are the preferred workflow API.
 Historical `AnyStructureFEM*` aliases remain available only for downstream
 compatibility. Material selection is centralized in
@@ -97,7 +115,7 @@ changes before making release claims.
 | Initial fields | Element-local shell membrane/bending stress or membrane/curvature prestrain, arbitrary configured beam-fiber stress/prestrain distributions, zero-external-load equilibration, admissibility checks, and provenance kept separate from geometric imperfections. |
 | Workflows | Normalized generated geometry to static/prestress/buckling; traceable static-to-buckling-to-imperfect nonlinear-capacity workflow. |
 | Interchange | Pure-Python SESAM formatted FEM record/document parsing, guarded round-trip writing, supported semantic import to `FEModel`, coordinate transforms, beam orientation, and SIF shell-stress reading by load case. |
-| Results | Result provenance; unified elastic or committed shell-layer/beam-fiber stress recovery; guarded Zienkiewicz-Zhu-style patch recovery for qualified shell neighborhoods; selected recovery; reaction filtering; validation diagnostics; deterministic baselines; benchmarks; and generated qualification reports. |
+| Results | Result provenance; unified elastic or committed shell-layer/beam-fiber stress recovery; Gauss-point membrane-force and bending-moment resultants for generated-geometry prestress; guarded Zienkiewicz-Zhu-style patch recovery for qualified shell neighborhoods; selected recovery; reaction filtering; validation diagnostics; deterministic baselines; benchmarks; and generated qualification reports. |
 | External verification | Reproducible CalculiX input generation plus opt-in isolated execution, FRD/DAT parsing, solver provenance, and tolerance-controlled analytical comparison. Deck-only reports remain explicitly `not_executed` and make no numerical-agreement claim. |
 
 Implemented does not automatically mean qualified for every geometry or load
@@ -139,6 +157,13 @@ Important limits:
 - material-history-aware recovery requires retained, matching committed
   nonlinear layer/fiber states; missing or invalid state is reported and the
   affected components fall back explicitly to elastic reconstruction;
+- with an active plastic constitutive history, `von_mises` covers the
+  return-mapped shell in-plane or beam-fiber stress components. Transverse
+  shell shear and beam shear/torsion remain elastic reconstructions and are
+  exposed separately through `mixed_reconstruction_von_mises`, rather than
+  being presented as a hardening-curve-consistent equivalent stress. A purely
+  elastic nonlinear state keeps the full mixed elastic value as its primary
+  equivalent stress;
 - the guarded patch-recovery fit is qualified only for locally planar,
   consistently oriented, homogeneous, full-integration Q4 or Q8 shell
   neighborhoods. Discontinuities remain separate, and the optional normalized

{anysolver-0.1.2 → anysolver-0.1.3}/src/anysolver/__init__.py

@@ -355,7 +355,7 @@ from .sesam_fem import (
     write_sesam_fem_document,
 )
 
-__version__ = "0.1.2"
+__version__ = "0.1.3"
 
 __all__ = [
     # Core classes

{anysolver-0.1.2 → anysolver-0.1.3}/src/anysolver/anystructure_fem_mode.py

@@ -767,40 +767,93 @@ def build_symmetric_load_case(
     return load_case
 
 
-def recover_prestress_from_static_result(model: FEModel, displacements: np.ndarray) -> Tuple[Dict[int, Dict[str, float]], Dict[str, Any]]:
-    """Recover element prestress states for buckling from a static solution."""
-    states: Dict[int, Dict[str, float]] = {}
-    stresses = compute_stresses(model, displacements)
+def recover_prestress_from_static_result(
+    model: FEModel,
+    displacements: np.ndarray,
+    *,
+    nonlinear_result: Any = None,
+) -> Tuple[Dict[int, Dict[str, Any]], Dict[str, Any]]:
+    """Recover buckling prestress, retaining Gauss-point and material history.
+
+    Linear calls use displacement-based stress recovery.  When a matching
+    nonlinear result is supplied, the unified recovery path reconstructs
+    stresses from committed shell-layer and beam-fiber states and records its
+    provenance.
+    """
+
+    states: Dict[int, Dict[str, Any]] = {}
+    recovery_provenance: Dict[str, Any] | None = None
+    if nonlinear_result is None:
+        stresses = compute_stresses(model, displacements)
+    else:
+        from .recovery import recover_stress_result
+
+        recovery = recover_stress_result(
+            model,
+            displacements,
+            nonlinear_result=nonlinear_result,
+            copy_committed_states=False,
+        )
+        stresses = recovery.element_stresses
+        recovery_provenance = recovery.provenance.to_dict()
     shell_count = 0
     beam_count = 0
     shell_compression = []
     beam_compression = []
     for element_id, element in model.mesh.elements.items():
-        stress = stresses.get(element_id)
-        if isinstance(element, ShellElement) and stress:
-            sx = float(np.mean(stress.get("membrane_xx", np.zeros(1))))
-            sy = float(np.mean(stress.get("membrane_yy", np.zeros(1))))
-            txy = float(np.mean(stress.get("membrane_xy", np.zeros(1))))
-            states[int(element_id)] = {
-                "membrane_force_x": sx * element.thickness,
-                "membrane_force_y": sy * element.thickness,
-                "membrane_force_xy": txy * element.thickness,
-            }
-            shell_compression.append(max(-sx * element.thickness, -sy * element.thickness, 0.0))
+        stress = stresses.get(element_id)
+        if isinstance(element, ShellElement) and stress:
+            sx_gp = np.asarray(stress.get("membrane_xx", np.zeros(1)), dtype=float).reshape(-1)
+            sy_gp = np.asarray(stress.get("membrane_yy", np.zeros_like(sx_gp)), dtype=float).reshape(-1)
+            txy_gp = np.asarray(stress.get("membrane_xy", np.zeros_like(sx_gp)), dtype=float).reshape(-1)
+            if sy_gp.size != sx_gp.size or txy_gp.size != sx_gp.size:
+                raise ValueError("inconsistent shell membrane stress recovery shape")
+            bx_gp = np.asarray(stress.get("bending_xx", np.zeros_like(sx_gp)), dtype=float).reshape(-1)
+            by_gp = np.asarray(stress.get("bending_yy", np.zeros_like(sx_gp)), dtype=float).reshape(-1)
+            bxy_gp = np.asarray(stress.get("bending_xy", np.zeros_like(sx_gp)), dtype=float).reshape(-1)
+            if bx_gp.size != sx_gp.size or by_gp.size != sx_gp.size or bxy_gp.size != sx_gp.size:
+                raise ValueError("inconsistent shell bending stress recovery shape")
+
+            thickness = float(element.thickness)
+            membrane_resultants = np.column_stack((sx_gp, sy_gp, txy_gp)) * thickness
+            bending_resultants = (
+                np.column_stack((bx_gp, by_gp, bxy_gp))
+                * thickness
+                * thickness
+                / 6.0
+            )
+            sx = float(np.mean(sx_gp))
+            sy = float(np.mean(sy_gp))
+            txy = float(np.mean(txy_gp))
+            states[int(element_id)] = {
+                # Legacy mean resultants remain for serialized/downstream
+                # compatibility; the enhanced Mindlin operator consumes the
+                # Gauss-point fields below.
+                "membrane_force_x": sx * thickness,
+                "membrane_force_y": sy * thickness,
+                "membrane_force_xy": txy * thickness,
+                "membrane_forces_at_gauss": membrane_resultants.tolist(),
+                "bending_moments_at_gauss": bending_resultants.tolist(),
+            }
+            shell_compression.append(
+                float(max(np.max(-membrane_resultants[:, :2]), 0.0))
+            )
             shell_count += 1
         elif isinstance(element, (BeamElement, QuadraticBeamElement)) and stress:
             axial_force = float(stress.get("axial_stress", 0.0)) * float(getattr(element, "_A", 0.0))
             states[int(element_id)] = {"axial_force": axial_force}
             beam_compression.append(max(-axial_force, 0.0))
             beam_count += 1
-    summary = {
+    summary = {
         "shell_elements": shell_count,
         "beam_elements": beam_count,
         "state_count": len(states),
         "max_shell_compression_resultant": float(max(shell_compression) if shell_compression else 0.0),
-        "max_beam_compression_force": float(max(beam_compression) if beam_compression else 0.0),
-    }
-    return states, summary
+        "max_beam_compression_force": float(max(beam_compression) if beam_compression else 0.0),
+    }
+    if recovery_provenance is not None:
+        summary["stress_recovery"] = recovery_provenance
+    return states, summary
 
 
 def _stress_statistics(model: FEModel, displacements: np.ndarray, percentile: float) -> Dict[str, float]: