Pith. sign in

REVIEW 3 major objections 5 minor 1 cited by

Matrix-Free Methods for Finite-Strain Elasticity: Automatic Code Generation with No Performance Overhead

T0 review · 3 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read Automatic differentiation produces matrix-free tangent kernels with no performance overhead for finite-strain elasticity.

desk verdict Solid engineering result on AD-generated matrix-free kernels, but the 'best' claim overreaches the paper's own 2D data. read the letter →

arxiv 2505.15535 v1 pith:4V2HHOOO submitted 2025-05-21 math.NA cs.NA

Micha{l} Wichrowski , Mohsen Rezaee-Hajidehi , Jože Korelc , Martin Kronbichler , Stanis{l}aw Stupkiewicz This is my paper · ORCID
classification math.NAcs.NA MSC 65N3074S05
keywords automaticdifferentiationmatrix-freemethodsfinite-strainelasticitytangentoperatorcodegenerationhyperelasticityhigher-orderfiniteelementscachingstrategies
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper claims that automatic differentiation can generate the quadrature-point code for matrix-free finite-strain elasticity tangents without any performance penalty. The generated kernels for two neo-Hookean hyperelastic models match or beat hand-written general-purpose kernels, whether the tangent is computed on the fly or built from cached tensors. If the claim holds, the hardest part of adopting matrix-free solvers for solid mechanics—deriving and hand-coding tangent operators—can be automated away, extending these fast solvers to arbitrary constitutive models.

What carries the argument

The load-bearing mechanism is the AD seed trick: set a fictitious scalar $\xi$ with $\partial F/\partial \xi = \mathrm{Grad}\,\Delta u$, then compute $\partial P/\partial \xi$; the chain rule yields the desired $L:\mathrm{Grad}\,\Delta u$ in one pass. The source-to-source AD generator applies this through an AD exception that overrides the actual dependency to insert the seed, and it simultaneously optimizes the function and derivative expressions, avoiding function calls. On the caching side, the fourth-order spatial tangent tensor $c$ (21 numbers in 3D, exploiting symmetries) and the Cauchy stress $\sigma$ are precomputed and stored per quadrature point, giving the partial-assembly variant that reduces per-application arithmetic at the cost of memory traffic.

What would settle it

Benchmark the same AD-generated and hand-written quadrature kernels on a different CPU microarchitecture (for example an Intel Xeon or an ARM processor) and on a GPU, with identical meshes and polynomial degrees, and compare per-degree-of-freedom matrix-vector throughput; if any platform shows hand-written kernels consistently faster than the AD-generated ones beyond measurement noise, the generality of the no-overhead claim would be refuted.

Watch

Extended reading notes

Core claim

The central discovery is that the tangent application $L:\mathrm{Grad}\,\Delta u$ can be obtained by differentiating the first Piola–Kirchhoff stress through a fictitious variable whose derivative is seeded to $\mathrm{Grad}\,\Delta u$, so the fourth-order tensor $L$ is never formed. The AD generator merges the energy, stress, and derivative code into one optimized routine, producing kernels that process roughly twice as many floating-point operations per second as the hand-written scalar strategies. Across polynomial degrees and in 2D and 3D, the AD-generated on-the-fly code outperforms the hand-written general caching strategies in 3D, while the AD-generated fourth-order-tensor caching is competitive with the fastest model-specific hand-written strategy in 2D. The paper also shows the same pipeline works unchanged for a more complex split neo-Hookean model, where the AD code still beats rescaled estimates of a hand-written implementation.

Load-bearing premise

The load-bearing premise is that the hand-written implementations used as baselines are near-optimally coded for the test platform, so the measured speed advantage reflects a property of the automatically generated code rather than weak baselines.

Editorial extensions

