AMBER: Adaptive Mesh Generation by Iterative Mesh Resolution Prediction
Authors: Niklas Freymuth
Tobias Würth
Nicolas Schreiber
Balázs Gyenes
Andreas Boltres
Johannes Mitsch
Aleksandar Taranovic
Tai Hoang
Philipp Dahlinger
Philipp Becker
Luise Kärger
Gerhard Neumann
Venue: NeurIPS 2025 poster ()
Keywords: Mesh Generation
Graph Neural Networks
Learned Simulation
AI4Science
Primary area: machine_learning_for_sciences
TL;DR: We iteratively predict target resolutions on intermediate meshes to generate fine-grained adaptive meshes on novel geometries.

Abstract: The cost and accuracy of simulating complex physical systems using the Finite Element Method (FEM) scales with the resolution of the underlying mesh. Adaptive meshes improve computational efficiency by refining resolution in critical regions, but typically require task-specific heuristics or cumbersome manual design by a human expert. We propose Adaptive Meshing By Expert Reconstruction (AMBER), a supervised learning approach to mesh adaptation. Starting from a coarse mesh, AMBER iteratively predicts the sizing field, i.e., a function mapping from the geometry to the local element size of the target mesh, and uses this prediction to produce a new intermediate mesh using an out-of-the-box mesh generator. This process is enabled through a hierarchical graph neural network, and relies on data augmentation by automatically projecting expert labels onto AMBER-generated data during training. We evaluate AMBER on 2D and 3D datasets, including classical physics problems, mechanical components, and real-world industrial designs with human expert meshes. AMBER generalizes to unseen geometries and consistently outperforms multiple recent baselines, including ones using Graph and Convolutional Neural Networks, and Reinforcement Learning-based approaches.

AMBER: Adaptive Mesh Generation by
Iterative Mesh Resolution Prediction
Niklas Freymuth" !- Tobias Würth Nicolas Schreiber' Balazs Gyenes' Andreas Boltres'
Johannes Mitsch Aleksandar Taranovic' Tai Hoang' Philipp Dahlinger!
Philipp Becker Luise Kärger? Gerhard Neumann'
Autonomous Learning Robots, Karlsruhe Institute of Technology, Karlsruhe
Institute of Vehicle System Technology, Karlsruhe Institute of Technology, Karlsruhe SSAP SE
Abstract
The cost and accuracy of simulating complex physical systems using the Finite Element Method (FEM) scales with the resolution of the underlying mesh. Adaptive meshes improve computational efficiency by refining resolution in critical regions, but typically require task-specific heuristics cumbersome manual design by a human expert. We propose Adaptive Meshing By Expert Reconstruction (AMBER), supervised learning approach to mesh adaptation. Starting from coarse mesh AMBER iteratively predicts the sizing field, i..., a function mapping from the geometry the local element size of the target mesh, and uses this prediction produce a new intermediate mesh using an out-of-the- process is enabled through hierarchical graph neural network, and relies on data augmentation by automatically projecting expert labels onto AMMBRR-geneaaae data during training. We evaluate AMBER on 2D and 3D datasets, including classical physics problems, mechanical components, and real-world industrial designs with human expert meshes. AMBER generalizes to unseen geometries and consistently outperforms multiple recent baselines, including ones using Graph and Convolutional Neural Networks, and Reinforcement Learning-basee approaches.
mesh generator. This
Introduction
Physical simulations fundamental tool in wide range of science and engineering applications. As simulations become more complex, researchers and practitioners increasingly rely on numerical solutions intricate Partial Differential Equations (PDEs). The Finite Element Method (FEM) discretizes complex geometries into simpler mesh elements and solves the resulting system of linear equations [1-4]. The FEM is ubiquitous numerical engineering, finding application in fluid flow simulations [5], structural mechanics [6. 7], electromagneties [8]. and injection molding [9].
For such simulations, both the simulation cost and accuracy scale with mesh resolution. Therefore, adaptive meshing, which assigns more mesh elements to key regions of the geometry, is essential for efficient and accurate simulations [10, 11]. An example is structural analysis in the automotive industry [7], where FEM is used to model complex components under varying forces and stresses. seat crossmember, where finer mesh is required near bends and holes. Traditional Adaptive Mesh Refinement (AMR) techniques iteratively refine existing meshes using predefined heuristics based problem geometry and process conditions [12-14]. Similarly, Adaptive Mesh Generation (AMG) generates meshes from functions such as sizing fields, which define local element sizes on the geometry [15, 16]. However, both methods are still limited in efficiency and adaptability to new applications. As a result, adaptive meshing in practice requires
Figure 1 shows such component,
"correspondence to niklas. freymuthhkit.eedi
39th Conference on Neural Information Processing Systems (NcurIPS 2025).

---

Training Loop
Inference Loop
Replay Butter
MPN
Prediction
Meah Generator
MPN
Prodiction
Mesh Generator
Mr
Loss
M411
M
M
Label Projection
Projected Sizing Field
M
Mg
My
Figure 1: AMBER learns adaptive mesh generation on complex geometries for simulation applications from expert dataset. Left: During training, AMBER predicts sizing field, as indicated by the mesh's color, from labels projected from an expert mesh M AMBER continuously updates a replay buffer with newly generated meshes to preserve diverse and accurate training data distribution. Right: During inference, AMBER starts from an initial mesh Mo. predicts a sizing field per element, and feeds it into a mesh generator that refines the mesh using the underlying geometry Ω. This process is repeated until a final mesh Mr is produced. On the car seat crossmember shown above, AMBER learns that the expert assigns more mesh elements holes and sharp bends, which particularly interesting for strength and durability analyses.
significant manual input and domain expertise. Engineers often hand-tune local mesh resolutions for each new geometry or problem [15, 17, 18]. This repetitive and time-consuming process creates bottlenecks in applications like iterative design and process optimization.
To address this issue, we propose Adaptive Meshing By Expert Reconstruction (AMBER), a data- driven method for iterative AMG. AMBER employs Message Passing Network (MPN) [19, 20], a class of Graph Neural Networks (GNNs) [21], to predict target element sizes across a sequence of mesh refinement steps. Trained on small datasets, each consisting of roughly 20 geometries and corresponding expert meshes, AMBER learns underlying meshing strategies and tackles the core challenge of extreme local variation in element sizes. Unlike prior learned AMG approaches [22-24), AMBER iteratively generates meshes using each intermediate mesh's vertices as sampling points to predict the next target sizing field. This iterative scheme, together with the MPN, enables adaptation to non-uniform geometries, while simultancously adjusting local sampling resolution in response previous mesh generation steps. As result, AMBER is highly effective in adaptive meshing, where spatially varying target sizes necessitate correspondingly localized prediction densities.
Figure shows overview of our method. At inference time, AMBER starts from a coarse initial mesh and iteratively predicts sizing fields to feed into an out-of- box mesh generator [25], which generates an adapted mesh. During training, predicted sizing fields are supervised by projecting element sizes from expert meshes onto intermediate meshes. To address the distribution shift intro- duced by intermediate meshes during inference, we maintain a replay buffer populated with meshes generated by the model itself. This strategy echoes online imitation learning approaches such as DAg- ger [26], but replaces the human-in-the-lovw toopp with automatic data generation and labeling. In doing so, AMBER bootstraps [27] its own training distribution, implicitly performing data augmentation [28] by including meshes on different local scales, to stabilize learning and inference.
We evaluate our method on six novel datasets introduced in this work, covering a wide range of 2D and 3D geometries meshed by human experts and heuristics?. These geometries vary in difficulty and model diverse set of common engineering problems. We compare AMBER against supervised learning [22, 29, 30) and Reinforcement Learning (RL) [31] baselines. AMBER consistently produces higher-quality meshes than all baselines, both in terms of visual quality and quantitative metrics. We additionally explore the runtime of AMBER's components. We find that AMBER's cost is dominated by the final mesh generation step. which is required for all mesh generation methods, and that the full AMBER mesh generation process is faster and scales significantly better than classical iterative error estimation methods. Furthermore, we present extensive ablations to show the effects of individual design choices, such as loss, refinement steps, and sizing field parametrization.
2 Prroject page, code and datasets available at htttps:/nikkassfrerre www.eauttt..tttttteee .ithub..th...... 10/ AMBER.

---

To summarize our contributions, we (1) propose AMBER. a novel approach for Adaptive Mesh Generation (AMG) that produces a sequence of meshes, using each intermediate mesh to predict a target resolution for the next mesh, (2) introduce six new datasets spanning both 2D and 3D geometries, designed to reflect realistic and diverse problem settings; two of these include human- generated meshes, and (3) conduct extensive experiments demonstrating that AMBER produces significantly better meshes than state-of-the-art supervised and RL methods on these datasets.
2 Related Work
Meshing for Simulation. Modern meshing approaches either use Adaptive Mesh Refinement (AMR). which refines an existing mesh [10, 32], or Adaptive Mesh Generation (AMG), which generates a new mesh [33-36]. Typical AMR techniques rely on heuristies [12] or eπror estimates [13, 14], which can be inaccurate, unreliable, or computationally expensive [14, 37, 38). In contrast, Adaptive Mesh Generation (AMG) methods generate new meshes from geometric or solution-derived features over the domain, such as curvature or Hessian information, to prescribe local element size and potentially anisotropy [39, 40, 16). While effective in practice [33, 11], they share the shortcomings of AMR and also require task-specific metrics or a tediously hand-crafted target sizing field for each domain [41, 11]. In contrast, we aim to learn scalar sizing fields directly from expert meshes.
bearning-Based Mesh Generation. Existing learning based AMG approaches train surrogate models to either directly predict a sizing field or the local solution error, which is inverted to obtain a sizing field. One line of work encodes the domain using a simple, parameterized representation, which is fed to an Multilayer Perceptron (MLP) that either predicts coordinate-condiiionee conditioned outputs [29, 23]. similar to NeRFs [42], or computes the sizing field on a fixed background mesh [43, 44] or as a set of point sources [45]. Huang et al. [22] discretize the domain into resoluueolttiin image and process with a CNN to directly predict sizing field. More recent methods use a Graph Convolutional Network (GCN) to operate on the vertices of coarse mesh. Of these, GraphMesh [24] generalizes to arbitrary polygonal domains and improves over prior GCN-based models [46]. AMBER also predicts sizing field on a discrete mesh, but does so iteratively across sequence of intermediate meshes. This enables dynamic adaptation of the sizing field across scales, without being restricted to any specific domain representation or discretization, allowing it to produce higher quality meshes.
Learning- Based Mesh Refinement. Several recent AMR approaches employ learning for mesh refinement by subdivision, i.e., they train model to iteratively decide which mesh elements to divide into multiple smaller elements. In this class, supervised methods include learning refinement strategies with recurrent networks [47], optimizing element anisotropy based on error estimates [48] and using hand-crafted features to estimate error for adjoint-based refinement [49, 50). Alternatively, recent line of work applies RL to AMR by element subdivision [31, 51-53], employing carefully crafted reward functions to quantify the benefit of each refinement. These reward functions typically require an underlying system of equations and either restrict the maximum mesh resolution [53, 31] or encode a specific, heuristic refinement criterion [52]. Out of these methods, Adaptive Swarm Mesh Refinement (ASMR) [31, 51] proposes local, element-wiss rewards, improving scaling capability and mesh quality over previous work. AMBER further improves over ASMR's 's scalability and mesh quality, while avoiding the complicated reward design and the requirement for Finite Element Method (FEM) in the loop by using expert meshes. Another class of learning- carning-based based AMR methods employs mesh movement [11] for refinement [54-56]. These methods start with uniform mesh and deform its elements, requiring a fixed starting resolution. In contrast, AMBER learns to produce a sequence of sizing fields from coarse uniform mesh inducing meshes with different numbers of elements. Other mesh movement based methods focus on highly specific tasks, such as fluid dynamics (8), while AMBER is task agnostic.
Graph Network Simulators, GNNs [21]. particularly MPNs [19, 20], are widely popular for mesh- based surrogate simulation [20, 59-63]. MPNs encompass the function class of several classical PDE solvers [64], making them a popular choice for learning representations on meshes [20, 59, 65]. We similarly use MPNs on meshes, but do not learn simulator. Instead, we generate application-specifie adaptive meshes for efficient and robust FEM-based simulation.
Online Data Generation. Imitation learning approaches such as DAgger [26) address distribu- tion shift by iteratively querying expert feedback on model rollouts. Bootstrapping methods like pseudo-labeling [66] and Noisy Student [67] expand the training set using model-generrted labels.
3

---

