Towards Automated Algebraic Multigrid Preconditioner Design Using Genetic Programming for Large-Scale Laser Beam Welding Simulations

Axel Klawonn; Dinesh Parthasarathy; Harald K\"ostler; Martin Lanser; Tommaso Bevilacqua

REVIEW 2 major objections 5 minor 32 references

Towards Automated Algebraic Multigrid Preconditioner Design Using Genetic Programming for Large-Scale Laser Beam Welding Simulations

T0 review · 2 major / 5 minor · reviewed 2026-08-11 · deepseek-v4-flash

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

Pith's one-line read Automated search beats hand-tuned multigrid in welding simulations.

desk verdict A useful engineering study showing G3P-evolved flexible AMG cycles generalize to a welding simulation, but the headline speedups rest on a single evolutionary run and a small training proxy. read the letter →

arxiv 2412.08186 v1 pith:E4ANB7BD submitted 2024-12-11 cs.CE cs.AIcs.NAmath.NA

Dinesh Parthasarathy , Tommaso Bevilacqua , Martin Lanser , Axel Klawonn , Harald Köstler This is my paper · ORCID

classification cs.CEcs.AIcs.NAmath.NA MSC 65N5565F1068W50

keywords algebraicmultigridgeneticprogrammingflexiblecyclesBoomerAMGlaserbeamweldingthermo-elasticitypreconditionerdesigngrammar-guided

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

The paper tries to show that the slow, hand-tuning phase of algebraic multigrid (AMG) preconditioner design can be automated with genetic programming, and that the automatically found preconditioners beat standard and hand-tuned ones on finite-element simulations of laser beam welding. The welding model is a coupled thermo-elasticity problem whose Newton-linearized systems are large and ill-conditioned; the paper uses AMG-preconditioned GMRES with BoomerAMG applied monolithically to the whole coupled system. The key move is to let a grammar-guided evolutionary search build flexible AMG cycles, meaning level-specific smoothing choices and non-recursive cycling patterns, rather than only the standard V-, W-, or F-cycles. If correct, the result is a practical recipe: train on one small proxy system and deploy the evolved solver on the full simulation. On the largest tested problem, the best evolved cycle is about 60 percent faster than the default BoomerAMG configuration and about 25 percent faster than a hand-tuned one.

What carries the argument

The load-bearing object is the flexible AMG cycle: a non-recursive traversal of the multigrid hierarchy in which each level visitation can specify its own smoother type, number of sweeps, relaxation weights, and coarse-grid correction scaling. The paper fixes the AMG setup phase, including coarsening, interpolation, and threshold parameters, and restricts the flexible part to the five finest levels, with the remaining coarse levels using standard BoomerAMG. This keeps the search space focused on the expensive levels while letting grammar-guided genetic programming explore a far larger cycle space than traditional V-, W-, and F-cycles. The context-free grammar also constrains crossover and mutation so that every generated program is a valid AMG-preconditioned GMRES solver, and the search is multi-objective, balancing solve time per iteration against convergence, with the final population sorted into a Pareto front.

What would settle it

Run a full 1.0 s welding simulation at 1.37 million degrees of freedom with the best evolved solver and the hand-tuned solver, reporting solve time per Newton iteration separately; if the evolved cycle is not faster than the hand-tuned method on Newton iterations beyond the second, or if its total time is not below the measured 277.6 s versus 341.7 s, the claimed generalization fails.

Watch

Extended reading notes

Core claim

The central discovery, stated on the paper's terms, is that grammar-guided genetic programming can synthesize flexible BoomerAMG cycles that are better black-box preconditioners for thermo-elastic laser beam welding simulations than the default PETSc BoomerAMG configuration and a hand-tuned V-cycle configuration. Trained only on the linear system at t=0.4 s and the second Newton iteration, with 89,100 degrees of freedom on 8 MPI processes, the evolved solvers are reported to beat both references on every time step of a 1.0 s simulation and across a weak-scaling study up to 1.37 million degrees of freedom. For the largest problem, the best evolved solver takes 277.6 s of solve time versus 436.7 s for the default and 341.7 s for the hand-tuned method, roughly 60 percent and 25 percent faster respectively. The authors also report that the generated flexible cycles achieve this by lowering the cost per iteration, for example by skipping pre-smoothing on the finest levels, while retaining acceptable convergence.

