M4GN: Mesh-based Multi-segment Hierarchical Graph Network for Dynamic Simulations
Authors: Bo Lei
Victor M Castillo
Yeping Hu
Venue: Accepted by TMLR ()

Abstract: Mesh-based graph neural networks (GNNs) have become effective surrogates for PDE simulations, yet their deep message passing incurs high cost and over‑smoothing on large, long‑range meshes; hierarchical GNNs shorten propagation paths but still face two key obstacles: (i) building coarse graphs that respect mesh topology, geometry, and physical discontinuities, and (ii) maintaining fine-scale accuracy without sacrificing the speed gained from coarsening. We tackle these challenges with M4GN—a three‑tier, segment‑centric hierarchical network. M4GN begins with a hybrid segmentation strategy that pairs a fast graph partitioner with a superpixel‑style refinement guided by modal‑decomposition features, producing contiguous segments of dynamically consistent nodes. These segments are encoded by a permutation‑invariant aggregator, avoiding the order sensitivity and quadratic cost of aggregation approaches used in prior works. The resulting information bridges a micro‑level GNN—which captures local dynamics—and a macro‑level transformer that reasons efficiently across segments, achieving a principled balance between accuracy and efficiency. Evaluated on multiple representative benchmark datasets, M4GN improves prediction accuracy by up to 56\% while achieving up to 22\% faster inference than state‑of‑the‑art baselines.

Published in Transactions on Machine Learning Research (09/2025)
M4GN: Mesh-based Multi-segment Hierarchical Graph Net- work for Dynamic Simulations
Bo Lei
leif @llnl. gov
Lawrennce Livermore National Laboratory
Victor M. Castillo
castillo3@llnl.cmm
Lawrence Livermore National Laboratory
Yeping Hu
hu25@ttnl.goo
Lawrence Livermore National Laboratory
Reviewed on OpenReview: https: /ttp:///opeeeveeeeeee net/ forum? R3aDbqWalv
Abstract
Mesh-based graph neural networks (GNNs) have become effective surrogates for PDE simulations, yet their deep message passing incurs high cost and over-smoothing on large, long-range meshes; hierarchical GNNs shorten propagation paths but still face two key obstacles: (i) building coarse graphs that respect mesh topology, geometry, and physical discontinuities, and (ii) maintaining fine-scale accuracy without sacrificing the speed gained from coarsening. We tackle these challenges with M4GN-a threo-tier, segment-centric hierarchical net work. M4GN begins with hybrid segmentation strategy that pairs fast graph partitioner with a superpixel-style refinement guided by modal-decompositionn features, producing contiguous segments of dynamically consistent nodes. These segments are encoded by a permutation-invann aggregation approaches used prior works. The resulting information bridges micro-level GNN which captures local dynamics and macro-level transformer that reasons efficiently across segments, achieving principled balance between accuracy and efficiency. Evaluated multiple representative benchmark datasets, M4GN improves prediction accuracy by up to 56% while achieving up to 22% faster inference than state-of-tho-art basclines.
aggregator, avoiding the order sensitivity and quadratic cost of
1 Introduction
Numerically solving partial differential equations (PDEs) to model dynamical systems is fundamental in science and engineering but is often computationally intensive, especially in time-sensitive applications requiring rapid inference. This has prompted increased attention on adopting learning-basse surrogate models (Sun et al,
2020) to expedite numerical simulations, addressing the computational challenges associated with traditional solvers. Among these methods, mesh-based Graph Neural Network (GNN) methods (Pfalf et al. 2020 Gao
et al. 2022 Hu et al.] 2023) have proved highly effective for simulating dynamical systems discretized
unstructured meshes. Information is propagated by stacking successive message- passing layers across mesh odges. When the mesh graph becomes very large-or when the underlying physics couples spatially distant regions (e.g,, vortex vortex-vorted vortex interactions in fluids or boundary loads transmitted along an elastic beam) a substantial mumber of message- paassaggpsssing iterations required for information to traverse the graph (Fortunato) ct al. 2022). This growth in node count and propagation depth inflates computational cost, while the deeper propagation ovorssmooths node embeddings and erodes accuracy (Chen al. 2020 Yang al.) (2020] Keriven
message-passing
20221. To mitigate these effects, recent. work has introduced hierarchical
GNNs that learn coarse graph

---

