Elasticity
Displacement, displacement–pressure and weakly symmetric stress formulations.
User-defined formulations compose these public numerical owners with
LocalEquations and Equation; their editable providers are listed in the
variational guide.
Physical field records provide optional interpretation of the resulting
coefficients. Named FieldDefinition views require no physical solver object.
Primal displacement and GaLS reconstruction return a symmetric raw Cauchy stress from the declared constitutive law; its macro traction moments do not make that stress globally \(H(\operatorname{div})\) conforming. The mixed stress owners use row-wise \(H(\operatorname{div})\) spaces and enforce symmetry in the rotation test moments. Their physical displacement/rotation kernel is coupled. Every local static cell retains \(d(d+1)/2\) rigid modes.
Herrmann pressure is \(p=-\lambda_L\operatorname{div}u\). The mixed stress hydrostatic gauge uses \(-\operatorname{tr}\sigma/d\); these quantities generally differ at finite bulk modulus. Traction inputs mean physical outward \(\sigma n\), while the MHM skeletal convention is \(-\sigma n\). The API below documents source responses, global coupling and gauges. Consult the original publications listed in References for each formulation's stabilization bounds, admissible spaces and dimensional scope.
Engineering-strain and rigid-motion tabulation for planar elasticity.
Nodal vector components are interleaved. The engineering shear is du_x/dy+ du_y/dx; its elastic Gram weight is one half relative to normal strains.
rigid_modes(points: FloatArray, center: FloatArray) -> FloatArray
Evaluate both translations and the infinitesimal counterclockwise rotation.
strain_and_divergence(gradients: FloatArray, hessian: FloatArray) -> tuple[FloatArray, FloatArray, FloatArray]
Tabulate engineering strain, vector divergence and divergence of symmetric strain.
Tetrahedral rigid modes and independent Cartesian traction projections.
Physical outward traction fixes the negative hybrid traction multiplier. Weak Dirichlet moments retain the same signed scalar macroface basis conventions.
rigid_modes_3d(points: FloatArray, center: FloatArray) -> FloatArray
Return three translations followed by e_x/e_y/e_z cross (x-center).
vector_boundary_data_3d(skeleton: TriangularSkeleton, dirichlet: Any, traction: dict[int, Any], order: int) -> tuple[FloatArray, dict[int, float]]
Reuse signed scalar face quadrature independently for each physical vector component.
Symmetric-strain volume integration independently of trace and kernel choices.
StrainOperators
dataclass
Literal vector energy/load and scalar mass in physical nodal coordinates.
trace_detecting_enrichment(fine: TriangleMesh, degree: int, coupling: FloatArray) -> FloatArray
Enrich Pk by one P(k+1) mode that detects its missing odd-degree trace.
This realizes the polynomial enrichment hypothesis of Lemma 6.8 in Harder, Madureira and Valentin (2016) on one triangular element. The added mode is selected from the null trace's nonzero moment functional and is not a zero-boundary bubble. Coordinate projection removes its Pk part without changing its missing-trace moment.
triangle_strain_operators(fine: TriangleMesh, degree: int, *, constitutive: Any = None, lame_lambda: Any = 1.0, lame_mu: Any = 1.0, source: Any = (0.0, 0.0), order: int = 6) -> StrainOperators
Integrate symmetric Kelvin strain energy, nodal mass and vector forcing.
Coefficients are interleaved Cartesian displacement at continuous Pk nodes. The constitutive law uses orthonormal Kelvin coordinates or a symmetric fourth-order tensor. No trace, boundary, rigid kernel or gauge is selected. Returned mass is scalar nodal mass; users tensor it with Cartesian identity.
Symmetric-strain volume integration independently of trace and kernel choices.
StrainOperators
dataclass
Literal vector energy/load and scalar mass in physical nodal coordinates.
tetra_strain_operators(fine: TetraMesh, degree: int, *, constitutive: Any = None, lame_lambda: Any = 1.0, lame_mu: Any = 1.0, source: Any = (0.0, 0.0, 0.0), order: int = 6) -> StrainOperators
Integrate symmetric Kelvin strain energy, nodal mass and vector forcing.
Coefficients are interleaved Cartesian displacement at continuous Pk nodes. The constitutive law uses orthonormal Kelvin coordinates or a symmetric fourth-order tensor. No trace, boundary, rigid kernel or gauge is selected. Returned mass is scalar nodal mass; users tensor it with Cartesian identity.
Cartesian Qk symmetric-strain forms on explicitly resolved integration cuts.
quadrilateral_strain_operators(mesh: CartesianMacroMesh, degree: int = 1, *, constitutive: Any = None, lame_lambda: Any = 1.0, lame_mu: Any = 1.0, source: Any = (0.0, 0.0), integration_field: CartesianCellField | None = None, order: int = 4) -> StrainOperators
Integrate Kelvin strain energy, scalar mass and Cartesian vector forcing.
Continuous Qk displacement coordinates interleave Cartesian components.
integration_field explicitly declares a pixel partition resolving all
coefficient and forcing discontinuities. Exact rectangle/pixel intersections
receive separate tensor Gauss rules, without averaging material values or
requiring approximation cells to fit those pixels. Callbacks otherwise use
the stated element quadrature; sampling does not certify global ellipticity.
Each cell is integrated separately to bound memory even on coarse elements
crossing many pixels. No boundary condition, rigid gauge or solve is chosen.
Herrmann elasticity volume forms and physical moments on triangular meshes.
ElasticityPressureOperators
dataclass
Displacement/pressure volume matrix, rigid modes and physical integral moments.
strain_inverse_bound(strain: FloatArray, strong: FloatArray, weights: FloatArray, h: FloatArray, diameter: float) -> float
Bound Eq. (4.4) by elementwise generalized eigenvalues modulo rigid motions.
Taking the minimum with one prevents a refinement-dependent growth of the stabilization. No PDE solution or reference error enters this computation.
triangle_elasticity_pressure_operators(fine: TriangleMesh, *, degree: int, formulation: str, lame_lambda: Any, lame_mu: Any, source: Any, order: int, diameter: float, rigid_center: FloatArray, stabilization_alpha: float | None = None, lame_mu_gradient: Any = (0.0, 0.0), shear_bounds: tuple[float, float, float] | None = None) -> ElasticityPressureOperators
Integrate 2muepsilon, div/pressure, compliance and optional GaLS residual.
Pk/Pk GaLS subtracts (alphah²R(u,p),R(v,q)) and adds (alphah²f,R(v,q)), R=div(2muepsilon(u))-grad(p). Taylor--Hood instead uses Pk/P(k-1) with no residual. Three rigid modes and moments are evaluated about the explicitly supplied physical center. Lambda=infinity has zero compressibility. Variable GaLS shear requires declared valid bounds and analytical derivatives; quadrature checks do not certify between samples. The residual signs and strict alpha bound follow Gomes--Pereira--Valentin (2024, arXiv:2403.16890v1), Eqs. (4.4), (4.7)--(4.10). Pressure is Herrmann pressure p=-lambda*div(u), not negative mean Cauchy stress.
Isotropic displacement-pressure elasticity forms on affine tetrahedra.
Pressure is p=-lambda*div(u). The GaLS residual is the full divergence
of 2*mu*sym(grad(u))-p*I, including derivatives of a variable shear modulus.
ElasticityPressure3DOperators
dataclass
Mixed local operator, rigid modes and physical pressure/displacement moments.
elasticity_contract_3d(lame_lambda: Any, lame_mu: Any, lame_mu_gradient: Any, shear_bounds: Any, formulation: str, degree: int, stabilization_alpha: Any, points: FloatArray) -> tuple[Any, tuple[float, float, float] | None]
Validate the finite/infinite compressibility and residual-coefficient contracts.
tetra_elasticity_pressure_operators(mesh: TetraMesh, *, lame_lambda: Any = 1.0, lame_mu: Any = 1.0, lame_mu_gradient: Any = None, shear_bounds: tuple[float, float, float] | None = None, source: Any = (0.0, 0.0, 0.0), degree: int = 1, formulation: str = 'gals', stabilization_alpha: float | None = None, macro_diameter: float | None = None, rigid_center: Any = (0.0, 0.0, 0.0), order: int = 6) -> ElasticityPressure3DOperators
Assemble tetrahedral GaLS Pk/Pk or Taylor-Hood Pk/P(k-1) elasticity.
The GaLS parameter is half the computed upper bound unless supplied:
alpha < C_I*mu_lower/[2*(mu_upper**2+h_K**2*grad_mu_bound**2)].
The inverse constant uses the physical tetrahedral strain/divergence forms,
not a constant transferred from triangles. All six rigid modes are retained.
Bounds for variable shear must be certified by the caller and are additionally
checked at the integration points. Discontinuous materials require fitted
tetrahedra; a callback does not automatically add interface cuts.
Public physical moment and volume integration owners; no solver dispatch.
mixed_elasticity_operators(mesh: TriangleMesh, lame_lambda: Any, lame_mu: Any, source: Any, order: int, family: BDMFamily = _DEFAULT_FAMILY, compliance: Any = None) -> tuple[Any, Any, Any, FloatArray]
Assemble compliance, divergence, asymmetry and body-force moments.
Stress rows are BDM, displacement and scalar weak rotation are DG of degree one lower. The asymmetry is sigma_xy-sigma_yx; its multiplier is (partial_y u_x-partial_x u_y)/2. The caller applies the force sign for -div(sigma)=f and couples rigid displacement with its rotation value. Devloo et al. (2021), DOI:10.1051/m2an/2021013, Eqs. (2.2)--(2.4), analyze this two-dimensional weak-symmetry construction.
bulk_compliance(lame_lambda: Any, mu: FloatArray, points: FloatArray) -> FloatArray
Evaluate 1/[2(mu+lambda)], including a zero incompressible compliance.
stress_trace_moments(mesh: TriangleMesh, size: int, lame_lambda: Any, lame_mu: Any, order: int, family: BDMFamily = _DEFAULT_FAMILY, compliance: Any = None) -> tuple[FloatArray, FloatArray, float]
Integrate trace(sigma) and its physical bulk-compliance-weighted moment.
traction_mapping(mesh: TriangleMesh, cell: int, fine: TriangleMesh, skeleton: SkeletonSpace, family: BDMFamily = _DEFAULT_FAMILY) -> FloatArray
Apply the shared BDM normal-moment map to each stress row.
rigid_values(points: FloatArray, center: FloatArray) -> FloatArray
Evaluate two translations and one centered rigid rotation.
displacement_rigid_moments(mesh: TriangleMesh, center: FloatArray, family: BDMFamily = _DEFAULT_FAMILY) -> FloatArray
Integrate discontinuous displacement basis against the three rigid motions.
Public physical moment and volume integration owners; no solver dispatch.
complete_rotation_basis(degree: int, points: FloatArray) -> FloatArray
Tabulate total-degree Legendre products P_s, excluding the Q_s cross corners.
tensor_rigid_moments(mesh: CartesianMacroMesh, degree: int, center: FloatArray) -> tuple[FloatArray, FloatArray]
Project rigid displacement into Q_s and return its physical moment matrix.
tensor_stress_operators(mesh: CartesianMacroMesh, degree: int, enrichment: int, lame_lambda: Any, lame_mu: Any, source: Any, order: int, compliance: Any = None) -> tuple
Assemble compliance, Q_s divergence, P_s asymmetry and physical force moments.
Three-dimensional AFW compliance, divergence and weak-symmetry moments on tetrahedra.
rigid_values(points: FloatArray, center: FloatArray) -> FloatArray
Evaluate translations and e_i cross (x-center), ordered as three plus three modes.
compliance_action(tensors: FloatArray, points: FloatArray, lame_lambda: Any, lame_mu: Any, compliance: Any) -> tuple[FloatArray, float]
Apply full-tensor compliance, retaining a cancellation-free isotropic deviatoric split.
General Cartesian compliance has shape (9,9), acts on row-major tensor entries, is self-adjoint and positive definite, and preserves symmetric and skew subspaces. Its skew extension is explicit. Isotropic lambda may be infinite; mu must be finite and positive. The returned scale is the largest sampled spherical compliance tr(A I)/3.
mixed_elasticity_operators_3d(mesh: AffineMixedMesh, family: HDiv3DFamily, *, lame_lambda: Any = 1.0, lame_mu: Any = 1.0, source: Any = (0.0, 0.0, 0.0), compliance: Any = None, quadrature_order: int = 5) -> tuple
Assemble AFW stress compliance, displacement divergence and three skew moments.
Stress rows use full BDM_k and both displacement and axial weak rotation use discontinuous P_(k-1). Row/coordinate components are interleaved within each scalar/vector moment. Source is the physical force in -div(sigma)=f. Returns M,D,R,f,plain stress-trace moments, weighted trace moments and the physical bulk-compliance gauge scale. The complete conforming family has AFW stability and error estimates in Arnold--Falk--Winther (2007), Eq. (7.1), Theorems 7.1--7.2. Restricting its normal traces in MHM requires a separate coupling compatibility check; the two-dimensional polygonal enrichment theorem does not establish it.
rigid_coefficients(mesh: AffineMixedMesh, family: HDiv3DFamily, center: FloatArray) -> tuple[FloatArray, FloatArray, FloatArray]
Return exact rigid DG coefficients, physical moments and fine-face dual values.
boundary_selector(mesh: AffineMixedMesh, family: HDiv3DFamily, size: int) -> Any
Select interleaved physical canonical stress-row moments on all fine exterior faces.
Public physical moment and volume integration owners; no solver dispatch.
TractionSkeleton3D
Three interleaved Cartesian moments of -sigma n on each original triangular macroface.
Every subtriangle carries an independent complete polynomial. Coefficients are physical integral moments, not nodal tractions; canonical normals point outward from the first neighboring macrocell.
__init__(mesh: AffineMixedMesh, degree: int = 1, subdivisions: int = 1) -> None
Create the vector trace from the shared oriented scalar moment partition.
cell_dofs(cell: int) -> IntArray
Return interleaved traction coordinates on one macrocell's original faces.
traction_boundary_data(skeleton: TractionSkeleton3D, dirichlet: Any, traction: dict[int, Any], order: int) -> tuple[FloatArray, dict[int, float], float, float]
Integrate displacement loads and physical outward traction moments, including volume flux.
Finite elastic constitutive tensors in orthonormal Kelvin coordinates.
These material evaluations are shared by static and dynamic vector forms and field reconstruction. Positivity is checked at supplied points; callbacks still require their own global material-bound premises.
constitutive_values(material: Any, points: FloatArray, *, lame_lambda: Any = 1.0, lame_mu: Any = 1.0) -> FloatArray
Evaluate and validate stiffness in orthonormal Kelvin coordinates.
Constant or callable matrices may have shape (3,3) or (2,2,2,2), optionally preceded by the point axis. Positivity is checked at supplied points; quadrature sampling does not certify uniform ellipticity everywhere. With material=None, finite nonnegative lambda and positive mu define the isotropic plane-strain tensor. A primal tensor with infinite bulk modulus is not supported; use the mixed incompressible formulations instead.
constitutive_values_3d(material: Any, points: FloatArray, *, lame_lambda: Any = 1.0, lame_mu: Any = 1.0) -> FloatArray
Validate general SPD Kelvin/Cartesian stiffness, or finite isotropic Lamé fields.
stress_compliance_values(material: Any, points: FloatArray) -> FloatArray
Evaluate a full Cartesian compliance, checking its sampled ellipticity.
Accept a constant or callback returning (4,4) or (2,2,2,2),
optionally preceded by the evaluation-point axis. The operator is real,
self-adjoint, positive definite and commutes with matrix transposition.
Its skew extension must be supplied explicitly. A symmetric-strain Kelvin
matrix alone does not define this full-tensor operator. Sampling does not
prove a coefficient's uniform ellipticity between quadrature points.
compliance_products(material: Any, points: FloatArray, tensors: FloatArray) -> tuple[FloatArray, FloatArray, float]
Return basis compliance products, tr(A sigma) and a positive gauge scale.
tensors has shape (cells, quadrature, basis, 2, 2). The physical
displacement identity is integral(tr(A sigma)) = integral(g dot n),
including anisotropic couplings between normal and shear stresses.
Positive finite or infinite Lamé compressibility with explicit reciprocal convention.
compressibility_values(lame_lambda: Any, points: FloatArray) -> FloatArray
Evaluate inverse first Lame modulus, allowing positive infinity pointwise.
Bases: VectorSolution
Displacement, Herrmann pressure and physical Cauchy-stress reconstruction.
gradient(cell: int, bary: FloatArray) -> FloatArray
Evaluate the broken displacement gradient, indexed fine cell/point/i/j.
stress(cell: int, bary: FloatArray) -> FloatArray
Evaluate symmetric Cauchy stress using pressure without lambda cancellation.
h1_seminorm_error(exact_gradient: Any, order: int = 6) -> float
Integrate the full broken displacement-gradient error, not the strain norm.
stress_l2_error(exact_stress: Any, order: int = 6) -> float
Integrate the Frobenius error of the full symmetric Cauchy stress.
compressibility_l2(order: int = 6) -> float
Measure div(u)+p/lambda without asserting pointwise satisfaction.
Physical displacement and raw Cauchy stress in the executed nodal coordinates.
PrimalElasticitySolution
dataclass
Bases: VectorSolution
Broken Pk displacement with raw symmetric stress from a general stiffness.
Raw stress is pointwise symmetric. A finite-dimensional local primal solve does not generally make it H(div)-conforming or equilibrated on every fine cell; skeletal rigid-motion equations impose macro force/moment balance.
gradient(cell: int, bary: FloatArray) -> FloatArray
Evaluate the full displacement gradient in each local fine cell.
stress(cell: int, bary: FloatArray) -> FloatArray
Evaluate physical stress at common or cellwise barycentric points.
At a material interface the coefficient's pointwise convention applies. Error integration instead uses exact pixel-intersection quadrature and material indices, preserving the two distinct traces without averaging.
stress_l2_error(exact: Any, order: int = 6) -> float
Integrate Frobenius stress error, splitting Cartesian material interfaces.
Displacement, Herrmann pressure and raw symmetric Cauchy stress in three dimensions.
evaluate(cell: int, bary: FloatArray) -> tuple[FloatArray, FloatArray]
Evaluate one-sided displacement and pressure on the local tetrahedra.
gradient(cell: int, bary: FloatArray) -> FloatArray
Return the broken displacement gradient indexed component then derivative.
stress(cell: int, bary: FloatArray) -> FloatArray
Return 2muepsilon(u)-p*I without multiplying lambda by a small divergence.
l2_error(exact: Any, order: int = 7) -> float
Integrate the displacement L2 error.
pressure_l2_error(exact: Any, order: int = 7) -> float
Integrate physical Herrmann-pressure error with the imposed mean convention.
h1_seminorm_error(exact_gradient: Any, order: int = 7) -> float
Integrate the full broken displacement-gradient error.
stress_l2_error(exact_stress: Any, order: int = 7) -> float
Integrate the complete symmetric Cauchy-stress Frobenius error.
compressibility_l2(order: int = 7) -> float
Measure div(u)+p/lambda in physical L2, including zero inverse lambda at infinity.
Executed displacement, velocity and force records for second-order equations.
These records retain physical bases and independent incident values. They do not choose time integration, local elimination, boundary data or a gauge.
ElastodynamicLocal
dataclass
Physical mass/stiffness, signed traction moments and continuous local Pk space.
load(field: Any, *, density_weighted: bool = False) -> FloatArray
Integrate physical force density or a density-weighted initial field.
Explicit triangular quadrature providers are supported for force loads. They are rejected for density-weighted initial projection, which would require a verified joint partition of both independent fields.
load_at_time(source: Any, time: float) -> FloatArray
Evaluate a temporal source while preserving opt-in spatial quadrature.
Ordinary callbacks retain the existing source(time, points) path.
A provider with at_time returns a spatial quadrature field. Both
paths supply physical force density, with no implicit density factor.
PreparedElastodynamicSource
dataclass
Read-only original spatial force vectors in their executed local nodal bases.
Loads use binary64 and have no implicit density weighting. Preparation is explicit: vectors belong to the exact local objects that integrated the source. They cannot be reused on another stepper or approximation space. The temporal factor is evaluated at every original endpoint/substep time. This snapshot owns no native factorization and imposes no time update.
__post_init__() -> None
Validate and copy original nodal vectors without narrowing their dtype.
load_at_time(local: ElastodynamicLocal, time: float) -> FloatArray
Scale the original vector, rejecting a different basis/mesh and nonreal time data.
ElastodynamicSolution
dataclass
Displacement and velocity at a common macro time, and slabwise negative traction.
evaluate(cell: int, bary: FloatArray) -> tuple[FloatArray, FloatArray]
Evaluate one-sided continuous local polynomials on every fine simplex.
l2_error(exact: Any, *, velocity: bool = False, order: int = 8) -> float
Integrate physical displacement/velocity L2 error with independent quadrature.
gradient(cell: int, bary: FloatArray, *, velocity: bool = False) -> FloatArray
Evaluate the full broken displacement or velocity gradient in physical coordinates.
stress(cell: int, bary: FloatArray) -> FloatArray
Evaluate raw symmetric Cauchy stress; no global H(div) conformity is implied.
stress_from_gradient(local: ElastodynamicLocal, points: FloatArray, gradient: FloatArray) -> FloatArray
Apply the local Kelvin constitutive law to an already evaluated gradient.
points has shape (fine cells, quadrature points, dimension) and
gradient appends its derivative coordinate axis. The caller owns the
one-sided cell evaluation; no spatial interpolation or averaging occurs.
Physical field records in the executed H(div) stress and broken kinematic spaces.
MixedElasticitySolution
dataclass
H(div) Cauchy stress, broken displacement and independent weak rotation.
Stress coefficients have shape (family.size(mesh), 2) on each local mesh;
displacement and rotation have shapes (cells,d,2) and (cells,d),
where d is the scalar dimension of P(k+n-1).
Rotation approximates half the asymmetry of the exact displacement gradient. The skeletal
traction is -sigma n and stress symmetry holds through P(k+n-1) moments.
displacement_degree: int
property
Return the discontinuous displacement and rotation polynomial degree.
l2_error(exact: Any, order: int = 5) -> float
Integrate the broken displacement error against an analytical field.
stress_l2_error(exact: Any, order: int = 5) -> float
Integrate the full Cauchy stress Frobenius error, including its skew part.
divergence_l2_error(exact: Any, order: int = 5) -> float
Integrate stress-divergence error, distinct from integrated force moments.
rotation_l2_error(exact: Any, order: int = 5) -> float
Integrate rotation error with the convention q=(du_x/dy-du_y/dx)/2.
fine_force_residuals() -> tuple[FloatArray, ...]
Return displacement-space moments of div(sigma)+f in every fine cell and component.
weak_symmetry_residuals() -> tuple[FloatArray, ...]
Return rotation-space moments of sigma_xy-sigma_yx, without symmetrizing the field.
normal_traction_residuals() -> tuple[FloatArray, ...]
Return moments of sigma n plus the signed macro traction on fine faces.
equilibrium_residuals() -> FloatArray
Return macro force and moment defects for the negative-traction skeleton.
Physical field records in the executed H(div) stress and broken kinematic spaces.
TensorRTElasticitySolution
dataclass
H(div) Cauchy stress with Q_s displacement and independent P_s weak rotation.
evaluate(cell: int, points: FloatArray) -> tuple[FloatArray, FloatArray, FloatArray, FloatArray]
Return displacement, full stress, stress divergence and rotation at reference points.
errors(displacement: Any, stress: Any, divergence: Any, rotation: Any, order: int = 6) -> dict[str, float]
Integrate four physical L2 errors with full Frobenius stress, without symmetrization.
fine_force_residuals() -> tuple[FloatArray, ...]
Return every fine-cell Q_s vector moment of div(sigma)+f.
weak_symmetry_residuals() -> tuple[FloatArray, ...]
Return P_s moments of stress asymmetry, which need not vanish pointwise.
normal_traction_residuals() -> tuple[FloatArray, ...]
Return moments of sigma n plus the signed macro traction on each fine boundary.
equilibrium_residuals() -> FloatArray
Return macro force and moment balance using physical signed skeletal traction.
Physical field records in the executed H(div) stress and broken kinematic spaces.
MixedElasticity3DSolution
dataclass
Row-wise H(div) stress, DG displacement and axial weak rotation on local tetrahedra.
Rotation is ((du_y/dz-du_z/dy), (du_z/dx-du_x/dz), (du_x/dy-du_y/dx))/2. Symmetry holds in DG P_(k-1) moments, not pointwise. Stress arrays have shape (Hdiv DOFs,3), with columns denoting stress rows; displacement and rotation have shape (fine cells,scalar modes,3).
evaluate(cell: int, points: FloatArray) -> tuple[FloatArray, FloatArray, FloatArray, FloatArray]
Evaluate displacement, full stress, axial rotation and divergence at reference points.
errors(displacement: Any, stress: Any, rotation: Any, *, order: int = 6) -> dict[str, float]
Integrate displacement, Frobenius stress and axial-rotation physical L2 errors.
fine_force_residuals() -> tuple[FloatArray, ...]
Return every DG displacement moment of div(sigma)+f on every fine tetrahedron.
weak_symmetry_residuals() -> tuple[FloatArray, ...]
Return the three independent skew-stress DG moments without symmetrizing the field.
normal_traction_residuals() -> tuple[FloatArray, ...]
Return canonical normal moments of sigma n plus the physical skeletal traction.
References
- Christopher Harder, Alexandre L. Madureira, and Frédéric Valentin (2016). A hybrid-mixed method for elasticity, ESAIM: M2AN 50, 311–336. DOI: 10.1051/m2an/2015046.
- Philippe R. B. Devloo et al. (2021). New H(div)-conforming multiscale hybrid-mixed methods for the elasticity problem on polygonal meshes. DOI: 10.1051/m2an/2021013.
- Antônio Tadeu Azevedo Gomes, Weslley da Silva Pereira and Frédéric Valentin (2024). A low-order locking-free multiscale finite element method for isotropic elasticity. arXiv: 2403.16890v1.
- Douglas N. Arnold, Richard S. Falk and Ragnar Winther (2007). Mixed finite element methods for linear elasticity with weakly imposed symmetry. DOI: 10.1090/S0025-5718-07-01998-9.