Load-bearing premise

The whole search is trained on one small linear system with 89,100 degrees of freedom, taken from time step 0.4 s and the second Newton iteration, and the claimed speedups assume that this system represents the harder later Newton systems and larger meshes.

Editorial extensions

If this is right

Hand-tuning of AMG solve-phase parameters can be replaced by an automated search, at least for this class of thermo-mechanical problems.
A solver evolved on one small linear system carries over to the whole time-stepping simulation and to meshes roughly four times larger, so the training cost is decoupled from the production run.
The Pareto front gives a menu of preconditioners with different cost-versus-convergence trade-offs; because they share one AMG hierarchy, switching among them during a simulation adds no setup overhead.
For the largest tested problem, the best evolved cycle cuts total solve time by about 60 percent relative to the default BoomerAMG configuration and about 25 percent relative to the hand-tuned method.

Reading between the lines

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

The reported iteration-count growth at later Newton iterations suggests the single-proxy training may overfit early Newton steps; a two-stage evolution that re-evaluates the final population on the 1.37M-degree-of-freedom system would test whether later-iteration performance can be improved without losing the early gains.
The same flexible-cycle grammar could be applied to block-triangular preconditioners for the coupled system, where each diagonal block gets its own evolved BoomerAMG cycle; the paper names this as a future direction rather than a demonstrated result.
Because the evolved cycles are expressed as grammar programs over standard BoomerAMG options, the approach could transfer to other multiphysics problems whose Newton systems are dominated by solve time, provided the setup phase is fixed and the training proxy is chosen carefully.
The Pareto-front selection strategy implies that an online controller could pick a preconditioner per Newton iteration based on the conditioning of the current system; this is an operational consequence the paper sketches but does not implement.

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.

Desk Editor's Note

read the letter

The thing to know: this is a solid application of grammar-guided genetic programming to AMG cycle design, building on the authors' companion work [23]. The genuinely new result is that cycles evolved on a single small proxy system—one time step, one Newton iteration, 89k DOFs—generalize to the full welding simulation and to weak scaling up to 1.37M DOFs, beating default and hand-tuned BoomerAMG by 25–60%. That held-out evaluation is the paper's real contribution, and it is credible.

What the paper does well: the experiment design is honest. They train on one system and test on everything else, and the GP solvers win across all time steps and all problem sizes. The paper also flags its own limitations without being asked: the elastic model is simplified, monolithic BoomerAMG may not be optimal, and later Newton iterations create a scaling bottleneck (Fig. 9). The flexible-cycle diagrams in Fig. 8 help make sense of why one solver is cheaper per iteration even with similar convergence.

The soft spots, in proportion. The main one is statistical: a single GP run, no error bars, no repeated seeds. Evolution is stochastic; one seed can land on a lucky Pareto front. Given that the headline is a 25–60% speedup, the absence of any variance estimate is a real gap. This is the biggest reason the paper should not be accepted as-is. Second, the proxy system is the authors' own choice, and they acknowledge it misses the later-Newton regime that limits scaling. That is a legitimate concern, but it is not fatal because the test set is comprehensive; I would not call the central claim circular or overfit, just not yet proven robust. Third, no code or data is released, so reproducibility is limited—the companion paper supplies the method, but the welding-specific data and fork of hypre would be needed to reproduce Table 4.

Who is this for? HPC solver developers and practitioners running large thermo-mechanical FE simulations. They will get practical guidance on whether to invest in GP-based cycle search. The paper deserves a serious referee: the idea is sound, the results are positive, and the weaknesses are fixable. I would send it to review and ask for repeated GP runs (or at least a sensitivity analysis over seeds), error bars on timings, and a commitment to release code and data.