Replay buffers [68-70] mitigate covariate shift by combining past and current experiences, while data augmentation [28. 71. 72] introduces synthetic variations enhance generalization. Unlike these approaches, AMBER stores model-generated meshes across resolutions in replay buffer and automatically projects labels onto them. This process effectively augments training data by provid- ing meshes of different resolutions, improving distributional robustness without requiring external supervision or expert relabeling.
Method
Our training datasets contain N tuples P. ))"); each consisting geometry 52 C IRd of dimension d, an optional set of process conditions P. and a corresponding expert mesh M Each geometry describes a closed physical body in 2D or 3D, which is discretized into simplical elements Mī on the subdomain S2 C S by the mesh. We aim to learn function that takes a geometry Q and process conditions from the dataset and generates a mesh M that minimizes distance metric d(M, M*) to the corresponding expert mesh M We make no further assumptions on the structure of the meshes, and use both heuristically refined and human- gennanegeeertedd meshes as expert data.
We factorize mesh generation into two parts. First, learnable function consumes geometry Q, process conditions P and derived features, and outputs a spatially-varyinng, ccalar-valued sizing field Ω - Rg Second, a non-parametric function frah (Ω x (Ω + R=o)) + M consumes geometry and sizing field and returns a mesh approximately conforming to this sizing field. The sizing field describes the desired average edge length of the generated mesh's elements over the domain. We consider isotropic meshes, i.e., meshes where the elements have a roughly equal aspect ratio. this case, the local sizing field is directly related to the desired volume of the resulting mesh elements.
Message Passing Network (MPN). We instantiate our backbone predict sizing fields using an MPN [19, 20J. An MPN iteratively updates the latent node and edge features over L message message-passing steps. We encode mesh vertices as nodes and their neighborhood relations as edges & V V of bidirectional graph Gn- G = (V. E). We assign process condition and domain- vertex features h2 and edge features h Using learned linear embeddings h. = h,M, and h h,M, of the initial node and edge features, each step 1 computes features
h h+1 h2 V (h', h/, hb),, with (u, v),,
h h¹, (h
h ".
<=(v,a)EE
The commutatiooninvariinn aggregation + can be realized via, e.g., sum, mean, maximum operator. All vi and vi are parameterized as learned MLPs. The output of the final layer is a learned representation h for each node v E V. We feed this representation into a decoder MLP to yield prediction xj- MPN(G, h., he); per node by V, which abbreviate as MPN(u;)-
Mesh Generation. We refer to the non-parametric function Jush as the mesh generator. creates mesh that matches the desired sizing field under several criteria the elements, such as their aspect ratio and size gradation. This results well-behaved elements and a smooth transition between element sizes. While differrntt mesh generators exist, we use the Frontal Delaunay algorithm implemented in GMSH [25] for simplicity.
3.1 Iterative Mesh Generation with AMBER
Predicting Sizing Field. Given geometry Ω and task-specific process conditions P, a coarse, uniform initial mesh is generated for the initial M with t = 0. This mesh is then encoded as a graph and processed using an MPN to predict the discrete sizing field f(1,) over mesh vertices ny, with f(;;) derived from the network's output z, through subsequent transformation.
We could alternatively predict sizing values per mesh element, yielding a piecewise constant sizing field. However, since the MPN operates on an intermediate mesh with a different topology from the target mesh, element-level predictions lack the granularity needed for effective refinement. Instead, AMBER predicts sizing field values over mesh vertices and applies the interpolant Inr (f) to yield sizing field that is piecewise linear. This interpolant weights the discrete sizing field at the vertices dj by the mesh's 's nodal basis functions Φ [3], yielding continuous sizing field. Given a point
R

---

we define the interpolant as
Σ f(55) f(1)),
if 94, M, E ((1s) for some j,
[x)()(z)
(I)
otherwise, where j' = arg min || p(1))l,
where p(ay) E TRd and W(xs)) c M are the position and element neighborhood of vertex Vij respectively. The fallback nearest-neighbor extrapolation ensures that the sizing field is defined across all of 22 including regions outside the discretized mesh domain.
Iterative Generation. At step I, the mesh generator consumes the continuous sizing field given by Im (f) and its underlying geometry Ω. Using the vertices of each mech the sampling points for the next continuous sizing field and repeating this process over 7 steps results in a final mesh MT. Intuitively, an accurately predicted intermediate sizing field results in mesh that is more similar to the expert mesh, and therefore provides better sampling points for the MPN to predict the next sizing field even more accurately. Compared one-step approaches that predict a sizing field on an image [22] or a single coarse mesh [24], AMBER therefore automatically adapts its sampling resolution, allowing it output arbitrarily complex and highly non-uniform meshes where required. We prove convergence of this process in the one-dimensional case under the assumption of perfect predictions in Appendix B. The right part of Figure 1 visualizes this process.
3.2 Training AMBER
Predictions and Targets. Let (MM) be the volume of the d-dimensional simplicial element Mj of the target mesh. We define the element-wiss sizing field as the average edge length of that element
(MM, = (V(M) vd+1 The union over the element's ' sizing fields induces a piecewise-constan
sizing field. To compute the target value yy of the discrete sizing field at vertex 2 of an intermediate mesh M we evaluate the sizing field of the expert mesh M at the vertex position p(.y). That is, we assign targets Y/j = fa(M)) where M E M and p(vz) E S a vertex lies outside the expert mesh due to, e.g., discretization of the domain, we project it to the nearest element. We could alternatively obtain target values by interpolating the expert sizing field using Equation However, as we show in experiments, due AMBER's iterative process, the local resolution of the expert mesh is sufficient to adequately represent the granularity of the solution everywhere.
We train a single shared MPN to regress the target sizing field of the current mesh generation step using simple Mean Squared Error (MSE) loss. Since sizing fields are strictly positive, we add a softplus transformation to the network's 's output. To increase the weight of numerically smaller elements in the loss function, we optimize in the untransformed space. Thus, given prediction ar = (P,();), our loss becomes
L Σ
(x softplus -1 (y;))²
We then recover the discrete predicted sizing field as f(v;) softplus(x,).
Replay Buffer, During inference, AMBER auto-regressively produces a series of intermediate meshes M.. The initial mesh M is coarse and uniform. However, the corresponding expert mesh M is generally finer and has highly varied topology. To prevent a distribution shift between the training data and the data seen during inference, therefore maintain a replay buffer [68, 70] of bootstrapped data containing intermediate meshes that AMBER generates during training. The replay buffer is initialized with one uniform coarse mesh per expert mesh. After each training epoch, we sample meshes from the replay buffer for producing new intermediate meshes. For each, we predict a discrete sizing field, generate new mesh from the induced continuous sizing field, annotate the vertices with a target sizing field using the expert mesh and store this new labeled mesh in the buffer. The full training pipeline shown on the left of Figure
AMBER
3.3 Empirical Improvements
Inspired by common best practices, we propose several algorithmic optimizations to further improve AMBER's applicability and efficiency.
5

---

(a) Poisson
(b) Laplace
(c) Airfoil
(d) Console
(c) Mold
(f) Beam
Figure 2: Exemplary AMBER meshes for each dataset. The color represents the local element size, with smaller elements being red. We propose six novel and challenging datasets for mesh generation. (a) Poisson uses L-shaped domain with multimodal load function.
(b) Laplace features (c) Airfoil includes geometries representative of aerodynamic flow setups. (d) Console consists of 3D car seat crossmembers. (c) Mold includes complex 3D plates used injection molding contexts. (f)eaam covers elongated, perforated beams inducing long-range mesh dependencies.
parameterized 2D lattices with complex Dirichlet boundaries.
Uniform Refinement Depth. During training, assign each intermediate mesh depth that corresponds to the number of refinement steps it has undergone from the initial uniform mesh. To reduce distribution shift between inference and training, we enforce uniform distribution over mesh depths in the replay buffer. When generating new intermediate meshes, we first uniformly sample target depth and then mesh with the corresponding depth. We the maximum depth the number of refinement steps used during evaluation, T.
ddptiiv Batch Size. Since the meshes in the replay buffer vary greatly in size, using fixed number of meshes per batch would sometimes lead to out cat-offmemory errors, or otherwise leave significant available memory unused. Instead, set maximum total size over all graphs in batch, and greedily fill a batch with the least-sampled meshes until is reached. We define the size graph as the sum of its number of nodes and edges (G) [V] + |
Hierarchical Architecture. The receptive field of an MPN is determined by the number message passing steps. As a mesh undergoes iterative refinement, the receptive field can vary significantly across the domain. This makes it challenging to choose appropriate hyperparameters and hinders long-range communication between regions of the graph during the later refinement steps. To ensure consistent, resolution-invarian
receptive field, we employ a hierarchical graph structure that combines the graph G (v*, Ed) corresponding the initial coarse mesh M with that of the current interme- diate mesh M for all 0. The hierarchical graph is defined as Gaier = (v"0 U VA g U U U geros) where geros = {e, π (w)), (T(v), v) E V*} contains bidirectional edges between each interme- diate vertex v E yd and its closest vertex in the coarse mesh π (v) = arg min,e vo [|p(v) - p(u)]|2 We provide binary node feature indicating the current mesh M and mask all node-level features of the initial mesh, using solely to provide consistent topological connectivity.
Input/Output Normalization. We normalize all network inputs. i.c., all node and edge features, to have zero mean and unit variance. The labels are normalized similarly, and the inverse normalization is applied to map predictions back to the original scale. Since the data distribution evolves as new meshes are added to the replay buffer, we maintain running statistics for each input and target feature.
Residual Prediction. We improve training stability by predicting the residual between the target sizing field y = fo (M,) and the current discrete sizing field neighborhood (Nxs)) ) of vertex and element-based sizing fields fe (M;;, we compute the current discrete sizing field by at vy from the current mesh the convex combination
f(U)). Given the element
V(M.) M.N((1,)) EMEN( V(M,) V(M. fe(M.).
b, = f(v))
Σ
We now recover the predicted sizing fields by f(v;) = softplus(ar, + softplus (oppllus-((bb))))) (bb)), and adapt the loss in Equation 2 accordingly.

---

Poisson (easy)
Poisson (medium)
Poisson (hard)
AMBER
0.6
AMBER (1-Step)
0.5
Image (Var.)
0.4
GraphMesh (Var.)
0.3
Image [22]
GraphMesh [24]
0.2
Laplace
Airfoil
Beam
Console
Mold
0.35
0.2
0.6
0.4
DCD
0.3
0.2
0.15
0.55
0.35
0.25
0.2
0.1
0.1
0.5
Figure 3: Mean and two times standard error of expert mesh similarity evaluated by Density-Aware Chamfer Distance (DCD) (lower is better). AMBER achieves the best results across all datasets, demonstrating its ability to generate highly accurate meshes on diverse and challenging domains. All methods perform well on Poisson (easy). As task complexity increases, the baselines and eventually variants become less reliable. AMBER (I-Step) remains strong across tasks, while the full model achieves further improvements through iterative refinement.
Scaling Sizing Fields. We can scale the resolution of generated meshes by introducing a simple refinement constant e depending on the generation step f, such that the next generated mesh M Inea (2,, cr (z)). While the predicted intermediate meshes allow AMBER to adaptively refine its sampling resolution, reaching the full resolution of the expert mesh is unnecessary and computationally expensive. To mitigate this, we set c,>1 for / < T to coarsen intermediate meshes, starting at the first step 1=0. Here, setting exponentially decaying reduces the number of elements for intermediate meshes without reducing the accuracy of the final mesh M Additionally, during inference, we can also set CT-1 <1 to generate meshes that have higher resolution than the expert. This adaptation allows the model to flexibly adapt to given element budget without retraining, which enables zero-shot generalization through a single scalar parameter.
4 Experiments
Datasets and Features. We introduce six novel datasets representing realistic FEM problems that need adaptive meshing to meet common efficiency and accuracy requirements. The datasets span 2D and 3D domains, as well as diverse applications in physics-based simulation, structural mechanics, and industrial design. Depending on the dataset, we generate geometries procedurally, or source them from openly available custom datasets. For datasets without concrete underlying system of equations, we generate meshes from human experts and manually designed, specialized heuristics. Other datasets consider concrete problem, where employ iterative refinement heuristic that utilizes a FEM eтror indicator. Using this heuristic, we create easy, medium, and hard variants of the Poisson dataset to provide expert meshes different scales. Here, more refinement steps results in an expert mesh with more elements and larger difference between the largest and smallest elements increases, making the dataset more challenging. Figure illustrates representative AMBER meshes from the test set of each dataset. Across datasets, mesh resolution ranges from 1 042 to 65 191 elements.
Appendix D provides training details for AMBER and Appendix E details the mesh generation process. We derive dataset-specific features function of the process conditions P for Poisson, Laplace and Mold, as detailed in Appendix C. The Poisson and Laplace datasets use a FEM solver in the loop for expert mesh generation via an iterative refinement heuristic. For these datasets, we therefore provide FEM solutions as a vertex-level input feature for each mesh. For all datasets, we add several geometric features, detailed in Appendix D.3.
Evaluation. We evaluate the generated meshes by comparing their local resolution to that of an unseen expert reference mesh on the same geometry and process conditions, using five random seeds per experiment. First, we use the Density-Aware Chamfer Distance (DCD) [73] over both mesh's vertices. The DCD is symmetric, exponentiated variant of the Chamfer distance that allows multiple
7

---

points in one set to match a single point in the other. Semantically, it treats both vertex sets as samples from an unknown density. Second, we compute symmetric relative projected L error between the sizing fields induced by the evaluated and expert meshes. In contrast to the DCD, this metric captures discrepancies in local element sizes. The combination of these two metries with different semantic interpretations is robust against potential artifacts in the generated meshes. Finally, we evaluate downstream simulation quality versus number of mesh elements for the Poisson task by using the norm of the error indicator of Equation 10. Appendix F details all metrics.
Baselines and Variants. We compare to GraphMesh [24], which is based on a two-step GCN. GraphMesh relies on mean value coordinates [74] and is limited to polygonal domains, only allowing us to evaluate it on the Poisson dataset. Image [22] predicts either pixel- or voxel-wise sizing fields from binary geometry masks of discretized domain using a 2D or 3D Convolutional Neural Network (CNN), respectively. We adapt both baselines to use softplus-transformer predictions. This transformation is omitted in the original works, which focus on relatively simple problems where training instabilities are less pronounced. Without it, models tend to diverge, producing overly fine meshes. To disentangle training and algorithmic design, we additionally introduce Variants of each baseline that incorporate our loss (Equation 2) and normalization. Additionally, we compare against AMBER (I-Step). This variant runs single AMBER generation step by setting T= which demonstrates the benefit of iterative mesh generation.
We compare against Adaptive Swarm Mesh Refinement (ASMR) [51] as an RL baseline. ASMR learns a policy iteratively mark elements for AMR, optimizing a reward function tied to the improvement of a specific FEM solution. This reward requires fine-graines uniform reference mesh to compare to, whose resolution bounds the maximum number of refinements. In Appendix H.9, we also explore a variant that omits the reference mesh in favor of using the error indicator from Equation 10. This modification enables deeper refinement and mesh resolutions comparable to those of the expert. We evaluate ASMR the Poisson task. Appendix G details all baselines and variants.
Runtime and Cross-Datasel Generalization. We measure the runtime of AMBER and its individual components for Poisson (easy/hard) and compare it to the expert heuristic used to generate the data. We additionally explore AMBER's ability to generalize across datasets by training single model on joint data of Poisson (hard), Laplace and Airfoil. We concatenate the 20 expert meshes per task into 60 total training meshes, using shared replay buffer for the data. We one-hot encode the task in the node features, and zero out task-specific features when unavailable. We do not change any other training or inference hyperparameters. We call this variant AMBER (Mixed).
Additional Experiments. For AMBER, we explore the loss in Equation 2 and the components from Section 3.3. We also vary training data size and test alternative sizing field parameterizations for f. For the Image (Variant) bascline, we explore lower input resolutions and versions that omit either the loss or input/output normalization. Appendix H provides additional details.
5 Results
Quantitative Results. Figure 3 evaluates Density-Aware Chamfer Distance (DCD) over vertex sets to the expert mesh across datasets. On Poisson (easy), all methods perform well. As complexity increases for, e.g., Poisson (mediun//hard), our training procedure shows more significant benefits, causing both variants to significantly outperform their published baselines. Across datasets, the AMBER (1 (1-Step) produces accurate sizing field predictions and high-quality meshes closely matching the expert. It also generalizes to 3D, where the Image methods struggle. AMBER further improves mesh quality, likely due to its iterative mesh generation. Here, multiple generation steps allow the intermediate meshes, which govern the prediction resolution, to adapt dynamically to the underlying geometry, improving mesh quality in complex regions. Appendix H.1 shows consistent trends using a symmetric L' error, supporting AMBER's s ability to generate high-quality meshes. Appendix H.2 matches these results on Poisson (hard) and Laplace for the norm of the error indicator of Equa- tion 10, which requires a concrete system of equations to evaluate. This strong correlation between the error indicator and DCD across methods supports the use of DCD a reliable proxy on datasets where downstream simulation error is not directly available.
Figure 4 compares AMBER, ASMR, and the expert meshes using the per-mesh norm of the same indicator for Poisson (easylmediumhhart). We obtain Pareto fronts by varying ASMR's element penalty and scaling AMBER's predicted sizing field at inference between 0.5 and 2.0. All methods
8

---

Em.. Indicator Norm
0.3
0.2
Method:
AMBER
0.1
ASMR
Expert
Difficulty:
easy
300
000
10000
30 000
100 000
medium
Number of Elements
hand
Figure 4: Log-log plot of emror indicator norm versus number of mesh elements (lower left is better) for AMBER, ASMR and the expert across Poisson (easy, medium, hard). Each marker shows the mean over the test set for given seed. AMBER and ASMR evaluations final predicted sizing field and tuning the element penalty, respectively. AMBER closely matches or exceeds expert performance in terms of indicator error, and generalizes meshes that are more than 3x finer, maintaining the expected error-element trend beyond 100 000 elements.
obtained by scaling the
Table I: Generalization across datasets. Comparison between AMBER trained individually per dataset and AMBER (Mixed) trained jointly on all datasets. The mixed model achieves nearly identical performance, indicating strong generalization and potential for multi-task learned mesh generation.
Method
Poisson (hard)
Laplace
Airfoil
AMBER
0.224 + 0.004
0.222 0.003
0.103 + 0.002
AMBER (Mixed)
0.226 + 0.011
0.222 + 0.005
0.102 + 0.002
follow the expected log-log error-element trend [75]. Markers show test-set averages per target resolution and random seed. ASMR exhibits high variance across seeds and degrades beyond ~30 000 elements due to fixed-depth reference mesh. In contrast, AMBER closely matches and slightly surpasses expert performance on fine meshes, likely due to smoother mesh generation. It also generalizes 100 000 elements, even though the largest expert mesh has only 31 510 elements. This generalization only requires adjusting a single scalar, enabling zero-shot, budget-aware mesh generation without retraining.
Runtime and Cross-Dataset Generalization. Appendix H.3 compares AMBER's runtime with that of the expert heuristic used generate Poisson data. For the same number of elements, both methods achieve similar error indicator norm. Yet AMBER is significantly faster on finer meshes, outperforming the iterative expert heuristic by than 30 000 elements. We additionally find in Table 6 that AMBER's runtime is dominated by its last mesh generation step, which is needed for any mesh generation method.
than order of magnitude on meshes with more
Table explores AMBER's s ability to train on multiple datasets at the same time. AMBER (Mixed) shows the approximately equal performance AMBER all considered tasks, opening up interesting avenues for multi-task and general-purpose purpose learned mesh generation algorithms in future work.
Qualitative Results. Figure 2 shows final AMBER mesh dataset and Figure 5 shows close-up of generated meshes for different supervised methods on Console. Both figures show that AMBER produces accurate sizing fields on diverse domains and geometries and produces high-quality meshes, closely resembling the expert. In contrast, the Image baselines only learn general, low- cow-frequency features of the expert's 's sizing field, but fail to capture finer details. The result is comparatively more uniform, less adaptive mesh. Figure 6 provides a full AMBER rollout on Console, showcasing the iterative generation process. In each step, AMBER consumes the previous mesh using it to predict an increasingly accurate sizing field. We provide further visualizations for AMBER rollouts and generated meshes for all baselines in Appendix I.
Additional Experiments. Appendix H.4 validates the algorithmic improvements from Section 3.3. In particular, the hierarchical architecture, the loss and normalization are critical for performance. Appendix H.5 finds piecewise-lines sizing fields work better than piecewise-conste ones. Ap- pendix H.6 shows that AMBER benefits modestly from additional data, and generalizes well from

---

Expert
AMBER
AMBER (I-Step) Image (Variant)
Image
Figure 5: Full views and clsse-uss generated Mold test meshes. The element size is denoted by color, with red indicating small elements. AMBER closely matches the expert mesh, producing finer elements near the hole and coarser elements near the mesh's 's border. In comparison, the Image baselines have less variation in the element size, matching the expert less closely.
t=0
t=1
t=2
t=3
Expert
Full View
Figure 6: Close-ups of intermediate and final AMBER meshes Mold, contrasted with the expert mesh. The color for intermediate meshes denotes the predicted sizing field (red is small), which is given mesh generator to produce the next mesh. The final mesh's 's color denotes its element size.
only five training samples on several datasets. This data-efficiency likely stems from AMBER's Fuclidean-invariant MPN architecture and implicit data augmentation. We find in Appendix H.7 that AMBER improves for more mesh generation steps, converging at around three steps. Appendix H.8 explores different configurations loss function, and normalization. Finally, Appendix H.9 introduces an ASMR variant with the error indicator as reward. While this version avoids ASMR's degradation on fine meshes, it performs worse overall, likely due to weaker reward signal.
Image (Variant), showing the importance of image resolution.
6 Conclusion
We introduce AMBER, a novel method for iterative Adaptive Mesh Generation (AMG) that combines replay buffer of bootstrapped data with Message Passing Graph Neural Networks operating intermediate meshes. At each step, AMBER consumes the current mesh to predict a target resolu- tion for the next one, allowing fine-grained adaptation complex geometries. AMBER generates high-quality adaptive meshes across six novel datasets spanning diverse and realistic 2D and 3D) geometries, consistently outperforming supervised and reinforcement learning baselines. These results demonstrate the effectiveness of learning-basse approaches in reducing manual meshing effort, contributing toward more efficient and scalable simulation workflows in engineering applications. Appendix A discusses the broader impact of our work.
Linitations and Future Work. AMBER predicts scalar- valued, piecewise-liness linear sizing fields, which limits expressiveness in scenarios requiring extreme variation local mesh density, or anisotropic refinement. Predicting tensor-valued sizing fields using higher-order polynomials is promising direction for future work. Furthermore, our experiments indicate that the same model can be trained different datasets, showing that there potential to train seneral-purpose model across vast amount of datasets. Lastly, assessing the performance of AMBER directly through simulation error metrics on real-world scenarios is an interesting avenue for future research.
10

---

Acknowledgements
This work is part the DFG AI Resarch Unit 5339 regarding the combination of physics-based simulation with Al-based methodologies for the fast maturation of manufacturing processes. The financial support by German Research Foundation (DFG, Deutsche Forschungsgemeinsccalle is gratefully acknowledged. This work is additionally funded by the German Research Foundation (DFG, German Research Foundation) SFB-1574 471687386. The authors acknowledge support by the state of Baden- Württemberg through bwHPC, as well as the HoreKa supercomputer funded by the Ministry of Science, Research and the Arts Baden-Württemberr and by the German Federal Ministry of Education and Research.
References
[1] Susanne C Brenner and L Ridgway Scott. The mathematical theory of finite element methods, volume 3. Springer, 2008
[2] Junuthula Narasimha Reddy, Introduction to the finite element method. McGraw- Education, 2019.
[3] Mats G. Larson and Fredrik Bengzon. The Finite Element Method: Theory, Implemen- tation, and Applications, volume 10 of Texts in Computational Science and Engineering. Springer, Berlin, Heidelberg, 2013. ISBN 978-3-642-33286-9 978-3-642-33287--6 doi: 1110077977-3-662-33225
[4] Wing Kam Liu, Shaofan Li, and Harold S Park. Eighty years of the finite element method: Birth, evolution, and future. Archives of Computational Methods in Engineering, pages 1-23, 2022.
[5] Jerome J Connor and Carlos Alberto Brebbia. Finite element techniques for fluid flow. Newnes, 2013.
[6] Thomas JR Hughes. The finite element method: linear static and dynamic finite element analysis. Courier Corporation, 2003.
[7] S Abdullah, NA Al-Asady, AK Ariffin, and MM Rahman. A review on finite element analysis approaches in durability assessment of automotive components. Journal of Applied Sciences, (12):2122-2001 2008.
[8] Jian-Ming Jin. The finite element method in electromagnetics. John Wiley & Sons, 2015.
[9] Markus Baum, Denis Anders, and Tamara Reinicke, Approaches for numerical modeling and simulation of the filling phase in injection molding: A review. Polymers, 15(21):4220, 2023.
[10] Tomasz Plewa, Timur Linde, V Gregory Weirs, al. Adaptive mesh refinement-therry and applications. Springer, 2005.
[11] Weizhang Huang and Robert D Russell. Adaptive moving mesh methods, volume 174. Springer Science & Business Media, 2010.
[12] Olgierd Cecil Zienkiewicz and Jian Zhong Zhu. The superconvergent patch recovery and posteriori error estimates. part 1: The recovery technique. International Journal for Numerical Methods in Engineering, 33(7):1333 (3()):1331-1364 1992.
[13] Marian Nemec, Michael Aftosmis, and Mathias Wintzer. Adjoint-based adaptive mesh refine- ment for complex geometries. 46th AIAA Aerospace Sciences Meeting and Exhibit, page 725, 2008.
[14] Wolfgang Bangerth and Rolf Rannacher. Adaptive Finite Element Methods for Differential Equations. Birkhäuser, 2013.
[15] Daniel SH Lo. Finite element mesh generation. CRC press, 2014.
[16] David Mareum and Frédéric Alauzet. Aligned metrie-based anisotropic solution adaptive mesh generation. Procedia Engineering, 13:2284444 2014.

---

[17] Kenji Shimada. Current trends and issues in automatic mesh generation. Computer-Aided Design and Applications, 3(6):741-750, 2006.
[18] Timothy J Baker. Mesh generation: Art or science? Progress in aerospace sciences, 41(1): 29 63, 2005.
[19] Justin Gilmer, Samuel S. Schoenholz, Patrick F. Riley, Oriol Vinyals, and George E. Dahl. Neural message passing for quantum chemistry. Proceedings of the 34th International Conference on Machine Learning (ICML), 70: 10:2263-127,, 06- 11 Aug 2017. URL https::////oooo https://proceedings
mlr.preee w.t.preess/v00 http///////mmmmmmee gilmer 17a. html.
[20] Tobias Pfaff, Meire Fortunato, Alvaro Sanchez-Gonzalez, and Peter W. Battaglia. Learning mesh-based simulation with graph networks. International Conference on Learning Representa- lions (ICLR), 2021.
[21] Michael M. Bronstein, Joan Bruna, Taco Cohen, and Petar Velickovic. Geometric deep learning: Grids, groups, graphs, geodesics, and gauges. CoRR, abs/2104. 13478, 2021.
[22] Keefe Huang, Moritz Krügener, Alistair Brown, Friedrich Menhorn, Hans-Joachim Bungartz. and Dirk Hartmann. Machine learning-based optimal mesh generation in computational fluid dynamics. arXiv preprint arXiv:2 12923, 2021.
[23] Zheyan Zhang, Peter K. Jimack, and He Wang. MeshingNet3D: Efficient generation of adapted tetrahedral meshes for computational mechanics. Advances Engineering Software, 157-158: 103021, 2021. ISSN 0965-9978. doi: 10.
[24] Ainulla Khan, Moyuru Yamada, Abhishek Chikane, and Manohar Kaul. GraphMesh: Geomet- rically generalized mesh refinement using gnns. International Conference on Computational Science, pages 120-133 134, 2024.
[25] Christophe Geuzaine and Jean- Jean- François Remacle. Gmsh: A 3-d finite element mesh generator with built-in pre-and post-procsssing facilities. International Journal for Numerical Methods in Engineering, 79(1 11:11399-11333 1331, 2009.
[26] Stephane Ross, Geoffrey Gordon, and Drew Bagnell. A reduction of imitation learning and structured prediction to no-regret online learning. Proceedings of the Fourteenth International Conference on Artificial Intelligence and Statistics (AISTATS), 15:627 635, 11-13 Apr 2011. URL
mlr. www.tpresssvve wttps//////rossssaa/ea
[27] Anthony Christopher Davison and David Victor Hinkley, Bootstrap methods and their applica- tion. Cambridge university press, 1997.
[28] Connor Shorten and Taghi Khoshgoftaar, A survey on image data augmentation for deep learning. Journal of Big Data, 6(1): 48, 2019.
[29] Zheyan Zhang, Yongxing Wang, Peter Jimack, and He Wang. Meshingnet: A new mesh generation method based on deep learning. Computational Science ICCS 2020: 20th Inter- national Conference, Amsterdam, The Netherlands, June 3-5, 2020, Proceedings, Part III 20, pages 186-198, 2020.
[30] Callum Lock, Oubay Hassan, Ruben Sevilla, and Jason Jones. Predicting the Near- Optt-ml Mesh Spacing for Simulation Using Machine Learning. In Eloi Ruiz-Gironés, Rubén Sevilla, and David Moxey, editors, SIAM International Meshing Roundiable 2023, volume 147, pages 115-136. Springer Nature Switzerland, Cham, 2024. ISBN 40594-5. doi: 000000099777--01140599900
978-3-031-
[31] Niklas Freymuth, Philipp Dahlinger, Tobias Würth, Simon Reisch, Luise Kärger, and Gerhard Neumann. Swarm reinforcement learning for adaptive mesh refinement. Advances in Neural Information Processing Systems (NeurIPS), 36, 2023.
[32] Krzysztof J Fidkowski and David Darmofal. Review of output-based error estimation and mesh adaptation in computational fluid dynamics. AIAA journal, 49(4):673-69) 2011.
12

---

[33] Pascal Jean Frey and Paul-Louis George. Mesh generation: application to finite elements. Iste, 2007. doi: 10.1002/97804706111
[34] Masayuki Yano and David L Darmofal. An optimization- framework for anisotropic simplex mesh adaptation. Journal of Computational Physics, 23 (212);77666666,, 2012.
[35] J-F Remacle, François Henrotte, T Barrier-Baudouin, Eric Béchet, E. Marchandise, Christophe Geuzaine, and Thibaud Mouton. A frontal delaunay quad mesh generator using the I-infinity norm. International Journal for Numerical Methods in Engineering, 94(5):994-522 2013.
[36] Hang Si. Adaptive tetrahedral mesh generation by constrained delaunay refinement. Interna- tional Journal for Numerical Methods in Engineering, 75(7):856- 8808,6666880000 2008.
[37] Jakub Cerveny, Veselin Dobrev, and Tzanio Kolev. Nonconforming mesh refinement for high-order finite elements. SIAM Journal on Scientific Computing. 41(4):C377-C392 2019.
[38] Joseph Gregory Wallwork. Mesh adaptation and adjoint methods for finte element coastal ocean modelling. PhD thesis, Imperial College London, 2021.
[39] Houman Borouchaki, Frederic Hecht, and Pascal J Frey. Mesh gradation control. International Journal for Numerical Methods in Engineering, 43(6):1 143-1165, 1998.
[40] Eduardo F D' Azevedo and R Bruce Simpson. On optimal triangular meshes for minimizing the gradient error. Numerische Mathematik, 59(1):321-348 1991.
[41] Adrien Loseille and Frédéric Alauzet. Continuous mesh framework part I: well-posed continuous interpolation error. SIAM Journal on Numerical Analysis, 49(1):38 60, 2011.
[42] Ben Mildenhall, Pratul Srinivasan, Matthew Taneik, Jonathan T Barron, Ravi Ramamoorthi, and Ren Ng. NeRF: Representing scenes as neural radiance fields for view synthesis. European Conference on Computer Vision (ECCV), pages 405-422 2020.
[43] Callum Lock, Oubay Hassan, Ruben Sevilla, and Jason Jones. Predicting the near-optimal mesh spacing for a simulation using machine learning. International Meshing Roundtable, pages 115-136, 2023.
[44] Sergi Sanchez- Sanchez-Gamero, Oubay Hassan, and Ruben Sevilla. machine learning approach to predict near-optimal meshes for turbulent compressible flow simulations. International Journal of Computational Fluid Dynamics, 38(2-3):211225, 2024.
[45] Callum Lock, Oubay Hassan, Ruben Sevilla, and Jason Jones. Meshing using neural networks for improving the efficiency of computer modelling. Engineering with Computers, 39(6): 3791-3820, 2023.
[46] Minseong Kim, Jaeseung Lee, and Jibum Kim. GMR-Net: GCN-based mesh refinement framework for elliptic PDE problems. Engineering with Computers, 395533371-33737, 2023.
[47] Jan Bohn and Michael Feischl. Recurrent neural networks optimal mesh refinement strategies. Computers & Mathematics with Applications, 97:61-76, 2021.
[48] Krzysztof J Fidkowski and Guodong Chen. Metric-based, goal-oriented mesh adaptation using machine learning. Journal of Computational Physics, 426: 109957, 2021.
[49] Julian Roth, Max Schröder, and Thomas Wick. Neural network guided adjoint computations in dual weighted residual error estimation. SN Applied Sciences, 4(2):62, 2022.
[50] Joseph Gregory Wallwork, Jingyi Lu, Mingrui Zhang, and Matthew D Piggott. E2N: Error estimation networks for goal-oriented mesh adaptation. arXiv preprint arXiv.2207.1133. 2022.
[51] Niklas Freymuth, Philipp Dahlinger, Tobias Würth, Simon Reisch, Luise Kärger, and Gerhard Neumann. Adaptive swarm mesh refinement using deep reinforcement learning with local rewards. arXiv preprint arXiv:2406.00 08040, 2024.
[52] Corbin Foucart, Aaron Charous, and Pierre FJ Lermusiaux. Deep reinforcement learning for adaptive mesh refinement. Journal of Computational Physics, 491:112381, 2023.
13

---

[53] Jiachen Yang, Tarik Dzanic, Brenden K Petersen, Jun Kudo, Ketan Mittal, Vladimir Tomov, Sean-Sylvain Camier, Tuo Zhao, Hongyuan Zha, Tzanio Kolev, Robert Anderson, and Daniel Faissol. Reinforcement learning for adaptive mesh refinement. International Conference on Artificial Intelligence and Statistics (AISTATS), 2023.
[54] Wenbin Song, Mingrui Zhang, Joseph G Wallwork, Junpeng Gao, Zheng Tian, Fanglei Sun, Matthew Piggott, Junqing Chen, Zuoqiang Shi, Xiang Chen, et al. M2N: Mesh movement networks for pde solvers. Advances in Neural Information Processing Systems (NeurIPS), 35: 7199-7210, 2022.
[55] Peiyan Hu, Yue Wang, and Zhi-Ming Ma. Better neural PDE solvers through data-free mesh movers. The Twelfth International Conference on Learning Representations (ICLR), 2024.
[56] Mingrui Zhang, Chunyang Wang. Stephan Kramer, Joseph G Wallwork, Siyi Li, Jiancheng Liu, Xiang Chen, and Matthew D Piggott. UM2N: Towards universal mesh movement networks. arXiv e-prints, pages arXiv-2407, 2024.
[57] Jian Yu, Hongqiang Lyu, Ran Xu, Wenxuan Ouyang, and Xuejun Liu. Flow2Mesh: A flow- guided data-driven mesh adaptation framework. Physics of Fluids, 36(3), 2024.
[58] YU Jian, LYU Hongqiang, XU Ran, LIU Xuejun, al. Para2Mesh: A dual diffusion framework for moving mesh adaptation. Chinese Journal of Aeronautics, page 103441, 2025.
[59] Jonas Linkerhägner, Niklas Freymuth, Paul Maria Scheikl, Franziska Ullrich and Gerhard Neumann. Grounding graph network simulators using physical sensor observations. The Eleventh International Conference on Learning Representations (ICLR), 2023.
[60] Kelsey R Allen, Tatiana Lopez Guevara, Yulia Rubanova, Kimberly Stachenfeld, Alvaro Sanzaez-Gonzalez, Peter Battaglia, and Tobias Pfaff. Graph network simulators can learn discontinuous, rigid contact dynamics. Conference on Robot Learning (CoRL), 2022.
[61] Kelsey R Allen, Yulia Rubanova, Tatiana Lopez-Guevare William F Whitney, Alvaro Sanchez- Gonzalez, Peter Battaglia, and Tobias Pfaff. Learning rigid dynamics with face interaction graph networks. International Conference on Learning Representations (ICLR), 2023.
[62] Tatiana Lopez-Guevart Yulia Rubanova, William F Whitney, Tobias Pfaff, Kimberly Stachen- feld, and Kelsey R Allen. Scaling face interaction graph networks to real world scenes, arXiv preprint arXiv:2401. 11985, 2024.
[63] Tai Hoang, Huy Le, Philipp Becker, Vien Anh Ngo, and Gerhard Neumann. Geometry-aware RL for manipulation of varying shapes and deformable objects. International Conference on Learning Representations (ICLR), 2025.
[64] Johannes Brandstetter, Daniel E Worrall, and Max Welling. Message passing neural PDE solvers. International Conference on Learning Representations (ICLR), 2022.
[65] Tobias Würth, Niklas Freymuth, Clemens Zimmerling, Gerhard Neumann, and Luise Kärger. Physics-informed meshgraphnets (PI-MGNs): Neural finite element solvers for stationaay and nonlinear simulations on arbitrary meshes. Computer Methods in Applied Mechanics and Engineering, 129:117102, 2024.
[66] Dong- Hyun Lee et al. Pseudo-label: The simple and efficient sumi-super learning method for deep neural networks. In Workshop on challenges in representation learning, ICML, volume 3, page 896. Atlanta, 2013.
[67] Qizhe Xie, Minh-Thang Luong, Eduard Hovy, and Quoe V Le. Self-training with noisy student improves imagenet classification. In Proceedings of the IEEE/CVF conference on computer vision and patlern recognition, pages 10687-10698, 2020.
[68] Jong- Lin. Self-improving reactive agents based on reinforcement learning, planning and 1992.
teaching. Machine Learning,
[69] Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A Rusu, Joel Veness, Marc G Bellemare, Alex Graves, Martin Riedmiller, Andreas K Fidjeland, Georg Ostrovski, et al. Human-level control through deep reinforcement learning, nature, 518(7540):599-53,, 2015.
14

---

[70] William Fedus, Prajit Ramachandran, Rishabh Agarwal, Yoshua Bengio, Hugo Larochelle, Mark Rowland, and Will Dabney. Revisiting fundamentals of experience replay. International Conference Machine Learning (ICML), pages 3061-3071, 2020.
[71] Hongyi Zhang, Moustapha Cisse, Yann N Dauphin, and David Lopez-Paz. mixup: Beyond empirical risk minimization. In International Conference on Learning Representations, 2018.
[72] Josh Tobin, Rachel Fong, Alex Ray, Jonas Schneider, Wojeiech Zaremba, and Pieter Abbeel. Domain randomization for transferring deep neural networks from simulation to the real world. In 2017 IEEE/RSJ international conference intelligent robots and systems (IROS), pages 23-30. IEEE, 2017.
[73] Tong Wu, Liang Pan, Junzhe Zhang, Tai Wang, Ziwei Liu, and Dahua Lin. Density-aware chamfer distance as a comprehensive metric for point cloud completion. Proceedings of the 35th International Conference Neural Information Processing Systems (NeurIPS), 2021.
[74] Michael S Floater. Mean value coordinates. Computer Aided Geometric Design, 20(1):19-27. 2003.
[75] Willy Dörfler. A convergent adaptive algorithm for poisson's equation. SIAM Journal on Numerical Analysis, 33(3): 106-1124, 1996.
[76] Tom Gustafsson and Geordie Drummond Mcbain. scikit-fem: A python package for finite element assembly. Journal of Open Source Software, 5(52):2369, 2020.
[77] Peter Binev, Wolfgang Dahmen, and Ron Vere Adaptive finite element methods with convergence rates. Numerische Mathematik, 97:219 268, 2004.
[78] Wolfgang Bangerth, Carsten Burstedde, Timo Heister, and Martin Kronbichler. Algorithms and data structures for massively parallel generic adaptive finite element codes. ACM Transactions on Mathematical Software (TOMS), 38(2):1-28, 2012.
[79] Carsten Carstensen. An adaptive mesh-refining algorithm allowing for an H' stable L projection onto courant finite element spaces. Constructive Approximation, 20:549-564, 2004.
[80] Claire Lestringant, Basile Audoly, and Dennis M Kochmann. A discrete, geometrically exact method for simulating nonlinear, elastic and inelastic beams. Computer Methods in Applied Mechanics and Engineering, 361: 12741, 2020.
[81] Stuart S Antman. Problems in nonlinear elasticity. Nonlinear Problems of Elasticity, pages 513-584, 2005.
[82] Dominick V Rosato and Marlene G Rosato. Injection molding handbook. Springer Science & Business Media, 2012.
[83] Donald F Heaney. Handbook of metal injection molding. Woodhead Publishing, 2018.
[84] Sebastian Koch, Albert Matveev, Zhongshi Jiang, Francis Williams, Alexay Artemov, Evgeny Burnaev, Mare Alexa, Denis Zorin, and Daniele Panozzo. ABC: A big CAD model dataset for geometric deep learning. Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), pages 9601-9611, 2019.
[85] Michael Smith. ABAQUS/Standard User's Manual, Version 6.9. Dassault Systèmes Simulia Corp, United States, 2009.
[86] Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, perf-mmer deep learning library. Advances in Neural Information Processing Systems (NeurIPS), 32, 2019.
[87] Diederik P. Kingma and Jimmy Ba. Adam: A method for stochastic optimization. International Conference on Learning Representations (ICLR), 2015. URI. htt:::ttt://ttii http///axwi.ooraa///aaaaaaaas/as 1412. 6980.
15

---

[88] Lei Jimmy Ba, Jamie Ryan Kiros, and Geoffrey E. Hinton. Layer normalization. CoRR, (bbs/1607.06450:22 2016.
[89] Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition (CVPR), pages 770-778, 2016.
[90] Yu Rong, Wenbing Huang, Tingyang Xu, and Junzhou Huang. DropEdge: Towards deep graph convolutional networks on node classification. International Conference Learning Representations (ICLR), 2019.
[91] Thomas N. Kipf' and Max Welling, Semi-supervised classification with graph convolutional networks. International Conference on Learning Representations (ICLR), 2017. URL https: / //openreview. mettfoorumid-SSJuayy
[92] Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. Medical Image Computing and Computer-Assisted Intervention-MICCAl 2015: 18th International Conference, Munich, Germany, October 5-9, 2015, Proceedings, Part III 18, pages 234-241, 2015.
[93] Nils Bjorck, Carla Gomes, and Kilian Q Weinberger. Towards deeper deep reinforcement learning with spectral normalization. Advances in Neural Information Processing Systems (NeurIPS), 34:8242-8255 2021.
[94] Michal Nauman and Marek Cygan, On the theory of risk-aware agents: Bridging actor-critic and economies. In JCML 2024 Workshop: Aligning Reinforcement Learning Experimentalists and Theorists, 2024.
16

---

NeurIPS Paper Checklist
1. Claims
Question: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?
Answer: [Yes]
Justification: As stated in the abstract and introduction, Section 5 provides qualitative and quantitative results on the experiments as introduced Section 4, supporting the claims made in the abstract and introduction. Additionally, more detailed results can be found in Appendix H and Appendix
Guidelines:
The answer NA means that the abstract and introduction do not include the claims made in the paper.
The abstract and/or introduction should clearly state the claims made, including the contributions made the paper and important assumptions and limitations. A No or NA answer to this question will not be perceived well by the reviewers.
The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize to other settings. It is fine to include aspirational goals as motivation as long it is clear that these goals are not attained by the paper.
2. Limitations
Question: Does the paper discuss the limitations of the work performed by the authors?
Answer: [Yes]
Justification: Section 6 discusses the limitations of AMBER, both in terms of assumptions made and the scope of the evaluations in the paper.
Guidelines:
The answer NA means that the paper has no limitation while the answer No means that paper has limitations, but those are not discussed in the paper.
The authors are encouraged to create a separate "Limitations" section their paper.
The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model well-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be.
The authors should reflect on the scope of the claims made, e.g., if the approach was only tested on a few datasets or with few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.
The authors should reflect the factors that influence the performance of the approach. For example, facial recognition algorithm may perform poorly when image resolution low images are taken in low lighting. Or speech-to-text system might be used reliably to provide closed captions for online lectures because it fails to handle technical jargon.
The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size.
If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness.
While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, worse outcome might be that reviewers discover limitations that aren't 't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an impor- tant role in developing norms that preserve the integrity of the community. Reviewers will be specifically instructed to not penalize honesty concerning limitations.
17

---

3. Theory assumptions and proofs
Question: For each theoretical result, does the paper provide the full set of assumptions and a complete (and correct) proof?
Answer: [Yes]
Justification: We provide convergence proof of the iterative mesh generation process of
AMBER in a simplified one-dimensional setting in Appendix B, assuming perfect predictions.
Guidelines:
The answer NA means that the paper does not include theoretical results.
All the theorems, formulas, and proofs in the paper should be numbered and cross- referenced.
All assumptions should be clearly stated or referenced in the statement of any theorems.
The proofs can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged to provide short proof sketch provide intuition.
Inversely, any informal proof provided in the core of the paper should be complemented by formal proof's provided in appendix supplemental material.
Theorems and Lemmas that the proof relies upon should properly referenced.
4. Experimental result reproducibility
Question: Does the paper fully disclose all the information needed to reproduce the main ex- perimental results of the paper to the extent that affects the main claims and/or conclusions of the paper (regardless of whether the code and data are provided or not)?
Answer: [Yes]
We provide an overview of our proposed method AMBER and its training process in Section 3. Additionally, we provide implementation details and hyperparameters for AMBER and the included baselines in Appendíx D, with additional information the baselines provided in Appendix G. We describe the setups used in our experiments in Section and provide details mesh generation and used datasets in Appendix C and E. Finally provide our source code and data as supplementary material. We ensure that the source code is well documented to facilitate reproduction of our experimental results.
Justification:
Guidelines:
The answer NA means that the paper does not include experiments.
If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.
If the contribution is dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.
Depending the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is specific model and empirical evaluation, it may be necessary to either make it possible for others to replicate the model with the same dataset, or provide access the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how replicate the results, access hosted model (e.g., in the of a large language model), releasing of a model checkpoint, or other means that are appropriate the research performed.
While NeurIPS does not require releasing code, the conference does require submis- sions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example
(a) If the contribution is primarily a new algorithm, the paper should make it clear how to reproduce that algorithm.
(b) the contribution is primarily a new model architecture, the paper should describe the architecture clearly and fully.
18

---

(c) If the contribution is a new model (e.g.. a large language model), then there should either way to access this model for reproducing the results or way to reproduce the model (e.g., with an open-source dataset or instructions for how to construct the dataset).
(d) We recognize that reproducibility may be tricky in some cases, in which case authors are welcome to describe the particular way they provide for reproducibility. the case of closed-source models, may be that access to the model is limited in some way (e.g., to registered users), but it should be possible for other researchers have some path reproducing or verifying the results.
5. Open access to data and code
Question: Does the paper provide open access to the data and code, with sufficient instruc- tions to faithfully reproduce the main experimental results, as described supplemental material?
Answer: [Yes]
Justification: We provide our source code and data as supplementary material upon submis- sion. We ensure that the source code is well documented and able out of the box to facilitate reproduction of our experimental results.
Guidelines:
The answer NA means that paper does not include experiments requiring code.
Please see the NeurIPS code and data submission guidelines (https://nips.c co/ public/uuides//ee Saaeieeee/oooeSeeeiiiiiiiii iwtiiissssiiioiiiiiiiiii for more details.
While we encourage the release of code and data, we understand that this might not be possible, so "No" is an acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (e.g., for new open-source benchmark).
The instructions should contain the exact command and environment needed to run to reproduce the results. See the NeurlPS code and data submission guidelines (https:
/ /twpsscccppuuliiie wwtpccppppcccc.cceccccccccceccll /ellic/guidee wwwgguuiiueeee /Code//ooiiisssseeeeee ssisnsolicyy for more details.
The authors should provide instructions data access and preparation, including how to access the raw data, preprocessed data, intermediate data, and generated data, etc.
The authors should provide scripts to reproduce all experimental results for the new proposed method and baselines. only subset of experiments are reproducible, they should state which ones are omitted from the script and why.
At submission time, to preserve anonymity, the authors should release anonymized versions (if applicable).
Providing as much information as possible in supplemental material (appended to the paper) recommended, but including URLs to data and code permitted.
6. Experimental setting/details
Question:
Does the paper specify all the training and test details (e.g., data splits, hyper- parameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?
Answer: [Yes]
Justification: In Section we provide an overview the training and test setups that lead to the results presented in Section 5. For brevity, the complete description of the training setting and task/baseline setups is provided Appendix C, D and G.
Guidelines:
The answer NA means that the paper does not include experiments.
The experimental setting should be presented the core the paper to level of detail that is necessary to appreciate the results and make sense of them.
The full details can be provided either with the code, in appendix, as supplemental material.
19

---

7. Experiment statistical significance
Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?
Answer: [Yes]
Justification: We repeat all experiments for five random seeds. We report mean and two times standard error for all bar charts. For the Pareto plot evaluations, we instead report all individual seeds without aggregation.
Guidelines:
The answer NA means that the paper does not include experiments.
The authors should answer "Yes" if the results are accompanied by error bars, confi- dence intervals, or statistical significance tests, at least for the experiments that support the main claims of the paper.
The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, overall run with given experimental conditions).
The method for calculating the error bars should be explained (closed form formula, call a library function, bootstrap, etc.)
The assumptions made should given (e.g.. Normally distributed errors).
It should be clear whether the error bar is the standard deviation or the standard error of the mean.
OK to report I-sigma error bars, but one should state it. The authors should preferably report a 2-sigma error bar than state that they have 96% CI, if the hypothesis of Normality of errors is not verified.
For asymmetric distributions, the authors should be careful not to show in tables or figures symmetric error bars that would yield results that are out of range (e.g. negative етror rates).
If error bars reported in tables plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables the text.
8. Experiments compute resources
For each experiment, does the paper provide sufficient information on the com- puter resources (type of compute workers, memory, time of execution) needed to reproduce the experiments?
Question:
Answer:
[Yes]
Justification: We provide additional information on the used compute resources in Ap- pendix D.I.
Guidelines:
The answer NA means that the paper does not include experiments.
The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage.
The paper should provide the amount compute required for each of the individual experimental runs well estimate the total compute.
The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't make into the paper).
9. Code of ethics
Question: Does the research conducted in the paper conform, in every respect, with the ines?
NeurlPS Code of Ethics bttps://neurr/ tttp://hearrpp.ccpppllcc///
Answer: [Yes]
Justification: We have read the NeurIPS Code of Ethics and made sure our research fully compliant with it.
Guidelines:
20

---

The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics.
If the authors answer No, they should explain the special circumstances that require deviation from the Code of Ethics.
The authors should make sure to preserve anonymity (e.g.. there is a special consid- eration due to laws regulations in their jurisdiction).
10. Broader impacts
Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?
Answer: [Yes]
Justification:
We include brief discussion on broader impact in Appendix A.
Guidelines:
The answer NA means that there no societal impact of the work performed.
If the authors answer NA or No. they should explain why their work has no societal impact or why the paper does not address societal impact.
Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations.
The conference expects that many papers will be foundational research and tied to particular applications, let alone deployments. However, if there is a direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that an improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that a generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster.
The authors should consider possible harms that could arise when the technology is being used intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional unintentional) misuse of the technology.
If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition to attacks, mechanisms for monitoring misuse, mechanisms to monitor how system learns from feedback over time, improving the efficiency and accessibility of ML).
11. Safeguards
Does the paper describe safeguards that have been put in place for responsible release of data models that have high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?
Question:
Answer: [NA]
Justification: We do not scraped datasets, and we perceive the risk for misuse of our mesh refinement architecture to be substantially lower than e.g. for pretrained language models. Nevertheless, we briefly discuss potential avenues of questionable use in Appendix A.
Guidelines:
The answer NA means that the paper poses no such risks.
Released models that have high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model. for example by requiring that users adhere usage guidelines or restrictions to access the model or implementing safety filters.
Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images.
We recognize that providing effective safeguards challenging, and many papers do not require this, but we encourage authors to take this into account and make best faith effort.
21

---

12. Licenses for existing assets
Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and the license and terms of use explicitly mentioned and properly respected?
Question:
Answer: [Yes]
Justification: We use the original code base for ASMR to implement this baseline. We credit this use in the paper.
Guidelines:
The answer NA means that the paper does not use existing assets.
The authors should cite the original paper that produced the code package dataset.
The authors should state which version of the asset is used and, if possible, include URL.
The name of the license (c.g., CC-BY 4.0) should be included for each asset. For scraped data from a particular source (e.g., website), the copyright and terms of service of that source should provided.
assets are released, the license, copyright information, and terms use in the package should be provided. For popular datasets, paperswi thcode. wwt.coo///aaaae/ com/dttasets has curated licenses for some datasets. Their licensing guide can help determine the license of dataset.
For existing datasets that are re-packaged, both the original license and the license of the derived asset (if it has changed) should be provided. If this information is available online, the authors are encouraged to reach out the asset's ' creators.
13. New assets
Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?
Answer: [Yes]
Justification: We introduce six novel datasets. Each dataset consists of geometries, expert meshes, and potentially process conditions. We integrate them in our codebase, which provides documentation for the dataset usage.
Guidelines:
The answer NA means that the paper does release new assets.
Researchers should communicate the details the dataset/code/model as part of their submissions via structured templates. This includes details about training, license, limitations, etc.
The paper should discuss whether and how consent was obtained from people whose asset used.
At submission time, remember to anonymize your assets (if applicable). You can either create anonymized URL or include anonymized zip file.
14. Crowdsourcing and research with human subjects
Question: For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given participants and screenshots, if applicable, as well as details about compensation (if any)?
Answer: [NA]
Justification:
This paper does not involve crowdsourcing nor research with human subjects.
Guidelines:
The answer NA means that the paper does involve crowdsourcing nor research with human subjects.
Including this information in the supplemental material is fine, but if the main contribu- tion of the paper involves human subjects, then as much detail as possible should be included in the main paper.
22

---

According to the NeurlPS Code of Ethics, workers involved in data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector.
15. Institutional review board (IRB) approvals or equivalent for research with human subjects
Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or equivalent approval/teview based on the requirements of your country institution) were obtained?
Answer: [NA]
Justification: This paper does not involve crowdsourcing research with human subjects.
Guidelines:
The answer NA means that the paper does not involve crowdsourcing nor research with
human subjects.
Depending on the country in which research is conducted, IRB approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper.
We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors adhere the NeurIPS Code of Ethics and the guidelines for their institution.
For initial submissions, do not include any information that would break anonymity (if applicable), such as the institution conducting the review.
16. Declaration of LLM usage
Question: Does the paper describe the usage of LLMs if it is important, original, or non-standard component of the core methods in this research? Note that if the LLM is used only for writing, editing, formatting purposes and does not impact the core methodology, scientific rigorousness, or originality of the research, declaration is not required.
Answer: [NA]
Justification: This research does not involve LLMs any important, original, or non- standard components.
Guidelines:
The answer NA means that the core method development in this research does not involve LLMs as any important, original, non-standard components.
Please refer to LLM policy (https: http://uurpsscc//oeeeeeeeeeeeeee cc/ for what should or should not be described.
23

---

A Broader Impact
The proposed method, Adaptive Meshing By Expert Reconstruction (AMBER), has the potential to benefit numerous domains that depend on computational modeling and simulation by significantly reducing computational costs without compromising accuracy. This efficiency can expand the scope of feasible simulations in engineering design, and support the deployment of simulation-base tools in snsource-constraiig environments. Nonetheless, as common with advanced computational tools, there is risk of misuse in contexts such weapons development unsustainable resource exploitation.
B Theoretical Convergence of the Iterative Mesh Generation Process
In this section, we provide a convergence proof of the iterative mesh generation process of AMBER in simplified one-dimensional setting. We consider the unit interval the domain of interest:
Ω [0, 1] C R.
A one-dimensional mesh M is defined as a set of points
M , uN
such that U1 0, un = 1, and U, < U/41 for all = l,..., N 1. The sizing field fe (M) induced by the mesh is directly related the spacing between points and defined for such that 0 S = < 0/41 as
(z)) = e++1 - 0/
which is defined for the general setting in Section 3.2.
We construct mesh generator Jmsh that, given sizing field f [0, - R2 generates mesh as follows: set U1 = and define
2/4 min(1; flv), 1).
We terminate the process when 1:41 1, resulting in a mesh (mssh(f) { uN J. It easy to see that
U++1 Σ f(1)),
(5)
j=1
for intermediate points < N - 1.. Note that this generator acts as an inverse to the sizing field in the sense that
Jmsh (Je M.
Given mesh M (uf...., an interpolated sizing field as
ofy} and a target mesh M assume perfect predictions and define
Ims (z) (1- fe + fd
(6)
for = = (1 of + d d with S 1.
Under these assumptions, we can prove the following: Theorem Let M = (ut.... -,,,} be an initial mesh and M = (ui,..., ,,y) ) a target mesh. For a given mesh M define one iteration of AMBER by
.i.....,yy
=+1
9mati (IMe (f))
Then, it holds that M M
Proof. We prove this by induction showing that the first & vertices of the k-th output for... of C R are equal to the target vertices {ui....
... 2 C M*.
For uN we set (=( ux UN-1-

---

Table 2: Overview of dataset characteristics.
Dim.
Application
Geometries
Online
Expert Meshes
Process Conditions
Poisson
2D
Electrostatics
Procedurally generated
Yes
Error indicator
Load function
Laplace
2D
Heat or fluid flow
Procedurally generated
Yes
Eror indicator
Dirichlet boundary
Airfoil
2D
Fluid dynamics
Open-source dataset
Tusk-specific heuristic
None
Bean
2D
Mechanical load
Procedurally generated
No
Task-specific heuristic
None
Console
3D
Durability analysis
Closed source dataset
Human labeled
None
Hold
3D
Injection molding
Open-source datasct
Human labelod
Inlet position
The case for k = trivial. Consider now the + 1-th AMBER step. holds for i S k:
Tass (f) = fe(M)) f
(cM) = o/+1 -
(8)
using Eq. for the first equality, the induction proposition for the second equality, and Eq. 4 for the last equality. From Eq. 5 and using the result from above, we get
0+1 = EIn
Σ Eit - vj = i=1
for all S k which proves the desired result.
C Datasets
We propose a total of six novel and varied datasets. Poisson features L-shaped domains with a Gaussian Mixture Model as the load function and zero Dirichlet boundaries, adapted from ASMR [31]. We vary the resolution of the expert mesh to define easy, medium, and hard variants. Laplace contains parameterized 2D lattices governed by the Laplace equation with complex Dirichlet boundary conditions, representative of structures used in, e.g.. materials design. Airfoil includes flow simulations around airfoil-like shapes, commonly encountered in aerodynamic engineering. Beam captures elasticity problems in mechanical engineering, using elongated beams with internal circular holes. The elongated beams induce long-range dependencies across the mesh. Console consists of 3D car seat crossmember geometries, parameterized and meshed by a human expert. The resulting meshes are optimized for downstream strength and durability analyses. Mold represents injection molding setups with complex 3D plates, varying inlet positions, and handcrafted expert meshes.
Table 2 summarizes dataset metadata. Poisson and Laplace solve concrete system of equations to yield a FEM solution over the mesh. This solution is used for expert mesh creation, and as features for the graph that input into the MPN. For the Mold task, the process conditions 'P of each data point are comprised of the inlet position for the molding process, which always lies on the surface of the geometry. As such, we re-use each Mold geometry multiple times with different inlet positions, and generate a suitable expert mesh for each of them.
Table 3 provides detailed statistics mesh resolution for the training sets. Meshes range from 705 to 116 704 elements in the training data. The 3D datasets, i.e., Console and Mold, have a higher ratio of elements to vertices, they use tetrahedral instead of triangular elements.
The sections below describe the construction of each dataset, including geometry generation and expert mesh creation. We implement the FEM Poisson and Laplace in SCIKIT-FEM [76]. For these datasets, we generate separate training data for each seed during training, but evaluate on a fixed set of validation and test data points. For the other datasets, created a fixed set of training, validation and testing data points.
C.1 Poisson
We consider adaptive, problem-specific meshes for Poisson's 's equation with zero Dirichlet boundary conditions, given in weak form
/
Vu- Vedæ
qu Vu V.
25

---

Table 3: Number of data points per split and min/mean/max number of vertices and elements per
mesh in the training data. FFor Mold, each geometry is paired with multiple inlet positions and
corresponding expert meshes. Each of the 18 training geometries used with inlet positions. We reserve 5 Mold geometries for validation and test, using and 2 inlet positions, respectively.
# Data Points
# Vertices
# Elements
Name
Train
Val
Test
Min
Mcan
Max
Min
Mcan
Max
Poisson (easy)
20
20
20
387
549
674
705
1042
192
Poisson (medium)
20
20
20
1562
2231
2736
2985
4 1358
5366
Poisson (hard)
20
20
20
9951
13224
15884
19553
26 185
31 510
Laplace
20
20
20
10161
13840
18 18193
263 19.08
34414
Airfoil
20
5
5
20229
20942
22 152
39 995
41 425
43 842
Beam
10
20
13011
27727
42306
161
53 804
82 521
Console
19
2
5
2222
6606
10 130
7.000
25 769
41 856
Moldt
3 x 18
1 x
2 x
7:369
13.088
22
33 308
65 191
704
Each domain is randomly generated L-shaped geometry of the form Ω = (0, 1)
(b6") 1] x lub" .1)), with Po = (pb :Po _) sampled from (0.22, 0.8)2. The load function q: + R is a Gaussian Mixture Model (GMM) with three components. Means are drawn from U(0.0,1.0) and re-sampled if they fall within 0.01 of the domain boundary or outside the domain. Covariances are initialized diagonally with log-uniform entries in exp(U(log 0.0001, log 0.0005)), and then randomly rotated to obtain full covariance matrices. Component weights follow exp(N((0,)) 1)) + 1, normalized across components, to provide meaningful weight to each component.
Expert meshes are constructed by refining a uniform coarse mesh with element volume 0.01 using threshold-based heuristic that accounts for the load function and gradient jumps across element facets [77, 78, 52]. The local error indicator for element M, is given by
err( M.) = 12 [ulli + ha II[ mlll
(10)
where h; denotes the characteristic length of M. and [v nn] denotes the jump in the normal derivative of u across facets of M,, where n is the outward unit normal. This estimator highlights regions with strong source terms or large inter-element gradient discontinuitis.. Elements are marked for refinement if orr(M,) > max, err(M,) with 0 = 0.85 fixed across all data points. Marked elements are refined via a conforming red-green-blue scheme [79], followed by Laplacian smoothing after each refinement step.
Each data point comprises a random domain, source term, and corresponding expert mesh. Addi- tionally, we vary task difficulty by controlling the number of refinement steps. We use 25 steps for an easy variant, 50 steps for medium, and 100 for hard. We solve the equation on each intermediate mesh and extract the solution per vertex as a vertex-level input feature to our MPN. In addition, we use the evaluation of at each vertex node feature. We use analogous features evaluated at pixel positions for the image baselines.
C.2 Laplace
The Laplace dataset emulates heat conduction or fluid transport through lattice structures during, e.g., compression-base manufacturing processes. follows the same setup and refinement procedure as Poisson (cf. Appendix C.I), but solves the Laplace equation
Vu Vudz 0 V.
We impose a complex Dirichlet boundary condition based on a GMM, applied only to the inner boundary (i.e.. the boundaries of the holes). The GMM has means sampled from (0.11, 0.9)² and covariances with diagonal entries drawn from exp(U (log 0.005, log 0.01)). followed by random rota- tion. The domain consists of parameterized family of lattice-like geometries. Each instance contains a uniform grid of l x & square holes, with E [5, 10) and hole sizes drawn from (0.04, 0.075). Holes are placed evenly, ensuring uniform ligament thickness throughout the lattice.
26

---

The refinement procedure is identical to that used in Poisson. Since there is no load function, i.e., q 0 for the Laplace equation, the local error indicator simplifies
err( (r. = h4 I[[u -nl =]1l)
(11)
We use fixed number of 100 refinement steps for all data points, corresponding to the hard setup of Poisson. Each data point consists of domain, boundary condition, and expert mesh. We solve the equation on each intermediate mesh and use the solution at each vertex as an input feature to our MPN.
C.3 Airfoil
We sample airfoil geometries from the UIUC AIRFOIL COORDINATES DATABASE", each with randomly selected angle of attack. Meshing is performed using a task-specific heuristic to generate high-quality meshes with large inflow/outflow regions and fine resolution near the airfoil. We generate 30 meshes, each placing the airfoil at the center of a circular domain within [0, 1]2. The mesh size is set to 0.01 near the airfoil and 0.25 at the outer boundary, yielding approximately 20 000 vertices per mesh.
which utilizes
C.4
Beam
Beam geometries are widely used in mechanical engineering to study structural responses under load, for example in the context of non-linear elasticity [80, 81]. We generate adaptive beam geometries in GMSH [25]. We start with elongated rectangular domains, sampled from height h and length
h (0.55, 0.05). I ~~ 101.0000,1
Randomly placed disks are subtracted from the domain. The i-th disk has radius
Ti (2.00.55h.20)))
and its center is placed at
F4 U( 1.5r,, 24-1 20.0r;). y: ((),
using an initial reference position vn 0.1/ to sample the first disk. Disk placement proceeds sequentially until the beam end is reached. minimum part thickness 0.001 enforced. Meshing uses manually crafted and carefully tuned heuristic that ensures fine resolution near disks and in thin regions of the geometry.
C.5
Console
Console uses data obtained from real-world scenario in the automotive industry. We have parameterized family of 3D geometries representing car's seat crossmembers. The geometries are obtained using ONSHAPE and feature various sharp bends as well as up two circular holes. Tetrahedral meshes for this dataset are generated by human expert using ANSA7 The expert initially presented with a coarse mesh, which they iteratively select regions to refine, specifying the target element size each selected region. The resulting meshes are optimized for downstream strength and durability analyses, but our experiments are conducted solely the meshes and their underlying geometry.
C.6 Mold
Injection molding is a key process for manufacturing thin, complex components in high-volume industrial settings [82, 83]. We select plane-like geometries from the ABC: BIG CAD MODEL. dataset [84], aligning them such that the longest dimension lies along and the shortest along z. This standardization does not affect the rotation-invariant AMBER, but helps the Image baselines.
"nttpe://n-selig.e ae. www.illimoii.. wttp://ii...aeea////ooooorrddddd 'https://github httpp////ggtuubb..ooc//snagngnn/ wonm/ffsengineernngg///
html htw.aeeerrreinnnnnnneeeee GMSH- Sastrfooll2D//i 2D/tree/main
"nttps://ww.onsti com/
hhttp:://ww www.:bbetaccee com/ ansa. htm
27

---

Geometries are normalized so that the longest in-plane dimension is 1. and their thickness is rescaled (0.066 0.09). Each geometry is duplicated three times with varying injection point locations, which are provided as process conditions and influence the meshing strategy. Geometries are imported into ABAQUS [85] and manually meshed by an expert using the standard tetrahedral meshing algorithm. Meshes are tailored for injection molding, with 4-6 elements across thickness and local refinement at holes, edges, and injection points. Mesh generation takes approximately 20 minutes per geometry, depending complexity.
D Training Setup and Hyperparameters
D.1 Hardware and Compute
All graph-based methods are trained an NVIDIA 3090 GPU. The image-based methods are instead trained on an NVIDIA A100 GPU to accommodate the memory requirement of the comparatively nigh-resolution images. Each method is given computational budget of up 36 hours, although most methods, including AMBER, usually converge after 4-12 hours, depending on the considered dataset. We train every method for five seeds. We evaluate four methods eight datasets, counting Poisson (easy/mediun/harc) separately, and four additional methods on three datasets. We additionally have total of 31 additional experiments across three datasets. Combined, this yields an estimated total compute of 8 [[hours] x 5[seeds] x (8 x 4 + 4 x 3 + 31) 3000fhours]. A comparable amount was used for preliminary runs and hyperparameter tuning.
D.2 Training
We implement all neural networks in PyTorch [86] and optimize using ADAM [87]. We use a learning rate of 1.0e-3 and linear learning rate scheduler with warmup from 0 to the full learning rate during the first 10 % of training. We apply weight decay of 1.0e-6. We train for a total of 25 600 mini-batches for Poisson and Laplace, Airfoil, and 51 200 mini-batches for Beam, Console and Mold.
D.3 Node and Edge Features
In addition to the dataset-specific features, as described in Appendix C each node is assigned features for the average sizing field of adjacent elements, as provided in Equation 3, and the vertex degree. As edge features, we the Fuclidean distance between vertex positions and an approximate curvature, defined as the signed angle between the averaged surface normals of the edge's endpoints. The curvature lies in [-1, 1]. with positive values for convex and negative values for concave regions. Since all features are invariant to Euclidean transformations, the architecture is invariant to rotation, translation, reflection, and vertex permutation [21].
D.4 AMBER Hyperparameters
The MPN of AMBER consists of 20 separate message passing steps for all datasets. Each message passing step uses separate two-layer MLPs and LeakyReLU activations for its node and edge updates. We apply Layer Normalization [88] and Residual Connections [89] independently after each node and edge feature update, and use Edge Dropout [90] of 0.1 during training. The final node features are fed into a two-layer MLP decoder. All MLPs use a latent dimension of 64. We experimented with slightly different parameterizations in preliminary experiments, finding that AMBER is relatively insensitive to the details of the underlying MPN. We provide an overview of AMBER hyperparameters in Table 4.
E
Mesh Generation
We use GMSH [25] for mesh generation. For simplicity, we clip the predicted sizing fields during
mesh generation to (0.8 (i:())(M))), 1.25 (Mx))) with M; C M M E D, i.e to a range around the most extreme values seen during training. Here, fe is the element- sizing field introduced in Section 3.2. This is only done during mesh generation, and does not impact the model predictions the loss of Equation 2. We further constrain the mesh generation process of AMBER to
28

---

Table AMBER parameters and experiment configuration (variable names used the main text)
Section
Parameter
Variable
Value
Optimizer
ADAM
Learning rate
1.0 x 10-3
Optimization
Learning rate scheduler
linear with 10 % warm-up
Weight decay
1.0 x 10-6
Aggregation function
mean
MPN steps
20
Activation function
Leaky ReLU
MPN
Edge dropout
0.1
MLP layers
Latent dimension
64
Refinement steps
T
3
Maximum buffer size
500 meshes
AMBER
Buffer addition frequency
8 samples every 128 batches
Training steps
25 600 or 51 200 (task (ask-dependent)
Batch size
500 000 graph nodes plus edges
Sizing field scaling
1.618
budget of 1.5 max MM S M",M" E D) elements, i.e., to 150 % of the mesh elements of the largest mesh in the training dataset. To ensure that this budget is met, we employ a conservative heuristic that estimates the number of elements in newly generated mesh from given sizing field, and then computes a scaling factor such that the new mesh does not exceed the available number of elements. This constraint makes training more predictable by preventing very large meshes and thus unexpected peaks in runtime between training epochs. While this constraint is also active during inference, we find that it practically never activates after the training has converged.
F
Metrics
F1
Density-Aware Chamfer Distance (DCD)
We evaluate mesh similarity using the DCD [73]. symmetric, exponentiated variant of the Chamfer distance that accounts for multiple points in one set matching single point in the other. Given vertex sets V1 and V2, the DCD is defined
dDCD(V1, 12)
1
- p(((,))l
2
V
7hp
PEV
(12)
1
- -p(oo) -pte }
1
+
12
Yhp
vEV,
where ū(v, V² = arg mingrvv [|p(v) p('')l2 is the nearest neighbor, and n, is the number of points in the other set for which is the nearest neighbor. The DCD is purely geometric metric that treats both vertex sets as samples from an unknown density over the domain.
F.2 2 Error
We additionally evaluate mesh similarity using a symmetric relative projected L error between the vertex-based sizing fields of the evaluated and expert meshes. This metric complements the purely geometric DCD by quantifying discrepancies in local element sizes. Let f and f denote the vertex-based sizing fields of Equation 3 on the evaluated mesh M and expert mesh M respectively. We use the interpolant I from Equation to evaluate each sizing field at the vertex positions of the opposite mesh. The symmetric relative projected I.² error then defined as
(1)) IM- (hx(((p())))) + I1f(e;) Iar [x(()))(()))1ll IMr- (N)P(1)))
dL2(M, = 2
(13)
(p(r)))))
29