If this is right

  • The seed-based differentiation removes the need to form and store the fourth-order tangent tensor for on-the-fly evaluation, so matrix-free operators can be applied with a minimal memory footprint.
  • Caching the fourth-order spatial tangent is the better strategy in 2D, while on-the-fly evaluation wins in 3D, and both automatically generated variants beat or match the hand-written general-purpose strategies.
  • Matrix-free evaluation with AD-generated code outperforms sparse-matrix solvers by up to about 40 times for operator application and about 80 times in time-to-solution at polynomial degree 4 in 3D.
  • The same generated-code workflow generalizes to a hyperelastic model with isochoric-volumetric split without re-deriving the tangent, and it still beats generous rescaled estimates of a hand-written implementation.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The seed technique is not tied to hyperelasticity: any constitutive law written as a differentiable energy can get tangent products for free, so the practical blocker for matrix-free solid mechanics shifts from derivation to code-generation tooling.
  • Because the measured advantage comes from one x86 CPU and one compiler, the no-overhead claim may not hold on SIMD-poor or GPU hardware; a portable code generator would need to target those architectures explicitly.
  • As models grow more complex, the crossover between on-the-fly and caching will shift; the paper's suggestion that fourth-order-tensor caching is the robust general strategy could be turned into a heuristic based on per-point operation count and cache size.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

3 major / 5 minor

Summary. The paper presents a matrix-free finite-strain hyperelasticity solver in deal.II in which the quadrature-point residual and tangent evaluations are generated by automatic differentiation with AceGen, and compares these generated kernels with hand-written kernels from Davydov et al. [9] and, indirectly, from Schussnig et al. [11]. Two computational strategies are considered: on-the-fly evaluation of L:Grad(Delta u) through an AD "seed" technique, and partial assembly that caches the fourth-order spatial tangent tensor. Benchmarks on an AMD EPYC 7282 machine cover serial and parallel vmult throughput, memory per degree of freedom, and time to solution for a compressible neo-Hookean model and a split isochoric-volumetric neo-Hookean model. The central claim is that AD-generated code has no performance overhead, is the best matrix-free implementation, and remains general across constitutive models.

Significance. Automating the derivation and implementation of tangent operators is practically valuable, because manual derivation is one of the main barriers to adopting matrix-free nonlinear solvers. The direct measurements support a meaningful and more modest claim: for the general-purpose strategies tested (on-the-fly evaluation and fourth-order-tensor caching), AceGen-generated kernels match or outperform the corresponding hand-written kernels of [9]. The paper also provides useful details: FLOP counts per quadrature point measured with LIKWID, cache and storage requirements, and a clear separation of operator throughput from overall solver time. However, the manuscript overstates its evidence by calling the generated code the best matrix-free implementation despite its own data showing the hand-written model-specific tensor2 strategy to be fastest in 2D and in the serial 3D test, and by using an indirect rescaling of published results to claim superiority over [11]. These issues do not invalidate the core methodological contribution, but they require qualification and revision.

major comments (3)
  1. [Section 1, Section 4, abstract wording] The unqualified claim that AceGen-generated code "stands out as the best matrix-free implementation" is not supported by the paper's own measurements. In Table 1 (Q2, 3D, serial), the hand-written tensor2 strategy is fastest at 2.41 ms versus 3.33 ms for ADstore and 3.43 ms for ADrecompute, and in Figure 2 the tensor2 strategy is fastest in 2D for every polynomial degree shown. The authors correctly note that tensor2 is model-specific and not generalizable, but the text should then state that the generated code is best among the general, model-agnostic strategies considered, not best overall. This qualification should be applied consistently in Section 1, the conclusion in Section 4, and any abstract or summary wording that implies an unconditional superiority claim.
  2. [Section 3.3.1 and Figure 5] The claim of superior performance for the split neo-Hookean model rests on an indirect comparison. The paper states that a direct comparison with [11] is not feasible, then rescales throughput values reported in [11] using ratios measured on different hardware and different test problems, taking the maximum ratio as a conservative estimate. The green uncertainty band in Figure 5 reflects spread, but it does not remove the dependence of the procedure on assumptions about how the hardware and problem differences transfer. Taking the maximum observed ratio does not bound the true performance difference unless those ratios are shown to be hardware-transferable. Please either benchmark the implementations from [11] on the same machine or explicitly demote this comparison to a rough indication, and remove the phrase "again demonstrating superior performance" from the introduction.
  3. [Section 1, Section 2.5, Table 1] The "no performance overhead caused by AD" claim is established only for the algorithmic strategies that were implemented both by hand and with AD. No AD-generated analogue of the tensor2 caching strategy is provided, even though tensor2 is the fastest hand-written approach in the paper's own benchmarks. Consequently, the comparison cannot separate the effect of AD from the effect of the caching strategy. The supported statement is that AD introduces no overhead relative to the hand-written general-purpose kernels of the same strategy; the paper should state this limitation explicitly, and ideally add an AD-generated tensor2-like variant to make the comparison complete.