Referee Report

2 major / 5 minor

Summary. The paper presents an automated approach to designing algebraic multigrid (AMG) preconditioners for the linear systems arising in finite element simulations of laser beam welding. The authors use grammar-guided genetic programming (G3P) to evolve flexible AMG cycles—non-recursive, level-specific cycling patterns with customizable smoothing sequences—for use as preconditioners for GMRES. Training is performed on a single proxy linear system taken from the second Newton iteration at time t = 0.4 s with 89,100 DOFs on 8 MPI processes. Three Pareto-optimal solvers (GP-10, GP-22, GP-54) are selected and then evaluated on the full welding simulation across all time steps and on weak-scaled problems up to 1.37 million DOFs. The reported results show these GP-generated cycles consistently outperform both the default PETSc BoomerAMG configuration and a hand-tuned V-cycle configuration, with the largest tested case showing a speedup of about 1.57 over the default configuration and about 1.23 over the hand-tuned configuration.

Significance. If the reported results are robust, the paper makes a practically useful contribution: it demonstrates a fully automated, grammar-guided evolutionary search that finds black-box AMG preconditioners outperforming both out-of-the-box and manually tuned baselines on a realistic thermo-elasticity simulation. The evaluation is genuine in that it uses held-out time steps and problem sizes not seen during training, and the setup parameters are fixed so the comparison isolates the cycling and smoothing choices. The authors also honestly discuss the scaling bottleneck of later Newton iterations and suggest a fine-tuning strategy. The main weakness is statistical: the evolutionary search is stochastic, but only a single run is reported, and no variance or repeatability information is given. This makes it difficult to know whether the observed speedups are a property of the G3P approach or of one particular run.

major comments (2)

[Section 6, Table 4; Appendix A, Table 5] The central speedup claim rests on a single stochastic G3P run. The evolutionary algorithm uses a random initial population, crossover probability 0.9, mutation, and NSGA-II selection (Appendix A, Table 5), so the final Pareto front and the selected solvers GP-10, GP-22, and GP-54 depend on the random seed. Table 4 reports only single timing measurements with no error bars, no repeated runs, and no statistical comparison. Because the claim is that GP-generated cycles are faster than default and hand-tuned baselines at all tested problem sizes, the authors should either run the evolutionary search multiple times with different seeds and report the range or distribution of resulting solver performance, or otherwise justify why a single run is representative. Without this, the 1.57x and 1.23x speedups cannot be distinguished from run-to-run variation.
[Section 5.2, Section 7, Figure 9] The training proxy is a single linear system from the second Newton iteration at t = 0.4 s with 89,100 DOFs on 8 MPI processes. The paper's own Section 7 and Figure 9 show that later Newton iterations (iteration >= 3) scale poorly and become the dominant cost at larger problem sizes, yet the fitness function never evaluates such systems. This is a correctness risk for the claim that the GP approach improves the full simulation: the evolved cycles may be overfit to the proxy's regime and therefore may not be optimal, or even reliable, for the Newton iterations that determine the largest-problem timings. The held-out evaluation is reassuring, but it does not rule out this risk. A concrete test would be to evolve (or fine-tune) on a system from a later Newton iteration or at a larger problem size and compare the resulting Pareto front and solve times, as the authors themselves suggest in Section 7.

minor comments (5)