---

where || l/2 denotes the discrete e² norm over vertices.
F33 Error Indicator Norm
For Poisson, we evaluate ASMR and AMBER using the norm of the error indicator of Equation 10, i.e.
den (M) = |err(M =
Σ
ear(M,)
(14)
M,EM
In contrast to the above metrics, the error indicator norm approximates the remaining simulation error for given mesh, independent of some reference mesh or vertex set. It naturally decreases for finer meshes, but quantifies how well given mesh works for downstream simulation for its budget. We thus evaluate the Expert, ASMR and AMBER for different target mesh granularities Pareto front of number of mesh elements compared to this norm.
G Baselines and Variants
The following sections provide detailed setups for all baselines and variants used in our experi- ments. Unless mentioned otherwise, the baseline and variant experiments follow the setup and hyperparameters described in Appendix D.
G.1 GraphMesh
GraphMesh [24] uses a two-stage GCN [91] extract geometric information from polygonal domains. It constructs a local copy of the boundary graph for each coarse mesh vertex, encoding relative features all boundary vertices. These features are mean value coordinates [74], spatial distances, and mesh- hop counts. Thus, each coarse vertex is represented by an individual boundary graph that contains features of the boundary relative to this vertex. This construction limits GraphMesh to polygonal domains, which in our case restricts it to the Poisson datasets. These graphs are processed by single-layer GCN, and the resulting embeddings are pooled to yield one latent vector per coarse vertex of the original mesh. To enable load- load-specific sizing field prediction, the same vertex-level features used in AMBER are appended to these embeddings. For the Poisson datasets, these features include vertex degree, interpolated sizing field, load function value, and solution value at the vertex position. The combined features are used as node inputs to a second GCN stage consisting of 6 residual graph convolutional layers with 128 dimensional hidden states. GraphMesh is trained using a Mean Average Error to the target sizing field and does not apply normalization. We find that GraphMesh quickly starts overfit, especially on Poisson (easy), likely due poor generalization capabilities of its GCN and the construction of the geometry embedding. To compensate, we reduce the number of training steps to 3 200/6 400/12 800 for Poisson (easy/medium/hard)) We tune the resolution of the underlying mesh by dataset for optimal validation performance.
In GraphMesh (Variant), instead apply the loss in the inverse-softplus space, in Equation 2, and add input/output normalization. We also use 20 layers with dimension 64 to match AMBER's MPN.
G.2 Image Baseline
The Image baseline [22] operates on discretized domain images. In 2D, the longest axis. We evaluate other resolutions in Appendix H.8. In 3D, we use 96 voxels along the longest axis. We follow the original setup and use U-Net [92] with 64 initial channels and down- and up-convolution blocks. Each block contains 2 convolutions with kernel size 3, followed by batch normalization and ReLU activation. After each down-convolution, we apply max-pooling with kernel size and stride 2 to halve the resolution and double the number of channels. The up- convolutions reverse this process, and skip connections are added between corresponding depths. We use 2D and 3D convolutions, batch normalization and pooling operations for the 2D and 3D datasets, respectively. For task-specific datasets, i.e., Poisson and Laplace, we generate uniform background mesh with roughly one element per pixel and compute an FEM solution this mesh to yield our input features. For Poisson, we additionally include the load function evaluated each pixel. Finally, for all datasets, we add binary mask that indicates if a given pixel or voxel is inside
512 pixels along
30