minor comments (5)
  1. [Table 1] The column header "FLOP/point [GFLOP/s]" mixes two different quantities; separate the FLOP count per quadrature point from the processing rate, as is done in the text.
  2. [Figure 5] The legend entries "scalar, curr.", "scalar, ref.", "tensor4, curr.", and "recompute, ref." are not expanded in the caption; please define current-configuration versus referential-configuration evaluations and state which quantities are measured and which are rescaled estimates.
  3. [Section 3.2.1] The sentence "Each of the four cores of the CPU had access to 16 MiB of L3 cache (64 MiB in total)" is confusing in view of the dual-socket 32-core setup described later; please clarify the exact CPU and core configuration used for the serial tests.
  4. [Section 4] The phrase "symbolic and stochastic simplifications" introduces the term "stochastic" without any previous definition or explanation; this appears to be a typo and should be corrected to "symbolic" or another appropriate qualifier.
  5. [General] The paper does not state whether the AceGen-generated code and benchmark scripts will be made publicly available; an artifact or repository link would strengthen the reproducibility of the performance claims.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the central claims are benchmark measurements against external hand-written baselines, not quantities defined by the paper's own assumptions.

full rationale

This is an empirical performance study. The central claim—that AceGen/AD-generated quadrature kernels achieve superior or at least competitive throughput relative to hand-written implementations—is supported by measured quantities (vmult timings, LIKWID FLOP counts, DoF/s processing rates, solver wall times) obtained on a specific hardware platform against externally published baseline implementations [9] and [11] and against a sparse-matrix approach. None of these measured quantities is derived from an equation that presupposes the conclusion; the AD seed formulation in Section 2.5.1 is a standard chain-rule identity, and the AceGen-generated code is benchmarked rather than assumed to be fast. There are overlapping authors with the earlier baseline papers, and the implementation extends the deal.II-based code from [9], but that does not make the comparison circular: the baseline results remain externally observable artifacts, and the paper explicitly notes where the comparison with [11] is indirect and rescaled with conservative ratios. The internal tension between the abstract's unqualified 'superior performance' wording and the paper's own Figure 2, where the hand-written model-specific tensor2 strategy is fastest, is an overstatement relative to the reported data, not a definitional circularity. No fitted parameter is renamed a prediction, no uniqueness theorem is imported from the authors' prior work, and no central premise reduces to a self-citation. Concerns about baseline optimality and single-platform generality are validity/fairness risks, not circularity. Therefore the circularity score is 0.

Assumptions & free parameters 0 free parameters · 4 assumptions · 0 invented entities

No physical parameters are fitted to data; the numeric choices are benchmark conditions such as mesh refinements and polynomial degrees, which are experimental settings rather than free parameters. The load-bearing assumptions are standard FEM/Newton theory, trust in AceGen's correctness, and two platform-specific generalization assumptions: single-hardware benchmarking and the rescaling of [11].

assumptions (4)
  • standard math Newton's method and the finite element discretization of the weak form are applicable and convergent for the benchmark problems.
    Sections 2.1 and 2.2 invoke standard FEM and Newton linearization without proof.
  • domain assumption AceGen's automatic differentiation and code optimization produce algebraically correct derivatives of the strain energy.
    Section 2.5 relies on AceGen correctness by construction; no formal verification of the generated kernels is provided.
  • ad hoc to paper Timings on one CPU (AMD EPYC 7282) with GCC 11.4.0 at -O3 -ffast-math generalize to the paper's claims of no overhead and best matrix-free implementation.
    Section 3.1 specifies the single platform; Section 4 states general conclusions beyond it.
  • ad hoc to paper The rescaling of [11] throughput ratios in Section 3.3.1 yields a conservative upper bound on hand-written performance.
    The paper assumes the maximum ratio across polynomial degrees gives a conservative estimate; this is a modeling assumption, not a proven bound.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Matrix-Free Methods for Finite-Strain Elasticity: Automatic Code Generation with No Performance Overhead." pith.science (2026). https://pith.science/paper/4V2HHOOO

@misc{pith2026250515535,
  author       = {Pith},
  title        = {Pith review of: Matrix-Free Methods for Finite-Strain Elasticity: Automatic Code Generation with No Performance Overhead},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/4V2HHOOO}},
  note         = {Machine review of arXiv:2505.15535}
}
read the original abstract