[Section 6.2, Table 4] The caption and text should define the quantities more precisely: T is described as 'Total solving time', but the text says the analysis focuses solely on the solve phase, and the iteration count is called 'average iteration count per time step'. Please clarify whether T is the sum over all time steps and Newton iterations, whether it includes only GMRES solve time or also preconditioner application time, and how the average iteration count is computed. The bold entries in Table 4 are not explained in the caption.
[Section 6.2, Table 4] The phrase 'approximately 60% faster than the default BoomerAMG' is ambiguous. Table 4 gives a time ratio of 436.7/277.6 = 1.573, which is a speedup factor of about 1.57, not a 60% reduction in solve time (which would be 1 - 1/1.573 = 36%). Please report speedups as multiplicative factors or state the percentage reduction in time.
[Section 6.1, paragraph 3] The text contains a typo: 'inspite of having a similar convergence rate' should read 'in spite of having a similar convergence rate'.
[Section 6, Figure 8] Figure 8 shows the flexible cycle structures for GP-10 and GP-54, but the caption does not explain the symbols or the color coding (e.g., which colors denote pre-smoothing, post-smoothing, or coarse-grid correction). A legend or a detailed caption would make the figure interpretable without relying on the surrounding text.
[Section 5.2, Table 3] The notation N_flex is used both as a variable in the text ('The top fine grid levels (N_flex)') and as a parameter in Table 3 ('Num. flex. levels'). It would be clearer to use a distinct symbol for the number of flexible levels, such as N_flex, and to explicitly state in the text that this parameter is fixed at 5 for all experiments.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: the GP-generated AMG solvers are optimized on a single proxy linear system and then measured on held-out time steps and problem sizes, so the reported speedups are genuine out-of-sample results.

full rationale

The paper's central claim is that grammar-guided genetic programming can evolve flexible BoomerAMG cycles that outperform both the default PETSc BoomerAMG configuration and a hand-tuned V-cycle configuration. This claim is not circular: fitness is evaluated on exactly one linear system (t = 0.4 s, 2nd Newton iteration, 89,100 DOFs, 8 MPI processes) using the two objectives 'solve time per iteration' and 'convergence', while the reported speedups are measured on the full 1.0 s simulation (all time steps and Newton iterations) and on larger weakly scaled problems with up to 1.37M DOFs on 128 MPI processes. The evaluation data are therefore not the same as the training data, and the results are not forced by construction. The paper also honestly discloses that later Newton iterations create a scaling bottleneck and suggests fine-tuning on larger problems as future work, which further confirms that the observed generalization is an empirical finding rather than a definitional identity. The self-citations to the authors' prior work ([23] for flexible algebraic multigrid and [24,25] for the EvoStencils framework) are citations to software and prior method development; they are implementation dependencies, not unverified uniqueness theorems or ansatze smuggled in to force the present conclusion. The present paper independently evaluates the generated solvers on new problems. Remaining concerns, such as the use of a single GP run without variance reporting and the selection of the best GP solver for the speedup columns, are robustness and statistical-support issues, not circularity. No load-bearing step reduces to its own input, so the appropriate circularity score is 0.

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

The central claim rests on the representativeness of the proxy training system and on the correctness of the forked hypre implementation, neither of which is independently verified. The fixed AMG setup parameters and GP search settings are hand-chosen inputs, not fitted to the target result. No invented entities are introduced.

free parameters (5)

AMG strength threshold = 0.8
Hand-chosen Falgout coarsening threshold (Table 6); affects the coarsening and therefore convergence for all compared solvers equally.
AMG max row sum = 0.9
Hand-chosen interpolation parameter (Table 6); part of the fixed AMG setup shared by all solvers.
GP generations = 100
Stopping criterion for the evolutionary search (Table 5); more generations could yield different Pareto fronts.
GP population size = 256
Population size for the (mu+lambda) evolution strategy (Table 5); a larger population might change the discovered cycles.
Proxy training system = t=0.4s, 2nd Newton iteration
The GP fitness is measured only on this system (Section 5.2); the paper's generalization claims rest on it, and it is a hand-chosen training input, not a fitted constant.

assumptions (4)