---

the domain as an input feature. We also mask the loss accordingly, only predicting and training on pixels within the domain. The Image baseline trained on a regular MSE loss over pixel-wise predicted and target sizing fields.
The Image Variantt extends the Image baseline to the loss of Equation 2 and input/output normaliza- tion. We evaluate both choices individually in Appendix H.8.
G.3 AMBER (1-Step)
We experiment with a variant of AMBER that only uses single mesh generation step, i.e., that predicts vertex-level sizing field on a uniform mesh, and uses this to generate the adaptive mesh. This variant explores AMBER without the ability to generate and act on an intermediate meshes, i.e., on a fixed sampling resolution for the predicted sizing field. We keep all AMBER hyperparameters the same, but omit all parts of the method that depend iterative mesh generation. Since AMBER (I-Step) heavily depends on the resolution of its input mesh, we tune this resolution separately for each dataset for optimal validation performance.
G.4 Adaptive Swarm Mesh Refinement (ASMR)
For ASMR [31, 51J we integrate the Poisson dataset into the provided codebase", replacing the original mesh generator with GMSH and adapting the dataset parameters to match Appendix C. We also adapt the batching scheme that used for AMBER to prevent too-large batches, sampling from the RL replay buffer until the combined number of graph nodes and edges reaches 500 000.
We adopt the MPN architecture and training schedule proposed by ASMR, using 2 MPN steps. Pre- liminary experiments with more message passing steps showed no improvement, which is consistent with prior observations RL model scaling [93, 94].
We use the reward function proposed by ASMR [31]. Given an element Mt at refinement step 4, reward is
EuCM MM)-))
rMM) V(M))
err(Mi)
Σ Edlem(attt (
(15)
where is scalar that controls the trade-off between accuracy and mesh complexity, and is given to the policy as context, and Q maps refined elements to their parents. The local error err(M,) is computed by integrating the element-win solution against reference solution on high-resolution mesh. This reference mesh is obtained by uniformly refining the initial mesh six times. Further refinement found to be computationally infeasible.
The reward function includes a 1/V(M()) scaling term. In ASMR, both reward and evaluation are based on integration against fine reference mesh, making the scaling consistent with the objective. We adopt the same reward and optimization, limiting ASMR to 6 uniform refinement steps. Appendix H.9 explores a variant that replaces the integrated error with the error indicator, allowing deeper refinement. In both cases, we evaluate using the error indicator, as a sufficiently fine uniform reference mesh is infeasible for our datasets. Under this metric, the scaling biases refinement toward small elements and can lead to a gap to expert performance. preliminary experiments, we tried to remove the scaling term, which led to unstable training and non-convergence.
We apply an adaptive element penalty during training by sampling a from a predefined range that yields mesh sizes comparable to Poisson (easylmediu/hhar(), At inference time, we evaluate across a range of geometrically spaced a values, producing meshes of varying resolution and corresponding indicator error for full comparison.
H Extended Results
H.1 1 Error Evaluations
Throughout our experiments, we primarily assess supervised approaches using the Density-Aware Chamfer Distance (DCD) the expert mesh. Here, we complement this with evaluations based on
31

---

Poi sssn (easy)
Poisson (medium)
Poisson (hard)
AMBER
0.65
AMBER (1-Step)
I Erro
0.55
Image (Var.)
0.45
GraphMesh (Var.)
0.35
Image [22]
0.25
GraphMesh [24]
Laplace
Airfoil
Beam
Console
Mold
0.3
0.2
0.4
L Earor
0.35
0.2
0.3
0.1
0.3
0.1
Figure 7: L error across datasets and supervised methods. Overall trends are consistent with Figure 3. AMBER shows larger relative improvements on datasets like Poisson and Beam compared to baselines. On Console, AMBER (I-Step) slightly outperforms AMBER, but with overlapping error bounds.
the 1.2 error defined Appendix F.2. Figure 7 reports 1.2 errors across all datasets and supervised methods. While scales different across datasets, the general trends closely mirror those in Figure with only minor differences relative performance. On the I,2 error, AMBER outperforms published baselines on all datasets, and shows slightly larger advantage over the variants compared the DCD on, c.g., Poisson and Beam. For Console, AMBER (1 (1-Step) performs well on the L metric, slightly improving over AMBER, although error bounds overlap.
H.2 Error Indicator Evaluations
evaluate the norm of the error indicator of Equation for Poisson (hard) and Laplace, i.c., for tasks that use concrete underlying system of equations. Table 5 shows this error indicator norm and the number of used mesh elements, to account for the norm naturally decreasing with higher element budgets. We find that AMBER closely adheres to the element budget of the expert heuristic that was used to generate the data, and that matches the expert in terms of error indicator. In contrast, many other supervised methods either fail to produce meshes with similar numbers of elements, or have worse error indicator norms, suggesting poor refinements and sub-optimal downstream simulation. These trends highlight AMBER's utility for downstream simulations and validate the of DCD proxy for downstream simulation error.
Table Error indicator norm Poisson (hard) and Laplace for the expert heuristic and different supervised methods. Overall trends are consistent with Figure 3, validating the use of DCD proxy for downstream simulation error.
Poisson
Laplace
Method
Em. Norm
#Elements
Em. Norm
#Elements
AMBER
0.031 + 0.001
27859.7 + 1583.1
2.555 0.050
27622.5 +:2 943.1
AMBER (1-Step)
0.032 = 0.001
28780.9 + 2196.8
2.568 + 0.039
27488.7 706.0
Image (Var.)
0.034 0.001
24836.3 1213.0
2.697 0.062
26745.2 - 866.7
Image
0.082 = 0.071
130571.3 # 119228.3
3.235 + 0.174
29297.8 = 8065.7
GraphMesh (Var.)
0.042 + 0.007
46841.7 + 15014.0
GraphMesh
0.034 + 0.001
31378.2 + 4776.3
Expert
0.033
25625.2
2.766
25130.5
32

---

AMBER
Expert
Err. Indicator Norm
0.3
0.2
0.2
0.1
0.1
0.05
0.05
0.03
0.03
0.02
0.02
300
1000
3000
10000
30 000
100.000
0.03
0.1
0.3
1.0
3.0
10.0
Number of Elements
Runtime [s]
Figure 8: Log-log plot of error indicator norm versus number of mesh elements (left) and runtime (right) for AMBER and the expert across Poisson (easylmedium/hard)) Lower left is better. Each marker shows the mean over the test set for a given seed and target mesh resolution. Left: As in Figure 4, AMBER achieves comparable error to the expert heuristic for given element budget. Right: For a given training dataset, i.e., any of Poisson (easy/medimm/hard) AMBER produces roughly the same intermediate meshes, only adapting to the element budget via the scaling constant er E [0.5, 2.0] at the last step. This process causes a distinct runtime curve for each training dataset. AMBER scales better with the element budget than the expert heuristic, eventually achieving a speed- up of more than 10x for meshes with more than 30 000 elements.
Table Runtime breakdown of Poisson (easy/hard) in milliseconds. Mesh generation the most expensive step, and becomes more costly as the number of mesh elements increases.
Poisson (easy)
Poisson (hard)
Category
Mean runtime (ms)
% of total
Mean runtime (ms)
% of total
Mesh to graph conversion Adding hierarchical graph Model forward
15.815
8.91
94.620 12.606
8.37
11.219
6.32
1.11
59.963
33.80
155.915
13.79
Mesh generation
90.406
50.96
867.760
76.73
H.3 Runtime Experiments
We explore AMBER's
runtime behavior across different mesh granularities by training on Poisson (easy/ediuu/haarl) datasets. We evaluate each trained model by setting the last step's 's scaling constant cr E [0.5, 2.0). as also done in Figure Figure 8 compares the error indicator norm against both the number of mesh elements and the total runtime for AMBER and the expert heuristic. Since the scaling constant only comes into effect at the last mesh generation step, the training dataset significantly influences runtime, with distinct curves for models trained with Poisson (easylmedium/hari)) AMBER attains an error comparable to the expert heuristic for all element budgets. However, AMBER scales significantly better with larger numbers of elements. For large meshes, AMBER eventually outperforms the heuristic by more than an order of magnitude, taking less than 3 seconds to generate mesh with more than 100 000 elements. We similarly find that AMBER takes less than 5 seconds to accurately imitate 3D mesh on both Console and Mold, where a human expert needs roughly 15 to 20 minutes for refinement.
Considering the cost of the individual components of AMBER, Table shows that, for cr 1, mesh generation quickly dominates runtime, taking up more than 50 % of total cost for Poisson (easy) and jumping to more than 75 % for Poisson (hard). This relative increase in cost is explained by the O(N log N) scaling of the mesh generation step, which outscales the linear graph-related operations, including the MPN forward, especially for finer meshes. Notably, AMBER acts on coarse intermediate meshes, and that the expensive last generation step is also required for the one-step baselines.
33

---

AMBER
Non Hierachical
No Sizing Field Scaling
No Prediction Offset
MSE Loss
No Normalization
Random Buffer Sampling
Laplace
Beam
Console
0.35
0.3
0.55
DCD
0.2
0.53
0.25
0.2
0.1
Figure 9: Ablation study AMBER using Density-Aware Chamfer Distance (DCD) across three datasets. Each bar represents a variant of the model with one component removed or modified. Using non-hierarchical MPN, omitting the prediction offset, or sampling newly generated meshes randomly degrades performance moderately, depending on the task. Omitting normalization or using regular MSE loss leads to substantially worse generated meshes.
H.4 Algorithm Design
We evaluate the importance of several of AMBER's components on Laplace, Beam and Console. To evaluate the impact of the loss of Equation 2, compare against AMBER (MSE Loss) variant using a direct MSE loss between the softplus-transformmed predictions and the sizing field targets, i.e.
predicciionso
1
L = V
(log(1 + + -2,)2
(16)
For the algorithmic components, we first replace the stratified sampling for the replay buffer with uniform sampling over all intermediate meshes (AMBER (Random Buffer Sampling)). This results in an repressprrnnntttoonn of meshes with many prior refinements, leading to a skewed and unbalanced disable the hierarchical mesh representation, feeding only the non-
training distribution. Next, hicrarchical graph G into the MPN (AMBER (Non-hies hinn-heerrcchcal)) This reduces consistency in the receptive field across and within meshes, regions with higher local resolution require more message passing steps. We also ablate the normalization (AMBER (No Normalization) and the offset term bj of Section 3.3 (AMBER (No Prediction Offset)). Finally, remove the scaling of sizing fields for intermediate meshes by setting the refinement constant of Section 3.3 to c=11 for all f (AMBER (No Sizing Field Scaling)). While this does not directly impact optimization, significantly increases intermediate mesh sizes, slowing down mesh generation during training inference, and reducing the number of meshes that fit in a training batch. Figure presents the results of aforementioned algorithmic variants. We find that AMBER consistently performs on par with or better than its variations across all datasets. Replacing our loss with a regular MSE leads the largest degradation in performance, consistently yielding worse meshes than AMBER across datasets. Depending on the dataset, different algorithmic components have different impact. The hierarchical graph representation is crucial on Beam, as it requires long-range message passing to capture the spatial dependencies loss essential for Laplace given its high
of the elongated geometry. The softplus-transfomet element scale variation. The sizing field scaling only improves mesh quality slightly, but decreases the size of intermediate meshes, speeding up training and inference. Other factors like normalization and buffer sampling have smaller effects, but still generally yield modest benefits.
H.S Sizing Field Parameterization
We experiment with different parameterizations of the predicted sizing field on Laplace, Beam and Console. Given an expert mesh M we consider using the vertex-interpolateed expert sizing field (1,)). as defined in Equation 3 to define labels y, = I (P)()())) using the interpolant of Equation H.5. We call this variant AMBER (Interpolated Labels).
Additionally, we consider a version that predicts piecewise-constant sizing field (M.) on the ele- ments Mj instead of a piecewise- linear sizing field f(1,) on the vertices uy. Here, the corresponding interpolant Zar (fe) is just the union over the element's predictions evaluated at their subdomain. i.c.,
34

---

Laplace
Beam
Console
0.35
0.3
0.6
DCD
0.2
0.55
0.25
AMBER
Element Sizing Field
0.2
0.1
0.5
Interpolated Labels
Figure 10: DCD comparison across tasks for different sizing field parameterizations. Interpolating the labels closely matches AMBER's parameterization, reflecting similar optimization objectives. In contrast, using a precewise-constnle sizing field on the elements yields worse meshes on Beam and Console, likely due to reduced expressiveness.
[M()), if 22 for some fe(My), otherwise, where arg min p(M))l-
[M(ss)(2)
where p(M) denotes the position of the element's midpoint. We assign each element the integrated sizing field of all expert elements that it contains, i.e., we compute a wolume-weighted average of the sizing field values from the fine mesh elements whose midpoints lie within the coarse element. Let f (Mā) be the sizing field the fine elements and V(M)) their volume. For each element M, of the current mesh we compute the target sizing field as
v(ME) ENEr. ((Mg) fe(M)), if 0
E
KEJ:
1/4
(e(M)) fc(M))
((M) E Si for some ME. otherwise, where k' = arg ming [l, P(M))],,
where J. = {j (MM)) E M,} is the set expert elements whose midpoints lie within the element such elements, we first attempt find expert element My that contains the
M,. If there midpoint of M. If that also fails, the meshes represent different discretizations of the underlying domain. Here, we fall back to nearest-neighhor interpolation using the element midpoint positions. We adapt the MPN input accordingly, constructing the graph G over mesh elements and element neighborhood. We use the same graph node and edge features, except for the neighborhood size, and always evaluate position-deeenndent features at the element midpoint. This process yields a variant AMBER (Element Sizing Field).
Figure 10 visualizes results. We find that AMBER (Interpolated Labels) performs very similarly to AMBER, likely because both optimize similar objective. While there small differences in the concrete sizing field targets, especially for early generation steps and coarser input meshes, both parameterizations work well. Here, both parameterizations provide targets that aim coarsen too-fine regions, while increasing the resolution in too-coarse regions the current mesh, eventually converging to very similar generated meshes. In contrast, AMBER Element Sizing Field predicts piecewise-consee sizing field over mesh elements. While this works well on Laplace, the reduced expressiveness of this parameterization compared to the piecewise-linear interpolant of Equation yields significantly worse meshes on both Beam and Console.
H.6
Data Efficiency
Figure 1l assesses AMBER's data efficiency. All other training settings are held constant, and evaluation is performed on the original test set. Accurate mesh generation is achieved with as few five training meshes and corresponding geometries. Using more samples consistently improves performance. On Laplace, where training data can be easily generated via the expert heuristic, there additional improvements for 100 instead of 20 meshes.
AMBER's efficient use of data likely stems from the local, por-node loss Equation and the symmetry-preservee features and structure of the MPN architecture.
35