This study explores matrix-free tangent evaluations in finite-strain elasticity with the use of automatically-generated code for the quadrature-point level calculations. The code generation is done via automatic differentiation (AD) with AceGen. We compare hand-written and AD-generated codes under two computing strategies: on-the-fly evaluation and caching intermediate results. The comparison reveals that the AD-generated code achieves superior performance in matrix-free computations.

Figures

Figures reproduced from arXiv: 2505.15535 by the authors.

Figure 1
Figure 1. Discretization of the heterogeneous structure at the coarsest mesh level and the prescribed boundary conditions. Both [PITH_FULL_IMAGE:figures/full_fig_p009_1.png] view at source ↗
Figure 2
Figure 2. Measured throughput of matrix–vector operator evaluation for the compressible neo-Hookean model. The processing [PITH_FULL_IMAGE:figures/full_fig_p011_2.png] view at source ↗
Figure 3
Figure 3. Memory requirements per degree of freedom for matrix–vector operator application for the compressible neo-Hookean [PITH_FULL_IMAGE:figures/full_fig_p012_3.png] view at source ↗
Figures from the paper (2 more)
Figure 4
Figure 4. Figure 4: Comparison of time to solution for matrix-free and sparse matrix approaches across different polynomial degrees [PITH_FULL_IMAGE:figures/full_fig_p013_4.png]
Figure 5
Figure 5. Figure 5: Measured throughput during application of matrix–vector operator for the split neo-Hookean model. The processing [PITH_FULL_IMAGE:figures/full_fig_p014_5.png]

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Matrix-Free Evaluation of High-Order Shifted Boundary Finite Element Operators

    math.NA 2025-07 conditional novelty 6.0 of 10

    A matrix-free implementation of the shifted boundary method achieves O(p^{2d-1}) per-face boundary complexity and outperforms a CutFEM baseline in microbenchmarks.

Reference graph

Works this paper leans on

47 extracted references · 43 canonical work pages · cited by 1 Pith paper

  1. [11]

    Matrix-free higher-order finite element methods for hyperelasticity,

    R. Schussnig, N. Fehn, P. Munch, and M. Kronbichler, “Matrix-free higher-order finite element methods for hyperelasticity,”Computer Methods in Applied Mechanics and Engineering, vol. 435, p. 117600, 2025

    work page 2025

  2. [9]

    A matrix-free approach for finite-strain hyperelastic problems using geometric multigrid,

    D. Davydov, J.-P. Pelteret, D. Arndt, M. Kronbichler, and P. Steinmann, “A matrix-free approach for finite-strain hyperelastic problems using geometric multigrid,”Int. J. Num. Meth. Engng., vol. 121, no. 13, pp. 2874–2895, 2020

    work page 2020

  3. [1]

    Spectralmethodsforproblemsincomplexgeometries,

    S.A.Orszag, “Spectralmethodsforproblemsincomplexgeometries,”Journal of Computational Physics, vol. 37, no. 1, pp. 70–92, 1980

    work page 1980

  4. [2]

    Efficient nonlinear solvers for nodal high-order finite elements in 3D,

    J. Brown, “Efficient nonlinear solvers for nodal high-order finite elements in 3D,”J. Sci. Comput., vol. 45, no. 1-3, pp. 48–63, 2010

    work page 2010

  5. [3]

    From h to p efficiently: Strategy selection for operator evaluation on hexahedral and tetrahedral elements,

    C. D. Cantwell, S. J. Sherwin, R. M. Kirby, and P. H. J. Kelly, “From h to p efficiently: Strategy selection for operator evaluation on hexahedral and tetrahedral elements,”Comput. Fluids, vol. 43, pp. 23–28, 2011

    work page 2011

  6. [4]

    A generic interface for parallel cell-based finite element operator application,

    M. Kronbichler and K. Kormann, “A generic interface for parallel cell-based finite element operator application,”Computers & Fluids, vol. 63, pp. 135–147, 2012

    work page 2012

  7. [5]

    A quantitative performance study for Stokes solvers at the extreme scale,

    B. Gmeiner, M. Huber, L. John, U. Rüde, and B. Wohlmuth, “A quantitative performance study for Stokes solvers at the extreme scale,”Journal of Computational Science, vol. 17, pp. 509–521, 2016. Recent Advances in Parallel Techniques for Scientific Computing

    work page 2016

  8. [6]

    Fast matrix-free evaluation of discontinuous Galerkin finite element operators,

    M. Kronbichler and K. Kormann, “Fast matrix-free evaluation of discontinuous Galerkin finite element operators,”ACM Transactions on Mathematical Software (TOMS), vol. 45, no. 3, pp. 1–40, 2019

    work page 2019