domain assumption The Q1-Q1 mixed finite element discretization of the simplified thermo-elasticity system is adequate for the solver-evaluation goal even though the inf-sup condition is not guaranteed.
Section 3 states 'we cannot guarantee that the selected finite elements satisfy the inf-sup condition.' The solver comparison is still meaningful only if the discrete systems are representative of the target problem.
domain assumption The material parameters and experimental melting pool geometry used in the simulation are accurate enough for the solver study.
Table 1 parameters come from [14] and the melting pool surface from [4]; errors in these inputs would shift the linear systems and could change the relative solver ranking.
domain assumption The forked hypre implementation correctly evaluates flexible AMG cycles, and the measured solve times are reliable.
Appendix A describes a forked version of hypre with added flexible cycling; no independent validation of this implementation is provided in the paper.
domain assumption A single GP run, with population 256 and 100 generations, yields a representative Pareto front.
No multiple seeds or statistical analysis are reported; the stochastic search could produce different fronts in different runs.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Towards Automated Algebraic Multigrid Preconditioner Design Using Genetic Programming for Large-Scale Laser Beam Welding Simulations." pith.science (2026). https://pith.science/paper/E4ANB7BD

@misc{pith2026241208186,
  author       = {Pith},
  title        = {Pith review of: Towards Automated Algebraic Multigrid Preconditioner Design Using Genetic Programming for Large-Scale Laser Beam Welding Simulations},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/E4ANB7BD}},
  note         = {Machine review of arXiv:2412.08186}
}

read the original abstract

Multigrid methods are asymptotically optimal algorithms ideal for large-scale simulations. But, they require making numerous algorithmic choices that significantly influence their efficiency. Unlike recent approaches that learn optimal multigrid components using machine learning techniques, we adopt a complementary strategy here, employing evolutionary algorithms to construct efficient multigrid cycles from available individual components. This technology is applied to finite element simulations of the laser beam welding process. The thermo-elastic behavior is described by a coupled system of time-dependent thermo-elasticity equations, leading to nonlinear and ill-conditioned systems. The nonlinearity is addressed using Newton's method, and iterative solvers are accelerated with an algebraic multigrid (AMG) preconditioner using hypre BoomerAMG interfaced via PETSc. This is applied as a monolithic solver for the coupled equations. To further enhance solver efficiency, flexible AMG cycles are introduced, extending traditional cycle types with level-specific smoothing sequences and non-recursive cycling patterns. These are automatically generated using genetic programming, guided by a context-free grammar containing AMG rules. Numerical experiments demonstrate the potential of these approaches to improve solver performance in large-scale laser beam welding simulations.

Figures

Figures reproduced from arXiv: 2412.08186 by the authors.