---

Laplace
Beam
Console
5 Samples
0.24
0.16
0.35
10 Samples
DCD
15 Samples
0.22
0.14
0.54
20 Samples
(AMBER)
0.2
Samples
Figure 11: DCD comparison for AMBER with different numbers of training samples for Laplace, Beam and Console. AMBER performs well with as little samples. but steadily improves for up to 20 samples. On Laplace, where additional training data is easy to generate, there is moderate improvement for 100 instead of train meshes and geometries.
Laplace
Beam
Console
Step
0.16
(AMBER (1-Step))
0.23
0.541
DCD
0.14
Steps
0.12
0.53
3 Steps
(AMBER)
0.1
0.52
Steps
Figure 12: DCD comparison for AMBER with different numbers of mesh generation steps for Laplace, Beam and Console. AMBER improves for more mesh generation steps, and converges at around three steps. A single mesh generation step is insufficient for accurate generations, likely because acts on fixed mesh resolution. Results for AMBER and AMBER (1-Step) are taken from Figure 3.
H.7 Mesh Generation Steps
We evaluate how AMBER behaves for different numbers of mesh generation steps. particular, use three generation steps in all main experiments, and have a single step for AMBER (1-Step) as baseline that acts on tuned but fixed mesh resolution per task. Figure 12 shows that AMBER improves for more mesh generation steps. converging at roughly three steps. Despite tuning the initial mesh size, single mesh generation step is insufficient for optimal performance, presumably because it does not allow for arbitrarily fine sizing field resolution. In contrast, starting from two mesh generation steps, AMBER learns to predict the sizing field used to generate intermediate meshes, allowing for a flexible, adaptive sizing field representations.
H.8 Image Ablations
We explore the behavior of the Image (Variant) baseline on the Laplace task. We vary image resolution and remove either input/output normalization (Image (No Normalization)) or the loss from Equation 2, replacing the latter with the MSE loss over the pixel-wise sizing fields (Image (MSE Loss)). Omitting both components recovers the original Image baseline. In all cases, still use softplus to transform the predictions, as we find that directly predicting sizing field leads to worse performance and unstable mesh generation. Figure 13 shows that performance improves with image resolution, although gains diminish at finer scales. Since the Image (Variant) enforces a uniform resolution by design, adapting high-detail regions becomes prohibitively expensive, leading substantial waste in less sensitive areas. In contrast, AMBER allows for variable sampling resolutions of the predicted sizing field by design, ensuring highly adaptive meshes. Other than that, both normalization and our loss are crucial for accurate mesh generation, which is consistent with the AMBER ablations in Section H.4.
efficient prediction process, especially for
H.9 ASMR (Error Indicator)
We experiment with version of ASMR that uses the error indicator in its reward function, i.e., sets err(M) in Equation 15 Equation 10, leaving the rest of the reward unchanged. To further adapt the resulting ASMR (Error Indicator) version our setup, disable normalization of the
36