Published in Transactions on Machine Learning Research (09/2025)
representations and pass messages across multiple resolutions, thereby shortening information information-rroogaaton paths and reducing the depth required for expressive receptive fields (Gao & Ji 2019 Li et al. 2020: Lino
et al., 2022j. Such models have achieved state-of-the-art accuracy on challenging benchmarks and some of them have shown substantial speed-ups over single-scale mesh-based GNNs. Nevertheless, two limitations persist, which we examine in detail the following subsections.
Table 1: Comparison of strategies used to construct coarse-level graphs in hierarchical GNN models for physics-based simulations. Here are the definitions for each evaluation criterion: Heuristic: the method is driven by a fixed, hand-crafted rule rather than by parameters learned from data; Conliguily: the method produces coarse elements that remain internally connected and never bridge gaps, holes, or material interfaces; Geometric Fidelity: the method maintains the original clement shapes and sizes closcly enough to avoid severe geometric distortion; Physics-Auaat Aware: the method incorporates physical information- such as material domains, boundary conditions, or regions of nearly uniform fields.
Geometric Fidelity
Physics Aware
Method
Heuristic
Contiguity
(a)
Learnable pooling (Gao & Ji 2019
X
(b)
Spatial proximity pooling Lino al. 2022
x
(c) Bi-Stride pooling
(Cao al.. 2023
X
X
(d) Same size k- k-means (Janny et al. 2023
X
(e) Hybrid mesh graph segmentation (Ours)
(b)
(c)
(d)
(a) Learnable pooling can indiscriminately merge distance vertices, disrupting connectivity, and becauee it lacks fixed heuristic- precludes offline sub-graph generation, shifting additional computation into the model runtime; (b) Spatial proximity pooling and (d) Same size k-mcans clustering iguore holes interfaces (shaded arcas), counecting/grouppi nodes gape; (c) Bi-Stride keeps connectivity but its hop-count stripes warp geometry into elongated, jagged stripes with poor aspect ratios.
1.1 Challenge in sub-graph construction
One of the key elements of these hierarchical methods is to generate coarse-level graphs, yet existing strategies each have different drawbacks (Table D. For example, learnable (Gao & Ji 2019) random pooling LLi ct al. 2020 can introduce artificial partitions in the sub-level graphs, which impedes information exchange
across partitions. Methods like spatial proximity pooling (Lino et al., 2022 Fortunato et al.] 2022) can lead to wrong connections across the boundaries at the coarser level. While Bi-Stride (Cao et al.) 2023) does guarantoe 2-hop connectivity and avoids cross-boundary odges, its hop-count fronticrs can severely warp the geometric metric. Alternatively, (Janny et al. 2023) preserves the original mesh and utilizes same size k-means to cluster mesh nodes by treating the mesh graph as point clouds. However, it ignores edge topology entirely: two nodes that are Euclidean-close yet separated by crack, thin wall, or hole can be grouped together. Because their physical states are incompatible, pooling them into single 'super-node' yields segment embeddings that misrepresent. local physics; these distorted features propagate through the model and ultimately amplify prediction error (Cao et al. 2023 Chen et al., 2020). Hence, the first challenge is to design gruph-coursening strategy that simullaaneussyy preserves mesh topology and geometrie fidelity while respecting physical discontinuúties.
1.2 Challenge in balancing accuracy and efficiency
Having an appropriate segmentation or pooling strategy addresses only part of the problem; the organization of sub-level graphs into a multi-resolution hicrarchy and the way information exchanges between levels are equally decisive for speed and fidelity. Most mooling-baeed hierarchies (Gao Jil 2019 Cao al. 2023) adopt U-Net-style
(Ronneberger et al. 2015 lightweight gating function scores vertices,
2

---

Published in Transactions on Machine Learning Research (09/2025)
the top-k fraction is retained, and the rest are discarded. Each pooling step shrinks the graph rapidly, deeper levels operate on far fewer nodes and enjoy substantial computational savings. The downside is that aggressive pooling or poorly designed coarsening levels act like an irreversible low-pass (and sometimes aliasing) filter on the graph signal (Chen et al. 2020 Li et al.] 2020), so the high-frequency physics "smears or vanishes" when the prediction is mapped back to the fine mesh, resulting in accuracy reduction. By contrast, segment-based approaches such as EAGLE (Janny et al., 2023) keep the original mesh intact within each segment, ensuring that no local geometric or physical detail is discarded. However, their reliance on gated recurrent units (GRU) (Cho et al., 2014) means that every node in every segment incurs three gating operations per time step, so computational cost grows with both segment size and feature dimension. Beyond the runtime and memory overhead on large meshes, long GRU chains also suffer from order sensitivity and information dilution (Vinyals el. al.) 2015 Bengio et al.) 1994), which can erode predictive accuracy even when enough compute available. The second challenge, therefore, is to design a hierarchical architecture that retains fine- graiegg geometric and physical cues like segment-bused methods, yet extracts and propagates ceemaalion-preeervinn
segment represenlalions through an aggregator that remains pernolltiion-ivvaiiae and compatationally light thus achieving principled balance between accuracy and efficiency.
1.3 Contributions
To overcome the challenges outlined above and comprehensively evaluate different surrogates, we make three primary contributions in this paper:
Hybrid mesh graph segmentation. We propose two-stage mesh-graph segmentation strategy: (i) lightweight graph partitioner first produces coarse segmentation, and (ii) each partition is then adaptively refined by a superpixel-inspiree algorithm guided by moddaldecomppsition features encoding local physics. The resulting segments preserve contiguity and goometric fidelity while encompassing nodes with coherent physical behavior.
Multi-segment hierarchical graph network. We introduce M4GN, a three-tier, segment-centric hierarchy with two crucial innovations compared to previous works: (i) integration of a hybrid mesh-graph segmentation scheme that yields segments of higher geometric and physical fidelity, facil- itating communication between adjacent hierarchy levels; and (ii) permutation-invarian aggregator for extracting segment featuros, which insensitive to mesh node orders and computationally efficient. As a result, M4GN preserves fine-scale physics (micrr-level), compress them into faithful segment tokens (intermediaaee-level), and enables efficient inter-segment reasoning (macro-level), yielding an effective balance between predictive accuracy and computational efficiency.
Additional dataset and its scaled-up version. We contribute DeformingBeam and its scaled counterpart DeformingBeam (large), the first public 3-D Lagrangian contact-deformatii benchmark that includes a scale-up version. The meshes' elongated geometry produces graph diameters several benchmarks, exposing explicit long-range interac-
times larger than those in previous tions. It enables rigorous testing of hierarchical surrogates and serves as benchmark for probing model scalability and cross-scale generalization.
2 Hybrid Mesh-graph Segmentation
This section is organized as follows. Section 2.1 motivates the hybrid mesh- grash segmentation approach.
Section 2.2 introduces the mathematical notation, and Scction 2.3 illustrates the modall-lccompositionn technique. Section 2.4 presents the complete segmentatiin pipeline, which serves as the intermediaae--evell module of the M4GN framework shown in Figure
2.1
Motivation
To avoid the uninterpretable and potentially erroneous dynamics that coarsened graphs or added edges might introduce, we propose preserving the original mesh structure and facilitating long-range information exchange through communication between sogmented mesh graphs. Traditional graph segmentation methods (Alprt & Yaol 1995 Delingette 1999) often prioritize geometric properties and computational efficiency
3

---

Published in Transactions on Machine Learning Research (09/2025)
Material Properties
Modal Decomposition
lterative
rollout
Density
mode
Updater
Youngs' Modulus
Poisson Ratio
Gi+1
GEvr
mode
Rigid object mesh node
Mesh Graph
Decader
Boundary Conditions
Fixed boundary mesk node
free boundary
Mesh Segment
3rd mode
Free boundary mesh node
Feature Dispatch
World edge
Fmn
fixed boundary
Mesh edge
Encoder
Position Encoding
Finite Element Mesh
Hybrid Segmentation
Graph-based Initialization
Processor
step
Mesh Segment Feature Extraction
Mesh Segment Transformer
Superpixel-basee Refinement
Mesh Segment
Mexh Segment
Self- Attentiooonn
xLx
Rigid Object
Graphs
Segment Overlap (8)
Segment Encoding (SE)
FFN
14
Sx
Input/ Output
Micro-level Process
IntermedKate-Ievel Process
Macro-level
Figure 1: Architecture of the proposed M4GN framework: Mesh- based Multi-Sege Multi-Segment Hierarchical (Micro- Intermediato-Macrr)) Graph Network. The framework operates on three modules: micro-level module capture fine-scale dynamic, intermediate-level module to generate mesh-based segmentation, and macro-level module to model segment-level interactions. The colored arrows trace the data flow within each module.
over underlying physical attributes. Conversely, superpixel approaches (Veksler et al. 2010 Achanta et al., 2012) group pixels based on user-defined similarity measures but rely on careful cluster-center initialization maintain segmentation quality. To merge the strengths of both, we apply a graph-basse method (fge) for initial mesh segmentation and refine it using superpirel-based method (fst), guided by leveraging features associated with dominant modes identified in the modal dccomposition module (Section 2.3 In this way, ensure these segments remain physically coherent and well-structured for effective communication. Grouping elements with similar physical properties enhances model convergence by minimizing discontinuities within cach segment (Diao et al. 2023), while grouping nodes with similar behaviors streamlines lcarning and ensures wniform handling of similar interactions (Dolean al. 2015). Eventually, this hybrid approach offers efficient. and reliable geometric partitioning alongside adaptive, feature-based refinement, producing high-quality mesh segments adaptable to diverse dynamical systems.
2.2 Mathematical Notation
We define the segmentation policy T(G) = fG( where the segmentation function fs takes the input graph and prior physical information (e.g., boundary conditions, material properties). and outputs a set of graph segments {S), S ......... Sk). The superscript denotes non-overlapping segmentation. For each segment S₁ (Vs, E. the set of nodes Vs. V and Es, C & are subsets of the original graph G. The union of all segments reconstructs the original graph, such that V UVg, and È LEg. In some cases, it may be bencficial to allow for overlapping segments, where nodes in V can belong to more than one segment. This overlap helps create smoother transitions belween segments and reduces inuciininuities at segment. boundaries We define the overlap amount by d N, with = representing no overlap. For > O, the node set Vgg is defined recursively as V/ S, 1 (Adj()
V To simplify the presentation, we disrogard the superscript 5 the remainder of this paper and use for all experiments with overlapping. The effect of adding overlapping segments is discussed in our ablation study, shown in Table
4

---

Published in Transactions on Machine Learning Research (09/2025)
2.3 Modal Decomposition
Modal decomposition is fundamental technique for exiracting dominant spatiotemporal patterns, modes, from complex physical systems (Fu & He 2001 SShhmid et al. 2011 Taira et al,) 2017). Each mode encapsulates coherent behavior- such as a characteristic deformation shape or flow structure serncture-allowing a reduced but meaningful representation of the underlying dynamics. In complex physical simulations, these dominant modes can effectively guide downstream tasks such as mesh segmentation, where the domain subdivided based on physical coherence (Yang et al. 2016;; Huang et al.) 2009). In this work, we employ two different modal decomposition approaches to address solid and fluid problems separately, given their distinct physical behaviors (Bathe 2001). The pseudocode of the modal decomposition module can be found in Algorithm 1
Structural Modal Analysis:
For solids, the decomposition naturally arises from the mass stiffness
relationship in clastodynamics, capturing genuine dynamic displacements (Andersen, 2006). Let K be the global stiffness matrix and M the global mass matrix arising from finite element assembly. The free vibration modes of structure are obtained by solving the generalized cigenvalue problem:
KØ = Φ
(1)
where À represents the square of the natural frequency, and Φ = (21,, is the corresponding structural modes, whose dimension (dim) matches the number of displacement components (e.g., 2D or 3D). Physically, each mode shape indicates a fundamental deformation pattern under vibrational motion (Fu &
He 2001 Wilson 2002). which is tied to the solid's 's geometry, boundary conditions, and material parameters. In practice, is typical to select the first m modes (A1 S 52 S ..... S Am) to construct an m-dimensional feature at each mesh node i: f.ud (i), (2(1)..... (i)).
Laplacian Eigenfunctions: In fluid contexts, particularly when lacking multiple snapshots a steady base flow (Wang et al. 2024)). Laplacian eigenfunctions (Grebenkov & Nguyen 2013 are used to capture geometry- and boundary-driven harmonic modes by solving:
220 X subject to boundary constraints,
(2)
yielding harmonic modes $1...., om. These modes serve as a practical proxy for flow-related structures, providing minimal but informative docomposition that respects the domain shape and boundary conditions
(De Witt et al. 2012 Taira et al. 2017). Similar to the solid case, cach node i in the fluid mesh is associated
with a feature vector: md
(01 (2), .....
2.4 Detailed Methodology
In the hybrid segmentation module, we first use METIS (Kayppis & Kumar 1998) for initial mesh regmentation due to its great balance of partition quality and speed. Formally, given a graph G, the partition function fgb will split it into K non-overlapped mesh-segment graphs: {SI..... Sx S. Ø, vi + j} fGt(G). Then, we apply SLIC (Achanta et al., 2012). the state-of-the-an superpixel-basee based clustering methods, to these mesh segments to iteratively update the segmentation centroids (Ci,..., Ck) } and corresponding node assignments using information obtained from modal decomposition (Section 2.3 It is worth noting that standard modal decomposition does not account for external obstacles (Fu & He 2001). Therefore, in models with moving rigid objects, this information will need to be incorporated separately. For node i in graph G, represent it by its spatial coordinates x,, features related to rigid objects or obstacles fohs, and features obtained from modal decomposition fmdd. For a given mesh segment 5₁ containing [Vs, nodes, we define its centroid Cn as its mean value along the features:
Cn = [x JC SC,
pnddT
[x,, fobn f.mdTT
(3)
VsL
Within each itcration, we improve the mesh segmentation by minimizing distance measure that considers both physical similarity and spatial proximity. The distance measure d(i, Ck) between node i e V and segment's 's centroid C₁ is defined as:
d(i, Ck)
||5.bo -Seke Il5mm smadll + 7 7|xx xcull:
(4)
5

---

Published in Transactions on Machine Learning Research (09/2025)
where is used to control the compactness of mesh segment. The pseudo code of the hybrid segmentation module can be found in Algorithm 2 In Appendix [B.4] we present a comprehensive comparison of various segmentation methods and their variants based on different distance measures. Additionally, we evaluate the impact of varying the number of mesh segments on model performance in Appendix D.5 and Appendix E.2 We also introduce several metrics to measure the quality of different mesh segmentations, specifically to understand the intra-segment and inter-segment characteristics, which can be found Appendix C.2
3 M4GN: Multi-segment Hierarchical Graph Network
This section details our proposed hierarchical framework (Figure I After a formal problem statement in Section 3.1 we describe its three-level modules: (i) a micro-level module (Section 3.2) that performs message passing along mesh edges to capture fine-scale dynamics; (fi) an intermediate-level segment module (Section 2) that constructs mesh segments offline using our heuristic hybrid segmentation algorithm; and (iii) macro-level module (Section 3.3) that aggregates segment features and exchanges information across segments to model long-range interactions.
3.1 Problem Definition
Let G (V,8) be a mesh graph with V being the set of nodes and & being the set of edges. The graph has | nodes and E |8| edges, with adjacency matrix A R representing graph connectivity. The dynamic simulation task is to learn a forward model of the dynamic quantities of the mesh graph at the next time step G.+1 given the current mesh graph G. and (optionally) a history of previous mesh graphs Ui-.....,G.AA.. Finally, the rollout trajectory can be generated through the simulator iteratively based on the previous prediction: GG, Gr-1...., G..I, where T the total simulation steps. In this paper, the proposed model (M4GN) can simulate both Eulerian and Lagrangian systems (Bontempi & Faravelli, 1998). For Eulcrian systems examined in this paper, where continuous fields such as velocity evolve on a stationary mesh, the graph & includes only mesh-related edges &. Conversely, for Lagrangian systems considered in this paper, where the mesh represents a moving and deforming surface or volume, additional world edges &w are incorporated into the graph. These edges enable the model to learn external dynamics such as collision and contact. The node features of node i are denoted by x,, while the features for an edge between node and j are indicated by eij.
3.2 Micro-level Module
Within the micro-level module, each node engages in the exchange of information with its neighboring nodes. This process holds particular significance in dynamical systems, where the behavior of adjacent nodes is closcly intertwined [Booij & Holthuijsen 1987: Emanuel 1994 Faby 2007 Kennett 2009). Furthermore, this module serves a crucial role in addressing discontinuities that may arise at the boundaries of adjacent mesh segments [La et al. 2009). By prioritizing micro-level information exchange, we effectively mitigate discontinuites introduced by subsequent macro-level operations. We follow the
(EPD)(Pfat) et al., 2020) architecture for our micro-level information exchange as it has shown great performance in dealing with mesh-based graphs. Specifically, we use the encoder and processor blocks for micro-level message passing, while the decoder head is detached and applied only after the macro-level module (Section 3.3 For a given graph G2 at time f, the model begins with extracting node and edge features through two separate Multi-Layer Perceptrons (MLPs):
M.D h4,-- fn(xxt)), b = 1.d (e
W.O h
1 (e
55)
where x,, E V, oyy, E EM, and oy, E gW denote node feature, mesh edge feature, and world edge feature vector al lime 4, respectively. For Lagrangian systems, world edges are created by spatial proximity, where for a fixed radius Tw; a world edge added between nodes and j when |x, 16-x4 x2y < rw, excluding node pairs alrcady connected in the mesh. The outputs of two MLPs (i.c. fn and fe) for node and edge are denoted as hº, and hi,.. respectively. Then, a L-step message passing (MP) is performed such that each node can receive and aggregate information from neighboring nodes within L steps of edge traversing. For each MP
6

---

Published in Transactions on Machine Learning Research (09/2025)
from 1 to L, the node and edge representations are updated as:
hi, f (
Σ
h h
ijft
Mi-1
Σ
hije
(6)
AEj(())
jEAd((i
MJ hgg - (h
- f
(
W.-1 h h 11111-
(7)
where Adj(i) denotes all adjacent nodes of node i. Up until this point, the node and edge information of the graph G. are updated. Additionally, we implement technique from (Godwin et al. 2021), which involves
corrupting the input graph with noise and adding noise-correcting node-level loss. We evaluate the impact of varying the number of message passing steps during micro-level information exchange step, where details can be found in Appendix[D.. D.I
3.3
Macro-level Module
3.3.1 Mesh Segment Feature Extraction
Segment Encoding (SE) In order to extract a global feature for each mesh segment, we perform average pooling all node vectors in S₂ and apply MLP (fs) to get the fixed-sized segment embedding: hs.. = fo( Lievs, b(,)). Different from the state-of-tho-art clustering-basel hierarchical model (Janny et al. 2023). we replace the GRU-based aggregator with a permutation-invarinl pooling operation when extracting segment features, which provides a more efficient and robust alternative for segment-level repre- sentation. sidesteps the order bias and gradient noise of sequence models, yielding representations that remain stable across epochs and insensitive to mesh reordering (Vinyals et al. 2015 Moreover, average pooling circumvents the information-dilution problem inherent in long RNN chains (Bengio al. 1994), preserving salient local features from vanishing-gradient effects and thereby enhancing predictive accuracy. Meanwhile, its computational burden is only ((Nd), compared with the O(Nd²) matrix operations and lengthy back-propagation demanded by GRU pooling (Chung et al. 2014). These properties make average pooling a proper choice when accuracy and efficiency need to be balanced.
Position Encoding (PE) As dynamic effect propagates continuously over mesh domains, knowing relative location among segments could provide extra information for next-step macro-level information exchange and increase expressivity of the network. Mathematically, for each pair of mesh segment graph, {S,, S,), their relative positional information can be obtained through segment-level adjacency matrix AK RRKK, A,,s, = Emevs, Eneve, Amn- We follow the strategy in (Rampášck et al., 2022) that uses random- walk structural encoding (RWSE) (Dwivedi et al. 2021 for PE calculation. Then the PE for the k-th segment, denoted as Psa.4, is processed through an MLP layer (Sap) and then added to update the SE as follows: hs.. < hs,,t + (pp.....). We can further enhance the nelwork's s expressivity by adding absolute PE to the graph nodes. We use an MLP (fap) to process each node's 's PE (Pr,r), calculated with a similar approach segment level, and add it to the imput node feature. Thus, Eq (5) becomes h fx (P..)) By incorporating node PE directly into the input features, these leatures participate in the micro-level information exchange described in Section 3.2 potentially improving the continuity of the extracted mesh segment features. Table 10 presents ablation results illustrating the impact of including or excluding PE on prediction performance.
3.3.2 Mesh Segment Transformer, Feature Dispatch, and Training
We construct a fully connected mesh segment graph, where the i-th mesh segment feature is represented by hs, Note that since the transformer operates on mesh segments rather than individual mesh nodes, and the total number of mesh segments (K) is significantly smaller than the total number of mesh nodes (N), the computational cost of our transformer substantially reduced compared to a traditional graph transformer that operates on graph nodes (i.c. O(K?) & O(N2)). The 1-th block of the mesh segment transformer layer is defined follows:
h/s = Σ
kl asis, (V (V
h h's, + +0 + FFNN + +
(8)

---

Published in Transactions on Machine Learning Research (09/2025)
Rdd where as,s, is self-attention weight between S, and S,, V Rd xd is a trainable parameter matrix, and 0 E Bddd is the learned output project matrix. == 1 to H denotes the number of attention heads, and I| denotes concatenation. d, is the dimension of mesh segment feature for each head, and d is the input and output dimension. We adopt a Pre-Tayer Norm architecture (Xiong et al., 2020), which is denoted as LN(,), and the point-wise Feed Forward Network is represented as FFN(-). The mesh segment transformer module facilitates information exchange among all mesh segments, updating the feature of cach segment hs, after passing through I mesh segment transformer blocks.
The mesh segment feature dispatch module (as shown in Figure integrates information obtained from both macro-level and micro-level exchanges. Specifically, the final feature for node at time step is updated as h + [ h where E Vs.. This ensures that each node incorporates information from both neighboring mesh nodes and spatially distant, yet correlated regions. Finally, we train our dynamics model by supervising on the per-node output features &i,,+1, produced by feeding hi into an MLP- decoder, using an L2 loss between & and the corresponding ground truth values x1,+1.
4 Experiment
4.1 Experiment Setup
Datasets - We benchmark on six datascts that together capture the two principal application regimes for mesh based surrogates Eulerian incompressible flow and Lagrangian hyper-elastic solids while also probing both short-range and long-range interactions, small and large graphs, and steady versus highly- sighll-trannient behavior. CylinderFlow and DeformingPlate are the widely-used public datasets of (Pfaff et al., 2020 CylinderFlow varies cylinder diameter, position and inlet velocity, while DeformingPlate changes obstacle trajectory, plate geometry, and boundary conditions. To challenge long-range coupling we introduce the DeformingBeam, 3-D hyper-elastic beam whose length, cross-section, and end loads vary, yielding the largest graph diameter in the suite. Morcover, DeformingBann-Lagge doubles the physical span of that beam and the total number of meshes to probe scalability. Finally, we utilize two supplementary benchmarks: FlagSimple Pfffff et al. 2020) and EAGLE (Janny et al., 2023 to further demonstrate the robustness of M4GN across distinct physical regimes and dataset types. For these two datasets, we report results in the Appendix and do not perform full ablation analysis to keep the experimental scope tractable and to maintain clarity in interpreting results. This mix exercises both short-range and long-range interactions, small and large graphs, and stcady versus highly-transient behavior. Because geometry, loading and obstacle parameters all change from run to run, the sets jointly test surrogate's ability to generalize across shape, boundary condition and scale variations, giving a balanced yet concise benchmark suite.
At cach time step, the network is provided with (i) nodal coordinates and edge vectors that describe the local mesh geometry, (ii) the current physical stale, and (iii) categorical node masks ident ifying walls, inlets/outlets, or greedhhandle//bba
regions. For the modal-decompositionn stage, we further supply the material parameters and boundary conditions already defined in the finito-clement sctup (density, Young's 's modulus, Poisson's ratio). The network outputs the next-step state (e.g., positions for solids) which is recursively fed back as input to generate full rollouts. Comprehensive dataset specifications are provided in Appendix A
M4GN and Baselines - As a default configuration for our M4GN model, we use message passing steps in the mesh graph network. The mesh segment: transformer adopts 4 self-attention layers with heads. We compare our method to five baseline models: 1) GCN (Kipf & Welling 2016; Belbute- et al. 2020), a basic GNN structure widely used for simulating fluid dynamics; 2) g- U-Nets (Gao & Ji. 2019 Alsentzer et al. 2020), a representative method that incorporates graph pooling modules to enhance long range interactions; 3) MeshGraphNets (MGNs) (Pfaff et al. 2020), a single-level GNN architecture that achieves great performance and generalizability across various dynamical systems; 4) BSMS-GNN (Cao et al., 2023), a recent work featuring a multi-level hierarchical GNN architecture that aims to enhance computational efficiency in simulating physical systems; and 5) BAGLE(Janny et al.] 2023), a recent work presenting a clustering- pooling method along with transformer to enhance performance on large-scale turbulent fluid dynamics. Detailed descriptions of the these models and training procedures can be found in Appendix B
8

---

Published in Transactions on Machine Learning Research (09/2025)
Metrics - In addition to traditional accuracy metrics, we also report mesh-quality metrics (Table 2 for the Lagrangian cases, where the computational mesh deforms with the material and may accumulate distortion. These evaluations are not required for the Eulerian dataset we used, because its meshes remain fixed in space and therefore cannot experience clement-quality degradation. Mcsh-quality metrics serve objectives that a nodal RMSE alone cannot address: (i) Many workflows feed the predicted mesh inlo inverse design or lopology-optimization loops (Han et al. 2012); if elements are inverted or highly skewed, gradient- updates fail even when the nodal RMSE is low. (ii) Well-shaped, smoothly graded elements improve the mumerical conditioning of the surrogate, yielding higher predictive accuracy and better generalization (Kamenski et al.] 2014p. Four mesh quality metries are used with concise descriptions in Table 2 where each metric targets a distinct failure mode, so a model may excel in one yet falter in another. For instance, a mesh can aligu perfectly with the true geometry while still containing many sliver elements. Evaluating all four metrics together thus offers a genuinely comprehensive view of the surrogate's output quality. More detailed descriptions and mathenatical definitions of these metries can be found in Appendix
Table 2: Compact summary of mesh quality metrics for evaluating prediction results
Metric
Geometric intuition
What it catches
Impact simulation outcomes
Hausdorff (GF))
Max node-surface gap
Isolated large outliers
Drives worst-case error; signals local shape failures.
Chamfer (GFe)
Mean node-surface gap
Uniform global drift
Lowers overall fidelity; raises global error norms.
Mesh Continuity (MC)
Neighbour cell-volume ratio
Abrupt size "cliffs"
Introduces artificial discontinuities noisy spatial gradients.
Aspect-Ratio crror (AR)
Deviation from idcal clement shape
Slivers stretched cells
Injects anisotropic bias; hampers generaliza-
tion.
4.2
Results and Discussion
4.2.1 Overall Performance Evaluation Across Multiple Datasets
The quantitative results in Table 3 show that M4GN outperforms all baselines across multiple evaluation metrics. Specifically, for the CylinderFlow dataset, M4GN achieves a 36% reduction in test. RMSF-all compared to the socond-best performing model, EAGLE. For the DeformingPlate datasct, M4GN reduces the test RMSE-all by 32%. This improvement even more pronounced for DeformingBeam datasel, where M4GN demonstrates a 56% reduction in test RMSE-all. Such performance in 50-step and longer-step predictions underscores its enhanced capability for long-tern predictions. In addition to its high prediction accuracy, M4GN demonstrates strong mesh quality, with up 48% reduction in GF and 14% reduction in MC compared to the second-best model across both Lagrangian system datasets.
4.2.2 Segmentation Quality and Its Impact on Performance Metrics
To rigorously assess the quality of our hybrid segmentation strategy and its influence on dynamics prediction, we employ three metrics Conductance, Aagge-Cut Ratio, and Silhouette Score that quantify intra-segment cohesion and inter-segment separation. These metrics assess segment isolation and intra-segment homogeneity properties that prevent feature dilution and lower prediction error. Formal definitions appear in Appendix
Fi Figure 2 ca-c) correlates segmentation scores with mesh quality and prediction error for FAGLE's node- based partitions and three variants of our hybrid scheme (see Appendix [.4]. The plots confirm that segmentation choice matters: our hybrid method, which better aligns partitions with underlying dynamic behaviors, consistently reduces error and improves mesh quality. Figure d(d-f) color nodes by each segment's mean prediction error at successive time steps. Our segments stay ncarly uniform in color across all datascts, indicating coherent. intra-segment dynamics. For example, in (d), segmentation follows periodic wave palterns in fluid dynamics, while in (f), it reflects symmetrical system dynamics with symmetric segment coloring. These visualizations demonstrate that our sogmentation effectively captures the temporal and spatial dynamics of the system, outperforming state-of-ther the-arrt method. Additional in-depth analysis can be found in Appendix
C.2
D.2 and D.3
9

---

Published in Transactions on Machine Learning Research (09/2025)
Table 3: Comparison of results with state-of-the-art methods across three datasets, where each model is trained independently for each dataset. Prediction accuracy is evaluated using Root Mean Square Error (RMSE), with the output being the next-step positions for DeformingPlate/BBll for CylinderFlow. Errors reported for 1-step rollout, 50-step rollouts, and the entire trajectory. Each mesh quality metric is evaluated at every time step then averaged over time by comparing the predicted mesh to the ground-truth configuration. Results are averaged over three experiments with different random seeds and presented as mean and standard deviation.
and ppressure fields
Mesh Quality Metrics
Prediction Error Metries 4
GF (x10-)
GF (x10-9) 9)
MC
ARt (x10-
RMSE-1 (x10-*)
RMSE-50 (x10 +)
RMSE-all
DATASET
MODEL
(x10-))
(x10 +)
GCN
g g-U-NET
401 +
179 3.32
758 a
CYLINDER
MGN
FLOW
BSMS-GNN
181 22
252 + 8.2
1218 =
EAGLE
456
69.6
525
M4GN (OuRS)
288
60.2
2.4
337 21
GCN
21.0 DM
323 +-4
11.0
9.33 0.57
34.8
26.1
169 +
g-U-NET
36.1
152+ 15S
20.1
12.4 4.5
41.2
30.1
179
DRFORMING
MGN
248
9:25 0.99
6.34 20.36
22.8
0.2
20.0
PLATE
DSMS-CNN
23.8
170 1
18.3 12531144
15.4 1.5.
30.3
23.7 3.5
118
8112
M4GN (OURS)
4.29 0.07
7.05 1.05
4.82 0.08
2.67
0.00
26.7 0.4
3.03 0.18
26.5
2.4
GCN
4.91 = 0.36
3.53 0.51
54.8
69.5 a.8
T:25 # 6.12
5.08 0.11
30.7
N-U.NFT
4.91
3.35
34.7
31.5
7.28
5.00
DRFORMING BEAM
MGN
0.82 1 u84
0.12
1: 0.00
16.9 1.0.1
7.43 0.00
4.43 0.0
2.41
0.18
4.72 0.27
BSMS-GNY GNN
0.99
0.21
32.5
16.1
6.86
1.95
4.98
EAGLE
0.64 = 0.04
0.17
# 0.01
5.98
0.63
5:17 0.87
1.51
# 0.04
0.67
= 0.12
4,22
= 0.30
M4GN (OueS)
0.31 0.01
0.05
5.26
3,08
1.17
0.01
0.34
1.87
Cylinder
Plate
Beam
1.
16
008
MION
MION
06
(MBRS 1
Sea Ca
C POR Mete And
Gmor
Pricitioon
DAGLE
CAGLE
CAGLE
IMGV
Figure 2: (a-c) Evaluation of different segmentation methods under three datasets. The heatmap (left) presents normalized Conductance, Edge Cut Ratio, and reversed Silhouette Score for EAGLE and three M4GN variants. Metrics are scaled between and 1, where lower values indicate better segmentation quality, The sidebar plot (right) depicts normalized Prediction Error and Mesh Quality, with a minimum value of 0.05 applied avoid invisible bars. (d-f) Visualization of simulation rollouts over time for three datasets, comparing our segmentation method with EAGLE. Nodes colored based the average prediction error within their segments.
4.2.3 Accuracy-Efficieng Trade-off Analysis
MGN excels on the small-diameted CylinderFlow but loses accuracy and speed on DeformingPlate and DeformingBeam, where deep message passing leads over-smoothing and higher latency; BSMS is memory-efficient thanks bi-stride pooling, yet that pooling lowers mesh fidelity and accuracy and slows inference when long-range details must be reconstructed; and EAGLE offers moderate
Figure B(a) shows distinct trade-offs:
10

---

Published in Transactions on Machine Learning Research (09/2023)
(a)
Cyl
DebeminngPate
Deforingoom
Speed
Thinleg
Treditt
Pradie
Accurney
Speed
Quality
Speed
Quality
Bihueecy
Traints Marser' Enidercy
Terting Marsry
Tratring Harsary Effceeccy
Teating Hemory Effictency
Tralntag Memsrry
(b)
1e-2
3,0
2,5
GCN
10.
Bearn (argo)
Mesh Continuity
MGN
Narm- RMSSE
IMSS-e11
2.0
RSASSGAN
EAGLE
1.5
1.0
0.0
10-12
13-17
18-25
26-35
BSMS
EAGLE
M4GN
Mesh Graph Diemeter
Models
Figure (a) Radar charts summarizing model performance on three datasets. All metrics are min-max normalized to the range [0.2, 1.0]; "lower-is-better" metrics are first inverted, and values below 0.2 are clipped to avoid visual collapse; larger filled areas reflect better overall performance. (b) RMSE-all accuracy versus graph diameter on the DeformingPlate dataset. (c) Performance comparison of each model when generalizing from DeformingBeam to DeformingBeam (large). Circles denote normalized RMSE (left axis), and squares demote mesh continuity error (right axis). Dashed lines highlight performance shifts. Lower values indicate better accuracy and mesh quality.
performance overall its plysics-agnostic clustering limits long-range capture, remaining efficient on the some datasets but slowing sharply on CylinderFlow dense meshes inflate the number of required clusters. By contrast, M4GN maintains high accuracy and efficiency across all cases because its hybrid segmentation groups physically coherent nodes and its three-level hierarchy offloads long-range reasoning to a lightweight segment-level transformer, reducing both message-passing depth and token count. This design lets M4GN preserve local fidelity while controlling computational cost, yielding the balanced performance seen in the plots. Additional qualitative results are provided in Table 12
4.2.4 Performance Analysis Across Graph Diameter and Scale
One of the main goals of hierarchical GNNs is to alleviate overssmoothing and capture long-range interactions. Exploiting the wide diameter range in our DeformingBeam benchmark, we group test. cases by graph diameter and plot RMSE-all versus diameter in Figure 3 B)). Errors for the baseline models escalate rapidly with increasing diameter, whereas M4GN's error increases only slightly, showing sustained accuracy on wide meshes with long-range interactions. This robustness comes from M4GN's hybrid segmentation, which clusters nodes that share modal behavior, and its segment-level transformer, which achieves global information exchange in one hop among segments; together, these mechanisms mitigate over-smoothing while preserving local detail, sustaining performance graph diameter grows. Moreover, we perform generalization tests to show whether a surrogate trained modest meshes stays reliable on larger domains. According to Figure ccc, all four surrogates deteriorate when directly generalize to larger mesh domain. The modest degradation of MGN confirms that a flat model can generalize spatially if the growth factor is moderate, but only at the expense of longer inference times and an elevated risk of smothhig as graph diameter continues to risc. Hicrarchical methods trim that cost, yet their performance hinges on how they coarsen the mesh and whether cross-level communication remains efficient. Among them, M4GN's smaller generalization gap indicates that. its hybrid segmentation and permutation-invarian aggregation alleviate- but do not.
11

---

Published in Transactions on Machine Learning Research (09/2025)
eliminate- this sensitivity, suggesting future work on adaptive segment counts depth-aware micro-level passes when extrapolating to substantially larger meshes.
4.3 Additional Studies
We conducted additional studies to comprehensively evaluate model performance, hyperparameter selection, and the impact of key architectural designs, with detailed results and discussions provided in the appendices. Results on additional datasets are reported in Appendix C.3 and the segnentaaioon-ffectiie in Appendix C.4 A systematic sensitivity study, detailing how each hyperparameter affects performance and offering practical tuning guidelines, can be found in Appendix [D] Additionally, a comprehensive analysis of generalization performance is provided in Appendix B and further insights into computational efficiency are included in Appendix F
study appears
5
Related Works
5.1 Hierarchical GNN Models for Dynamical System Simulation
The application of Graph Neural Networks (GNN) for dynamic system prediction an emerging research area in scientific machine learning due to their versatility and effectiveness (Chang et al.) 2016: Li et al. 2018b; Belbute-Peres et al. 2020 Hu et al.]
2023 Unlike image-based learning methods such Convolutional
Neural Networks (CNNs) (Um et al.
2018 Ummenhofer et al., 2019). GNNs can directly handle unstructured simulation meshes, making them well-suite for simulating systems with complex domain boundaries while ensuring spatial invariance and locality Wu et al. [2020). A notable milestone in this field NeshGraphNets
Pfaff et al., 2020), which enables the general schemn for learning mesh-based dynamical simulations. To mitigate the smoothing issue (Li et al., 2018a) that typically occurs GNNs when applied to large or complex datasets with long-range interactions, several hierarchical models have been introduced recently. For instance, GMR-GMUS (Han et al. 2022) utilizes pooling method to select pivotal nodes through uniform sampling. Similarly, the EAGLE (Janny et al. 2023 employs clustering- based pooling method along with a transformer mechanism, showing promising performance in fluid dynamics. MS-MGN (Fortunato et al. 2022 proposes a dual-layer framework that passes mossages at both finc and coarse resolutions for mcsh- based simulation learning. BSMS-GNN (Cao al.] 2023) analyzes limitations of existing pooling stralegies and introduces a bi-stride pooling method using breadth- firsst search (BFS) to select nodes. (Yu et al. 2023)
proposes similar hicrarchical structure as (Cao et al. 2023 but with two different transformers to enable long-range interactions.
5.2 Datasets for Unstructured Mesh-based Simulations
As a cornerstonn in the field, GeshGGaahNNees (Pfafl et al. 2020) introduces a collection of datasets, showcasing the versatility of graph-based surrogates in various problems involving unstructured mesh simulations. Moreover, EAGLE (Janny et al.
2023
presents a fluid dynamics dataset capturing unsteady and turbulent
airflows; BSMS-GNN (Cao et al.)
2023 provides the InflatingFont dataset, which focuses on the quasi-static
inflation of enclosed elastic surfaces. Despite recent progress, existing public datasets still leave two critical gaps for assessing hierarchical surrogates: (1) Many benchmarks contain thousands of vertices, yet their graph diameter-the maximum shortest-path length between any two mesh nodes-remaing small, which under-exercises long-range message passing. (2) Most datasets expose only one mesh density size band, preventing systematic studics of how surrogate trained on small problems generalizes to larger ones. To bridge these gaps, we contribute DeformingBear together with its enlarged variant DeformingBBeam-Laae This pair constitutes the first public 3-D Lagrangian contact-deffrmation benchmark that also provides a scalc-up case. The beam's 's slender geometry yields graph diameters several times longer than existing solid mechanies datasets, exposing long-range interactions. Such a dataset enables rigorous testing of hierarchical surrogates and serves benchmark for probing model scalability and cross-scale generalization.
12

---

Published in Transactions on Machine Learning Research (09/2025)
6 Conclusion
In this work addressed two challenges in hierarchical mesh-GNN surrogates physics-faithful graph coarsening and the accuracy-eficieng, imbalance- introducing M4GN, three-tier, segment-centrie framework built on two key innovations: a physics-aware, hybrid segmentation strategy that yields contiguous, dynamically coherent segments, and a permutation-invariann and computational efficient mesh segment aggregator. We systematically compared M4GN with leading basclines across multiple benchmarks using both traditional error metrics and proposed mesh-quality metrics, and we quantified segmentation quality through three different intra- and inter-segment scores to illuminate how hybrid segmentation shapes downstream accuracy. Additional studies assessed the vecuracy-veruus-ppere trade-off and robustness across graph diameter and scale. Across all tests, M4GN achieved the strongest overall balance of accuracy, efficiency, and mesh fidelity, exhibited the smallest error growth on wide-diameter graphs, and maintained the smallest gencralization gap among all hicrarchical models. Despite these advances, M4GN still exhibits limitations that need further investigalion. For example, the method currently imposes no hard constraints on contact. boundaries and offers no formal guarantees of physical consistency across segment interfaces. In addition, selecting segmentation
still requires modest empirical tuning despite the provided guidelinos. In summary, the findings in this paper underscore the value of coupling principled segmentation with balanced hierarchical reasoning for scalable, high-fidelity mesh simulation. Future research will focus incorporating constraint enforcement, automating hyper-parameter selection, and extending the framework to coupled multi salti-phyyics scenarios.
Broader Impact Statement
This paper presents work whose goal is to advance the field of Machine Learning for Physics, Surrogate Modeling, and Dynamical System Simulation. There are many potential societal consequences of our work, none of which we feel must be specifically highlighted here.
Acknowledgments
This work was performed under the auspices of the U.S. Department of Energy by the Lawrence Livermore National Laboratory under Contract DE-AC52-07NA27444 LLNL release mumber: LLNL-JRNL-2000112
References
Radhakrishna Achanta, Appu Shaji, Kevin Smith, Aurelien Lucchi, Pascal Fua, and Sabine Süsstrunk. Slic superpixels compared to state-of-the-art superpixel methods. IEEE transactions on pattern analysis and machine intelligence, 34(11):2274-222 2012.
Charles J Alpert and So-Zen Yao. Spectral partitioning: The more cigenvectors, the better. In Proceedings of the 32nd ansuual ACM/TEER design automalion conference, pp. 195 200, 1995.
Emily Alsentzer, Samuel Finlayson, Michelle Li, and Marinka Zitnik. Subgraph neural networks. Advances in Neural Information Processing Systems, 33:8017-8029) 2020.
Lars Andersen. Linear elastodynamic analysis. 2006.
JürnenJürgen Bathe. Computational fluid and solid mechanics. Elsevier, 2001.
Filipe De Avila Celbute-Peres, Thomas Economon, and Zico Kolter. Combining differentiable pde solvers and graph neural networks for fluid flow prediction. In international conference on machine learning, pp- 2402-2411. PMLR, 2020.
Yoshua Bengio, Patrice Simard, and Paolo Frasconi. Learning long-term dependencies with gradient descent is difficult. IEEE Iransactions on neural networks, 5(2):157- 166, 1994.
Franco Bontempi and Lucia Faravelli. Lagrangian/enlerian description of dynamic system. Journal of Engineering Mechanics, 124(8):901-91 1998.
13

---

Published in Transactions on Machine Learning Research (09/2025)
Nico Booij and Leo H. Holthuijsen. Propagation of ocean waves in discrete spectral wave models. Journal of Compulational Physics, 68(2):307 -26, 1987.
Yadi Cao, Menglei Chai, Minchen Li, and Chenfanfu Jiang. Efficient learning of mesh-based physical simulation with bi-stride multi-scale graph neural network. International Conference on Machine Learning, pp. 3541-3558 PMLR, 2023.
Michael B Chang, Tomer Ullman, Antonio Torralba, and Joshua B Tenenbaum. A compositional object-based approach to learning physical dynamics. arXiv preprinl ar X6v: 00344, 2016.
Deli Chen, Yankai Lin, Wei Li, Peng Li, Jie Zhou, and Xu Sun. Measuring and relieving the over-smoothing problem for graph neural networks from the topological view, In Proceedings of the AAAI conference on artificial intelligence, volume 34, pp. 3438-344 3445, 2020.
Kyunghyun Cho, Bart Van Merriënboer, Caglar Gulcehre, Dzmitry Bahdanau, Fethi Bougares, Holger Schwenk, and Yoshua Bengio. Learning phrase representations using encoder-decoder for statistical machine translation. arXiv preprint arXiv: 1078, 2014.
Junyoung Chung, Caglar Gulechre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014.
Tyler De Witt, Christian Lessig, and Eugene Fiune. Fluid simulation using laplacian eigenfunctions. ACM Transactions Graphics (TOG), 31(1):1-11, 2012.
Hervé Delingette. General object reconstruction based on simplex meshes. International journal of computer vision, 32:111-146, 1999.
Yu Diao, Jianchuan Yang, Ying Zhang, Dawei Zhang, and Yiming Du Solving multi-material problems in solid mechanics using physics-informed neural networks based on domain decomposition technology. Computer Methods in Applied Mechanics and Engineering. 413:116120, 2023.
Victorita Dolean, Pierre Jolivet, and Frédéric Nataf. An introduction to domain decomposition methods:
algorithms, theory, and parallel implementation. STAM, 2015.
Vijay Prakash Dwivedi, Anh Tuan Luu, Thomas Laurent, Yoshua Bengio, and Xavier Bresson. Graph neural networks with learnable structural and positional representations. ar preprint arXiv:2110007875, 2021.
Kerry A Emanuel. Atmospheric convection. Oxford University Press, USA, 1994.
Frank J Faby. Sound and structural vibration: rudiation, transmission and response. Elsevier, 2007.
Meire Fortunato, Tobias Pfasf, Peter Wirnsberger, Alexander Pritzel, and Peter Battaglia. Multiscale meshgraphnets. In ICML 2022 2nd AI for Science Workshop, 2022.
Zhi-Fang Fu and Jimin He. Modal analysis. Elsevier, 2001.
Han Gao, Matthew J Zahr, and Jian-Xun Wang. Physics-infore informed graph neural galerkin networks: A unified framowork for solving pde-governed forward and inverse problems. Computer Methods in Applied Mechanics and Engineering, 390:114502 2022.
Hongyang Gao and Shuiwang Ji. Graph u-nets. In international conference on machine learning, pp- PMLR, 2019.
Jonathan Godwin, Michael Schaarschmidt, Alexander Gaunt, Alvaro Sanchez-Gonzalle Yulia Rubanova, Petar Veličković, James Kirkpatrick, and Peter Battaglia. Simple gun regularisation for 3d molecular property prediction & beyond. arXiv preprint x:Xiv:2106.07971. 2021.
Denis Grebenkov and B-T Nguyen. Geometrical structure of laplacian eigenfunctions. siam REVIEW, 55 (4):601-66) 06660-667,7700 2013.
14

---

Published in Transactions on Machine Learning Research (09/2025)
Xu Han, Han Gao, Tobias Pfaff, Jian-Xun Wang, and Li-Ping Liu. Predicting physics in mesh-reduced space with temporal attention. arXiv preprint arXim:2201.091 099113, 2022.
Chong-Hua Han, Ke-Shi Zhang, el al. Surrogate-based optimization. Real-world applications of genetic algorithms, 343:343 362, 2012.
Yeping Hu, Bo Lei, and Victor M Castillo. Graph learning in physical-informed mesh-reduced space for real-world dynamic systems. In Proceedings of the 29th ACM SIGKDD Conference on Knowledge Discovery and Data Mining, pp. 4166 4174, 2023.
Qi-Xing Huang, Martin Wicke, Bart Adams, and Leonidas Guibas. Shape decomposition using modal analysis. In Computer Grophics Forum, volume 28, pp. 407-416. Wiley Online Library, 2009.
Daniel P Huttenlocher, Gregory A. Klanderman, and William Rucklidge. Comparing images using the hausdorff distance. IEEE Transactions on pattern analysis and machine intelligence, 15(9):850 863, 1993.
Steeven Janny, Aurélien Beneteau, Madiha Nadri, Julie Digne, Nicolas Thome, and Christian Wolf. Eagle: Large-scale learning of turbulent fluid dynamics with mesh transformers. arXiv preprint arXw:2902.10800, 2023.
Lennard Kamenski, Weizhang Huang, and Hongguo Xu. Conditioning of finite element equations with arbitrary anisotropic meshes. Mathemalics of compulation, (3(8))222187 2187-1111 2014.
George Karypis and Vipin Kumar. A fast. and high quality multilevel scheme for partitioning irregular graphs. SIAM Journal on scientific Computing, 20(1):359 392, 1998.
Brian Kennett. Seismic wave propagation in stratified media. ANU Press, 2009.
Nicolas Keriven. Not too little, not too much: a theoretical analysis of graph (over) smoothing. Advances in Neural Information Processing Systems, 11:2268-2287 2022.
Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint Xrx: 02907, 2016.
Patrick Knupp. Remarks on mesh quality. Technical report, Sandia National LSbL(SN), Albuquerque, NM (United States), 2007.
W Michael Lai, David Rubin, and Erhard Krempl. Introduction to continuum mechanics. Butterworth- Heinemann, 2009.
Qimai Li, Zhichao Han, and Xiao-Ming Wu. Deeper insights into graph convolutional networks for semi- supervised learning. In Proceedings of the A AAT conference on artificial intelligence, volume 32, 2018a.
Yunzhu Li, Jiajun Wu, Russ Tedrake, Joshua B Tenenbaum, and Antonio Torralba. Learning particle dynamics for manipulating rigid bodies, deformable objects, and fluids. ar preprint 1rXic:1810.011 2018b.
Zongyi Li, Nikola Kovachki, Kamyar Azizzadeneshelli Burigede Liu, Andrew Stuart, Kaushik Bhattacharya, and Anima Anandkumar. Multipole graph neural operator for parametric partial differential equations. Advances in Neural Information Processing Systems, 33:6755-67766 2020.
Mario Lino, Stathi Fotiadis, Anil A Bharath, and Chris Cantwell. Towards fast simulation of environmental fluid mechanics with multi-scale graph neural networks. arXiv preprint arXiv:2205.028 026677, 2022.
Tobias Pfaff, Meire Fortunato, Alvaro Sanchez- Gonzalez, and Peter W Battaglia. Learning mesh-based simulation with graph networks. arXiv preprint arXiv:2010.03409, 2020.
Ladislav Rampášck, Michael Galkin, Vijay Prakash Dwivedi, Anh Tuan Luu, Guy WOlf, and Dominique Beaini. Recipe for general, powerful, scalable graph transformer. Advances in Neural Information Processing Systems, 15:14501-14511 2022.
15

---

Published in Transactions on Machine Learning Research (09/2025)
Olaf Ronneberger, Philipp Fischer, and Thomas Brox. U-net: Convolutional networks for biomedical image segmentation. In Medical image compuling and compuler-ossisted Indervention-MCCCC 2015: 18th international conference, Munich, Germany, October 5-9, 2015, proceedings, part 111 18, pp. 234 241. Springer, 2015.
Peter J Schmid, Larry Li, Matthew P Juniper, and Oliver Pust. Applications of the dynamic mode decomposition. Theoretical and computational fluid dynamics, 25:249-255 259,, 2011.
Luning Sun, Han Gao, Shaowu Pan, and Jian-Xun Wang. Surrogate modeling for fluid flows based on plyssics-constrained deep learning without simulation data. Computer Methods in Applied Mechanics and Engincering, 361:112733 11::2, 2020.
Kunihiko Taira, Steven Brunton, Scott TM Dawson, Clarence W Rowley, Tim Colonius, Beverley McKeon, Oliver T Schmidt, Stanislav Gordeyev, Vassilios Theofilis, and Lawrence S Ukeiley. Modal analysis of fhuid flows: An overview. Aiaa Journal, 55(12):4013 4041, 2017.
Kiwon Um, Xiangyu Hu, and Nils Thuerey. Liquid splash modcling with neural networks. In Computer Graphics Forum, volune 37, pp. 171 182. Wiley Online Library, 2018.
Benjamin Ummenhofer, Lukas Prantl, Nils Thucrcy, and Vladlen Koltun. Lagrangian fluid simulation with continuous convolutions. In International Conference on Learning Represenlations, 2019.
Olga Veksler, Yuri Boykov, and Paria Mehrani. Superpixels and supervoxels in an energy optimization framework. In Computer -ihon 2010: 11th European Conference on Compuler Vision, Heraklion, Crete, Greece, September 5-11, 2010, Proceedings, Part V 11, pp. 211-224 Springer, 2010.
Oriol Vinyals, Samy Bengio, and Manjunath Kudlur. Order matters: Sequence to sequence for sets. arXiv preprint ar (rXi::511.06330) 2015.
Haixin Wang, Yadi Cao, Zijie Huang, Yuxuan Liu, Peiyan Hu, Xiao Luo, Zezheng Song, Wanjia Zhao, Jilin Liu, Jinan Sun, et al. Recent advances machine learning for computational fluid dynamics: A survey. arxiv preprinl ar (tl:2400.12170 2024.
Edward L Wilson. Three-dimensional static and dynamic analysis of structures. Computers and structures, Inc, 1, 2002.
Tong Wu, Liang Pan, Junzhe Zhang, Tai Wang, Ziwei Liu, and Dahua Lin. Balanced chamner distance as a comprehensive metric for point cloud completion. Advances in Neural Information Processing Systems, 34: 29088 29100, 2021.
Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and S Yu Philip. A comprehensive survey on graph neural networks. IEEE transactions on neural networks and learning systems, 32(1):4 24, 2020.
Ruibin Xiong, Yunchang Yang, Di He, Kai Zheng, Shuxin Zheng, Chen Xing, Huishuai Zhang, Yanyan Lan, Liwei Wang, and Tieyan Liu. On layer normalization in the transformer architecture. In International Conference on Machine Learning, pp. 10524-10533. PMLR, 2020.
Chaoqi Yang, Ruijie Wang, Shuochao Yao, Shengzhong Liu, and Tarek Abdelzaher. Revisiting over-smoothing in deep gens. Xiv preprint 2000::00031666 2020.
Chen Yang, Shuai Li, Yu Lan, Lili Wang, Aimin Hao, and Hong Qin. Coupling varyingrying modal analysis and fem for real-time cutting simulation of objects with multi-material sub-domains. Computer Aided Geomelric Design, 43:53 67, 2016.
Youn-Yoor Yu, Jeongwhan Choi, Woojin Cho, Kookjin Lee, Nayong Kim, Kiseok Chang, ChangSeung Woo, Ilho Kim, SeokWoo Lee, Joon Young Yang, et al. Learning flexible body collision dynamics with hierarchical contact mesh transformer. ar preprint WxXx:2331..14000 2023.
Olek C Zienkiewicz and Robert. I. Taylor. The fonite element method set. Elsevier, 2005.
16

---

Published in Transactions on Machine Learning Research (09/2025)
Appendix: Table of Contents
A Datasets
18
Datascts Details
18
B Model Details
18
B.1 M4GN Configurations
18
Baselines
B.3
Training Details
19
B.
4
Hybrid Mesh Segmentation Details
20
B.5
Mesh Segment Hyperparameter Selection
21
C
Additional Evaluation Metrics and Results
23
Metrics for Mesh Quality Measure
23
Segmentation Quality Metrics
23
C33
Evaluation Supplementary Datasets
24
Evaluation on the L'flectiveness of Segmentation Algorithm
25
D Hyperparameter Sensitivity Analysis
25
D. Message Passing Steps in Micro-level Module
26
D.2 Variations of Hybrid Segmentation
27
Number of Segmentation
D.4 Influence of Positional Encoding
28
D.5
Influence of Segment Overlap
29
E
Generalization Studies
29
E.
Performance on Larger-Scale Datasets
29
E.2 Effect of Mesh Segment Count on Generalization
31
F
Computational Efficiency Analysis
34
Porformance Comparison
34
2 Complexity Analysis
34
Qualitative Results
34
17

---

Published in Transactions on Machine Learning Research (09/2025)
A Datasets
A.1 Datasets Details
CylinderFlow This public dataset includes simulations of transient incompressible flow around a cylinder, with varying diameters and locations, on a fixed 2D Eulerian mesh. In all fluid domains, the node type distinguishes fluid nodes, wall nodes, and inflow /outflow boundary nodes. The inlet boundary conditions are given by a prescribed parabolic profile, Un uo[1 4(y/H), where ug and H are the centerline velocity and the distance between the sidewalls, respectively. The dataset contains 1000 training simulations, 100 validation simulations, and 100 test simulations.
EAGLE- - This public dataset contains simulations of complex airflow generated by a 2D unmanned acrial vehicle maneuvering in 2D scenes with varying floor profiles. While the scene geometry varies, the UAV trajectory is constant: the UAV starts in the center of the scene and navigates, hovering near the floor surface. The node types are fluid nodes, wall nodes, and acrial vehicle nodes. The datasct contains 948 training simulations, 118 validation simulations, and 118 test simulations.
FlagSimple* This public dataset includes simulations of a flag blowing in the wind and flag direction, with variation in wind speed. The mesh is static and remains the same for all simulations. Node types are flag nodes and handle nodes that are fixed. This dataset contains 1000 training simulations, 100 validation simulations, and 100 test simulations.
DeformingPlate This public dataset includes simulations of hyperelastic plates deformed by a moving obstacle, with variations in plate design and obstacle design. The node types are plate nodes, handle nodes that are fixed, and obstacle nodes. This dataset contains 1000 training simulations, 100 validation simulations, and 100 test simulations.
This dataset is generated using solids4foam which is toolbox for performing solid mechanics and fluid-solid interaction simulations in OpenFOAM and foam-extend. A nearly incompressible nco-Hookean model is used where the material propertics are density Po = 1000 kg/m², Young's modulus E =1 MPa, and Poisson's 's ratio v 0.4. The beam comes different geometries with various initial conditions and boundary conditions. The node types are plate nodes, handle nodes that are fixed, and obstacle nodes. This datasct contains 355 training simulations, 40 validation simulations, and 60 test simulations.
DeformingBeam
DeformingBeam (large) A large domain DeformingBeam dataset is created for generalization studies. The physical domain size is doubled. The size of the mesh cell is kept consistent with the regular DeformingBeam dataset. This generalization dataset contains 112 simulations.
Table 4: Detailed information for each dataset.
Sysrra
DATASET
Ava. Napes
* STEPS
MEai TyPn
GRAPH DIAMETER
Noor FEATURE
EDor FEATURE
Octser
Fles
Fre EAGLE"
600
950
TREANCER, RuLERTAN,
THANGLE, BOUSLAN, 2D
11 29,5 1.7
v., P., D.
may [m.
May may
V.
V.
FLOw: STRUCTURE
1379
400
THIAGGES LAGIANGIAN, 3D
41
Xi. Xi, Di
may [may]
1271
400
TEmARROON,, LAURANGIAS, 3D
16,9 4: 5.5
Xeen
may. (mn)
%:
SouD
1542
400)
FRuss, LaGIANGIa,, 3D
41.3 4: 11.8
Xeen
[ig
Maps Imi
X:
DEPonsisoBBns (LARGE)
4540
400
Passi, LAGRANCIN, 3D
52.1 4 20.0
Roass
Myy 18y an. jon.
2.
B Model Details
B.1 M4GN Configurations
The GNN part of M4GN adopts the encoder and graph processor in the MGN model Pfafff et al. 2020 The basic building block is Multi-Layer Perceptron (MLP). The MLP has 3 layers, a hidden dimension of 128, ReLU activation, and a single layer of Layer Normalization at the end. The node encoder and
"EAGLE and FlagSimple included only as supplementary beuchmarks show robustucss across different dataset types and support additional analysis; we exclude ablation studies on these datasets maintain a focused experimental scope and ensure clarity in result interpretation.
18

---

Published in Transactions on Machine Learning Research (09/2025)
edge encoder(s) are 3-layer MLPs. By default, the M4GN has 7 message passing steps in the GNN. The mesh segment transformer consists of 4 self-attention layers, each with 8 heads. The output decoder is a 3-aayer MLP without Layer Normalization. For Deforming(Patee and DeformingBeam, M4GN only considers world edges between contacting mesh objects. The world edge radius is set to 0.01 for DeformingPlate and 0.002 for DeformingBeam. As both the DeformingBeam and DeformingPlate datasets feature rigid object with quasi-static motion, we use only the first mode from our modal decomposition, which sufficiently captures the largest-scale deformation pattern. For the CylinderFlow dataset, we employ modes, determined by an energy threshold criterion, ensuring more comprehensive representation of the flow's multi-scale dynamics. For Table B every dataset uses SLIC-MDODe segmentation, but the hyper-parameterss differ: For the CylinderFloww Fow dataset, 36 segments are used with compactness value = 1.0, segment overlap, and positional encoding (PE) are both enabled. For DeformingPlale and DeformingBeam, 19 segments are used with the former using т = 1.0 with no overlap or PE, while the latter uses T = 0.5 with overlap but without PE. Ablation studies are also conducted based on these configurations.
B.2 Baselines
GCN The GCN model consists of 15 GCN layers with a hidden dimension of 128. The GCN model does not have edge input. Node input includes mesh position x; for CylinderFlow. The implementation is from PyTorch Geometric.
g-U-Net The g- g-U-Net model is modified version from PyTorch Geometric. Instead of GCN layers, it is built using the GNN layers similar to MGN. The level of scale is 7 for CylinderFlow, 6 for DeformingPlate, and 4 for Deforming ReformingBeaam. Beam.
MGN Our implementation of MGN follows the one described in Pfaff et al. (020)) The processor of MGN contains 15 MP steps. World edges are constructed as specified in the paper, with a world edge radius of 0.03 for DeformingPlane and 0.003 for DeformingBeam.
BSMS-GNN We followed the BSMS-GNN implementation Cao et al. 2023 from https://github... Sydcao/BSMS-GNY We introduced modification to the original code by incorporating oulput normalization, which we observed to enhance the model's performance. For CylinderFlow and Deforming we used the same number of multi-scale levels as specified in the BSMS-GNN paper, at 7 and 6 levels, respoctively. The number of multi-scale levels for DeformingBeam is set at as an optimal configuration.
The implementation of EAGLE follows the paper Janny et al. (2023) and the code repository We set the number of nodes per cluster at 20, which offers a balanced performance and efficiency according to the paper. This results in 94 clusters for CylinderFlow, 64 for DeformingPlate, and 38 for DeformingBeam. In addition, we add contacting world edges in the EAGLE implementation for DeformingPlate and DeformingBeam to improve performance. The world edges are added the same as in M4GN.
EAGLE
https://gittnn http::///gtttu...c//gggleeedadad hamm/eagll-dattaeteee Bar.aaaaeeeeesaasrrrrrreeee
B.3 Training Details
During training, random Gaussian noise is added to the spatial node inputs, as described in Pfaff et al. (2020) For CylinderFlow, all models use a noise scale of 0.02. For DeformingPlate, all models use a noise scale of 0.003. For DeformingBeam, EAGLE and M4GN use a noise scale of lc-4 and other models use noise scale of 1e-3.
For GCN, g- g-U-Net, MGN, EAGLE and M4GN, we adopt the same training scheme: For CylinderFlow and DeformingPlate, we trained the model for 2M steps. The learning rate starts at 1c-4 and exponentially decays to le-6 from 1M to 2M steps. For DeformingBeam, we trained the model for 1M steps. The learning rate starts at 1e-4 and exponentially decays to 1e-6 from 500K to 1M steps.
For BSMS-GNN, we adopt the training scheme from the original implementation. Models for CylinderFlow and DeformingPlate were trained for 50 epochs, corresponding to 3.75M and 3M training steps, respectively. DeformingBeam model was trained for 100 epochs, corresponding to 1.775M training steps.
19

---

Published in Transactions on Machine Learning Research (09/2025)
Across all models and datasets, use batch size of 8. Experiments were conducted using PyTorch distributed training over two Nvidia Tesla P100 GPUs.
B.4 Hybrid Mesh Segmentation Details
In Figure several cases selected from each dataset to illustrate the difference of each mesh graph segmentation method. It's worth noting that the graph will be partitioned only once during the training and lesting phase for each simulation, and this partitioning will remain consistent across all time steps. This is because the segmentation is based solely on the system's properties and initial conditions prior to the start of the simulation.
METIS
SLIC-MD
SLIC-MDOD,
SLIC-MDOD,
(a)
(b)
(c)
(d)
(e)
Figure 4: Illustration of different segmentation methods under various cases: (a):CylinderFlow; (b) DeformingPlate (d)(c): DeformingBeam. Mesh nodes are colored based on segment id and all boundary nodes are colored in black.
The pseudo code of the hybrid segmentation module proposed in this work can be found in Algorithm 2 Here, METIS (Karypis & Kumar 1998 is graph partitioning technique that efficiently divides meshes into approximately equal-sized partitions. It leverages multilevel partitioning algorithms to minimize the edge-cul or communication costs between the resulting partitions. We employ METIS due to its versatility in creating a uscr-specified number of equal-sized mosh segments. SLIC (Achanta et al., 2012) is a clustering algorithm employed for partitioning data. In our approach, we adapt SLIC to segment the mesh based on physics- informed features. These features could guide SLIC to create segmentation that captures the underlying physics of the system. The consequent mesh segments can potentially enable efficient macro-level information exchange tailored to the system's dynamics. Concretely, for each node incorporate physics-aware feature pmdd derived from modal decompasition Additionally, we augment these features by concatenating a measure of the shortest distance to obstacle nodes dhhs, To ensure that this measure dominates when doha is small, we apply either an exponential or logarithmic transformation, defined as:
(d) exp(-d), fiog log(d).
Depending on the selection of features and the transformation function, we design 6 variants of SLIC:
SLIC-OD: fa ddob
SLIC-OD; fa flog (dqbe)
20

---

Published in Transactions on Machine Learning Research (09/2025)
Algorithm 1: Modal Decomposition
Case Type: solid or fluid
Input: Finite element mesh, boundary conditions, material properties for solid (e.g. p), number of modes
Build Finite Element Basis:
4: Define shape functions on each element using the node connectivity
5:
Enumcrate degrees freedom (DOFs) for each node/component
Case Type = solid then
Structural Modal Analysis
Assemble stiffness matrix K (using elasticity)
Assemble mass matrix M (using density)
10:
Apply boundary conditions to eliminate fixed DOFs
11:
Solve KØ = MM for the first m modes
12:
Output: Eigenpairs {(),, + (structural modes)
13:
else Case Type = fluid then
14: Laplacian Eigenfunctions
15:
Assemble Laplacian matrix
16:
Assemble Ly-type matrix
17:
Apply Dirichlet constraints boundary nodes
18:
Solve V26 = oø for the first m modes
19:
Output: Eigenpairs {(),, d:) (hormonic modes)
20:
end
21: Return: m-dimensional feature vector smnd (i) (1)) (1)) at each mesh node
ST.C--D,; fi Sexp
SLIC-MD: fi s.md
SLIC-MDOD;; [foo (debe), fmi]
SLIC-MDOD f4 = [Jexp (dobe), smnd
After we have the physics-aware feature, can apply the SLIC algorithm to get. the mesh node segments.
B.5 Mesh Segment Hyperparameter Selection
The compactness parameter in the SLIC algorithm controls the trade-off between physics-guided feature similarity and spatial proximity. Our goal is to choose 5 such that the resulting segmentation captures both underlying physical patterns and spatial coherence (i.e., grouping nodes that are close to each other). For CylinderFlow and DeformingPlate, DeformingBeam, we set a lower T at 0.5 to promote a better alignment with physical features. The cluster size S is determined such that the domain area satisfies: Domain Area KS22, where K is the number of segments and the domain area given by (Imax - 2miu 2 (ymax Vmin). The average cluster size S for CylinderFlow; DeformingPlate and DeformingBeam is set be V0.656/K. K, /0.125/K and /0.005/K, K, respectively.
set = 1.0, which provides balanced segmentation. For
Systematically choosing the optimal number of segments K requires both domain insight and practical experimentation. In our experience, two main factors drive the choice of K: (1) the total mesh size (N) and (2) local variations in mesh density. For instance, CylinderFlow is particularly dense near boundaries, which benefits from a larger K, whereas DeformingBeam, Defonm/ieD have more uniformly distributed nodes, so smaller K can suffice.
To make this selection concrete, we typically perform short hyperparameter sweep over a small set of candidate values for K. A simple heuristic is to pick K values on a roughly geometric or linear scale, for instance: K (VN/2, VN, ....... up to point where adding more segments longer improves
21

---

Published in Transactions on Machine Learning Research (09/2025)
Algorithm 2: Hybrid Mesh Segmentation
1: Input:
2: Initial mesh graph G = EV
3: Perform modal decomposition and compute mesh node feature Si
4: Number of segments K, compactness parameter т, average cluster size
Output: Mesh node segmentation (Vs,kE=1
Graph-based Mesh Segment Initialization
Coarsening Phase:
7: Geoarse + G
8: while size of Gooarse is larger than threshold do
9: Combine pairs of connected nodes in Geoarse to form a coarser graph
10: Geoarse f- coarsened graph
11: end while
12: Initial Partitioning:
13: Partition Geoarse into K segments using standard partitioning method (e.g., spectral partitioning)
14: Uncoarsening and Refinement Phase:
15: while Geoarse + G do
16: Expand Geoarse to the next finer graph Gine
17: Project partitions onto Gūne
18: Refine the partitioning on Gime by iteratively moving vertex to neighboring segments iff the move lowers the total number (or weight) of edges that cross between segments, provided each segment. remains roughly balanced in size.
19: Geoarse + Gfue
20: end while
21: Obtain initial clusters (Vs, K from the final partitioning, which will be updated next
Superpizel-based Mesh Segment Refinement
22: repeat.
23: for each mesh segment centroid C do
24: Update Cg by averaging over all mesh nodes assigned to it:
C [xc, fcul"=
1
Σ Ja fil"
[esl kEVS,
where Vs, is the set of mesh nodes assigned to segment Sy
25: end for
26:
for each mesh node i E V do
27:
Compute the distance measure d(i, Ck) to each cluster center Cs using: d(i, Cx) = Ilft - fc, + xc2
where and IC, are the spatial coordinates, fs and fc, are the physics-guided features. 28: Assign mesh node to the nearest segment centroid Cs if d(i, Ck) <
29: end for
30:
until convergence or a maximum number iterations is reached
22

---

Published in Transactions on Machine Learning Research (09/2025)
validation metries (e.g., prediction accuracy, mesh quality). In practice, testing each candidate K on subset (e.g., 10%) of the training data is typically enough to identify a near-optimal configuration, and then we finalize training with that K on the full dataset. This strategy is computationally manageable and provides a principled way to tailor to new domains.
C Additional Evaluation Metrics and Results
C.1 Metrics for Mesh Quality Measure
Hausdorff Distance The HausdorfT Distance measures how well the mesh with the predicted node positions conforms to the system's true geometry. It is defined as:
GF (V, V) = max ((V, (O.
(10)
where 1(V,
D) = supxev inf xev ||x - *|| is the directed Hausdorff distance (Huttenlocher al. 1993) from the ground-truth node set V to the predicted node set D
Chamfer Distance - The Chamfer Distance (Wu et al. 2021 measures the average distance between points on the predicted mesh and the true mesh, providing a balanced assessment of GF Unlike the Hausdorff Distance, which focuses on the maximum deviation, the Chamfer Distance is sensitive to the overall distribution of errors across the mesh surfaces. As both Chamfer and Hausdorff distance are measures for GF, we name them as GF& and GFA, for simplicity, respectively. The Chamfer distance is mathematically defined as:
GF 1)
Σ XEV
RED min min |x - x|1² 2 + M
Σ RED
m - x||²
(11)
M
where V and ' are the set of vertices in the ground-truth and predict mesh, respectively. [V] and | denote the number of vertices in each mesh.
evaluates the uniformity of predicted mesh cell sizes to Mesh Continuity Mesh Continuity Knupp
2007
ensure stability and is defined as
minezeAdj(es) V(e,)' MC = C Σ
1
maxe, EAdile.) V(e))
(12)
where Adj(c:) is the neighboring cells of cell o;, and V(c)) calculates the volumetric area for G,.
Aspect Ratio (error) The Aspect Ratio (Zienkiewicz & Taylor 2005) assesses the shape quality of individual 2D or 3D mesh elements and is widely used finite clement mothod (FEM) litcrature to evaluato how closely each element approaches the ideal shape, such as an equilateral triangle or a regular tetrahedron. For example, for triangular meshes, the aspect ratio is defined as Emax where Lmax is the longest edge
2V/3A'
length, A is the area of the triangle. For tetrahedra mesh, it is defined as VoLumus where V the volume of the tetrahedron. High aspect ratios indicate elongated or distorted elements, which can cause numerical instability and reduce simulation accuracy. By analyzing the aspect ratios across all elements, we can assess the overall uniformity and regularity of the mesh. To evaluate the accuracy of the predicted mesh compared to the ground truth, we calculate the aspect ratio for both the predicted and actual meshes. The Aspect Ratio Error is then determined as the L2 distance between these two values. This error metric quantifics the deviation in shape quality between the predicted and true meshes, providing a direct measure of how well the prediction preserves the ideal element shapes. Incorporating the Aspect Ratio Error allows for a more procise evaluation of mesh quality and prediction accuracy, ensuring that the segmented meshes maintain the necessary geometric properties for reliable simulations.
C.2 Segmentation Quality Metrics
In order rigorously evaluate the quality of our hybrid mesh segmentation and its impact on the prediction of system dynamics, it is essential to consider metrics that assess both inter-segment and intra-segment
23

---

Published in Transactions on Machine Learning Research (09/2025)
characteristics. We introduce three such metrics -Cndductance, Edge Cut Ratio, and Silhouette Score which provide comprehensive assessment of segmentation quality by quantifying the cohesion within segments and the separation between segments. The necessity of these metrics arises from the need to ensure that segments are well-separated, minimizing unnocessary interactions between dissimilar regions (inter-segment quality), and that nodes within the same segment share similar properties or behaviors (intra-segment quality).
Moreover, in our hierarchical model architecture, the intra-segment quality pertains to the micro-level information exchange stage. High intra-segment quality facilitates accurate modeling of local dynamics within cach segment by ensuring that nodes are cohesive and share similar dynamic behaviors. Conversely, the inter-segment quality directly relates to the macro-level information exchange stage. High inter-segment quality ensures efficient communication between segments by reducing redundant or irrelevant interactions, which is crucial for capturing global dynamics across the entire mesh. Below are the details of three metrics to mcasure segmentation quality.
Conductance Conductance measures the fraction of total edge connections that cross between different segments relative to the total connections of the segments. It assesses how well the segmentation minimizes inter-segment connections while maintaining intra-segment cohesion. Let G = (V,E) as an undirected graph representing the mesh, where V is the set of nodes and & is the set of edges. Let S be a segment and $ = G AS be its complement. The conductance of segment S is defined as:
u) E UE S}
Conductance
(13)
min (vol(S). vol(S))
where the numerator is the number of edges crossing between S and S. The volumn of segment. S is given by vol(S) Eves deg(u), where degu is the degree of node u (the number of edges connected to u).
Edge Cut Ratio - The Edge Cut Ratio quantifies the proportion of edges that are cut by the segmentation relative to the total number of edges in the mesh. It is defined as:
Edge Cut Ratio = [[u,, u) Seg(u) + Seg(v))
(14)
E
where the denominator is the number of edges that connect nodes in different segment. Seg(u) denotes the segment to which node u belongs and E = [ is the total number of edges.
Silhouette Score For each node i, the Silhouette Score evaluates how similar is to nodes in its own segment compared nodes in other segments. It is defined as:
Silhouctte Score 1
b(1) - a(1) N maxfa(1). b(1)}
N Σ
(15)
where is the total number of nodes, a(i) the average dissimilarity of node i with all other nodes in the same segment and b(i) the lowest average dissimilarity node i to any other segment which does not belong. To be more specific a(i) Ta--Eren d(i,)), b(t) mins [ Ejes d(i.j)), where S, is the
segment containing node i and j(i,j) can be any appropriate distance metric, such Euclidean distance based node features positions.
By combining these metries, we achieve comprehensive evaluation of sogmentation quality that covers both the internal cohesion of segments and their external separation. Having these metrics, along with prediction result metrics, can better help us understand the effect of segmentation on the predicted system dynamics. These metrics can be used help finding better physics-aware sogment fcatures and determining the optimal segmentation number (results and discussion in Appendix D.5)
C.3 Evaluation on Supplementary Datasets
To evaluate the robustness of our approach across distinct physical regimes, we retrained all models on two additional datasets -FAGLE and FlagSimple and compared the proposed M4GN architecture with the
24

---

Published in Transactions on Machine Learning Research (09/2025)
Table 5: Comparison of results with state-of-the-art methods across two additional datasets, where each model trained independently for cach dataset. Prediction accuracy evaluated using Root Mean Square Error (RMSE), with the output being the 2D velocity and pressure field for EAGLE and the 3D position for FlagSimple. Results are averaged over three experiments with different random seeds and presented as mean and standard deviation.
Quality Metries
Prodiction and Computation Motrica
DATASET
Moner
GF (X10 2)
GF. (x10 )
(X10 3)
MC
(x10
RMSE-all
TRAIN MEMORY [MB]
TIME PER STEP [Ms"
MGN
4.13 : und
10525
35.8
EAGLE
EAGLE
4.24 + 0.0
7251
35.2
MHGN (OuRS)
3.95 0.06
5308
28.4
FLAG SIMPLE
EAGLE
MGN
1.82 = 0.8
1.73
5.22
5.01
1: 0.0
1 0.00
6.02 = 0.99
6.71
0.0
4.16 a o.45
5.49
1.05
1.01 1 1:114
0:25 0:31
1060
1336
41.9
36.5
MAGN (OURS)
0.98 0.05
2.23
0.19
0.40
0.02
0.15
0.01
549
Table 6: Transfer--egmmenaate experiment on the DeformingBeam dataset. Replacing EAGLE's native segmentation with the proposed hybrid M4GN segmentation (sccond row) isolates the effect of segmentation quality, while the full M4GN row (third row) shows the additional benefit of our modified hierarchical architecture. Lower values indicate better performance.
Mesh Quality Metrics
Prediction Error Metrics
GF (x10-))
GF. (x10-9)
MC
AR
RMSE-1 (x10-9)
RMSE-50 (x10-*)
RMSE-all (x10-1)
DATASET
MODEL
SECMENTATION
(x10-2)
(x10-
DEFORMING
BEAM
EAGLE EAGLE
M4GN
MIGN
EAGLE
M4GN
0.31 0.00
0.48 am
0.64 ne1
0.05
0.17 1 nm
0,11 a.o
0.00
6.26
5.43
5.98 3.4
0.00
3.08
5.17
4.02 0.00
0.00
6:17
1.17
1.28 + c.
4:
0.01
0.34
0.57 + e.8
0.02
1.87 0.12
3.27 +amm
strongest baselines identified carlier, MGN and the task-spocific EAGLE solver. As summarized in Table 5 M4GN atlains the lowest prediction error on both datasels, lowering RMSE by 4% on EAGLE and by 40% on FlagSimple comparing to the second best model. For FlagSimple, M4GN also yields the most faithful meshes, reducing goometric-quaality defect metrics by 25-57% relative to both baselines. Morcover, it halves peak training memory consumption and accelerates inference by up to 19%. Collectively, these results demonstrate that M4GN sustains its performance ad advantages on the supplementary datasets, delivering higher predictive accuracy, better mesh quality, and more efficient computation.
C.4 Evaluation on the Effectiveness of Segmentation Algorithm
To isolate the impact of the proposed hybrid segmentation algorithm, we replace EAGLE's original segmen- fation with those generated by our method while holding all other settings unchanged. Table 0 shows a clear gain: mesh-quality metrics improve by 28%-35% and prediction errors fall by 15%-23% When the same segmentation is paired with the full M4GN architecture, prediction errors are reduced even further and every mesh-quality metric reaches its best value. These results indicate that (i) the proposed hybrid mesh segmentation alone contributes a portion of the improvement, and (ii) the archilectural changes in M4GN provide additional, complementary boost. Hence both components better segmentation and the modified model-are necossary for the overall performance gains.
Hyperparameter Sensitivity Analysis
This section presents a systematic sensitivity study, detailing how each hyperparameter affects performance and offering practical tuming guidelines. Importantly, the model already putforrssms all basclines with default or minimally adjusted settings; additional tuning only refines an existing advantage rather than creating it. The following subsections analyze each hyperparameter in detail and Table 7 summarizes the key findings.
25

---

Published in Transactions on Machine Learning Research (09/2025)
Hyper- parameter
Ranges/ Vari- ants
Observed impact on performance
Practical tuning guideline
Message passing steps (TMP)
1-8
Few steps + under-reach, large RMSE and discontinuities; moderate steps + improve both RMSE and mesh quality; very high steps + over-smoothing and slight accuracy decay.
Start with 3-5 steps; increase while RMSE drops, stop when gains plateau or mesh quality stalls.
Hybrid segmenta- tion flavour
METIS, SLIC variants
SLIC variants outperform METIS; physics-aware features give 7-35 % lower RMSE and better segment metrics; best overall: SLIC-MDOD..
Use SLIC-MDOD. by default; avoid single-cue variants unless domain knowledge shows other- wise.
Number of seg- 3-51 ments (Msug)
Accuracy fairly stable; too few segments + coarse resolution, RMSE rise; too many segments + diminishing returns followed by possible degradation and added overhead.
Compute Silhouette over candi- date Naog, then train 3-4 values near the peak; pick the point where RMSE/ stop im- proving.
Positional encod- off on ing (PE)
Improves RMSE when Naeg small and ge- omelry simple; neutral harmful when segments already fine or geometry com- plex.
Enable PE for coarse segmenta- tions (Nang < 15) or 2-D flows; disable for high-resolution or highly deformable 3-D meshes.
Segment overlap
(none),
Helps Eulerian or directional meshes at high Nagg (smoother transitions); can add redundancy and hurt Lagrangian cases.
Use ô for high Nong and the mesh is fixed; keep 8 = for low Noeg-
(6)
5 = (one-ring)
Table Summaay of key hyperparameters, their tested ranges, performance effects, and tuning recommenda- tions derived from the sensitivity study in Appendix D
D.1 Message Passing Steps in Micro-level Module
According to Figure with fewer message passing steps, each node updates only based on immediate neighbors, resulting in higher prediction errors and mesh discontinuities. As more steps are introduced, nodes gather information from a broader neighborhood, leading to more accurate predictions and smoother mesh transitions. The early iterations of message passing yield the most noticeable improvements, as nodes rapidly gather useful information from their surrounding environment. Later iterations primarily serve to fine-tune the mesh continuity and reduce local errors, but the impact on overall accuracy diminishes. Interestingly, increasing the number of message- passsngg steps beyond certain point continues to improve mesh quality, but prediction accuracy may degrade. This suggests the occurrence of oversmoothing, where the model excessively homogenizes node features, overfitting, where the model starts to memorize local information rather than generalize. This phenomenon highlights the importance of carcfully selecting the number of message- message-passing steps during the micro-level information exchange step to strike the right balance between improving prediction accuracy and maintaining mesh quality.
Cylinder
Beam
Plate
RMSE
35
RMSE
Contung RMSE
RMSE
Continuity Error
Continulty Error
Continulty Error
RMSE
RMSE
La
3.0
Message Passing Steps
Message Passing Steps
Message Passing Steps
Figure Ablation study on the impact of varying message-passing steps in the micro-level information exchange on prediction performance across three datasets.
26

---

Published in Transactions on Machine Learning Research (09/2025)
D.2 Variations of Hybrid Segmentation
As detailed in Appendix B.4 4, the hybrid segmentation admits six variants depending on the selected feature set and transformation. Table 8 summarizes the resulting model performance. Compared with METIS alone, SLIC-based variants lower R.MSEa by 16 %, 27 %, and 7% on CylinderPlow, DeformingPlate,, and Deform- ingBeam, respectively, with SLIC-MDOD, emerging as the best choice across all three datasets. In terms of the impact of modal decomposition features in SLIC, for the two solid mechanics cases (Deforming and DeformingBeam), modal-deconpositionn features enrich the descriptor space with physics-relovant mode shapes, and every OD+ MD variant SLIC-MDOD, and SLIC-MDODe beats its OD-only counterpart across all metrics, delivering 24 35% lower RMSE and up to 25% better mesh-quality scores. These consistent gains confirm that modal information and boundary-distance cues are complementary for solid mechanics. On CylinderFlow; however, the flow is dominated by rapidly varying vortical patterns; the MD basis, derived purely from geometry in this Fulerian setting, adds little new information and can perturb the SLIC clusters, so SLIC-MD alone shows a slight RMSE rise. When MD is combined with the (exponentially weighted) distance cue in SLIC-MDODe, the boundary-aware term stabilizes the segmentation while the modal vectors still provide complementary detail, giving a net improvement over distance or modal information used in isolation.
Moreover, refining the coarse METIS partitions with SLIC improves accuracy only when the added SLIC features better align local cuts with the true physics; otherwise, the refinement can fragment physically coherent regions and hurt performance. SLIC-OD, for example, uses only geometric distance to boundaries; on DeformingPlate this over-wesghts proximity and splits mode-consistent areas, so RMSE increases relative to the original METIS segmentation. Likewise, on DeformingBeam the distance-only (SLIC-OD) and modal-only (SLIC-MD) variants either ignore contact boundaries or long-range bending modes, producing finer- but less mcaningful seggenttssssestsss and therefore higher error than METIS. Only the combined SLIC-MDOD,, which couples modal information with an exponentially weighted distance term, strikes the right balance between global coherence and local adaptation.
To thoroughly evaluate the different segmentation methods, we utilize the three metrics -Conductance, Edge Cut Ratio, and Silhouette Score - introduced in Appendix C.2 to assess both inter-segment and intra-segment qualitics of mesh partitions, providing a comprchensive understanding of cach method's effectiveness. We then analyzed the correlation between these segmentation metrics and overall dynamic system performance, including mesh quality and prediction error, as illustrated in Figure 2 (a-c). Our findings indicate that segmentation methods incorporating physics-aware features, particularly those utilizing obstacle distances with exponential transformations, generally enhance model performance across various datasels. This improvement can be altributed to three key factors: (1) Aligmment with Dynamics, where segmentation reflecting physical influences enables more effective learning of the system's dynamics; (2) Enhanced Segment Quality, achieved through improved intra-segment cohesion and minimized inter-sogment interactions, facilitating better learning of localized patterns; and (3) Benefil to Learning, where emphasizing critical regions via exponential transformations allows the model to focus areas with significant. dynamic changes, thereby enhancing prediction accuracy. These results demonstrate that the choice of segmentation method impacts the model's ability to Iearn dynamic behaviors, and the introduction of additional metries reveals that physics-aware segmentation effectively aligns mesh partitions with the system's 's inherent physical properties, thereby benefiting the learning process.
D.3 Number of Segmentation
Table 9 and Table I0 present the RMSE-1, RMSE-all, and various mesh quality metries as the total number of mesh segments is varied during training on three different datasets. In general, M4GN maintains stable performance with relatively low variance, indicating that results are not highly sensitive to segment count. This robustness ensures reliable accuracy across different mesh granularities. However, increasing the number of segments-tin thereby reducing finite elements per segment- can lead to slight decreases in accuracy and performance.
To comprehensively evaluate the effect of segment mumber and determine the optimal segmentation for given dataset, we analyzed prediction accuracy across wide range of segment counts (from to 51)
27

---

Published in Transactions on Machine Learning Research (09/2025)
Table 8: Ablation study on different segment extraction methods over different dataset.
SEOMENTTTION METHOD
DATaSeU
GF& 4
GFc 4
MC 4
AspeET RATI J
RMSE-1
RMSE-ALL
CYLINDER
3.44R-03
4.50R-02
METIS
PLATE
6.32x-03
1.36x-00
5.331-03
2.97k-03 3.09g-03
2.67k:004
3.29k-03
BEAM
3.88c-04
5.61n-08
5.18p-03
1.15g-05
2.10g-04
CYLINDER
3.281c-33
4.40k-02
SLIC-OD
PLATE
5.248-03
1.50e-05
5.162-03
3.04g-03
2.698-06
3. 3.708-03
BRAM
3.78k-04
5.41n-08
5.39
3.608-03
R.05
2.31
CYLINDER
3.33e-03
4.37E-02
SLIC-OD;
PLATE
5.11R-03
8.01x-06
5.09
2.90k-03
R-84
3.44x-03
BEAM
3.95g-04
5.41t-08
5.331=03
3. 3.30ts-3
1.18x-05
2.68c-04
CYLINDER
R.21
3.95e-02
SLIC-OD,
PLATE
6.27k-03
1.31k-05
4.58a-03
2.54ts-3
2.61x:04
3.511-03
BEAM
3.81E-04
5.68E-08
5.40E-03
3.328-03
1.20g-05
2.518-04
CYLINDER
3.16G-03
5.62t-02
SLIC-MD
PLATE
5.10g-03
8. 3838--
4.672-03
2.533-03
2.7 2.7/1-00
3.02E-03
BEAM
3.81x-04
5.45k-08
5.32s-03
3. 3.20k-03
1.17ks-05
2. 2.32t-04
CYLINDER
4.1 1R-03-
5.20e-02
SLIC-MDOD;
PLATE
4.84k-03
7. 7.23+-06
4.56x-03
2-476-03
2.68is-04
2.82x-03
BEAM
3.53g-03
5. 5.10E-08
5.29g-03
3. 3.40g-03
1.22t-05
2. 2.256-01
CYLINDER
3. 3.09k-03
3. 86u-02
SLIC-MDOD,
PLATE
4.26g-03
6.199-06
4.73p-03
2.58e-03
2.71g-04
2. 2.40p-03
BEAM 3.02E-03
4.47E-U8
5.31E-03
3.08E-03
1.178-05
2.016-04
during training on the DeformingBeam dataset. The impact varying the number of mesh segments on prediction accuracy illustrated Figure 0 and Figure 7 According to the plots, we identify 19 segments the optimal number. At this segmentation level, the model achieves the lowest RMSE and Chamfer Distance, indicating high prediction accuracy and precise shape representation. The Hausdorff Distance is also minimized, reflecting excellent alignment between the predicted and true meshes. While the Silhonette score peaks at 9 segments suggesting well-defined and compact clusters the slight decrease at 19 segments is offset by siguificant gains in other performance metrics. Choosing a lower number of segments, such as or 9, may result in higher Silhouette scores but can compromise mesh detail and prediction accuracy due to insufficient spatial granularity. Conversely, selecting higher number of segments beyond 19 shows diminishing ret returns, with only marginal improvements or slight degradations in some metrics and continued decline in Silhouette scores, potentially indicating verr-eegenntttion and unnecessary computational complexity.
In conclusion, when presented with a new dataset, the optimal number of sogments can be determined by first computing Silhouette scores for various segment. counts to assess cluster cohesion and separation without requiring model training. This provides initial guidance on meaningful segmentation levels. Subsequently, training the model with different segment numbers and evaluating performance metrics like RMSE, Hausdorff Distance, and Chamfer Distance will help identify the point where performance improvements plateau or begin to reverse, indicating the optimal balance between segmentation detail and model efficacy.
D.4 Influence of Positional Encoding
Table 10 and Figure a(a) show the effect of adding positional encoding for small and large numbers segments across three datasots. According the results, we identified several key findings. Firstly, the effectiveness of PE depends on the number of segments: in the CylinderFlow and Deforming Plate datasets, incorporating PE with fewer segments improves performance across multiple metrics by reducing positional ambiguity. With low segment counts, each segment covers larger, more diverse areas, limiting the model's spatial detail and understanding of segment relationships. PE provides explicit positional information, allowing the model to distinguish distinct regions within the same segment and better comprehend their interactions. However, as the number of segments increases and spatial resolution improves, the benefits of PE diminish and may even introduce unnocessary complexity that hinders performance. Additionally, datasct-specific factors influence PE's effectiveness; for example, the DeformingBeam dataset, with its complex geometry and deformation, did not benefit from PF. This indicates that PE's success depends not only segment count but also
28

---

Published in Transactions on Machine Learning Research (09/2025)
how well the PE implementation aligns with the dataset's unique characteristics. Consequently, tailored PE approaches that consider specific geometry and deformation patterns are necessary for complex systems to achieve performance gains, In summary, while PE enhances the performance of graph-based networks, further advancements are needed to develop optimal encoding strategics that consistently improve performance across diverse dynamic systems.
D.5 Influence of Segment Overlap
Table 9 and Figure B(b) illustrate the effect of adding segment overlap for small and large number segments across three datasets. According to the results, the effectiveness of adding overlap between segments (6 1) depends on both the segment count and the characteristics of the dataset, such as dimensionality, mesh type, and system dynamics. Overlapping segments are more beneficial with higher segment counts where discontinuities are more prevalent. In Eulerian systems, overlaps enhance the capture of complex interactions and smooth transitions on fixed meshes, leading to improved representation of fluid dynamics. Conversely, in Lagrangian systems where meshes move with the material, overlaps can create redundancy and complicate connectivity, with their impact on model performance varying based on mesh structures and deformation behaviors. For example, the Deforming Beam dataset, which uses a prism mesh suited for directional deformation, overlapping segments improve performance by facilitating smooth transitions along its mesh surface, especially with higher number of segments. In contrast, the Deforming Plate dataset employs tetrahedral mesh with complex, isotropic deformations, where overlaps introduce unnecessary complexity and redundancy, resulting in decreased performance. Therefore, despite both being 3D Lagrangian systems, the different mesh types and deformation patterns explain why overlapping segments benefit the Deforming Beam but not the Deforming Plate.
2.8
1.15
2.6
Continulty Error
RMSE-1
1.10
2.2
15.0
2.0
1.05
1.8
4.8
1.00
9
1.9
3.5
$1
10
3.3
1.9
33
5.1
Num Mashh Segments (TTaiin Thstt
Num Mash Segments (Train Test)
Num Mesh Segments (Train & Test)
Figure 6: Impact of varying mesh segment numbers during training on prediction accuracy under the DeformingBeam dataset. The number of mesh segments remains consistent during both training and testing. In general, M4GN maintains stable performance with relatively low variance, indicating that results are not highly sensitive to segment count. This robustness ensures reliable accuracy across different mesh granularities However, increasing the number of segments thereby reducing finite elements per segment can lead slight decreases in accuracy and performance. More detailed analysis the effect of segmentation numbers
various metrics can be found in Figure 7
E
Generalization Studies
To evaluate the generalizability of our M4GN model, we created a larger-scale DeformingBeam dataset, detailed in Appendix
E.1 Performance on Scale Datasets
Table 11 summarizes the generalization performance of various models trained on the DeformingBeam datasct and directly applied to DeformingBeam (large), a scaled-up version. The results demonstrate that M4GN consistently outperforms all other models across all metrics. In terms of mesh quality, M4GN achieves a 53% improvement over both EAGLE and BSMS for Geometric Fidelity (GF). Similarly, for Mesh Continuity (MC), M4GN achieves the best performance with a value of 1.08c-02, representing a 45% improvement over EAGLE, the next-best model. For the RMSE metrics, M4GN delivers the lowest. RMSE-1, RMSF-50, and
29

---

Published in Transactions on Machine Learning Research (09/2025)
Table 9: Ablation study of number of segments, and effect of adding segment overlap.
DATASET
Naza
OVERLAP
GF +
GF. 4
MC 4
ASPECT RATIO 4
RMSE-1
RMSE-ALL
16
3.16E-03
5.03E-02
3.196-03
5.35p-02
CYLINDER
36
X
3.41x-03
4.42t-02
3.09k-03
8.6--02
X
4.98k-03
9. 9.58x-06
5.01x-03
2. 2.83x-03
2.77k-04
3. 3.88e-03
5.32t-03
9.871=06
5.24x-03
2.95g-03
2.83r-04
2.98--03
PLATE
19
4.51E-03
6.91e-06
4.73E-03
2. 2.58E-03
2. 2.71E-04
2. 40E-03
4.76--
7.01x=00
4.81x-03
8.85-00
2.77k-04
3. 3.50uu03
3.46R-04
5.23v-08
5.17P-03
3.31R-03
1.14k-05
2.39k-04
3.38k-04
5.071=08
5.31x-03
3.30k-03
1.15-005
2.40u-04
BEAM
19
3.57E-04
1.92E-U8
5.20E-03
3.299-03
1.18E-05
2. 2.282-04
1.176:05
2.01E.04
Table 10: Ablation study of number of segments and whether to add PE or not.
DATASET
Naa
PE
GF4 4
GF. 4
MC 4
ASPECT RATIO 4
RMSE-1
RMSE-ALA
16
3.19E-03
5.35e-02
3.34x-03
4.70x-02
CYLINDER
3.09E-03
3.86E-02
36
3.00
3.80=-02
X
4.81E-03
9.338-06
5.018.03
2.836-03
2.77p-04
3.88e-03
4.24v-03
6.72k-06
5.048-03
2.81s-03
2.84x-04
2.72F-03
PLATE
19
5.10x-03
6.51u-06
4.73u-03
2.58a-03
2.71x-04
2.40s-03
5.13E-03
6.78E-06
1.748-03
2.64E-03
2.68E-01
2.91E-03
3.75x=04
5 888908
5.31u-03
3.30s-03
1.15x-05
2.40z-01
3.51E-01
3.338-08
5.18E-03
3.315-03
1.175-05
2.36E-01
BEAM
19
3.22E-04
8.866-08
5.31E-03
3.08E-03
1.172-05
2.01E-04
3.19E-01
4. 1.81p-08
5.276-03
3.182-03
1.15E-05
2.218-01
1.0
RMSE Hausdorff
Chamfer Aspect Ratio
Silhouette
Normalized Metric Value
0.8
0.6
0.4
10
20
30
40
50
Number of Segments
Figure 7: Dependence of various performance metrics the number of segments in M4GN under Deforming Beam dataset. The plot illustrates how the normalized values of several performance metrics vary with the number of segments. Each metric is represented by a distinct curve, demonstrating the relationship between segment number and overall performance. This figure evaluates the effect sogment number and guides the selection of the optimal number of segments for balanced performance across all metries.
30

---

Published in Transactions on Machine Learning Research (09/2023)
Hausdorff
RMSE
Hausdorff
1074
10
10"9
Gpenaer
(beg 10)
Greneer May
beterming Plae
Oayy
Defernsty Hate
Dettmningg (eg
Detheming Bram (Dog
Oatumann
Bea s)
Detominn (dep 10y
Aspect Datereing Bram
Dertemnnng Gigg kJ
(beg
Oetneer Flle
Cynnter 3ei
Getoming Hase
Gey 9)
Defoming
(dog 19)
Defomenn Beamn
Detoring Blam (Srg
Deforming Paate (ag
Deforming Hate
Detorming Beaan
Detomeinng (Sag Te)
Chamier
-100)
Chamier
Aspect Ratio
10-1
10*2 10
10
10-1
Detondier
(bng
Detonding (Seg Aiy
Outaminn Keep
Outembing
(Seg 18)
Detumning (drg
Deforming (Seg Ai
oetoming
flog Pl
Oelorinng Roam
(Se)
Detorming Paat (lng
Detormiio Phote (Seg
Oafortinng Saums (aay
Oetominn Raamn (Seg
Delorming Paae (bog
Detormbo Paat
Oeforning Beam (aey
Deforming Stamm (Per
Whth 2E
Without FE
Noth PC better than Withour Pt
a
bb)
Figure 8 Ablation study the effects of position encoding and segment overlap across datasets with varying seginent numbers. The figure presents the performance metrics for models both with and without the position encoder (a); and with and without considering segment overlap (b) across three distinct datasets, each characterized by a different number of segments. By comparing these conditions, the study highlights how the inclusion of position encoding and the handling of segment overlap inffuence overall performance, thereby informing the selection of optimal model configurations.
RMSE-all. Notably, M4GN's RMSE-all is 46% lower than EAGLE. These findings suggest that M4GN not only preserves prediction accuracy but also enhances mesh quality when generalizing to larger-scale data, significantly surpassing statc-of-the-art models both accuracy and mesh quality. This demonstrates M4GN's robust generalization ability, making highly suitable for complex, largo-scale dynamical systems. Figure is visualization of generalization results Weforninggeam((arree dataset for different models.
Table 11: Generalization performance of our method and five baseline models on the DeformingBeam (aaeeammmargeeeeee (large) dataset. M4GN demonstrates great accuracy and mesh quality when generalizing to an unseen dataset with denser mesh and more extensive long-range dynamic effects.
METROD
GF
GF, 4
MC
ASPECT ILATIO 4
RMSE-1
RMSEE-50
ALL
GCN
2.188-02
3.25p-05
1.218-01
1.69-001
2.576-04
1.95R-03
1.11F-02
g- J-U-NET
1.94u-02
2.80x-05
4.56x-02
7.01x-02
1.60s-04
1.87x-03
1.0
MGN
2.32b-02
1.43a-05
2.00r-02
2.37E-02
1.3/1-01
1.43r-03
6.426-03
BSMS
1.72E-02
3.34E-05
1.35e-01
1.17s-01
4.47E-04
3.192-03
1.03E-02
EAGLE
1.696-02
2.208-05
1.988.02
5.158-02
6.426-05
1.45R-03
8.37F-03
M4GN
7.96o-03
5.35e-06
1.08e-02
2.246-02
5.47e-05
9.20e-04
4.58e-03
E.2 Effect of Mesh Segment Count on Generalization
Generalization with Varying Segment Counts During Testing Across three datasets, we perform generalization studies where the model is tested using varying nunber of segments. The results in Figure I0 illustrate the generalization performance. Pink columns are the references for regular testing and the others are generalization to different number of segments from training. Overall, the M4GN model can generalize very well to different number of segments during testing.
Impact of Segment Count During Training and Testing Equipped with message passing and trans- former mechanisms, M4GN can handle an arbitrary number of segments. Figure [T shows the generalization performance of our M4GN model to larger domain as heatmaps, where models trained with a specific number of segment under BeformingBeam dataset tested with varying number of segments under deformingBeam
31

---

Published in Transactions on Machine Learning Research (09/2025)
D DUUN
BSMS
High
EAGLE
Ours
Low Error
t=
t=
t= 200
t=
Figure 9: Generalization results for different models under (abbrmmnngBaa(llrggg))) dataset.
Ie-3
Rollout RMSE-all CylinerFion
Je-2
Rallout RMSE
Cylinder
(a)
36
64
100
36
64
100
Num Mesh Segments (Test)
Num Mesh Segments (Test)
1e-4
1e-3
Rollout AMS5-1 Detomingfatt
RolloutRMSE- DefominngPaat
33
51
73
73
19
Num Mesh Segments (Test)
Num Mesh Segments (Test)
Num Mesh Segments (Tesi)
boloout RMSE-1 DeformingBeom BiaminngBamm
1e-5
Pollout RMSE all
Delormin mgBedm
1e-4
Continuity Error beformigBcomm
1e-2
(c)
2.5
0.0
0.0
30 Num Mesh Segments (Test)
73
199
51
73
33
51
Num Mesh Segments (Test)
Num Mesh Segments (Test)
Figure 10: Generalization performance of our method under varying segment counts during testing over three datasets. (a) CylinderF low: effect of number of segments for test set on different metrics, where model is trained under 36 segments (colored in pink); (b) DeformingPlate: effect of number of segments for test set on different metrics, where model trained under 19 segments (colored in pink); (c) DeformingBeam: effect of number of segments for test set on different metrics, where model is trained under 19 segments (colored in pink). This figure illustrates that M4GN model, despite being trained with fixed number of mesh segments, maintains strong accuracy and mesh quality when tested with varying numbers of mesh segments.
32

---

Published in Transactions on Machine Learning Research (09/2025)
Rollout RMSE-all
Continuity Error
DeformingBeam(Large)
DeformingBeam(LLage))
Num Mesh Segments (Train)
high
Num Mesh Segments (Train)
high
9
(100))
19
19pm
33
33pm
51g91
51251
low
low
9
33
51
9
19
33
51mm
Num Mesh Segments (Generalization)
Num Mesh Segments (Generalization)
Figure 11: Generalization performance of our method on larger domains under different number of mesh segmentation during training and testing. The subscript of cach mesh segment indicating the average number of nodes per segment. M4GN demonstrates robustness and adaptability in handling larger domains with varying mesh segments, making it well-suited for real-world applications involving large and complex mesh structures.
Table 12: Comprehensive evaluation of our method alongside MGN, BSMS, and EAGLE under three datasets. M4GN consistently delivers stable, competitive efficiency while maintaining high accuracy and mesh quality.
TRAIN TIVE
TRAIN MEMORY [MB]
TEST TIMR PER STEP [Ms)] J
TEST
TRAIN TIME
DATASET
MODEL
RMSE-ALL
PER STEP [MS]] 4
MEMORY [MB]
TOTAL [a]
MGN
4.81x-02
66.7
698.5
20.2
67.2
37.1
CYLINDRR
BSMS
1.37E-01
54.7
430.3
23.8
57.9
30.4
EAGLE
3.83E-002
69.5
618.7
28.8
280.8
38.6
M4GN
3.80x-02
56.2
366.6
20.0
65.0
31.2
MGN
1.47F-02
9.25e-03
131.9
6021.5
36.2
445.5
73.3
BSMS
1.18--02
1.83x-02
83.9
9100.1
37.7
77.9
46.6
PLATE
EAGLE
3.87e-03
5.562-03
81.2
1090.8
32.4
362.7
45.1
M4GN
2.65e-03
4.828.03
76.5
648.1
29.3
103.3
42.5
MGN
4.72E-04
1. 1.69--02
79.1
1074.4
28.6
83.8
22.0
BSMS
4.98s-04
3.25x-02
61.8
213.7
30.7
35.6
17.2
BEAM
EAGLE
4.22s-01
5.98g-03
53.5
410.3
26.0
153.5
14.9
MAGN
1.87E-01
5.26E-03
33.4
234.5
21.2
47.1
14.8
(large). We observe that better results are seen when the number of nodes per segment during training is less than or equal that in the generalizing domain, when the number of segments is greater. Overall, demonstrate M4GN's robustness and adaptability in generalizing to larger domains with varying mesh segments, making it highly suitable for real-world applications involving large and diverse mesh graphs
The per-step timing of our model against ground-trute trrth simulators across datasets. Since Cylinder- Flow and DeformingPlate (tcr). The time of our model tours is computed by adding the time used for segmentation and inference single NVIDIA Tesla P100 GPU.
Table 13:
datasets from MGN paper, adopt their reported values for simulator timing
DATASET
SOLVER
tor MS/STEP faura MS MS/STEP
SPEEDUP
CYLINDEFFLOW
COMSOL
40.2
DEPORMINGPLATE
COMSOL
2893
97.4
DEPORMINGBEAM
OPENFOAM
3261
24.6
132.6
33

---

Published in Transactions on Machine Learning Research (09/2025)
F Computational Efficiency Analysis
F.1 Performance Comparison
Table 12 lists the training time, test time, and memory usage for four models MGN, BSMS-GNN, EAGLE, and M4GN across three dalasets. The RMSE-all also listed as a performance reference. Our M4GN model has comparable or better efficiency compared with other models. Notably, the M4GN model has the best efficiency with RMSE-all compared to other basclines. We also compare the per-step timing of our model against ground-truth simulators across dalasets in Table 13 Since CylinderFlow and DelormingPlate are datasets from the MGN paper, adopt their reported values for simulator timing (ler). The time of our model tours is computed by adding the time used for segmentation and inference on single NVIDIA Tesla P100 GPU.
F.2 Complexity Analysis
M4GN is composed of four key components: an Sosrddrr-Proees--eeoooo (EPD) network operating mesh graphs, modal decomposition, hybrid mesh segmentation, and a mesh segment. transformer. For the learnable part of the model, the computational complexity mainly depends on the EPD and mesh segment transformer components. The complexity of the EPD is: O(LiVV|e + L1 L2]E)d?, where L1 is the mumber of message passing layers, d is the feature dimension, [V] is the number of mesh nodes, and [ε] is the number mesh odges. The complexity of the mesh segment transformer is O K2d + L2Kd)), where L2 is the number of multi-head atlention layers, K is the number of segments, and d is the feature dimension. The overall time complexity is OLL + L1 Eld LgK?d L2Kd²).
Modal decomposition and mesh segmentation are performed only once at the initial time step. For modal decomposition, with sparse finite element matrices, the selup steps basis construction, matrix assembly, and application of boundary conditions- each require O([V)) time. The dominant cost is extracting the first m eigenmodes via Lanczos/ AAnoodii solver; because each Krylov iteration involves one sparse matrix vector product, the eigen-solve scales as (mmx|>) with 10-100 iterations per converged mode and m the number of modes requested. Hence, for fixed number of modes, the overall algorithm is linear in mesh size. Our hybrid segmentation approach consists of graph-based method for initial mesh segmentation (METIS) and a superpixel- based method guided by features for refinement (SLIC). In the case of Lagrangian systems where segmentation varies with time, only the refinement part is needed since the initialization segmentation is only based on connectivity and is invariant to feature and coordinate variations. SLIC is based on a local search in k-means clustering, resulting in a time complexity of O(V))).
G Qualitative Results
Figure
13
and
15 illustrate selected rollout results for all three datasets under different models.
34

---

Published in Transactions on Machine Learning Research (09/2025)
MGN
High Emor
Low Emor
Our
1:50
t= 150
200
1= 250
1= 300
Figure 12: Additional simulation results for different models under DeformingPlate dataset.
6SMS
High
EAGLE
Low Enor
GT
250
Figure 13: Additional simulation results for different models under DeformingPlate dataset.
35

---

Published in Transactions on Machine Learning Research (09/2025)
GCN
G-UNet
MGN
High Error
BSMS
EAGLE
Low Error
M4GN (ours)
GT
t=
t= 150
t= 250
t= 400
Figure 14: Additional simulation results for different models under Deforming Beamn dalaset
GCN
High Error
G-UNet
MGN
BSMS
EAGLE
Low Error
Ours
t 50
t0
t= 400
t= 600
Figure 15: Additional sinulation results for different models under CylinderFlow dataset.
36


Reviews:
[{"review_id": "GMDPn8BVq2", "reviewer": "Reviewer_ufzj", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "## Strengths:\n- Comprehensive ablation studies of all involved components\n- Clear writing overall; all notations are well-defined without excessive technical jargon, making all parts easy to understand\n- Solid improvements to existing methodology that can be easily migrated and deployed in future studies or real applications\n\n## Weaknesses:\n- Several elements of the paper suggest the authors prefer \"fancy storytelling\" over honest and clear description of different components. This is evident in both text and figures:\n- Text-wise: The Meso scale is essentially a made-up concept. The authors present it as part of the training pipeline when in reality, it is a pre-processing step. (I recognize their design and ablation study provides better pre-processing, but misrepresenting it as part of forward/training is problematic). This contributes to the convoluted logical flow in Section 3.3.\n- Figure-wise: The figures use vivid colors and elements and are well-drawn but some lack clarity. For example, Figure 1, the main schematic plot for their method, has no caption at all. This figure also lacks any legend for micro/meso/macro scales, suggesting the multi-scale storytelling may have been retrofitted. Figures 2(a) and (c) are visually pleasing but significantly harder to interpret for baseline comparison. Basic bar/line plots with error bars would be more effective.\n- (Minor) Some settings such as default values for overlap layers are not specified.", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "# Updates after revision\nAuthor adopted most of my suggestions. I am recommending acceptance now.\n\n# Old Overall rating: **Major revision**\n\n## Overall comments: \nThis paper combines MP-GNN and GraphTransformer for multi-scale information exchange in physics simulation on meshes. The methodology presents a solid improvement compared to EAGLE[1], specifically by: 1) incorporating a microscale level MP-GNN and 2) implementing a better mesh segmentation design. The experimental results are comprehensive, but the writing somewhat exaggerates the narrative in a \"fancy\" way that hinders clarity. While I recognize the method's technical contributions and improvements, I recommend a **major revision** focusing on writing clarity and reducing unnecessary embellishment of the \"fancy\" story-telling before publication.\n\nDetailed comments are provided in later sections.\n\n[1] EAGLE: Large-Scale Learning of Turbulent Fluid Dynamics with Mesh Transformers. https://arxiv.org/abs/2302.10803", "claims_and_evidence_yn": "Yes", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "## Requested Changes:\n\nThe following changes should be **incorporated into the new manuscript for the benefit of readers:**\n\n**Very important**:\n\n- Clearly identify improved mesh segmentation as a key contribution and relocate the entire Section 3.3 to stand as a separate pre-processing section prior to model description. This will properly frame it as part of pre-processing rather than the forward training pipeline, improving logical flow.\n\n- Remove the \"meso-scale\" terminology from the paper's narrative. Geometric segmentation is not a standard interpretation for meso-scale effects in physics and appears to be used primarily as a buzzword.\n\n- Restructure the current Section 3.3's introduction to provide an immediate high-level overview of your segmentation method before diving into details. Currently, readers must reach Section 3.3.3 to understand your hybrid approach involves: 1) METIS as initial hot start, and 2) K-Means clustering using features that include modal decomposition. Introducing this framework earlier would significantly reduce confusion.\n\n- Move the ablation study on segmentation types to the main results section, as this represents one of your primary contributions.\n\n**Added results or technical details**:\n\n- Address the time complexity of your hybrid segmentation approach for Lagrangian systems where segmentation may vary with time (changing world configuration). Since segmentation must be performed during inference, time complexity report is essential.\n\n- Strengthen your results section with 1-2 additional demonstrations: either showcase scenarios where other methods (like EAGLE[1]) catastrophically fail (similar to the approach in your referenced BSMS-GNN[2] paper), or present a zero-shot demonstration for a scaled-up configuration not seen during training to highlight the GNN family's generalization capabilities.\n\n- Consistently specify default values for all meaningful settings discussed in ablation studies (e.g., overlap layers). Remove unused notations (e.g., policy π which appears once but is never used again). Review the entire paper for similar instances of unnecessary or incomplete information.\n\n[1] EAGLE: Large-Scale Learning of Turbulent Fluid Dynamics with Mesh Transformers. https://arxiv.org/abs/2302.10803\n\n[2] Efficient Learning of Mesh-Based Physical Simulation with Bi-Stride Multi-Scale Graph Neural Network; https://proceedings.mlr.press/v202/cao23a/cao23a.pdf", "broader_impact_concerns": "NA", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "zYWV0Bj8Te", "reviewer": "Reviewer_odhF", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "### Strengths\n- The paper is easy to follow and clearly divided.\n- The figures are high-quality and easy to understand, which helped during reading.\n- The overall method and its components are well-motivated.\n- Code and data will be released, and many details are provided, especially in the appendix.\n- Various ablation studies and experiments to analyze the impact of different hyperparameters.\n- The method seems to beat current baselines, either or both in terms of accuracy and computational efficiency, on the chosen datasets.\n- The choice of the baselines seems adequate.\n\n### Weaknesses\n- Very efficient methods exist for mesh-based simulations. One of your key claims is to provide an alternative to expensive simulators. Actual figures and comparisons with the ground-truth simulators used for each dataset would strengthen this argument, which looks neglected in the rest of the paper.\n- The main text lacks some details that require going through the appendix for proper understanding, and even often explicitly suggests going into the appendix.\n\t- The datasets description is very short and not motivated in the main text, even in the results discussion.\n\t- For mesh-quality metrics, you motivate them but only list them. Could you maybe add a simple sentence that highlights what kind of cases it covers or a geometric intuition behind them? \n\t- Predicted quantities for each dataset. Also, what exactly does the model require as input (all physical quantities for all three stages) for each dataset?\n- More importantly with respect to the mesh quality metrics, you incorrectly state \"mesh quality is less critical\" as the mesh remains constant. Mesh quality is extremely important. In your case, I guess you assume you have access to some given mesh over which you have no control, as it's external to your method, so you assume it's good, and either do not need to assess it here if it's fixed, because your method does not make it vary, or you need to because your method modifies it in Lagrangian systems. This is very different, and must be made clear in the text.\n- Some results across radar plots and tables are inconsistent. Although the radar plots are useful to highlight how M4GN's high performance is more versatile across these 3 datasets than the baselines, a few checks lead to inconsistencies between these figures and reported values in Table 7 of the appendix, except if you used a different method to compute these numbers, which I doubt considering some values do match. For example, training speed for MGN should respectively be 0.82 and 0.58 in CylinderFlow and DeformingPlate, and training memory efficiency should respectively be 0.52 and 0.11. Instead, they are all set to 0.2. On CylinderFlow, this strongly undermines how close MGN actually is to your method. Just another example issue is EAGLE's testing memory efficiency, which \"declines dramatically\" (Section 4.2.2) should be 0.28 and not 0.2 in the radar plot. It seems the common issue is many values set to 0.2?\n- MGN reports generalization capabilities from a training mesh of 2k nodes to a test mesh of 20k nodes (Figure 4b on Page 6). First, could you run your method in such conditions? Otherwise, do you think it *could* perform as well in such conditions? In your larger version of DeformingBeam, MGN managed to scale-up quite well, especially in terms of mesh continuity. This also questions the actual contribution of the DeformingBeam dataset, if much larger datasets are available. \n- Your method includes a certain number of hyperparameters to tune, such as the number of segments. You provide a concrete strategy, which is appreciated, but it requires training some models on 10% of the data. On CylinderFlow, do you include this in your total training time? Otherwise, this process which seems needed for any new dataset adds $n \\times \\frac{T}{10}$ where $n$ is the number of $K$ values tested, and $T$ the total training time. For CylinderFlow, this adds a 15h overhead to training time if not parallelized. This is a minor concern but I think there should be more discussion, especially in the limitations, with respect to the complexity of using your method, compared to e.g. MGN. Also, do the time and memory performance include the overhead of the segmentation (structural mode computation + SLIC/METIS)? This overhead might be a bit confusing because it requires comparing both total time (which includes it) and separately mentioning that per-step performance excludes it.\n- Compared to the text dedicated to explaining the method, the experimental part is weaker.\n\t- With respect to the number of datasets, why have you chosen these three and not included others, such as the different flag datasets in MGN? These datasets exhibit quite different mechanics and interaction with static world objects. Does your method also outperform the baselines on these datasets? \n\t- In section 4.2.3, you state that your method generalizes the best to scaled-up datasets. This is misleading; your method does indeed stay the best in terms of accuracy on the scaled-up version, but MGN better preserved its initial mesh quality (which is not much higher), which means MGN is more invariant. This questions the robustness to larger-scale datasets, which is suggested as a key point of your method. \n- The conclusion is also a bit weak and short and would be strengthened by more discussion, other words than \"significant\" and more proper discussion about the practical usage of your method. But the part that is more neglected to me is limitations:\n\t- The datasets might look carefully selected to only highlight cases where your method applies, without any mention of the limits if this is the case. You mention the possibility of overlapping meshes and physical consistency at segmentation interfaces. Did you observe this in any datasets? When could this happen and what kind of behavior can one expect versus over methods? The invariance of mesh quality (and MSE) with respect to the size of the dataset for generalization does not seem as good as you claim it is. \n\t- Even though you provide principled ways to select the hyperparameters, the method looks much harder to both implement and use, than e.g. MGN. \n\t- Compared to MGN, if I'm not wrong, your method also requires more input variables and physical information?\n\t- Would the static segmentation method suffice for different physical cases? \n\t- In terms of scaling (such as for Section 4.2.3), can we expect larger $K$ values for very large systems? The $O(K^2)$ complexity will as some point limit the enhancements over purely micro-level-stage level methods such as MGN, especially in terms of performance.\t\n\t- One of your three key contributions include a dataset, but it is barely described and discussed in the main text, and not even mentioned in the conclusion.\n\n### Questions\n- I am less familiar with mesh simulations and mesh-quality metrics. Are the latter computed at every time step then averaged over time? Only at the end of the rollout?\n- It is unclear how you operate for Lagrangian meshes to update the mesh once $\\dot{x}_{t+1}$ is predicted. Do you simply use Euler integration? \n- Compared to MGN, which is essentially a \"sub-part\" of your method, how do you achieve such greater memory efficiency? Is it because your additional components allow to reduce the complexity of the micro-scale module?\n- Do you pre-cache the segmentation for each simulation of your training set? Do you re-run this part at every training step?\n- I am not very familiar with these methods, such as EAGLE, which seemed like a strong contestant. Do you think the accuracy and performance of your method compensate for its added complexity? In terms of ease of implementation and use, how do your method and the baselines compare? \n- In Equation 10, I do not think defining a $Cut$ operator helps describing the quantity $A_{ij}^K$. I am unsure I properly understood your definitions. You state that the sub-graphs are disjoint. My understanding is that for each pair of segments and for each pair of connected nodes between them, only one of the two nodes is owned by both segments? Otherwise, the size of the intersection of node sets is not equal to $\\sum\\_{m \\in \\mathcal{V}\\_{S\\_i}} \\sum\\_{n \\in \\mathcal{V}\\_{S\\_j}} A\\_{mn}$. How exactly do you define the links between disjoint graph partitions/segments?\n\n### Typos & misc.\nThe following are just some minor notes and typos I noted during my readings.\n- In section 2.1, you cite Ummenhofer et al. (2019) (i.e., continuous convolutions) as convolutional networks that cannot operate on irregular geometries, but this work precisely introduces convolutions that can be applied on point clouds. Convolutions are anyway a sub-case of graphs. CNNs with positional encoding or continuous convolutions could run on irregular meshes. I think you can simply refer to MGN which shows, among other works, that even graphs (without mesh positional encoding) perform very poorly on meshes. At least remove or replace this incorrect sentence and citation.\n- Table 7 does not report the number of parameters, which would be very interesting to report, even in the main text. \n- In the whole paper, you mostly use \"dynamic\" instead of \"dynamical\" to refer to the simulated systems. Although it is the correct term for some parts (e.g., dynamic quantities), I think \"dynamical\" is more appropriate, especially when referring to dynamical systems. This notably includes the title, several occurrences in the abstract, and others in the main text.\n- In section 3.2, right below Eq. (1), you forgot to put $\\in \\mathcal{V}$ for ${\\bf x}_{i,t}$.  \n- In the \"Structural Modal Analysis\" paragraph of section 3.3.2, after the citations of Fu & He and Wilson, an \"is\" is missing after \"which\", and on the line below, \"it is typical to select\" and not \"select***s***\".\n- On page 6, in the \"Detailed Methodology\" paragraph, on the last line, \"this information\" instead of \"these\".\n- At the very end of section 3.4.1: \"Table 5 presents ablation studies show how [...]\". \"which\" or \"that\" is missing.\n- In section 3.4.3: penultimate line of page 7, \"an MLP\" (instead of \"a\") and the same for \"an $L_2$ loss\".\n- Section 4.1, \"Datasets\" paragraph. \"We create ***the*** DeformingBeam ...\".\n- Still Section 4.1, \"Metrics\" paragraph, last sentence: \"Detail***ed***\" instead of \"Details\".\n- Caption of Figure 4 (a): \"different models\" and not \"difference models\".\n- Appendix A.2 DeformingBeam: which ***is*** a toolbox.\n- Appendix C.4: \"To visualize the how predict mesh properties in each segment various through time for different method\"; I guess you meant \"To visualize how predicted mesh properties in each segment vary through time for the different methods\".\n- Later in that same paragraph in appendix C.4: \"our methods is able\" $\\to$ \"our method is able\".\n- Next sentence: \"in case with in inherent\" $\\to$ \"in the case of inherent\".\n- Section D.2 of appendix, first sentence. \"As shown in Table 3, ***the*** mesh segment***ation*** method ...\".\n- Second line of D.3: \"small and large number***s***\" (missing s at \"number\").\n- Very end of page 26: \"effect ... on various metrics\" and not \"to\".\n- Title of appendix section F.2: Complexity instead of Compelxity.", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "No", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "The authors propose a novel method for mesh-based simulation that includes a micro-level part, akin to popular encode-process-decode GNN-based methods. A macro-level stage helps the model simulate long-range interactions by processing features aggregated from sub-graphs which are defined based on meso-level information, such as modal decomposition and material properties. The results from these stages are combined to produce the estimate of physical quantities at the next time step, thus proposing an autoregressive emulator for mesh-based representations. The key claim is the method outperforms current data-driven baselines, whose goal is to address the slowness of traditional methods, while staying competitive in terms of computational efficiency. They also provide a new dataset which includes both a normal version and a scaled-up one to demonstrate generalization of mesh-based emulators.", "claims_and_evidence_yn": "No", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "I think the method will definitely be interesting to related audience. Beside answering the questions above (some of them mainly for curiosity and better understanding), I think that several changes are required, and others would strengthen the paper. \n\nTherefore, I suggest accepting with modifications.\n\n**Changes essential for acceptance:** \n- Address the typos and miscellaneous stuff listed above.\n- Depending on your answer to the questions about Equation 10, please clarify that part.\n- Fix Figure 4 and inconsistencies with Table 7. Please adapt your discussion and wording depending on the adapted figure.\n- Clarify and reword metrics discussion, especially with respect to Eulerian systems and the importance of mesh quality metrics for these systems versus Lagrangian systems. It must be clear that *assessing* it might be less critical (and not the quality itself) as you assume you have some initial given mesh. Less importantly, could you slightly elaborate on the overall importance of mesh-quality metrics and how they are computed to be reported?\n- Clarify and reword section 4.2.3 with better interpretation of the robustness of your method to scaling up. If your method is not capable of scaling up as well as MGN (2k to 20k nodes), then you *need* to reword claims about robustness to scaling up and generalization, or even completely remove that claim. That claim needs to be backed up by strong evaluation and empirical results.\n- Improve your discussion of the limitation, if possible address (some of) the points I raised in the weaknesses, or answer them here if you think I missed or incorrectly understood something.\n- Provide more details and better motivation for the choice of your datasets as an experimental setup. Do these datasets cover most practical uses? What is varying over the different simulations of your sets? What are the sizes of the different splits? What kind of physical information is required and provided to the model? What are the predicted metrics? This should all be in the main text, in a concise manner.\n\n**Changes That Would Strengthen the Work (Recommended but not Essential for Acceptance):**\n- Run your method on some of the other publicly available datasets, such as those proposed by MGN (e.g., Flags). I understand you provided many ablation and additional studies for the three datasets and this requires work. Snapshots and a metric table would already strongly help, even in the appendix.\n- Even in the appendix only, please provide more information and comparisons with the simulators used for the datasets and the advantages of ML-based methods. Are GPU-accelerated simulators much slower?\n- Please try to provide some videos as part of your supplementary material. Considering you do not aim for fixed-point PDE resolution, videos would very well highlight the difference with other methods over time and could strengthen your points.\n- Could you add the missing ground truth in Figure 15? Even if one of the methods reaches low error, it is always better to visualize what it actually should be. Maybe even Figure 3 (b & c) would benefit from it, although I think it is less necessary considering the low error makes me guess it's very close to GT?", "broader_impact_concerns": "N/A", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "gHrIAW4h0R", "reviewer": "Reviewer_wSzx", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "I’ll first summarize the strengths and weaknesses before detailing their motivations:\n1) **Strength**: The authors propose a quite promising idea: _\"smart clustering can have an impact on accuracy of hierarchical model in physics_\". This is sound and deserves attention from the community. **Weakness:** However, a substantial portion of the paper introduces a \"new\" model emphasizing long-range interactions—an area already explored in prior work. The proposed model is extremely similar to Eagle.\n2) **Strength**: The paper presents several evaluations across tasks, using diverse metrics, including mesh accuracy. **Weakness**: Yet, crucial datasets are missing, and some conclusions drawn from the figures appear questionnable, if not erroneous.\n3) **Strength:** the appendix explores the proposed segmentation technique in depth, with several ablations and experiments. **Weakness:** However, the results are poorly analyzed. Readers must compute statistics themselves to assess the impact. These suggest that, on average, the paper's contributions have limited to no effect on performance.\n\n### 1. Limited / no novelty in model\n\nI tried to compile an exhaustive list of differences between M4GN and Eagle (based on Eagle's official implementation on Github):\n\n- **Encoder**: M4GN increases GNN layers from 4 to 7,\n- **Segmentation**: core contribution of M4GN -- augments spatial clustering with mesh geometry and material features,\n- **Pooling (\"Meso\")** : M4GN replaces per-segment RNN with average pooling,\n- **Mesh Transformer**: increases attention heads from 4 to 8, adds positional embeddings (PE),\n- **Decoder**: removes the last GNN layer used in Eagle.\n\nI am uncomfortable with the ambiguity surrounding the comparison to Eagle, given their similarity. The authors repeatedly claim M4GN's superiority stems from its handling of long-range interactions—but Eagle does this too. The paper introduces architectural changes in the main text, but ablations (relegated to the appendix) reveal that positional embeddings and segment overlap offer limited benefit, or are even detrimental on the `Deforming *` datasets.\n\nGiven the space dedicated to describing the model (at the expense of results on segmentation algorithm), it may appear—surely unintentionally—that the authors are claiming credit for earlier work on long-range interactions in physics. This could be resolved with a careful rewrite of the main paper.\n### 2. Issue with evaluation\nTwo critical tasks are missing:\n1. Not only M4GN shares similar architecture as Eagle, but the authors also tackled similar problems (mesh-based physics simulation) and similar paradigm (transformer-based hierarchical model for long-range interaction). A comparison on the `Eagle` dataset seems mandatory.\n2. I would also appreciate evaluation on `FlagDynamic`/`SphereDynamic` from MeshGraphNet paper, which follows a different dynamics. This would strengthen the generalizability of the contribution.\n\nI noticed disturbing choices and claims concerning the results and tasks discussed in the main paper:\n- M4GN **only simulates the velocity field on CylinderFlow**, omitting pressure. This makes the task physically unsolvable. Pressure field is mandatory to solve Navier-Stokes equations. The fact that models still succeed in solving the task shows that they can overfit to regularities in CylinderFlow, which highlights the limitations of this dataset (and motivates for more complex one), and also question the capacity of M4GN to actually solve Navier-Stokes simulations. Note that pressure is simulated in previous work (Eagle and MeshGraphNet).\n- MeshGraphNet and Eagle are compared on CylinderFlow in the Eagle paper, and shows contradictory conclusions concerning performances and efficiency. This is not discussed here.\n- Given offline segmentation and similar architecture, it’s unclear how M4GN outperforms Eagle in efficiency.\n- In Figure 4c, all models degrade similarly (Norm. RMSE increases 10x). The only difference is the lower in-domain error for M4GN, yet the paper claims it generalizes better. \n- When evaluating on solid dataset, M4GN is implicitly informed of the material properties through clustering, while the other baselines are not, which makes the comparison unfair. \n- To disentangle the impact of clustering algorithm vs. model changes, it would have been interesting to use the introduced segments into the hierarchical baseline to see how they would also benefit from it. It would also make the claim stronger, showing that better clustering improves performances on different models.\n### 3. Segmentation algorithm seems ineffective\nThe term \"_physics informed_\" used throughout the paper might be bit misleading. The term is typically used in the context of PINNs, involving explicit use of the PDE. Here, it only applies to the segmentation algorithm, and only for solids (via material properties). For fluid, clustering is still purely geometric.\n\nThe proposed clustering algorithm involves initial graph partitioning and refinement via modal decomposition. The method outperforms simpler method based on local proximity in term of mesh quality, but here, mesh quality is directly used as an optimization target, making this unsurprising. Moreover, the metrics used are from computer graphics and their relevance to physics simulation is unclear.\n\nMoreover, the modal decomposition appears detrimental in average. Frame Table 2, I  found that mode decomposition features degrades performances by 7% with `SLIC-MD` and 1,7% with `SLIC-MDOD-L`. The best performing segmentation method is `SLIC-MDOD-E`, which increases performances by 16%, but gives more importance to the *distance to boundary* features (thanks to the exponential). This raises doubts about the actual utility of the modal feature.\n\nGiven the task-dependent and variable results, along with limited analysis, it's difficult to draw clear scientific conclusions about the clustering algorithm’s effectiveness.", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "No", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "The paper addresses physics simulation on irregular meshes for both fluid and solid dynamics. It claims the following contributions:\n- A novel hierarchical framework,\n- Superior mesh quality and high prediction error,\n- A new dataset modeling the deformation of a beam under a constraint.\n\nThe authors also announced public code and dataset release, which is appreciated. They conduct extensive evaluations of various baselines and ablations on three datasets.", "claims_and_evidence_yn": "No", "claims_explanation": "", "audience_yn": "Yes", "audience_explanation": "", "requested_changes": "**Related works**\n- The claim \"MeshGraphNet being a pioneering work\" is factually incorrect. Prior work includes Li et al. (_Learning Particle Dynamics for Manipulating Rigid Bodies, Deformable Objects, and Fluids_) and Chang et al. (_A Compositional Object-Based Approach to Learning Physical Dynamics_), to name a few.\n- Related work on physics dataset is in the appendix. It should be moved to the main paper to better motivate the need for another task, and `Eagle` & `MeshGraphNet` datasets should be added to Table 2. \n\n**Methodology**\n- I strongly encourage the authors to restructure the methodology to highlight the actual contribution: the segmentation algorithm. One option: synthesize the model description (by deriving it from Eagle), explaining the difference and sharing summarized_analysis of the impact of these changes (while keeping the in-depth analysis in the appendix). This should free space in the main paper allowing to move experiments on segmentation algorithm from the appendix to the main paper, while summarizing the findings.\n- Section 3.3.2 is underused, and should be better integrated.\n- Section 3.1 incorrectly states that Eulerian systems use fixed meshes. They can use dynamic meshes; the key distinction is field-based vs. particle-based modeling.\n- Section 3.2 says \"Encoder-Process-Decoder\" is used, but there appears to be no decoder at the micro level.\n\n**Results and discussion**\n- I would like to highly recommend to tone down the language and the hyperbolas in this section. A scientific paper should not estimate its own impact: \"Outstanding performances\", \"remarkable reduction\", \"such exceptional performance\", \"excellent mesh quality\", \"excels in memory efficiency\", \"remarkable performances\", etc...\n- Revisit claims and results as flagged above.\n- Clarify how mesh quality metrics relate to physics simulation outcomes.\n\n**Appendix**\n- Provide analysis on the actual impact of mode decomposition features in SLIC. Table 2 would benefit from evaluation without mode decomposition features as well (`SLIC-OD` (Linear, Log and Exp)).\n- Labels are missing in Tables 4 and 5.\n- Specify which variant of M4GN is used (e.g., overlap, PE, which SLIC) in each table.\n- Table 9 uses normalized scales (0–1) that obscure real variation, this should be reconsidered.", "broader_impact_concerns": "Ultimately, papers should be judged on the knowledge they contribute. In this regard:\n- The paper suffers from: missing key datasets (`FlagDynamics` and `Eagle`), infeasible tasks (`CylinderFlow` without pressure), high variability of the conclusions depending on the task and hyper-parameters, and limited impact on average. This makes unclear how the proposed contribution could benefit future research on the subject.\n- The impact of the clustering method itself is difficult to assess. The algorithm is only weakly connected to physics (on solid case, with material property), and ablations indicate that the main impactful change is the use of _distance to boundary_ . Several elements (Modal decomposition, Positional embedding and segment overlap) seems to be negative results (which is ok) but are not stated as being negative in the paper.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}]

Author rebuttal:

Decision: Accept (poster)