Show all 47 references
  1. [7]

    GPU algorithms for efficient exascale discretizations,

    A. Abdelfattah, V. Barra, N. Beams, R. Bleile, J. Brown, J.-S. Camier, R. Carson, N. Chalmers, V. Do- brev, Y. Dudouit,et al., “GPU algorithms for efficient exascale discretizations,”Parallel Computing, vol. 108, p. 102841, 2021

    2021

  2. [8]

    Efficient exascale discretizations: High-order finite element methods,

    T. Kolev, P. Fischer, M. Min, J. Dongarra, J. Brown, V. Dobrev, T. Warburton, S. Tomov, M. S. Shephard, A. Abdelfattah,et al., “Efficient exascale discretizations: High-order finite element methods,” The International Journal of High Performance Computing Applications, vol. 35...

    2021

  3. [10]

    Performance portable solid mechanics via matrix-freep-multigrid,

    J. Brown, V. Barra, N. Beams, L. Ghaffari, M. Knepley, W. Moses, R. Shakeri, K. Stengel, J. L. Thompson, and J. Zhang, “Performance portable solid mechanics via matrix-freep-multigrid,”arXiv preprint arXiv:2204.01722, 2022

    2022 arXiv

  4. [12]

    Roofline: an insightful visual performance model for multicore architectures,

    S. Williams, A. Waterman, and D. Patterson, “Roofline: an insightful visual performance model for multicore architectures,”Communications of the ACM, vol. 52, no. 4, pp. 65–76, 2009

    2009

  5. [13]

    AI and memory wall,

    A. Gholami, Z. Yao, S. Kim, C. Hooper, M. W. Mahoney, and K. Keutzer, “AI and memory wall,” arXiv preprint arXiv:2403.14123, 2024

    2024 arXiv

  6. [14]

    A large-scale comparison of tetrahedral and hexahedral elements for solving elliptic pdes with the finite element method,

    T. Schneider, Y. Hu, X. Gao, J. Dumas, D. Zorin, and D. Panozzo, “A large-scale comparison of tetrahedral and hexahedral elements for solving elliptic pdes with the finite element method,”ACM Transactions on Graphics (TOG), vol. 41, no. 3, pp. 1–14, 2022

    2022

  7. [15]

    p-FEM applied to finite isotropic hyperelastic bodies,

    A. Düster, S. Hartmann, and E. Rank, “p-FEM applied to finite isotropic hyperelastic bodies,”Computer Methods in Applied Mechanics and Engineering, vol. 192, no. 47-48, pp. 5147–5166, 2003. 15

    2003

  8. [16]

    Wriggers,Nonlinear finite element methods

    P. Wriggers,Nonlinear finite element methods. Springer Verlag, 2008

    2008

  9. [17]

    ptatin3d: High-performance methods for long-term litho- spheric dynamics,

    D. A. May, J. Brown, and L. Le Pourhiet, “ptatin3d: High-performance methods for long-term litho- spheric dynamics,” inSC’14: Proceedings of the International Conference for High Performance Com- puting, Networking, Storage and Analysis, pp. 274–284, IEEE, 2014

    2014

  10. [18]

    Fully discrete hp-finite elements: fast quadrature,

    J. M. Melenk, K. Gerdes, and C. Schwab, “Fully discrete hp-finite elements: fast quadrature,”Computer Methods in Applied Mechanics and Engineering, vol. 190, no. 32–33, p. 4339–4364, 2001

    2001

  11. [19]

    A fast algorithm for spectral differentiation,

    A. Solomonoff, “A fast algorithm for spectral differentiation,”Journal of Computational Physics, vol. 98, pp. 174–177, 1992

    1992

  12. [20]

    Efficient matrix-free high-order finite element evaluation for sim- plicial elements,

    D. Moxey, R. Amici, and M. Kirby, “Efficient matrix-free high-order finite element evaluation for sim- plicial elements,”SIAM Journal on Scientific Computing, vol. 42, no. 3, pp. C97–C123, 2020

    2020

  13. [21]

    Scalability of high-performance pde solvers,

    P. Fischer, M. Min, T. Rathnayake, S. Dutta, T. Kolev, V. Dobrev, J.-S. Camier, M. Kronbichler, T. Warburton, K. Świrydowicz,et al., “Scalability of high-performance pde solvers,”The International Journal of High Performance Computing Applications, vol. 34, no. 5, pp. 562–586, 2020

    2020

  14. [22]

    A performance comparison of continuous and discontinuous Galerkin methods with fast multigrid solvers,

    M. Kronbichler and W. A. Wall, “A performance comparison of continuous and discontinuous Galerkin methods with fast multigrid solvers,”SIAM Journal on Scientific Computing, vol. 40, no. 5, pp. A3423– A3448, 2018

    2018

  15. [23]

    A flexible, parallel, adaptive geometric multigrid method for fem,

    T. C. Clevenger, T. Heister, G. Kanschat, and M. Kronbichler, “A flexible, parallel, adaptive geometric multigrid method for fem,”ACM Trans. Math. Softw., vol. 47, Dec. 2020

    2020

  16. [24]

    Exploiting high-contrast stokes precon- ditioners to efficiently solve incompressible fluid–structure interaction problems,

    M. Wichrowski, P. Krzyżanowski, L. Heltai, and S. Stupkiewicz, “Exploiting high-contrast stokes precon- ditioners to efficiently solve incompressible fluid–structure interaction problems,”International Journal for Numerical Methods in Engineering, vol. 124, no. 24, pp. 5446–5470, 2023

    2023

  17. [25]

    The deal.II finite element library: Design, features, and insights,

    D. Arndt, W. Bangerth, D. Davydov, T. Heister, L. Heltai, M. Kronbichler, M. Maier, J.-P. Pelteret, B. Turcksin, and D. Wells, “The deal.II finite element library: Design, features, and insights,”Computers & Mathematics with Applications, vol. 81, pp. 407–422, 2021

    2021

  18. [26]

    Thedeal.II library, version 9.5,

    D. Arndt, W. Bangerth, M. Bergbauer, M. Feder, M. Fehling, J. Heinz, T. Heister, L. Heltai, M. Kro- nbichler, M. Maier, P. Munch, J.-P. Pelteret, B. Turcksin, D. Wells, and S. Zampini, “Thedeal.II library, version 9.5,”Journal of Numerical Mathematics, vol. 31, no. 3, pp. 231–...

    2023

  19. [27]

    Automatic generation of finite-element code by simultaneous optimization of expressions,

    J. Korelc, “Automatic generation of finite-element code by simultaneous optimization of expressions,” Theoretical Computer Science, vol. 187, pp. 231–248, 1997

    1997

  20. [28]

    Extending the functionality of the general- purposefiniteelementpackagesepranbyautomaticdifferentiation,

    C. Bischof, H. Buecker, B. Lang, A. Rasch, and J. Risch, “Extending the functionality of the general- purposefiniteelementpackagesepranbyautomaticdifferentiation,”International Journal for Numerical Methods in Engineering, vol. 58, pp. 2225–2238, 2003

    2003

  21. [29]

    Griewank and A

    A. Griewank and A. Walther,Evaluating derivatives: principles and techniques of algorithmic differen- tiation. SIAM, 2008

    2008

  22. [30]

    Multi-language and multi-environment generation of nonlinear finite element codes,

    J. Korelc, “Multi-language and multi-environment generation of nonlinear finite element codes,”Engi- neering with computers, vol. 18, pp. 312–327, 2002

    2002

  23. [31]

    Korelc and P

    J. Korelc and P. Wriggers,Automation of Finite Element Methods. Switzerland: Springer International Publishing, 2016

    2016

  24. [32]

    Mathematica, Version 14.1

    Wolfram Research, Inc., “Mathematica, Version 14.1.” Champaign, IL, 2024

    2024

  25. [33]

    Automation of primal and sensitivity analysis of transient coupled problems,

    J. Korelc, “Automation of primal and sensitivity analysis of transient coupled problems,”Computational mechanics, vol. 44, pp. 631–649, 2009. 16

    2009

  26. [34]

    Reverse-mode automatic differentiation and optimization of gpu kernels via enzyme,

    W. S. Moses, V. Churavy, L. Paehler, J. Hückelheim, S. H. K. Narayanan, M. Schanen, and J. Doerfert, “Reverse-mode automatic differentiation and optimization of gpu kernels via enzyme,” inProceedings of the international conference for high performance computing, networking, s...

    2021

  27. [35]

    An overview of the Trilinos project,

    M. A. Heroux, R. A. Bartlett, V. E. Howle, R. J. Hoekstra, J. J. Hu, T. G. Kolda, R. B. Lehoucq, K. R. Long, R. P. Pawlowski, E. T. Phipps,et al., “An overview of the Trilinos project,”ACM Transactions on Mathematical Software (TOMS), vol. 31, no. 3, pp. 397–423, 2005

    2005

  28. [36]

    P. G. Ciarlet,The Finite Element Method for Elliptic Problems. North-Holland, 1978

    1978

  29. [37]

    Parallel multigrid smoothing: polynomial versus gauss–seidel,

    M. Adams, M. Brezina, J. Hu, and R. Tuminaro, “Parallel multigrid smoothing: polynomial versus gauss–seidel,”Journal of Computational Physics, vol. 188, no. 2, pp. 593–610, 2003

    2003

  30. [38]

    ExaDG: High-order discontinuous Galerkin for the exa-scale,

    D. Arndt, N. Fehn, G. Kanschat, K. Kormann, M. Kronbichler, P. Munch, W. Wall, and J. Witte, “ExaDG: High-order discontinuous Galerkin for the exa-scale,” inSoftware for Exascale Computing - SPPEXA 2016-2019(H.-J. Bungartz, S. Reiz, B. Uekermann, P. Neumann, and W. Nagel, eds....

    2016

  31. [39]

    Gruber, J

    T. Gruber, J. Eitzinger, G. Hager, and G. Wellein, “Likwid,”Version v5, vol. 2, p. 20, 2022

    2022

  32. [40]

    Large deformation isotropic elasticity–on the correlation of theory and experiment for incompressible rubberlike solids,

    R. W. Ogden, “Large deformation isotropic elasticity–on the correlation of theory and experiment for incompressible rubberlike solids,”Proc. Roy. Soc. Lond. A, vol. 326, pp. 565–584, 1972

    1972

  33. [41]

    The mechanics of rubber elasticity,

    L. R. Treloar, “The mechanics of rubber elasticity,”Proc. Roy. Soc. Lond. A, vol. 351, pp. 301–330, 1976

    1976

  34. [42]

    Remarks on rate constitutive equations for finite deformation problems: computational implications,

    J. C. Simo and K. S. Pister, “Remarks on rate constitutive equations for finite deformation problems: computational implications,”Comp. Meth. Appl. Mech. Engng., vol. 46, pp. 201–215, 1984

    1984

  35. [43]

    Numerical analysis and simulation of plasticity,

    J. C. Simo, “Numerical analysis and simulation of plasticity,” inHandbook of Numerical Analysis(P. Cia- rlet and J. Lions, eds.), vol. VI, pp. 184–499, Amsterdam: Elsevier Science B.V., 1998

    1998

  36. [44]

    Smoothers with localized residual com- putations for geometric multigrid methods,

    M. Wichrowski, P. Munch, M. Kronbichler, and G. Kanschat, “Smoothers with localized residual com- putations for geometric multigrid methods,”arXiv preprint arXiv:2407.02100, 2024

    2024 arXiv

  37. [45]

    Cut finite element methods for linear elasticity problems,

    P. Hansbo, M. G. Larson, and K. Larsson, “Cut finite element methods for linear elasticity problems,” inGeometrically Unfitted Finite Element Methods and Applications: Proceedings of the UCL Workshop 2016, pp. 25–63, Springer, 2017

    2016

  38. [46]

    High-performance matrix-free unfitted finite element operator evaluation,

    M. Bergbauer, P. Munch, W. A. Wall, and M. Kronbichler, “High-performance matrix-free unfitted finite element operator evaluation,”arXiv preprint arXiv:2404.07911, 2024

    2024 arXiv

  39. [47]

    Preconditioning discretizations of systems of partial differential equa- tions,

    K.-A. Mardal and R. Winther, “Preconditioning discretizations of systems of partial differential equa- tions,”Numerical Linear Algebra with Applications, vol. 18, no. 1, pp. 1–40, 2011. 17

    2011

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.