---

Laplace
Image ( (Var.)
(512 512)
0.3
MSE Loss
DCD
No Norm.
256 256
0.25
128 128
64 x 64
Figure 13: DCD comparison for different Image (Variant) ablations. Both the loss of Equation 2 and normalization are crucial for Image (Variant). Performance improves with higher image resolutions, although the rate of improvement eventually slows down.
Method:
AMBER
ASMR
ASMR (Error Indicator)
Expert
Difficulty:
easy
medium
hard
Err. Indicator Norm
0.2
0.1
0.05
0.02
300
1.000
000
10.000
30
100 000
Number of Elements
Figure 14: Log-log plot of error indicator norm versus number of mesh elements (lower left better) for AMBER, ASMR, ASMR (Error Indicator) and the expert across Poisson (easy, medium, hard). Each marker shows the mean over the test set for a given seed and target mesh resolution. This figure overlays Figure with ASMR (Error Indicator). We find that training ASMR the indicator error yields less reliable, more noisy policies. However, as this ASMR variant no longer constrained to a fixed refinement depth, it does degrade strongly for high-resolution meshes.
initial errors, we found this to be unstable when using the indicator, and adapt the MPN architecture 10 message passing steps. We then increase the number refinement steps to 7/9/11 91 for Poisson (easylmediuum/harde allowing for elements with maximum refinement depth to be of the same size as the minimum expert elements.
Figure 14 overlays Figure 4 with ASMR (Error Indicator). We find that this method performs worse than ASMR, presumably because the error indicator is less expressive than the integrated reward. In comparison to the integrated reward, the indicator is noiser, yielding low relative contrast for elements of the same scale. This imbalance makes the reward function harder to optimize, reducing the consistency of the resulting policy. Yet, the indicator does not constraint the refinement depth, allowing for higher mesh resolutions and thus less saturation in simulation quality for finer meshes.
I
Visualizations
We provide additional visualizations for AMBER on all datasets, and for all methods on Poisson (hard). We visualize the first test data point on the first trained seed for methods. All visualizations include the expert mesh for reference, and zoom in on representative region of the geometry.
37

---

Poisson (Expert, full view)
Expert
AMBER
AMBER (1-Step)
ASMR
Image (Variant) GraphMesh (Variant) Image [22)
GraphMesh [24]
Figure 15: Expert mesh and generated meshes for all baseline methods and AMBER on the Poisson (hard) dataset. The enlarged view of the expert mesh shows the FEM solution, while other plots show the element size, with red indicating smaller elements. AMBER yields more accurate and adaptive meshes, especially in regions with high resolution variability. ASMR has a constrained depth, leading to too- uniform refinements, and both Image [22] and GraphMesh [24] fail to correctly estimate sizing fields local regions.
I.1 Baseline Comparisons
Figure 15 visualizes mesh outputs from all baseline methods and AMBER on the Poisson (hard) dataset. AMBER produces more accurate and adaptive meshes, particularly in regions requiring fine detail and large variation in local mesh resolution. In contrast, the baseline methods exhibit artifacts or provide overly smooth or uniform sizing fields. For example, ASMR constrained by the depth of its reference mesh, leading to too-uniform meshes, while GraphMesh [24] and the Image [22] baseline greatly over- and under-estimate local regions.
I.2 Full Rollouts
Figures 16 and 17 illustrate full AMBER rollouts, showing the iterative mesh generation process from 1=0 to t=T=3 across all datasets. Figure 16 also visualizes the FEM solution on the expert for reference. Across datasets, each generation step incrementally refines the mesh adding geometric detail and improving alignment with the target solution. The refinement constant G, introduced in Section 3.3 ensures that early iterations produce coarser meshes, reducing computational cost in the initial stages.
38

---

+
1=0
t-2
1-3
Expert
Expert
Solution
Solution
Figure 16: Close-ups of AMBER rollouts on the Poisson (easylmedium/hard) and Laplace datasets from t=0 to t===3. Left, middle: For t<3, the colorscale denotes the prediction, otherwise the element size. Right: The colorscale shows the FEM solution on the zoomed-in in and full domain for the expert. Successive AMBER steps produce increasingly refined meshes that better match the expert, improving sampling resolution for the next sizing field prediction. The refinement constant ea from Section 3.3 controls mesh granularity over time, enabling coarse and efficient early steps.
t=0
t=1
1=2
1-3
Expert Expert (full view)
Figure 17: AMBER rollouts across the Airfoil, Console, Mold and Beam. The colorscale denotes predictions for I<3, and element size otherwise, with red indicating smaller values. As in Figure 16, each step provides an increasingly detailed mesh, improving the next prediction's 's sampling resolution.
39


Reviews:
[{"review_id": "H1TpxlVg59", "reviewer": "Reviewer_1QCu", "summary": "Authors propose AMBER, which introduces a hierarchical Message Passing Neural Network to iteratively predict spatially adaptive mesh sizing fields, guided by expert-labeled meshes. During training, each intermediate mesh’s vertices are “labeled” with target sizes derived from an expert-designed mesh for the same geometry. Through this label projection onto intermediate meshes, the model learns to mimic expert meshing strategies at each refinement step. This is an iterative process wherein, in each step, a graph model takes the mesh at that step as input and predicts the mesh element sizing field. This field is then passed on to the existing meshing tool (gmsh) to re-mesh the geometry. The method employs online data augmentation via a replay buffer of self-generated meshes to handle distribution shift. \n\nThe authors evaluate AMBER on six new datasets spanning 2D and 3D geometries (e.g. an L-shaped domain for a Poisson PDE, a lattice for Laplace’s equation, an airfoil shape, a 3D car console component, injection molding plates, and perforated beams). Comprehensive benchmarks on diverse 2D/3D datasets demonstrate substantial improvements over supervised and RL baselines in mesh quality and simulation accuracy. AMBER’s meshes are not just closer to the expert in a mathematical sense, but also improve actual simulation accuracy, as shown by the error-vs-element plots where AMBER’s curve nearly overlaps the expert’s and even trends slightly better for very fine meshes.\n\nThe authors introduce 6 novel datasets of geometries and corresponding expert-refined meshes. Some of these expert-refined meshes seem to be generated using heuristic rules, while others seem to be generated by a human expert refining the input mesh. It would be helpful to report how the different human experts refining and heuristic mesh quality differs.", "questions": "Is it feasible to train one AMBER model across multiple datasets or a very broad distribution of geometries? If the core strategy is truly task-agnostic, it would be interesting to know if the model could learn a more universal meshing strategy given a sufficiently diverse training set (maybe with additional conditioning on the type of problem)\n\nHow sensitive is AMBER to the quality and quantity of expert examples? \n\nCould the authors provide more evidence or reasoning on how the improved mesh quality translates to simulation accuracy or efficiency across tasks? \n\nWhat are the runtime and memory implications of AMBER compared to traditional adaptive meshing? An analysis of how long it takes to generate a mesh with AMBER (for a given number of elements) vs. a heuristic or an expert doing it manually would be very informative.", "limitations": "Yes", "rating": 4, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 3, "significance": 2, "originality": 2, "strengths_and_weaknesses": "The lack of experiments on cross-dataset generalization is a missed opportunity to demonstrate broader applicability. The current approach trains a separate model for each dataset/task, and there is no unified model or transfer learning demonstrated across different geometry types. While each model generalizes to new geometries within its domain (e.g., new airfoil shapes or new console designs) as shown in the experiments, it is unclear if a single model could handle multiple categories or if knowledge could be shared.\n\nThe paper doesn’t explore how the method might perform if the expert examples are suboptimal or inconsistent, or how many expert examples are needed. This limitation means AMBER’s success is tied to the availability of good training data, which could limit cases where it can be applied (e.g., novel applications with no prior meshing solutions available).\n\nMethod should directly evaluate simulation accuracy on the more complex 3D tasks and not just the simple Poisson example.\n\nDiscuss runtime or memory costs as mesh size becomes larger. The paper could discuss the sensitivity of the method to the initial mesh or the number of refinement steps (fixed or adaptive?) If fixed, choosing too low a value for refinement steps might limit quality, while too high adds cost but the paper does not detail how it is set, except that it matches the “number of refinement steps used during evaluation”. Clarifying such implementation details would improve reproducibility and clarity.", "was_revised": true, "final_justification": "The authors effectively addressed my primary concerns on cross-dataset generalization, runtime analysis, and sensitivity to refinement steps. A minor limitation remains regarding AMBER's dependence on the quality and consistency of expert meshes, though the authors clearly acknowledge this. Considering the substantial improvements provided in the rebuttal, I have positively updated my score.", "rebuttal": "We thank the reviewer for their thorough review and for acknowledging the comprehensive evaluation on our datasets. We address the raised questions below.\n\n> It would be helpful to report how the different human experts refining and heuristic mesh quality differs.\n> \n\nWe agree on the need to clarify mesh generation and quality. Appendix C details each dataset, and Table 1 summarizes the process. Each dataset uses human or heuristic meshes with strategies tailored to their applications. ```Poisson``` and ```Laplace``` apply an iterative heuristic based on an estimated FEM error. The other tasks have no single governing PDE associated with them, so their meshes are adapted for practical scenarios where one high‑quality mesh serves multiple simulations. For example, ```Console```   considers stress tests and thus refines around inner radii and bends, while ```Airfoil```  refines around the airfoil center. We will update the main paper to clarify this relationship.\n\n> The lack of experiments on cross-dataset generalization is a missed opportunity […] Is it feasible to train one AMBER model across multiple datasets or a very broad distribution of geometries?  […]\n> \n\nWe agree with the reviewer that training a single model across multiple datasets is an important experiment.  We have now additionally trained an AMBER model using the combined training data of ```Poisson``` (*hard*), ```Laplace``` and ```Airfoil```. We use the same experimental setup as in the paper. We append a one‑hot task indicator to the vertex features and zero unused dataset‑specific features. We use a shared replay buffer and do not weight the datasets. The markdown table below presents the Density-Aware Chamfer Distance (DCD) to the expert meshes, which is the metric used in Figure 3. We compare this new *Mixed* setup to the previous per-task AMBER and report mean and two times standard error across five seeds.\n\n| Method | Poisson | Laplace | Airfoil |\n| --- | --- | --- | --- |\n| Amber (Mixed) | 0.226 ± 0.011 | 0.222 ± 0.005 | 0.102 ± 0.002 |\n| Amber (Original)  | 0.224 ± 0.004 | 0.222 ± 0.003 | 0.103 ± 0.002 |\n\nWe observe no significant difference from training per‑task models, indicating that AMBER applies directly to datasets spanning multiple geometry families and meshing strategies. We plan to explore broader generalization in future work.\n\n> The paper doesn’t explore how the method might perform if the expert examples are suboptimal or inconsistent, or how many expert examples are needed.\n> \n\nAMBER is a supervised approach and thus assumes that the provided meshes are i.i.d. and optimal. It therefore imitates the given data and produces near‑optimal meshes when the data is optimal. Handling imperfect or inconsistent meshes is an interesting direction but beyond this paper’s scope.\n\nTable 10 in Appendix H.4 reports results for more and fewer expert meshes on ```Laplace```. We further evaluate the DCD across five seeds for 5, 10, 15, and 20 training meshes on ```Laplace```, ```Beam``` and ```Console``` in the table below. \n\n| #Samples | Laplace | Beam | Console |\n| --- | --- | --- | --- |\n| 5 | 0.240 ± 0.007 | 0.156 ± 0.002 | 0.542 ± 0.005 |\n| 10 | 0.231 ± 0.006 | 0.134 ± 0.003 | 0.540 ± 0.009 |\n| 15 | 0.224 ± 0.003 | 0.129 ± 0.002 | 0.534 ± 0.004 |\n| 20 (Default) | 0.222 ± 0.003 | 0.122 ± 0.003 | 0.535 ± 0.004 |\n\nAMBER benefits from more data, but yields accurate adaptive meshes from only 5 training meshes, still performing on par with or better than the best baselines of Figure 3, which are trained on 20 meshes. \n\n> Method should directly evaluate simulation accuracy on the more complex 3D tasks and not just the simple Poisson example.\n> \n\nWe thank the reviewer for suggesting more FEM evaluations. While most tasks have no concrete PDE associated with them, as mentioned above, we do simulate for ```Laplace``` and ```Poisson```. \n\nThe tables below show the error indicator norm of the simulation alongside DCD and element count across five seeds for AMBER and different baselines. We provide expert statistics on the test set for reference.\n\n| ```Laplace``` | Err. Indicator Norm | DCD | #Elements |\n| --- | --- | --- | --- |\n| Amber | 2.555 ± 0.050 | 0.222 ± 0.003 | 27622.5 ± 943.1 |\n| Amber (1-Step) | 2.568 ± 0.039 | 0.232 ± 0.002 | 27488.7 ± 706.0 |\n| Image (Var.) | 2.697 ± 0.062 | 0.253 ± 0.006 | 26745.2 ± 866.7 |\n| Image | 3.235 ± 0.174 | 0.328 ± 0.027 | 29297.8 ± 8065.7 |\n| Expert | 2.766 | N/a | 25130.5 |\n\n| ```Poisson``` (*hard*) | Err. Indicator Norm | DCD | #Elements |\n| --- | --- | --- | --- |\n| Amber | 0.031 ± 0.001 | 0.224 ± 0.004 | 27859.7 ± 1583.1 |\n| Amber (1-Step) | 0.032 ± 0.001 | 0.243 ± 0.011 | 28780.9 ± 2196.8 |\n| Image (Var.) | 0.034 ± 0.001 | 0.239 ± 0.010 | 24836.3 ± 1213.0 |\n| Image | 0.082 ± 0.071 | 0.454 ± 0.167 | 130571.3 ± 119228.3 |\n| GraphMesh (Var.) | 0.042 ± 0.007 | 0.330 ± 0.032 | 46841.7 ± 15014.0 |\n| GraphMesh | 0.034 ± 0.001 | 0.265 ± 0.005 | 31378.2 ± 4776.3 |\n| Expert | 0.033 | N/a | 25625.2 |\n\nThe error indicator norm strongly correlates with DCD, which measures expert similarity, across methods and tasks. This indicates that expert similarity is a good proxy for downstream simulation quality. AMBER consistently attains a lower FEM error indicator norm than baselines while closely matching the expert’s geometry and element budget. Its superior performance and the error–DCD correlation suggest AMBER meshes would perform well in downstream simulation.\n\n> Discuss runtime or memory costs as mesh size becomes larger.  […] What are the runtime and memory implications of AMBER compared to traditional adaptive meshing?\n> \n\nAMBER uses an MPN with runtime and memory costs linear in mesh size. Each AMBER step builds a graph, integrates it hierarchically, forwards through the MPN, and generates the next mesh from the predicted sizing field. The mesh generation step scales in O(N log N) and dominates cost. Since AMBER acts on coarse intermediate meshes, most of this cost incurs at the last generation step, which is also needed for all other methods. We report detailed AMBER runtimes for ```Poisson``` (*easy*/*hard*) in the table below to show how runtime costs shift for different mesh sizes.\n\n|  | Poisson (easy) |  | Poisson (hard) |  |\n| --- | --- | --- | --- | --- |\n| Category | Mean runtime (ms) | % of total | Mean runtime (ms) | % of total |\n| Mesh to graph conversion | 15.815 | 8.91 | 94.620 | 8.37 |\n| Adding hierarchical graph | 11.219 | 6.32 | 12.606 | 1.11 |\n| Model forward | 59.963 | 33.80 | 155.915 | 13.79 |\n| Mesh generation | 90.406 | 50.96 | 867.760 | 76.73 |\n\nGraph-related operations require linear memory cost. AMBER’s iterative process acts on coarser intermediate meshes, and the MPN never needs to process the final mesh. During evaluation, intermediate meshes with >100,000 elements fit on a consumer-grade NVIDIA 3090 GPU, allowing for potentially much finer meshes depending on the application.\n\n> The paper could discuss the sensitivity of the method to the initial mesh or the number of refinement steps (fixed or adaptive?)\n> \n\nWe thank the review for the suggestion to discuss the sensitivity to the initial mesh. We use 3 mesh generation steps for all experiments for AMBER, and compare to a AMBER (1-step) baseline that uses only one step. \n\nWe tested the sensitivity to the initial mesh for AMBER and AMBER (1-Step) on ```Laplace```. The table below shows DCD over five seeds for different maximum volumes of the initial mesh elements. The `*`  designates the resolution chosen in the paper. The resolution of AMBER (1-step) was tuned to be optimal while keeping the initial mesh smaller than the expert mesh.\n\n|  | Max. Initial Volume | DCD |\n| --- | --- | --- |\n| Amber | 0.001* | 0.222 ± 0.003 |\n|  | 0.0003 | 0.218 ± 0.002 |\n|  | 0.0001 | 0.218 ± 0.002 |\n|  | 0.00003 | 0.218 ± 0.003 |\n|  | 0.00001 | 0.222 ± 0.002 |\n| Amber (1-Step) | 0.001 | 0.360 ± 0.003 |\n|  | 0.0003 | 0.288 ± 0.002 |\n|  | 0.0001 | 0.255 ± 0.003 |\n|  | 0.00003* | 0.232 ± 0.002 |\n|  | 0.00001 | 0.229 ± 0.006 |\n\nAMBER is robust to initial mesh size, whereas AMBER (1‑Step) requires tuning.\n\nWe additionally ran experiments on two and four mesh generation steps on ```Laplace```, ```Beam``` and ```Console``` across five seeds, and provide the results in the table below.\n\n| #Steps | Laplace | Beam | Console |\n| --- | --- | --- | --- |\n| 1 (Amber (1-Step)) | 0.232 ± 0.002 | 0.260 ± 0.058 | 0.561 ± 0.021 |\n| 2 | 0.223 ± 0.002 | 0.126 ± 0.004 | 0.537 ± 0.004 |\n| 3 (Amber) | 0.222 ± 0.003 | 0.122 ± 0.003 | 0.535 ± 0.004 |\n| 4 | 0.223 ± 0.002 | 0.119 ± 0.002 | 0.540 ± 0.005 |\n\nAMBER performs well with two steps, improves slightly with three, and shows no gain beyond that, though additional steps may help for larger geometries.\n\n> An analysis of how long it takes to generate a mesh with AMBER (for a given number of elements) vs. a heuristic or an expert doing it manually would be very informative.\n> \n\nThe time to generate an expert mesh depends on the underlying task and the type of expert. For ```Console``` and ```Mold```, our human experts took 15-20 minutes per mesh. In contrast, AMBER generates a 3D mesh in <5 seconds. The table below additionally measures runtimes for AMBER and the expert heuristic on ```Poisson```.\n\n| Difficulty | Method | Total Time (s) | #Elements | Err. Indicator Norm |\n| --- | --- | --- | --- | --- |\n| Easy | Expert | 0.221 | 1091.1 | 0.160291 |\n|  | Amber | 0.150 | 1114.7 | 0.166470 |\n| Medium | Expert | 0.949 | 4472.9 | 0.079407 |\n|  | Amber | 0.271 | 4704.9 | 0.077271 |\n| Hard | Expert | 8.616 | 26372.8 | 0.032524 |\n|  | Amber | 1.024 | 28136.9 | 0.031236 |\n\nWe find that Amber has a relatively high overhead for small meshes, but becomes significantly faster than the iterative expert heuristic as meshes become larger.\n\n \n\nWe thank the reviewer for these suggestions and hope that we addressed all concerns raised. We will include the new results in the revised paper and welcome further questions in the discussion phase."}, {"review_id": "jPSYKlwFbG", "reviewer": "Reviewer_hXSF", "summary": "The paper introduces AMBER (Adaptive Meshing By Expert Reconstruction), a supervised framework for adaptive mesh generation (AMG). Starting from a coarse, uniform mesh, a message-passing network (MPN) iteratively predicts a vertex-wise sizing field using a hierarchical graph neural network formulation that keeps receptive fields stable across refinements, after which an off-the-shelf generator (Gmsh) refines the mesh accordingly. Each newly produced mesh is fed back as input, allowing the model to adjust its sampling density over successive steps. Training uses \"expert” meshes: AMBER projects their element sizes onto every intermediate mesh and stores these labelled rollouts in a replay buffer, mitigating covariate shift in the DAgger style. \n\nExperiments on six new 2-D/3-D datasets show that, against all baselines runnable on each task, AMBER lowers Density-Aware Chamfer Distance (DCD) and projected L2 errors.  On Poisson, it matches – and slightly surpasses – expert meshes on the high-resolution end ($\\approx$ 100 k elements) of the Poisson error-indicator curve. On the Laplace dataset, AMBER remains data-efficient, needing as few as five training geometries.", "questions": "1) Have you tried pre-training on one dataset and fine-tuning on another, or training a single model on all six datasets? \n2) What fraction of wall-clock time is spent inside Gmsh vs. the GNN forward pass?\n3) You fix $T=3$ (three mesh-generation steps).  How does performance change for $T=1,2,4$ in both training and inference?", "limitations": "Yes.", "rating": 5, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 4, "clarity": 4, "significance": 3, "originality": 3, "strengths_and_weaknesses": "**Strengths**\n\n- **Thorough Empirical Study (Quality and Significance):** The evaluation pipeline includes ablations on loss, hierarchical graph, buffer sampling, sizing-field parameterisation and data size, as well as comparisons to three baselines: Image (supervised, all datasets), GraphMesh (supervised, Poisson only) and ASMR (RL, Poisson only).\n\n- **Clarity:** The manuscript is well-written, results are well illustrated, and diagrams depicting the pipeline are present, which aid with understanding the proposed approach.\n- **Well-motivated Problem (Significance):** The problem is well-motivated. Manual AMG is a recognized bottleneck in FEM workflows, and replacing hand-tuned heuristics with learned sizing-field prediction is valuable.\n- **Clean and Modular Design (Originality):** The three-step roll-out with a self-bootstrapped replay buffer is conceptually simple yet effectively addresses covariate shift (a weakness of prior one-shot approaches).\n\n**Weaknesses**\n\n- **Isotropic Sizing Field (Significance):** The current formulation cannot express anisotropic element stretching, a common requirement near boundary layers and shock fronts.\n- **Baseline Coverage (Significance):**  Because GraphMesh and ASMR run only on Poisson, the cross-dataset comparison relies mainly on the authors’ Image baseline. \n- **Physics-level Validation (Significance):** Only Poisson tasks include an FEM error indicator, while the other five datasets are judged purely on geometric distance.", "was_revised": true, "final_justification": "The authors have sufficiently addressed my questions during the rebuttal period, and I maintain my positive score of **Accept**.", "rebuttal": "We thank the reviewer for their detailed and positive review, especially for highlighting the rigour of our experimental setup. In the following, we will briefly address the individual questions and concerns raised.\n\n> The current formulation cannot express anisotropic element stretching, a common requirement near boundary layers and shock fronts.\n> \n\nWe agree that anisotropic meshing is an important property for adaptive mesh generation approaches. While extending AMBER to anisotropic meshes is out of scope for this work, doing so should be relatively straightforward. Instead of using a frontal Delaunay algorithm for meshing, we would need to use an anisotropic mesh generation algorithm, such as BAMG, which is readily implemented in gmsh. AMBER then needs to provide a tensor instead of a scalar field, which can be realised by adapting its output dimension per vertex and making its GNN architecture equivariant, similar to [1]. We leave this as an interesting avenue for future work.\n\n[1] Bekkers, Erik J., et al. \"Fast, Expressive SE(n) Equivariant Networks through Weight-Sharing in Position-Orientation Space.\" *2024*, ICLR\n\n> Because GraphMesh and ASMR run only on Poisson, the cross-dataset comparison relies mainly on the authors’ Image baseline.\n> \n\nWe fully agree that broader baseline coverage would strengthen the comparison. However, existing methods are constrained to specific settings. For example, GraphMesh only works on polygonal domains and ASMR ties its refinement to an underlying FEM, so they cannot be applied to the full range of tasks supported by AMBER. To still provide meaningful comparisons, we extended the image baseline to 3D CNNs for 3D tasks, introduced Image (Var.) as a more optimized image-based approach, and included AMBER (1‑Step) as a general-purpose GNN-based one-step mesh generation method. We additionally provide example meshes in Appendix I for a qualitative comparison to other methods and the expert.\n\n> Only Poisson tasks include an FEM error indicator, while the other five datasets are judged purely on geometric distance.\n> \n\nMost of our datasets only consider expert meshes rather than any specific underlying PDE, and therefore no FEM error indicator is available. These meshes reflect practical engineering scenarios, where the same adaptive mesh may serve multiple downstream simulations without being tied to a single scenario. For example, ```Console``` meshes may be used for various stress tests, and ```Airfoil``` for different kinds of fluid flow simulations.\n\nFor the two tasks that do have an associated FEM, i.e., ```Laplace``` and ```Poisson```, we report FEM error indicator norms in the table below. We report the (*hard*) version of ```Poisson``` as it is the most challenging, and also provide the number of elements and the Density-Aware Chamfer Distance (DCD) to the expert mesh. These metrics correspond to Figures 4 and 3 of the main paper, respectively. Values are reported as mean and twice the standard error over 5 seeds. For reference, we also include the error indicator norm and element count of the expert heuristic. All statistics are computed on the test set, while Table 2 in Appendix C reports expert statistics on the training set.\n\n| ```Laplace``` | Err. Indicator Norm | DCD | #Elements |\n| --- | --- | --- | --- |\n| Amber | 2.555 ± 0.050 | 0.222 ± 0.003 | 27622.5 ± 943.1 |\n| Amber (1-Step) | 2.568 ± 0.039 | 0.232 ± 0.002 | 27488.7 ± 706.0 |\n| Image (Var.) | 2.697 ± 0.062 | 0.253 ± 0.006 | 26745.2 ± 866.7 |\n| Image | 3.235 ± 0.174 | 0.328 ± 0.027 | 29297.8 ± 8065.7 |\n| Expert | 2.766 | N/a | 25130.5 |\n\n| ```Poisson``` (*hard*) | Err. Indicator Norm | DCD | #Elements |\n| --- | --- | --- | --- |\n| Amber | 0.031 ± 0.001 | 0.224 ± 0.004 | 27859.7 ± 1583.1 |\n| Amber (1-Step) | 0.032 ± 0.001 | 0.243 ± 0.011 | 28780.9 ± 2196.8 |\n| Image (Var.) | 0.034 ± 0.001 | 0.239 ± 0.010 | 24836.3 ± 1213.0 |\n| Image | 0.082 ± 0.071 | 0.454 ± 0.167 | 130571.3 ± 119228.3 |\n| GraphMesh (Var.) | 0.042 ± 0.007 | 0.330 ± 0.032 | 46841.7 ± 15014.0 |\n| GraphMesh | 0.034 ± 0.001 | 0.265 ± 0.005 | 31378.2 ± 4776.3 |\n| Expert | 0.033 | N/a | 25625.2 |\n\nThese new results show a high correlation between the error indicator norm and the DCD, suggesting that expert similarity is a good indicator for downstream performance. AMBER achieves a significantly lower FEM error indicator norm than the baselines while remaining close to the expert’s geometry and element budget. AMBER’s strong performance on both FEM-associated datasets, combined with the correlation between error indicator and DCD, indicates that AMBER meshes would likely perform similarly well on different downstream simulations on the other datasets.\n\n> Have you tried pre-training on one dataset and fine-tuning on another, or training a single model on all six datasets?\n> \n\nWe ran additional experiments on a dataset combining ```Poisson``` (*hard*) ```Laplace```, and ```Airfoil```. The experiment uses the same model- and hyperparameters as all other AMBER experiments in the paper, and simply concatenates the 20 training meshes of all tasks into a total of 60 expert meshes for training. For the node features, we additionally one-hot encode the task and zero out task-specific features that are not available for some tasks. We use a shared replay buffer and do not weight meshes from the datasets. The table below shows the mean and two times standard error of the DCD for this *Mixed* setup. \n\n| Method | Poisson | Laplace | Airfoil |\n| --- | --- | --- | --- |\n| Amber (Mixed) | 0.226 ± 0.011 | 0.222 ± 0.005 | 0.102 ± 0.002 |\n| Amber (Original)  | 0.224 ± 0.004 | 0.222 ± 0.003 | 0.103 ± 0.002 |\n\nWe find that there is no significant difference in performance to training individual models, suggesting that AMBER can straightforwardly be applied to datasets comprising multiple different geometry families and meshing strategies. These results open up interesting avenues for future work, such as training a general-purpose foundation model for mesh generation.\n\n> What fraction of wall-clock time is spent inside Gmsh vs. the GNN forward pass?\n> \n\nEach AMBER iteration consists of a creating a graph, adding this to a hierarchical graph, forwarding the result through the MPN model, and then generating the next mesh from the predicted sizing field. The fraction of time that each step takes depends on the size of the created mesh. We show results for ```Poisson``` (*easy*) and ```Poisson``` (*hard*) in the tables below. \n\n|  | Poisson (easy) |  | Poisson (hard) |  |\n| --- | --- | --- | --- | --- |\n| Category | Mean runtime (ms) | % of total | Mean runtime (ms) | % of total |\n| Mesh to graph conversion | 15.815 | 8.91 | 94.620 | 8.37 |\n| Adding hierarchical graph | 11.219 | 6.32 | 12.606 | 1.11 |\n| Model forward | 59.963 | 33.80 | 155.915 | 13.79 |\n| Mesh generation | 90.406 | 50.96 | 867.760 | 76.73 |\n\nAs meshes become bigger, the graph generation and model forward scale linearly with the size of the mesh, while the mesh generation scales in O(N log N). Since AMBER acts on a series of coarse intermediate meshes, the last generation step is by far the most expensive. A similar generation step is also needed for the one-shot baselines. \n\n> How does performance change for T=1,2,4 in both training and inference?\n> \n\nWe thank the reviewer for the insightful question. We ran five AMBER with 1-4 mesh generation steps for five seeds on the datasets that we used for the extended results in Appendix G, i.e., ```Laplace```, ```Beam``` and ```Console```. We report the DCD in the table below. \n\n| #Steps | Laplace | Beam | Console |\n| --- | --- | --- | --- |\n| 1 (Amber (1-Step)) | 0.232 ± 0.002 | 0.260 ± 0.058 | 0.561 ± 0.021 |\n| 2 | 0.223 ± 0.002 | 0.126 ± 0.004 | 0.537 ± 0.004 |\n| 3 (Amber) | 0.222 ± 0.003 | 0.122 ± 0.003 | 0.535 ± 0.004 |\n| 4 | 0.223 ± 0.002 | 0.119 ± 0.002 | 0.540 ± 0.005 |\n\nThe results indicate that as few as two mesh generation steps are sufficient, although three steps perform slightly better. Adding an additional fourth step does not generally improve performance. Note that the MPN’s prediction is independent of the step, and that a model trained on, e.g., four steps can also be evaluated for only two steps, potentially at slight degradation of performance because of some irrelevant data in the training replay buffer.\n\nWe hope that our clarifications and newly provided results address the concerns raised. If there are further questions about the paper, we encourage the reviewer to reach out to us during the discussion for further clarification. We also want to thank the reviewer again for suggesting the above experiments, and will include them and their results in the revised paper."}, {"review_id": "vDU9dYeZ42", "reviewer": "Reviewer_MLnH", "summary": "This work introduces AMBER, a novel data-driven method for adaptive mesh generation. AMBER iteratively refines a mesh sizing field, which can subsequently be utilized by standard mesh generators for downstream application. During its training phase, the method is supervised by projecting element sizes from expertly crafted meshes onto intermediate meshes. Additionally, a replay buffer is maintained, containing model-generated meshes to facilitate data augmentation and stabilize the training process. Extensive experiments conducted on both 2D and 3D datasets indicate that AMBER consistently produces meshes of superior quality compared to both supervised learning and reinforcement learning baselines.", "questions": "Using a graph neural network makes sense but then why a MPN and not for instance a GAT ? Please elaborate.\n\nFrom an end-user perspective, controllability is essential: did you consider the possibility of conditioning your approach on a user input such as a picture/mask or a specific mesh annotation to enforce -- for instance -- mesh refinement (or simplification) in a user-defined area?", "limitations": "yes", "rating": 5, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 3, "significance": 3, "originality": 2, "strengths_and_weaknesses": "### Strengths\n\nThe paper is clear, well structured, backed by strong experiment results and ablations. The literature review is also addressed seriously and seems quite comprehensive and up to date. \n\nTo the best of my understanding of GNN, the paper is mathematically sound. \n\nThe provided code is clean, well structured and well documented. \n\n### Weaknesses\n\nI'm a bit confused as it seems AMBER was introduced last year in this paper: https://arxiv.org/pdf/2406.14161\nIs the current paper supposed to be a new version of this paper or should rather it be considered as a revision ?", "was_revised": true, "final_justification": "I appreciate the effort and detailed response provided by the authors in the rebuttal. I believe that my concerns have been well addressed, leaving me with a positive opinion about this work. I update my rating from 4: Borderline accept to 5: Accept.", "rebuttal": "We would like to thank the reviewer for the positive review, and we appreciate the feedback that the paper is well-structured, has strong evaluations and is mathematically sound. \n\nThe reviewer raised one weakness, namely an arXiv paper they linked. We appreciate the detailed research of the related work and want to highlight that the mentioned arXiv paper was only presented at a non‑archival workshop. According to the NeurIPS guidelines, specifically the second question in the FAQ section, such workshop versions do not preclude submission to NeurIPS:\n\n> *Q: What if I’ve seen similar work in a NeurIPS/ICML workshop?*\n> \n> \n> ***A:** We allow work that has been submitted to non‑archival workshops to be submitted to NeurIPS. To maintain anonymity, do not mention the workshop paper in your review.*\n> \n\nThe present submission substantially extends prior non-archival work and has not appeared in any archival venue. It includes new theoretical results, a different parameterization of the sizing field, two additional baselines and four additional datasets, as well as more thorough evaluation. We kindly ask the reviewer to assess the submission without considering the arXiv paper.\n\nWe thank the reviewer for the questions they raised, and will provide detailed answers in the following.\n\n> Using a graph neural network makes sense but then why a MPN and not for instance a GAT?\n> \n\nWe thank the reviewer for asking about this comparison. MPNs have been shown to be a more expressive class of GNNs than GATs [1,2] and encompass the function class of several classical solvers [3]. As such, they have been widely used for physical simulations [4, 5] and adaptive mesh refinement [6]. We therefore adopt the MPN architecture for AMBER, as it is a natural and popular choice for processing graphs in physics-based applications.\n\nThat said, AMBER predicts a scalar sizing field per vertex, leading to relatively smooth predictions across the graph topology. A GAT with edge features, as used in an ablation in [6], could therefore perform similarly well, and a detailed exploration of alternative GNN architectures would be an interesting avenue for future work.\n\n[1] Veličković, Petar. \"Everything is connected: Graph neural networks.\" *Current Opinion in Structural Biology,* 2023.\n\n[2] Bronstein, Michael M., et al. \"Geometric deep learning: Grids, groups, graphs, geodesics, and gauges.\" *arXiv*, 2021.\n\n[3] Brandstetter, Johannes, et al. “Message passing neural PDE solvers”. *ICLR,* 2022.\n\n[4] Pfaff, Tobias, et al. \"Learning mesh-based simulation with graph networks.\" *ICLR*, 2020.\n\n[5] Linkerhägner, Jonas, et al. \"Grounding Graph Network Simulators using Physical Sensor Observations.\" *ICLR*, 2023.\n\n[6] Freymuth, Niklas, et al. \"Swarm reinforcement learning for adaptive mesh refinement.\" *NeurIPS*, 2023.\n\n> did you consider the possibility of conditioning your approach on a user input such as a picture/mask or a specific mesh annotation to enforce -- for instance -- mesh refinement (or simplification) in a user-defined area?\n> \n\nWe thank the reviewer for the question and suggestion. The current work does not consider user inputs during runtime, and instead relies on the quality of the expert meshes that the model is trained on. \n\nHowever, AMBER works by predicting a series of sizing fields, which are scalar functions on the given domain. To integrate user input, one could simply manipulate this sizing field in user-defined regions, e.g., by interpolating between the user’s preferences and AMBER’s suggested sizing field. We show in Figure 4 that AMBER can generate meshes with different numbers of elements by scaling all predictions with a single scalar. To adapt this to user preferences, one could derive a scaling term for each region of the mesh, or even each mesh vertex, from the user annotations.\n\n> Figure 4 is somewhat hard to read\n> \n\nWe would like to thank the reviewer for pointing this out and will improve the figure and the extended Figure 11 in the appendix in the revised version of the paper.\n\nWe hope that our clarifications, especially regarding the non-archival workshop paper posted by the reviewer, address the concerns raised. If there are any remaining questions, we encourage the reviewer to reach out to us during the discussion for further clarification."}, {"review_id": "ttgEBNhtcr", "reviewer": "Reviewer_h6nt", "summary": "This paper introduces AMBER - Adaptive Meshing By Expert Reconstruction an Adaptive Mesh Generation (AMG) algorithm used to generate meshes for finite element methods for solving stationary PDEs. The problem setting is formulated as a supervised learning problem, where the target is the element sizing field (ESF) extracted from expert meshes and a MPN style hierarchical GNN is trained to predict the ESF over the PDE domain. Secondarily the ESF is input into the existing frontal Delauney algorithm implemented in GMSH for generating the adapted meshes.\n\nThe literature review in the paper correctly sights existing works in this line of research that predict mesh sizing field, however they point several advances on the existing works. The two main novelties of this work are the iterative, instead of 1-shot, mesh generation pipeline and the contribution of the 6 new expert mesh datasets.\n\nA key component of the iterative pipeline is the experience replay buffer, a trick adopted from the RL baseline ASMR, that facilitates training at different lengths scales by bootstrapping a dataset preventing distribution shift from coarse to refined meshes. The bootstrapped dataset is created via projecting the expert mesh sizing fields (targets) onto the intermediate meshes generated from training predictions.\n\nSeveral other training tricks including stratified batching, normalisation, residual prediction, clipping and softplus transform are used to create a stable training pipeline.\n\nThe method is evaluated on 6 new meshing datasets derived from expert methods using density aware chamfer distance (DCD) and error indicators as evaluation metrics.", "questions": "As stated above I have a few clarifications needed on the iterative procedure andconcerns over the time complexity of the method.\nHow does the mesh generator consume the per vertex predicted sizing field? I am used to specifying regions or functions for sizing field in GMSH not a pointwise sizing field - providing more details here would be useful for the reader.\nHow are the GNN parameters of different scales of the GNN message treated? Are they shared or are there different parameters for different length scales?", "limitations": "Yes", "rating": 4, "confidence": 5, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 2, "clarity": 3, "significance": 3, "originality": 3, "strengths_and_weaknesses": "ML based adaptive meshing via prediction of the element sizing field is a technique already employed by multiple works as referenced by the authors. However the iterative mesh generation, in both training and inference, seems novel and key in achieving successful performance of the model. Other strengths of the paper include the detailed explanation of the tricks used in training and the controllability of the resolution of the model. The new datasets provided by the authors include complex tasks, non-convex domains and 3D examples and are a valuable assets for the community.\n\nClarity - I found there is some ambiguity in the explanation of the iterative procedure section 3.1, I had to infer extra understanding from the paragraphs on \"Residual Prediction\" and \"Scaling Sizing Fields\". I am still not clear how the iterative procedure exactly works. Is the intermediate mesh refined as in old nodes are kept and new nodes are added. Or at each step is the intermediate used to generate the sizing field but the mesh is thrown away? Then the number of nodes is roughly decided by the c_t parameter? If so what is an example schedule of the {c_t} and how does this typically translate into number of nodes?\n\nAlso in training based on the \"residual prediction\" it is unclear how the \"current discrete sizing field\"  is generated. Is it the expert sizing field or the previous step prediction?\n\nEvaluation - Whilst the evaluation is done using the DCD distance metric against the expert meshes I think this misses the point that adaptive meshing is intended to reduce FEM approximation error which is not reported. All baseline M2N/UM2N/ASMR have some actual FE error based metric. Without seeing this evaluation it is difficult to know if the generated meshes actually perform better in terms of error reduction and solution stability.\n\nTiming - Also no meshing times are provided. This is concerning because adaptive meshing is intended to accelerate FE methods by optimising the trade off between error and complexity. I am confident the method scales in the size of the mesh as evidenced by the use of reasonably large meshes (up to 100k nodes) in the experiments. However I have some concerns on the time complexity of the approach. There are a few reasons the method might be prohibitively slow. At each step in the iteration, I understand, a full new mesh is generated, rather than iterative refinement. I also notice at each step there is a requirement to; i) construct the hierarchical graph using multiple meshes via nearest neighbours, ii) calculate surface normal edge features, iii) add labels of the ESF for the replay buffer, all these step may incur significant cost.\n\nOne fundamental requirements for scaling this aproach is that the framework requires expert meshes. Currently the datasets are quite small (20 examples). The authors show evidence AMBER generalize to higher number of elements (100k versus 30k seen in training) and on the Lapalce 2D lattice problem with few-shot learning (but still in-distribution) lattices. The question remains does the framework generalise to a new tasks? Or would it need expert meshes and retraining?\n\nMy concerns over evaluation and timing are the main factor in my currently low score.", "was_revised": true, "final_justification": "My previous concerns over evaluation were too strong given the method is PDE independent. The authors have also addressed my concern on time complexity and somewhat on dataset generalisation.", "rebuttal": "We thank the reviewer for their thorough review, and especially their critical assessment of the clarity of writing for our iterative mesh generation procedure. In the following, we will clarify the mentioned points and address the individual concerns raised by the reviewer.\n\n> AMBER [is] used to generate meshes for finite element methods for solving stationary PDEs. […] the target is the element sizing field (ESF)\n> \n\nWe would like to clarify that AMBER may generate meshes independent of an underlying PDE. In our experiments, four datasets rely solely on geometry, and while the two PDE-specific datasets are stationary, the method is not limited to stationary cases and datasets like ```Airfoil``` and ```Console``` are created with non-stationary simulations in mind.\n\nWhile the sizing field describes the element sizes, it is defined on vertices rather than elements, yielding a piecewise‑linear rather than piecewise‑constant field.  We detail and justify this choice in Appendix H.3.\n\n> […] at each step is the intermediate used to generate the sizing field but the mesh is thrown away? Then the number of nodes is roughly decided by the c_t parameter? If so what is an example schedule of the {c_t} and how does this typically translate into number of nodes?\n> \n\nAMBER generates a new mesh at each step from predicted sizing fields, using previous meshes only as sampling points to predict the sizing field on. We briefly contrast adaptive mesh refinement methods in the “Related Work” and will further clarify this relationship in the revision.\n\nThe $c_t$ parameter is a scalar applied to the predicted sizing field. As mentioned in Table 3 in Appendix D.4, we set it to the golden ratio $1.618^{T-t-1}$ for all experiments, with $c_{T-1}=1$ leading to no scaling for the last generation step. The mesh size scales roughly in $\\frac{1}{c_t}^d$, where $d$ is the dimension of the data.\n\n> Also in training based on the \"residual prediction\" it is unclear how the \"current discrete sizing field\" is generated. Is it the expert sizing field or the previous step prediction?\n> \n\nThe current discrete sizing field is generated by projecting the characteristic edge lengths of the elements of the *current* mesh onto its vertices, as described by Equation 3. We use neither the expert sizing field nor the previous prediction directly. We will clarify this relationship in the revised version of this paper.\n\n> I think this misses the point that adaptive meshing is intended to reduce FEM approximation error which is not reported. All baseline M2N/UM2N/ASMR have some actual FE error based metric.\n> \n\nWe fully agree that adaptive meshing is intended to reduce FEM approximation error. Most of our datasets are designed to evaluate general‑purpose mesh generation without a specific associated PDE. We assume optimal expert meshes and therefore expect that accurate imitation leads to near‑optimal meshes for downstream simulations.\n\nHowever, we do have a concrete PDE for both ```Laplace``` and ```Poisson``` and already evaluate the FEM error indicator norm for the latter in Figure 4. The table below reports mean and two times standard error over five seeds for both datasets for AMBER, the baselines, and the expert heuristic. We provide DCD and element counts for reference.\n\n| ```Laplace``` | Err. Indicator Norm | DCD | #Elements |\n| --- | --- | --- | --- |\n| Amber | 2.555 ± 0.050 | 0.222 ± 0.003 | 27622.5 ± 943.1 |\n| Amber (1-Step) | 2.568 ± 0.039 | 0.232 ± 0.002 | 27488.7 ± 706.0 |\n| Image (Var.) | 2.697 ± 0.062 | 0.253 ± 0.006 | 26745.2 ± 866.7 |\n| Image | 3.235 ± 0.174 | 0.328 ± 0.027 | 29297.8 ± 8065.7 |\n| Expert | 2.766 | N/a | 25130.5 |\n\n| ```Poisson``` (*hard*) | Err. Indicator Norm | DCD | #Elements |\n| --- | --- | --- | --- |\n| Amber | 0.031 ± 0.001 | 0.224 ± 0.004 | 27859.7 ± 1583.1 |\n| Amber (1-Step) | 0.032 ± 0.001 | 0.243 ± 0.011 | 28780.9 ± 2196.8 |\n| Image (Var.) | 0.034 ± 0.001 | 0.239 ± 0.010 | 24836.3 ± 1213.0 |\n| Image | 0.082 ± 0.071 | 0.454 ± 0.167 | 130571.3 ± 119228.3 |\n| GraphMesh (Var.) | 0.042 ± 0.007 | 0.330 ± 0.032 | 46841.7 ± 15014.0 |\n| GraphMesh | 0.034 ± 0.001 | 0.265 ± 0.005 | 31378.2 ± 4776.3 |\n| Expert | 0.033 | N/a | 25625.2 |\n\nAMBER achieves lower error indicators than the baseline methods while keeping in the expert’s element budget. The strong correlation between the error metric and DCD across methods further supports the use of DCD as a reliable proxy on datasets where direct FEM error is not available. As AMBER performs best in terms of DCD on all six datasets, its meshes would likely perform well on downstream simulations.  Appendix I further supports these findings by showing that AMBER meshes are qualitatively similar to the expert.\n\nBoth M2N and UM2N are mesh movement methods that act on a fixed number of mesh elements and require PDE parameters as input. We thus do not consider these methods as baselines. We will make this distinction more explicit in our \"Related Work\" section in the revision.\n\n> […] no meshing times are provided. […] There are a few reasons the method might be prohibitively slow. […] there is a requirement to; i) construct the hierarchical graph using multiple meshes via nearest neighbours, ii) calculate surface normal edge features, iii) add labels of the ESF for the replay buffer, all these step may incur significant cost.\n> \n\nWe decompose AMBER’s runtime into graph construction, hierarchical extension, model forward, and mesh generation. We note that label calculation is only performed during training and has negligible runtime impact. The table below shows how runtimes and relative costs differ between mesh sizes for ```Poisson``` (*easy*/*hard*).  \n\n|  | Poisson (easy) |  | Poisson (hard) |  |\n| --- | --- | --- | --- | --- |\n| Category | Mean runtime (ms) | % of total | Mean runtime (ms) | % of total |\n| Mesh to graph conversion | 15.815 | 8.91 | 94.620 | 8.37 |\n| Adding hierarchical graph | 11.219 | 6.32 | 12.606 | 1.11 |\n| Model forward | 59.963 | 33.80 | 155.915 | 13.79 |\n| Mesh generation | 90.406 | 50.96 | 867.760 | 76.73 |\n\nThe mesh generation step is in O(N log N) and dominates runtime compared to the linear graph-related operations, especially for larger meshes. We note that AMBER acts on coarse intermediate meshes, and that the expensive last generation step is also required for the one-step baselines.\n\nFor reference, we also provide the average total mesh generation times of AMBER and the expert heuristic for  ``Poisson``` (*easy/medium/hard*) in the table below. \n\n| Difficulty | Method | Total Time (s) | #Elements | Err. Indicator Norm |\n| --- | --- | --- | --- | --- |\n| Easy | Expert | 0.221 | 1091.1 | 0.160291 |\n|  | Amber | 0.150 | 1114.7 | 0.166470 |\n| Medium | Expert | 0.949 | 4472.9 | 0.079407 |\n|  | Amber | 0.271 | 4704.9 | 0.077271 |\n| Hard | Expert | 8.616 | 26372.8 | 0.032524 |\n|  | Amber | 1.024 | 28136.9 | 0.031236 |\n\nAMBER is slightly faster than the expert for small meshes and shows significantly better scaling as mesh size increases. Similarly, AMBER mesh generation for the 3D tasks takes less than five seconds, while the human experts took 15 to 20 minutes per mesh.\n\n> […] does the framework generalise to a new tasks? Or would it need expert meshes and retraining?\n> \n\nWe agree that data efficiency and cross-task generalization are important factors of adaptive mesh generation algorithms. \n\nTo test AMBER across datasets, we trained a single model on a combined dataset containing ```Poisson``` (*hard*), ```Laplace```, and ```Airfoil```. We used the same architecture and hyperparameters as in the main experiments and simply concatenated the 20 expert meshes per task into 60 total training meshes. We one-hot encode the task in the node features, and zero out task‑specific features when unavailable. We use a shared replay buffer and do not weight the data. The table below shows the mean and two times standard error of the DCD for this *Mixed* setup. \n\n| Method | Poisson | Laplace | Airfoil |\n| --- | --- | --- | --- |\n| Amber (Mixed) | 0.226 ± 0.011 | 0.222 ± 0.005 | 0.102 ± 0.002 |\n| Amber (Original)  | 0.224 ± 0.004 | 0.222 ± 0.003 | 0.103 ± 0.002 |\n\nThe *Mixed* setup performs on par with AMBER trained on individual tasks, indicating that the same model can learn meshing strategies across different datasets and domains. We leave a general-purpose mesh generation model for future work.\n\n> How does the mesh generator consume the per vertex predicted sizing field?\n> \n\nConceptually, we use the vertex-level sizing fields to create a piecewise linear function via the interpolant of Equation 1. Here, we essentially interpret the sizing field as a linear basis on the vertices and interpolate it onto the full mesh.\n\nCode-wise, we use gmsh’s `.pos` options to write the sizing field onto the vertices of a background mesh using “Scalar Triangle” for and “Scalar Tetrahedron” formats. We then provide this background mesh to the meshing algorithm. We refer to the `def update_mesh()`  function in the supplementary code submission for technical details.  \n\n> How are the GNN parameters of different scales of the GNN message treated? Are they shared or are there different parameters for different length scales?\n> \n\nAMBER uses the same MPN to process all meshes. Each message passing layer has its own parameters as described in Section 3, but these parameters are shared across mesh generation steps. Differences in scale and hierarchy are handled purely by encoding distances between vertices as edge features and by one‑hot encoding vertices that belong to the hierarchical mesh.\n\nWe want to thank the reviewer again for the detailed questions. We hope that our clarifications and new results, particularly regarding generalization and runtime, address the concerns raised. We will add both to the revised paper. We encourage the reviewer to reach out to us during the discussion if there are further questions."}]

Author rebuttal:

Meta-review: The paper proposes a graph neural network to efficiently predict/refine the meshes to match expert-created meshes. The main contribution of this work is the network architecture and the datasets that match real-world settings. The reviewers have unanimous support for this paper, valuing its significance in the task and the quality of the paper’s presentation. There were a few clarifying questions on the papers’ details, and they were resolved during the discussion period. The AC does not find reason to overturn the reviewers’ recommendation.
Decision: Accept (poster)