Static analysis
===============

Linear elastostatic problem
:math:`\mathbf{K}\, \mathbf{u} = \mathbf{f}`, driven by
:meth:`Model.solve <femorph_solver.Model.solve>`.

Algorithm
---------

1. **Assemble** the global stiffness :math:`\mathbf{K}` and
   force :math:`\mathbf{f}` from the per-element ``ke`` and
   ``apply_force`` calls (see :doc:`../theory/assembly`).

2. **Eliminate Dirichlet DOFs.** The free / constrained
   partition gives :math:`\mathbf{K}_{ff}\, \mathbf{u}_f =
   \mathbf{f}_f - \mathbf{K}_{fc}\, \mathbf{u}_c` — the
   reduced system the backend factorises (see
   :doc:`../theory/bc_elimination`).

3. **Factor and solve** :math:`\mathbf{K}_{ff}` through the
   registered linear backend (see :doc:`linear_backends`).
   Backend dispatch order:
   ``Pardiso → CHOLMOD → MUMPS → UMFPACK → SuperLU``,
   first-installed wins.

4. **Reaction recovery** — :math:`\mathbf{r}_c =
   \mathbf{K}_{cf}\, \mathbf{u}_f + \mathbf{K}_{cc}\,
   \mathbf{u}_c - \mathbf{f}_c`.  Populates
   :attr:`StaticResult.reaction <femorph_solver.solvers.static.StaticResult.reaction>`.

5. **Stress / strain recovery** is **lazy** — the static
   result returns a DOF-indexed displacement plus a thin
   accessor protocol that calls ``Model.eel(u)`` /
   :func:`compute_nodal_stress
   <femorph_solver.result._stress_recovery.compute_nodal_stress>`
   on demand.

Public API
----------

* :meth:`femorph_solver.Model.solve` — the main entry point.
* :class:`femorph_solver.solvers.static.StaticResult` — the
  return type, with ``displacement`` / ``reaction`` /
  ``free_mask`` arrays.
* :func:`femorph_solver.io.static_result_to_grid` — scatter
  the DOF vector onto ``(n, 3)`` ``UX/UY/UZ`` point data on
  a copy of the input grid.

Verification cross-references
-----------------------------

The verification gallery exercises every static-solve path:

* :ref:`sphx_glr_gallery_verification_example_verify_single_hex_uniaxial.py` — single-hex Hooke's law.
* :ref:`sphx_glr_gallery_verification_example_verify_cantilever_eb.py` — Euler-Bernoulli cantilever.
* :ref:`sphx_glr_gallery_verification_example_verify_cantilever_udl.py` — uniform-distributed load.
* :ref:`sphx_glr_gallery_verification_example_verify_cantilever_tip_moment.py` — tip moment, parabolic deflection.
* :ref:`sphx_glr_gallery_verification_example_verify_propped_cantilever_udl.py` — statically-indeterminate beam.
* :ref:`sphx_glr_gallery_verification_example_verify_ss_beam_central_load.py` — simply-supported beam.
* :ref:`sphx_glr_gallery_verification_example_verify_cc_beam_central_load.py` — clamped-clamped beam.
* :ref:`sphx_glr_gallery_verification_example_verify_lame_cylinder.py` — Lamé thick-cylinder.
* :ref:`sphx_glr_gallery_verification_example_verify_clamped_plate_static.py` — NAFEMS LE5.
* :ref:`sphx_glr_gallery_verification_example_verify_ss_plate_static.py` — Navier plate.
* :ref:`sphx_glr_gallery_verification_example_verify_nafems_le1.py` — NAFEMS LE1 plane-stress.

Implementation: :mod:`femorph_solver.solvers.static`.

References
----------

* Cook, R. D., Malkus, D. S., Plesha, M. E., Witt, R. J.
  (2002) *Concepts and Applications of Finite Element
  Analysis*, 4th ed., Wiley, §2.10 (Dirichlet partitioning).
* Bathe, K.-J. (2014) *Finite Element Procedures*, 2nd ed.,
  §3.4 (boundary-condition imposition), §8 (linear elastic
  static analysis).
* Saad, Y. (2003) *Iterative Methods for Sparse Linear
  Systems*, 2nd ed., SIAM, §3 (sparse direct solvers).