**Figure 2.** A simplified illustration of the evolution of [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗

**Figure 3.** Representation of the temperature field of a fully [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗

Figures from the paper (7 more)

**Figure 4.** Figure 4: Processor topology for MPI parallelism with 89 100 [PITH_FULL_IMAGE:figures/full_fig_p005_4.png]

**Figure 6.** Figure 6: ). Solvers on the tail ends of the Pareto front are excluded, as they only minimize one of the two objectives, leaving the remaining options as viable choices for the simulation. The flexible cycle structures for GP-10 and GP-54 are shown in [PITH_FULL_IMAGE:figures/f…

**Figure 5.** Figure 5: Evolution of AMG-preconditioned GMRES programs (blue dots) with respect to solve time per iteration and convergence, progressing from an initial random population to the final generation (clockwise from top left: initial population, generation 1, generation 10, gener…

**Figure 7.** Figure 7: Performance of GP generated flexible AMG preconditioners and standard AMG preconditioners for the numerical simulation with 89 100 DOFs. seen in [PITH_FULL_IMAGE:figures/full_fig_p007_7.png]

**Figure 8.** Figure 8: Visual representation of the GP generated flexible cycles. [PITH_FULL_IMAGE:figures/full_fig_p008_8.png]

**Figure 9.** Figure 9: Average iteration count of GP-10 for different New [PITH_FULL_IMAGE:figures/full_fig_p008_9.png]

**Figure 10.** Figure 10: Overview of the software pipeline for automated [PITH_FULL_IMAGE:figures/full_fig_p010_10.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

32 extracted references · 25 canonical work pages

[23]

Evolving Algebraic Multigrid Methods Using Grammar-Guided Genetic Programming

Dinesh Parthasarathy, Wayne B. Mitchell, and Harald Köstler. 2024. Evolving Algebraic Multigrid Methods Using Grammar-Guided Genetic Programming. arXiv:2412.05852 [cs.CE] https://arxiv.org/abs/2412.05852

work page Pith review arXiv 2024
[1]

Baker, Robert D

Allison H. Baker, Robert D. Falgout, Tzanio V. Kolev, and Ulrike Meier Yang. 2011. Multigrid Smoothers for Ultraparallel Computing. SIAM Journal on Scientific Computing 33, 5 (Jan. 2011), 2864–2887. https://doi.org/10.1137/100798806

doi:10.1137/100798806 2011
[2]

Baker, Axel Klawonn, Tzanio V

Allison H. Baker, Axel Klawonn, Tzanio V. Kolev, Martin Lanser, Oliver Rheinbach, and Ulrike Meier Yang. 2016. Scalability of Classical Algebraic Multigrid for Elasticity to Half a Million Parallel Tasks. In Software for Exascale Computing - SPPEXA 2013-2015, Hans-Joachim Bungartz, Philipp Neumann, and Wolfgang E. Nagel (Eds.). Springer International Publ...

work page 2016
[3]

Baker, Tzanio V

Allison H. Baker, Tzanio V. Kolev, and Ulrike Meier Yang. 2010. Improving algebraic multigrid interpolation operators for linear elasticity problems. Numer. Linear Algebra Appl. 17, 2-3 (2010), 495–517. https://doi.org/10.1002/nla.688

doi:10.1002/nla.688 2010
[4]

Nasim Bakir, Antoni Artinov, Andrey Gumenyuk, Marcel Bachmann, and Michael Rethmeier. 2018. Numerical Simulation on the Origin of Solidification Cracking in Laser Welded Thick-Walled Structures. Metals 8, 6 (2018), 406

work page 2018
[5]

Satish Balay, Shrirang Abhyankar, Mark Adams, Jed Brown, Peter Brune, Kris Buschelman, Lisandro Dalcin, Alp Dener, Victor Eijkhout, William Gropp, et al

work page
[6]

Wolfgang Banzhaf. 2001. Artificial Intelligence: Genetic Programming. Elsevier, 789–792. https://doi.org/10.1016/b0-08-043076-7/00557-x

work page doi:10.1016/b0-08-043076-7/00557-x 2001
[7]

Tommaso Bevilacqua, Axel Klawonn, Martin Lanser, and Adam Wasiak. 2024. Monolithic overlapping Schwarz preconditioners for nonlinear finite element simulations of laser beam welding processes. arXiv preprint arXiv:2407.03230 (2024)

work page Pith review arXiv 2024

Show all 32 references

[8]

Kalyanmoy Deb, Amrit Pratap, Sameer Agarwal, and Tanaka Meyarivan. 2002. A fast and elitist multiobjective genetic algorithm: NSGA-II. IEEE Transactions on Evolutionary Computation 6, 2 (2002), 182–197. https://doi.org/10.1109/4235. 996017

2002 doi
[9]

Falgout, Jim E

Robert D. Falgout, Jim E. Jones, and Ulrike Meier Yang. 2006. The Design and Implementation of hypre, a Library of Parallel High Performance Preconditioners. In Numerical Solution of Partial Differential Equations on Parallel Computers, Are Magnus Bruaset and Aslak Tveito (Eds...

2006
[10]

Félix-Antoine Fortin, François-Michel De Rainville, Marc-André Gardner, Marc Parizeau, and Christian Gagné. 2012. DEAP: Evolutionary Algorithms Made Easy. Journal of Machine Learning Research 13 (jul 2012), 2171–2175

2012
[11]

Daniel Greenfeld, Meirav Galun, Ronen Basri, Irad Yavneh, and Ron Kimmel. 2019. Learning to Optimize Multigrid PDE Solvers. In Proceedings of the 36th International Conference on Machine Learning (Proceedings of Machine Learning Research, Vol. 97), Kama- lika Chaudhuri and Rus...

2019
[12]

Philipp Hartwig, Nasim Bakir, Lisa Scheunemann, Andrey Gumenyuk, Jörg Schröder, and Michael Rethmeier. 2024. A Physically Motivated Heat Source Model for Laser Beam Welding. Metals 14, 4 (2024), 430

2024
[13]

Philipp Hartwig, Lisa Scheunemann, and Jörg Schröder. 2023. On the numerical treatment of heat sources in laser beam welding processes. PAMM 23, 1 (2023), e202200220

2023
[14]

Philipp Hartwig, Lisa Scheunemann, and Jörg Schröder. 2023. A volumetric heat source model for the approximation of the melting pool in laser beam welding. PAMM 23, 4 (2023), e202300173

2023
[15]

Van Emden Henson and Ulrike Meier Yang. 2002. BoomerAMG: A parallel alge- braic multigrid solver and preconditioner. Applied Numerical Mathematics 41, 1 (2002), 155–177. https://doi.org/10.1016/S0168-9274(01)00115-5 Developments and Trends in Iterative Methods for Large System...

2002 doi
[16]

Ru Huang, Ruipeng Li, and Yuanzhe Xi. 2023. Learning optimal multigrid smoothers via neural networks. SIAM J. Sci. Comput. 45, 3 (June 2023), S199– S225

2023
[17]

Alexandr Katrutsa, Talgat Daulbaev, and Ivan Oseledets. 2017. Deep Multigrid: learning prolongation and restriction matrices. arXiv:1711.03825 [math.NA]

2017 arXiv
[18]

Alexandr Katrutsa, Talgat Daulbaev, and Ivan Oseledets. 2020. Black-box learning of multigrid parameters. J. Comput. Appl. Math. 368 (April 2020), 112524. https: //doi.org/10.1016/j.cam.2019.112524

2020
[19]

Axel Klawonn, Stephan Köhler, Martin Lanser, and Oliver Rheinbach. 2020. Com- putational homogenization with million-way parallelism using domain decom- position methods. Computational Mechanics 65, 1 (2020), 1–22

2020
[20]

Ilay Luz, Meirav Galun, Haggai Maron, Ronen Basri, and Irad Yavneh. 2020. Learning algebraic multigrid using graph neural networks. In Proceedings of the 37th International Conference on Machine Learning (ICML’20). JMLR.org, Article 602, 11 pages

2020
[21]

Daniel Manrique, Juan Ríos, and Alfonso Rodríguez-Patón. 2009. Grammar-Guided Genetic Programming. IGI Global, 767–773. https: //doi.org/10.4018/978-1-59904-849-9.ch114

2009 doi
[22]

Michael Orlov, Moshe Sipper, and Ami Hauptman. 2009. Genetic and Evolutionary Algorithms and Programming: General Introduction and Application to Game Playing. Springer New York, 4133–4145. https://doi.org/ 10.1007/978-0-387-30440-3_243

2009 doi
[24]

Jonas Schmitt and Harald Köstler. 2022. Evolving generalizable multigrid- based helmholtz preconditioners with grammar-guided genetic programming. In Proceedings of the Genetic and Evolutionary Computation Conference (GECCO ’22). ACM. https://doi.org/10.1145/3512290.3528688

2022
[25]

Jonas Schmitt, Sebastian Kuckuk, and Harald Köstler. 2021. EvoStencils: a grammar-based genetic programming approach for constructing efficient geo- metric multigrid methods. Genetic Programming and Evolvable Machines 22, 4 (Sept. 2021), 511–537. https://doi.org/10.1007/s10710...

2021 doi
[26]

Simo and Christian Miehe

Juan C. Simo and Christian Miehe. 1992. Associative coupled thermoplasticity at finite strains: Formulation, numerical analysis and implementation. Computer Methods in Applied Mechanics and Engineering 98, 1 (1992), 41–104

1992
[27]

MacLachlan, Luke Olson, and Matthew West

Ali Taghibakhshi, Scott P. MacLachlan, Luke Olson, and Matthew West. 2021. Optimization-Based Algebraic Multigrid Coarsening Using Reinforcement Learn- ing. ArXiv abs/2106.01854 (2021). https://api.semanticscholar.org/CorpusID: 235313621

2021 arXiv
[28]

Robert L Taylor. 2014. FEAP - - A Finite Element Analysis Program

2014
[29]

Peter A. Whigham. 1995. Grammatically-based Genetic Programming. https: //api.semanticscholar.org/CorpusID:14127572

1995
[30]

Ulrike Meier Yang. 2004. On the use of relaxation parameters in hybrid smoothers. Numer. Linear Algebra Appl. 11, 2-3 (2004), 155–172. https://doi.org/10.1002/ NLA.375

2004
[31]

Enrui Zhang, Adar Kahana, Alena Kopaničáková, Eli Turkel, Rishikesh Ranade, Jay Pathak, and George Em Karniadakis. 2024. Blending neural operators and relaxation methods in PDE numerical solvers. Nature Machine Intelligence 6, 11 (Oct. 2024), 1303–1313. https://doi.org/10.1038...

2024 doi
[2019]

PETSc users manual. (2019)

2019

Pith tools

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

[1] [23]

Evolving Algebraic Multigrid Methods Using Grammar-Guided Genetic Programming

Dinesh Parthasarathy, Wayne B. Mitchell, and Harald Köstler. 2024. Evolving Algebraic Multigrid Methods Using Grammar-Guided Genetic Programming. arXiv:2412.05852 [cs.CE] https://arxiv.org/abs/2412.05852

work page Pith review arXiv 2024

[2] [1]

Baker, Robert D

Allison H. Baker, Robert D. Falgout, Tzanio V. Kolev, and Ulrike Meier Yang. 2011. Multigrid Smoothers for Ultraparallel Computing. SIAM Journal on Scientific Computing 33, 5 (Jan. 2011), 2864–2887. https://doi.org/10.1137/100798806

doi:10.1137/100798806 2011

[3] [2]

Baker, Axel Klawonn, Tzanio V

Allison H. Baker, Axel Klawonn, Tzanio V. Kolev, Martin Lanser, Oliver Rheinbach, and Ulrike Meier Yang. 2016. Scalability of Classical Algebraic Multigrid for Elasticity to Half a Million Parallel Tasks. In Software for Exascale Computing - SPPEXA 2013-2015, Hans-Joachim Bungartz, Philipp Neumann, and Wolfgang E. Nagel (Eds.). Springer International Publ...

work page 2016

[4] [3]

Baker, Tzanio V

Allison H. Baker, Tzanio V. Kolev, and Ulrike Meier Yang. 2010. Improving algebraic multigrid interpolation operators for linear elasticity problems. Numer. Linear Algebra Appl. 17, 2-3 (2010), 495–517. https://doi.org/10.1002/nla.688

doi:10.1002/nla.688 2010

[5] [4]

Nasim Bakir, Antoni Artinov, Andrey Gumenyuk, Marcel Bachmann, and Michael Rethmeier. 2018. Numerical Simulation on the Origin of Solidification Cracking in Laser Welded Thick-Walled Structures. Metals 8, 6 (2018), 406

work page 2018

[6] [5]

Satish Balay, Shrirang Abhyankar, Mark Adams, Jed Brown, Peter Brune, Kris Buschelman, Lisandro Dalcin, Alp Dener, Victor Eijkhout, William Gropp, et al

work page

[7] [6]

Wolfgang Banzhaf. 2001. Artificial Intelligence: Genetic Programming. Elsevier, 789–792. https://doi.org/10.1016/b0-08-043076-7/00557-x

work page doi:10.1016/b0-08-043076-7/00557-x 2001

[8] [7]

Tommaso Bevilacqua, Axel Klawonn, Martin Lanser, and Adam Wasiak. 2024. Monolithic overlapping Schwarz preconditioners for nonlinear finite element simulations of laser beam welding processes. arXiv preprint arXiv:2407.03230 (2024)

work page Pith review arXiv 2024