Learning Mesh-Based Simulation with Graph Networks

Tobias PfaffMeire FortunatoAlvaro Sanchez-GonzalezPeter W. Battaglia

article2020ICLR1,417 citationsOutstanding Paper Award

Introduces MeshGraphNets, a graph neural network framework that predicts complex physical dynamics on adaptive meshes across aerodynamics, structural mechanics, and cloth while running up to two orders of magnitude faster than traditional numerical solvers.

Listen

High-fidelity scientific and engineering simulations are essential for modeling physical systems such as aerodynamics, structural mechanics, and materials. Traditional mesh-based numerical solvers solve underlying partial differential equations accurately, but they require enormous computational power, extensive runtime, and manual per-system tuning. In contrast, existing machine learning approaches primarily rely on regular grids or particle-based representations, struggling to accommodate irregular geometries, multiscale details, or resolution-adaptive meshes.

The article demonstrates MESHGRAPHNETS, a machine learning framework that learns forward mesh-based physical simulations directly from data using graph neural networks. It evaluates the model's accuracy, execution speed, and generalization capability across a broad range of physical domains, including fluid flow, deforming structures, and dynamic cloth.

The approach operates by translating simulation states into multigraphs using an Encode-Process-Decode architecture. Internal material mechanics and continuous fields are computed through message-passing over mesh edges, while external interactions like collisions and contact are captured via dynamic world-space proximity edges. To maintain efficiency, the model learns a sizing field to guide dynamic remeshing during inference, adding fine resolution only where needed without requiring external domain-specific solvers in the loop. The system was trained on next-step data using targeted training noise across several benchmark simulators, including SU2, COMSOL, and ArcSim.

The findings show that the model delivers significant speed and accuracy improvements over traditional methods and standard machine learning baselines. First, inference executes one to two orders of magnitude faster than conventional numerical solvers, showing GPU speedups between 11x and 290x and CPU speedups between 4x and 22x. Second, the model generates stable, high-fidelity rollouts over thousands of steps, maintaining stability across trajectories lasting up to 40,000 steps despite being trained only on one-step transitions. Third, it consistently outperforms grid-based convolutional networks (such as U-Nets) and standard graph convolutional networks, accurately capturing fine multiscale phenomena like airfoil wake turbulence that grid baselines miss. Finally, the framework demonstrates strong generalization, accurately predicting systems with untrained physical parameters, novel geometries, and domain sizes over an order of magnitude larger (scaling from 2,000 to 20,000 nodes) without retraining.

These results demonstrate that deep learning can bypass the severe computational bottlenecks of traditional partial differential equation solvers while preserving the flexibility of adaptive meshes. For engineering organizations, this speedup dramatically lowers computing costs, accelerates product design cycles, and enables real-time physical prediction. Furthermore, because the learned model is differentiable, it provides direct utility for downstream applications such as design optimization and control.

To build on this work, organizations should explore integrating learned mesh simulators into high-throughput design pipelines and prototype testing environments. Further technical development should focus on testing learned discretizations optimized directly for end-to-end simulation accuracy and integrating domain-specific physics constraints, such as energy conservation laws, into the training loss.

The primary limitations include accumulation of decoherence errors in chaotic systems like turbulent cloth dynamics over very long rollouts, as well as the need for representational datasets from high-fidelity solvers to train the models initially. Nonetheless, there is high confidence in the method's ability to provide fast, robust approximations for complex engineering and physical simulations.

Google engineering graph neural networks numerical integration methods mesh-based simulation graph networks adaptive mesh representations

arXiv: 2010.03409 google-deepmind/deepmind-research

Paper: Learning to Simulate Complex Physics with Graph Networks, Alvaro Sanchez-Gonzalez et al. (2020). This foundational work establishes Graph Network-based Simulators (GNS) for particle physics and rollout-noise training, which MeshGraphNets directly builds upon and adapts to mesh discretizations.
Paper: Interaction Networks for Learning about Objects, Relations and Physics, Peter W. Battaglia et al. (2016). It introduces interaction networks for learning physical dynamics over graph representations, establishing the core relational message-passing principles that underlie learned physical simulation.
Paper: Geometric Deep Learning: Going beyond Euclidean data, Michael M. Bronstein et al. (2016). This survey provides essential background on geometric deep learning, detailing how convolutional operations and message passing generalize to non-Euclidean domains like meshes and manifolds.
Paper: The Graph Neural Network Model, Franco Scarselli et al. (2009). It defines the foundational Graph Neural Network architecture and recursive state-updating mechanism on which modern graph-based physical surrogate models rely.
Paper: Semi-Supervised Classification with Graph Convolutional Networks, Thomas N. Kipf et al. (2017). This seminal work establishes the localized first-order spectral approximations for graph convolutional networks that form the operational backbone of message passing on spatial discretizations.
Paper: Mesh optimization, Hugues Hoppe et al. (1993). It introduces classical principles of surface mesh remeshing and topology optimization (edge collapses, splits, and swaps), providing the geometric basis for dynamic adaptive meshing.

Paper: Neural Operator: Learning Maps Between Function Spaces With Applications to PDEs, Nikola Kovachki et al. (2023). This work formalizes neural operators that learn resolution-invariant mappings between infinite-dimensional function spaces for PDEs, offering an operator-theoretic extension to learned mesh-based simulation.
Paper: E(n) Equivariant Graph Neural Networks, Victor Garcia Satorras et al. (2021). It extends graph neural physical modeling by introducing explicit E(n) rotational and translational equivariance to coordinate and feature updates across dynamical systems.
Paper: E(3)-equivariant graph neural networks for data-efficient and accurate interatomic potentials, Simon Batzner et al. (2021). It advances geometric graph networks for scientific modeling by incorporating full 3D equivariant tensor convolutions to predict interatomic physical forces with high data efficiency.
Paper: Scientific Machine Learning Through Physics–Informed Neural Networks: Where we are and What’s Next, Salvatore Cuomo et al. (2022). This comprehensive review examines physics-informed neural modeling paradigms alongside numerical PDE solvers, providing a broader comparative perspective for learned surrogate simulators.

Cover for Learning Mesh-Based Simulation with Graph Networks

Abstract

Mesh-based simulations are central to modeling complex physical systems in many disciplines across science and engineering. Mesh representations support powerful numerical integration methods and their resolution can be adapted to strike favorable trade-offs between accuracy and efficiency. However, high-dimensional scientific simulations are very expensive to run, and solvers and parameters must often be tuned individually to each system studied. Here we introduce MeshGraphNets, a framework for learning mesh-based simulations using graph neural networks. Our model can be trained to pass messages on a mesh graph and to adapt the mesh discretization during forward simulation. Our results show it can accurately predict the dynamics of a wide range of physical systems, including aerodynamics, structural mechanics, and cloth. The model's adaptivity supports learning resolution-independent dynamics and can scale to more complex state spaces at test time. Our method is also highly efficient, running 1-2 orders of magnitude faster than the simulation on which it is trained. Our approach broadens the range of problems on which neural network simulators can operate and promises to improve the efficiency of complex, scientific modeling tasks.

Topics

engineering graph neural networks numerical integration methods state space trade network architecture numerical solution mesh topologies feedforward neural networks recurrent neural networks

Keywords

mesh-based simulation graph networks adaptive mesh representations cloth simulation structural mechanics fluid dynamics granular materials complex physical systems local remesher

1 Introduction
2 Related Work
3 Model
3.1 Learning Forward Dynamics
3.2 Adaptive Remeshing
3.3 Model Training
4 Experimental Domains
5 Results
6 Conclusion
References
A Appendix
A.1 Dataset Details
A.2 Additional Model Details
A.2.1 Architecture and Training
A.2.2 Training Noise
A.2.3 Hyperparameters
A.3 A Domain-Invariant Local Remesher for Triangular Meshes
A.3.1 Estimating Sizing Field Targets
A.4 Additional Baseline Details
A.4.1 Baseline Training
A.4.2 GCN Baseline
A.4.3 Grid (CNN) Baseline
A.5 Additional Analysis
A.5.1 Performance
A.5.2 Error Metrics
A.5.3 Additional analysis on generalization and scaling

Knowls

Knowl 1 — MeshGraphNets Architecture for Learned Physical Simulation
model/method
MeshGraphNets models the discrete dynamics of physical systems defined on 2D or 3D meshes using an Encode-Process-Decode graph neural network architecture followed by numerical time integration.

A physical state at time $t$ is represented by a mesh $M^t = (V, E^M)$ , where $V$ is the set of mesh vertices and $E^M$ is the set of mesh edges. Each vertex $i \in V$ carries a reference coordinate in mesh space $u_i$ (representing the rest/intrinsic coordinate frame) and physical state features $q_i^t$ (such as velocity, momentum, or density). In Lagrangian systems (where the mesh moves in space), each node also carries a world-space position $x_i^t \in \mathbb{R}^3$ .

The model executes four main stages:
1. Graph Construction and Feature Encoding: The mesh is converted to a multigraph $G = (V, E^M, E^W)$ . Mesh edges $E^M$ are bidirectional. For Lagrangian domains, world edges $E^W$ are dynamically created between any pair of distinct nodes $(i, j)$ whose current Euclidean distance satisfies $|x_i^t - x_j^t| < r_W$ (where $r_W$ is a fixed neighborhood radius on the order of small mesh edge lengths), excluding pairs already connected by a mesh edge. Edge and node features are constructed to preserve spatial translation invariance by using relative vectors:
  - Mesh edge input: $e_{ij}^M = [u_i - u_j, |u_i - u_j|, x_i^t - x_j^t, |x_i^t - x_j^t|]$ (omitting world vectors for Eulerian systems).
  - World edge input: $e_{ij}^W = [x_i^t - x_j^t, |x_i^t - x_j^t|]$ .
  - Node input: $v_i = [q_i^t, n_i]$ (plus velocity history $\dot{x}_i^t = x_i^t - x_i^{t-1}$ for second-order systems), where $n_i$ is a one-hot node type descriptor (e.g., normal, wall, inflow, outflow, kinematic). Separate multilayer perceptrons (MLPs) $\epsilon^M$ , $\epsilon^W$ , and $\epsilon^V$ embed edge and node features into 128-dimensional latent vectors.
2. Message-Passing Processor: The processor applies $L$ successive message-passing blocks (with $L=15$ ). Each block updates latent representations with residual connections: $e_{ij}^{\prime M} \leftarrow e_{ij}^M + f^M(e_{ij}^M, v_i, v_j)$ $e_{ij}^{\prime W} \leftarrow e_{ij}^W + f^W(e_{ij}^W, v_i, v_j)$ $v_i' \leftarrow v_i + f^V\Big(v_i, \sum_{j \in \mathcal{N}_i^M} e_{ij}^{\prime M}, \sum_{k \in \mathcal{N}_i^W} e_{ik}^{\prime W}\Big)$ where $f^M, f^W, f^V$ are two-hidden-layer MLPs with ReLU activations, layer normalization, and 128 hidden/output units.
3. Decoding: A node decoder MLP $\delta^V$ maps final node embeddings $v_i^{(L)}$ to output features $p_i$ , representing time derivatives of the dynamic quantities or auxiliary fields (such as pressure $p$ or von Mises stress $\sigma$ ).
4. Time Integration: Using a forward-Euler step with $\Delta t = 1$ , the next state is computed as:
  - For first-order systems: $q_i^{t+1} = q_i^t + p_i$ .
  - For second-order systems: $x_i^{t+1} = 2x_i^t - x_i^{t-1} + p_i$ (where $p_i = \ddot{x}_i^{t+1}$ ).
Knowl 2 — Adaptive Remeshing via Learned Sizing Fields
model/method
MeshGraphNets supports dynamic resolution adaptation during forward rollout by predicting a continuous sizing field tensor $S(u) \in \mathbb{R}^{2 \times 2}$ over the mesh manifold, which governs local mesh refinement and coarsening without requiring a domain-specific external solver in the loop.

The sizing tensor $S_i$ at node $i$ represents an anisotropic metric specifying the maximum permissible edge lengths in each direction. A mesh edge connecting nodes $i$ and $j$ with displacement $u_{ij} = u_i - u_j$ in mesh space is defined as valid under the metric if and only if: $u_{ij}^T S_i u_{ij} \le 1$ If $u_{ij}^T S_i u_{ij} > 1$ , the edge is too long and must be split.

A dedicated MeshGraphNets model (or an extra output head from the node decoder $\delta^V$ ) is trained to predict the sizing tensor $S_i$ at each node alongside the next-step physical state. At test time, given the predicted mesh state $\hat{M}^{t+1}$ and predicted sizing field $\hat{S}^{t+1}$ , a domain-independent geometric remesher $\mathcal{R}$ updates the discretization: $M^{t+1} = \mathcal{R}(\hat{M}^{t+1}, \hat{S}^{t+1})$ .
Knowl 3 — Domain-Independent Local Remeshing Algorithm for Triangular Meshes
algorithm
Given a triangular mesh $M = (V, E^M)$ and per-node symmetric positive-definite sizing tensors $S_i \in \mathbb{R}^{2 \times 2}$ , the local remesher executes edge split, collapse, and flip operations to satisfy the sizing field criteria while preserving element aspect ratios.
Input: Current mesh M = (V, E), per-node sizing tensors {S_i for all i in V}
Output: Remeshed mesh M' = (V', E')
1. Compute edge metrics: for each edge (i, j) in E, S_ij = 0.5 * (S_i + S_j), metric(i, j) = (u_i - u_j)^T * S_ij * (u_i - u_j)
2. Edge Splitting (Refinement):
   for each edge (i, j) in E sorted in descending order of metric(i, j):
     if metric(i, j) > 1:
       Insert new vertex k at midpoint of (i, j)
       Set attributes of k (position, sizing tensor) to average of i and j
       Split edge (i, j) and subdivide incident triangles into 4 triangles
3. Edge Flipping (Quality Improvement):
   for each internal edge (i, j) with opposing vertices k and l:
     S_A = 0.25 * (S_i + S_j + S_k + S_l)
     if (u_jk x u_ik) * u_il^T * S_A * u_jl < (u_jk^T * S_A * u_ik) * (u_il x u_jl):
       Flip edge (i, j) to connect (k, l)
4. Edge Collapsing (Coarsening):
   for each edge (i, j) in E sorted in ascending order of metric(i, j):
     if collapsing (i, j) does not invert triangles and creates no edge with metric > 1:
       Merge vertex j into vertex i
       Update connectivity and remove degenerate triangles
5. Secondary Edge Flipping:
   Repeat step 3 for all candidate internal edges to optimize final element aspect ratios
return M'
Knowl 4 — Target Sizing Field Estimation via Minimum Enclosing Ellipsoids
model/method
When training an adaptive remeshing network on simulation data where the simulator's internal sizing field is unrecorded or inaccessible, target sizing tensors $S_i \in \mathbb{R}^{2 \times 2}$ can be estimated directly from successive mesh discretizations $M^t$ and $M^{t+1}$ .

Assuming the ground-truth remesher yields near-optimal edges that are valid and maximal under metric $S_i$ , the estimated sizing tensor for node $i$ with 1-ring neighborhood $\mathcal{N}_i$ is the solution to the constrained optimization problem: $S_i = \arg\max_{S \succeq 0} \sum_{j \in \mathcal{N}_i} (u_i - u_j)^T S (u_i - u_j) \quad \text{subject to} \quad \forall j \in \mathcal{N}_i, \; (u_i - u_j)^T S (u_i - u_j) \le 1$

Geometrically, this problem is equivalent to computing the minimum-area, origin-centered bounding ellipse enclosing the set of mesh-space displacement vectors $\{u_i - u_j \mid j \in \mathcal{N}_i\}$ . This is solved in linear time $O(|\mathcal{N}_i|)$ using Welzl's Minidisk algorithm adapted for origin-centered ellipses.
Knowl 5 — Training Noise Injection and Target Adjustment for Stable Rollouts
model/method
To prevent error accumulation during autoregressive rollouts of hundreds to thousands of steps when trained only with one-step loss, zero-mean Gaussian noise is added to the model's input dynamical variables during training, accompanied by an explicit target adjustment.
1. First-Order Systems: When Gaussian noise $\epsilon \sim \mathcal{N}(0, \sigma^2)$ is added to the input state $x_i^t$ yielding perturbed input $\tilde{x}_i^t = x_i^t + \epsilon$ , the decoder target velocity $\dot{x}_i^t$ is adjusted to: $\tilde{\dot{x}}_i^t = \frac{x_i^{t+1} - \tilde{x}_i^t}{\Delta t}$ This forces the integrated output $\tilde{x}_i^t + \tilde{\dot{x}}_i^t \Delta t$ to land exactly on the unperturbed ground-truth position $x_i^{t+1}$ , teaching the network error-correcting behavior.
2. Second-Order Systems (e.g., Cloth): Adding noise to position $x_i^t$ induces noise in estimated velocity $\dot{x}_i^t = x_i^t - x_i^{t-1}$ . Because no single acceleration can simultaneously correct both position and velocity errors, adjusted acceleration targets are formed as a convex combination: $\tilde{\ddot{x}}_i^t = \gamma \tilde{\ddot{x}}_i^{P} + (1 - \gamma) \tilde{\ddot{x}}_i^{V}$ where $\tilde{\ddot{x}}_i^P$ is the acceleration that recovers exact next position $x_i^{t+1}$ , and $\tilde{\ddot{x}}_i^V$ is the acceleration that recovers exact next velocity $\dot{x}_i^{t+1}$ . The optimal blending parameter was determined empirically to be $\gamma = 0.1$ .

Knowl 6 — MeshGraphNets Inference Timings and Rollout Error Across Domains

data/table

MeshGraphNets was evaluated across six benchmark datasets spanning cloth, hyperelastic solids, incompressible flow, and compressible aerodynamics. The model achieved 1-to-2 orders of magnitude inference speedup over CPU ground-truth solvers on both CPU (8-core workstation) and GPU (NVIDIA V100), while maintaining low root-mean-squared error (RMSE) over trajectories up to 600 steps.

Dataset	# Nodes	Steps	$t_{\text{model}}$ (GPU)	$t_{\text{full}}$ (GPU)	$t_{\text{GT}}$ (CPU)	GPU Speedup	RMSE 1-step	RMSE Rollout-all
	(avg.)		[ms/step]	[ms/step]	[ms/step]		$\times 10^{-3}$	$\times 10^{-3}$
FLAGSIMPLE	1579	400	19	19	4166	$214.7\times$	$1.08 \pm 0.02$	$139.0 \pm 2.7$
FLAGDYNAMIC	2767	250	43	837	26199	$31.3\times$	$1.57 \pm 0.02$	$151.1 \pm 5.3$
SPHEREDYNAMIC	1373	500	32	140	1610	$11.5\times$	$0.292 \pm 0.005$	$28.3 \pm 2.6$
DEFORMINGPLATE	1271	400	24	33	2893	$89.0\times$	$0.25 \pm 0.05$	$15.1 \pm 4.0$
CYLINDERFLOW	1885	600	21	23	820	$35.3\times$	$2.34 \pm 0.12$	$40.88 \pm 7.2$
AIRFOIL	5233	600	37	38	11015	$289.1\times$	$314 \pm 36$	$11529 \pm 1203$

$t_{\text{model}}$ denotes neural network evaluation time per step; $t_{\text{full}}$ includes neural network inference, mesh-space remeshing, and dynamic graph/world-edge recomputation; $t_{\text{GT}}$ denotes the run time of classical solvers (ArcSim for cloth, COMSOL for plate and cylinder flow, SU2 for airfoil). On the same CPU hardware, MeshGraphNets achieved $4.0\times$ to $22.3\times$ speedups over the numerical solvers.

Knowl 7 — Ablation and Comparison Against Particle, GCN, and Grid Baselines
empirical result
Comparative evaluations between MeshGraphNets and baseline paradigms revealed specific structural requirements for physical mesh learning:
1. Particle-based Graph Networks (GNS): A fixed Euclidean radius connectivity without reference mesh-space coordinates $u$ fails to simulate thin structural materials like cloth because it lacks a rest-state representation, diverging rapidly. Augmenting GNS edges with relative mesh coordinates ( $u_i - u_j$ ) improves stability on regular meshes but causes severe triangle entanglement and failure on irregular meshes because a fixed spatial radius oversamples dense areas and undersamples sparse areas.
2. Graph Convolutional Networks (GCNs): GCN architectures without edge feature updates or relative displacement vectors (such as the Belbute-Peres et al. baseline) failed to produce stable dynamical rollouts on AIRFOIL, resulting in visual artifacts and high error (rollout RMSE of 26.5 vs. 11.5 for MeshGraphNets). Increasing network depth (15 blocks) and adding MLPs did not resolve the instability, confirming that computing edge messages on relative spatial displacements is required to learn local differential operators and avoid overfitting.
3. Grid-based Convolutional Networks (UNet): A 128x128 grid-based UNet spanning a region of interest around the wing in AIRFOIL used 4x more cells than MeshGraphNets over a region 16x smaller, yet produced higher rollout RMSE and failed to resolve high-gradient boundary layer dynamics around the wingtip and trailing wake.
4. World Edges in Lagrangian Systems: Eliminating world-space edges $E^W$ and passing messages exclusively through mesh edges $E^M$ increased rollout RMSE by 51% on FLAGDYNAMIC and 92% on SPHEREDYNAMIC, due to the inability to detect external contact and non-local self-collisions.
Knowl 8 — Out-of-Distribution and Scale Generalization of MeshGraphNets
empirical result
Because MeshGraphNets uses purely local message passing and translation-invariant relative spatial encodings over unstructured meshes, models trained on small, canonical simulations generalize to unseen parameters, larger domains, and novel geometric topologies at inference time:
- Physical and Flow Parameters: On the compressible AIRFOIL dataset, a model trained on inflow Mach numbers $\in [0.2, 0.7]$ and angles of attack $\alpha \in [-25^\circ, 25^\circ]$ generalized to Mach numbers $\in [0.7, 0.9]$ (RMSE increased marginally from 11.5 to 13.1) and angles $\alpha \in [-35^\circ, 35^\circ]$ (RMSE increased to 12.4).
- Varying Boundary Conditions: A model trained on cloth with trajectories of fixed wind speed and direction accurately simulated dynamically changing wind vectors at test time.
- Mesh Size and Topology Scaling: A model trained on single flat rectangular flags (average $\sim 2.7$ k nodes) successfully generalized to multiple disconnected fish-shaped flags, as well as a 3D cylindrical windsock with dangling tassels averaging 20,000 nodes (a $10\times$ scale increase in node count) without retraining.

Coverage note — None was omitted; all key architectural components, adaptive remeshing algorithms, training noise techniques, empirical comparisons, and generalization experiments have been fully covered.

References

1.MS Albergo, G Kanwar, and PE Shanahan. Flow-based generative models for markov chain monte carlo in lattice field theory. Physical Review D, 100(3):034515, 2019.
2.Ferran Alet, Adarsh Keshav Jeewajee, Maria Bauza Villalonga, Alberto Rodriguez, Tomas Lozano-Perez, and Leslie Kaelbling. Graph element networks: adaptive, structured computation and memory. In International Conference on Machine Learning, pp. 212–222, 2019.
3.V Bapst, T Keck, A Grabska-Barwinska, C Donner, ED Cubuk, SS Schoenholz, A Obika, AWR Nelson, T Back, D Hassabis, et al. Unveiling the predictive power of static structure in glassy systems (vol 16, pg 448, 2020). NATURE PHYSICS, 16(6):702–702, 2020.
4.Peter W Battaglia, Jessica B Hamrick, Victor Bapst, Alvaro Sanchez-Gonzalez, Vinicius Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, et al. Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv:1806.01261, 2018.
5.Filipe de Avila Belbute-Peres, Thomas D. Economon, and J. Zico Kolter. Combining differentiable PDE solvers and graph neural networks for fluid flow prediction. In Proceedings of the 37th International Conference on Machine Learning ICML 2020, 2020.
6.Saakaar Bhatnagar, Yaser Afshar, Shaowu Pan, Karthik Duraisamy, and Shailendra Kaushik. Prediction of aerodynamic flow fields using convolutional neural networks. Computational Mechanics, 64(2):525–545, 2019.
7.Frank J Bossen and Paul S Heckbert. A pliant method for anisotropic mesh generation. In 5th Intl. Meshing Roundtable, pp. 63–74. Citeseer, 1996.
8.Ricardo Branco, FV Antunes, and JD Costa. A review on 3d-fe adaptive remeshing techniques for crack growth modelling. Engineering Fracture Mechanics, 141:170–195, 2015.
9.Michael M. Bronstein, Joan Bruna, Yann LeCun, Arthur Szlam, and Pierre Vandergheynst. Geometric deep learning: going beyond euclidean data. CoRR, abs/1611.08097, 2016.
10.German Capuano and Julian J Rimoli. Smart finite elements: A novel machine learning application. Computer Methods in Applied Mechanics and Engineering, 345:363–381, 2019.
11.Comsol. Comsol multiphysics® v. 5.4. http://comsol.com, 2020.
12.Emmanuel de Bezenac, Arthur Pajot, and Patrick Gallinari. Deep learning for physical processes: Incorporating prior scientific knowledge. Journal of Statistical Mechanics: Theory and Experiment, 2019(12):124009, 2019.
13.Thomas D Economon, Francisco Palacios, Sean R Copeland, Trent W Lukaczyk, and Juan J Alonso. Su2: An open-source suite for multiphysics simulation and design. Aiaa Journal, 54 (3):828–846, 2016.
14.Exxact. ANSYS Mechanical GPU Benchmarks. https://blog.exxactcorp.com/ansys-mechanical-benchmarks-comparing-nvidia-rtx-6000-vs-tesla-v100s-gpu-vs-cpu-only, 2020.
15.Thibault Groueix, Matthew Fisher, Vladimir G Kim, Bryan C Russell, and Mathieu Aubry. A papier-macĥ e approach to learning 3d surface generation. In ´ Proceedings of the IEEE conference on computer vision and pattern recognition, pp. 216–224, 2018.
16.Xiaoxiao Guo, Wei Li, and Francesco Iorio. Convolutional neural networks for steady flow approximation. In Proceedings of the 22nd ACM SIGKDD international conference on knowledge discovery and data mining, pp. 481–490, 2016.
17.Rana Hanocka, Amir Hertz, Noa Fish, Raja Giryes, Shachar Fleishman, and Daniel Cohen-Or. Meshcnn: a network with an edge. ACM Transactions on Graphics (TOG), 38(4):1–12, 2019.
18.Daniel Holden, Bang Chi Duong, Sayantan Datta, and Derek Nowrouzezahrai. Subspace neural physics: Fast data-driven interactive simulation. In Proceedings of the 18th annual ACM SIGGRAPH/Eurographics Symposium on Computer Animation, pp. 1–12, 2019.
19.Sara Hooker. The hardware lottery. arXiv preprint arXiv:2009.06489, 2020.
20.Gurtej Kanwar, Michael S. Albergo, Denis Boyda, Kyle Cranmer, Daniel C. Hackett, Sébastien ´ Racaniere, Danilo Jimenez Rezende, and Phiala E. Shanahan. Equivariant flow-based sampling ` for lattice gauge theory. Phys. Rev. Lett., 125:121601, Sep 2020. doi: 10.1103/PhysRevLett. 125.121601.
21.Thomas N. Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. In 5th International Conference on Learning Representations, ICLR 2017, Toulon, France, April 24-26, 2017, Conference Track Proceedings. OpenReview.net, 2017.
22.L’ubor Ladický, SoHyeon Jeong, Barbara Solenthaler, Marc Pollefeys, and Markus Gross. ` Data-driven fluid simulations using regression forests. ACM Transactions on Graphics (TOG), 34(6):1–9, 2015.
23.Sangseung Lee and Donghyun You. Data-driven prediction of unsteady flow over a circular cylinder using deep learning. Journal of Fluid Mechanics, 879:217–254, 2019. doi: 10.1017/ jfm.2019.700.
24.Yunzhu Li, Jiajun Wu, Russ Tedrake, Joshua B. Tenenbaum, and Antonio Torralba. Learning particle dynamics for manipulating rigid bodies, deformable objects, and fluids. In International Conference on Learning Representations, 2019.
25.Ran Luo, Tianjia Shao, Huamin Wang, Weiwei Xu, Xiang Chen, Kun Zhou, and Yin Yang. Nnwarp: Neural network-based nonlinear deformation. IEEE transactions on visualization and computer graphics, 2018.
26.Steffen Marburg and Bodo Nolte. Computational acoustics of noise propagation in fluids: finite and boundary element methods, volume 578. Springer, 2008.
27.Rahul Narain, Armin Samii, and James F. O’Brien. Adaptive anisotropic remeshing for cloth simulation. ACM Trans. Graph., 31(6), 2012.
28.Rahul Narain, Tobias Pfaff, and James F. O’Brien. Folding and crumpling adaptive sheets. ACM Trans. Graph., 32(4), 2013.
29.Charlie Nash, Yaroslav Ganin, SM Eslami, and Peter W Battaglia. Polygen: An autoregressive generative model of 3d meshes. In International Conference on Machine Learning, 2020.
30.nVidia. GPU-accelerated ANSYS FLUENT. https://www.nvidia.com/en-us/data-center/gpu-accelerated-applications/ansys-fluent, 2019.
31.SK Panthi, N Ramakrishnan, KK Pathak, and JS Chouhan. An analysis of springback in sheet metal bending using finite element method (fem). Journal of Materials Processing Technology, 186(1-3):120–124, 2007.
32.D Pardo, L Demkowicz, C Torres-Verdin, and M Paszynski. A self-adaptive goal-oriented hp-finite element method with electromagnetic applications. part ii: Electrodynamics. Computer methods in applied mechanics and engineering, 196(37-40):3585–3597, 2007.
33.Tobias Pfaff, Rahul Narain, Juan Miguel De Joya, and James F O’Brien. Adaptive tearing and cracking of thin sheets. ACM Transactions on Graphics (TOG), 33(4):1–9, 2014.
34.Ravi Ramamurti and William Sandberg. Simulation of flow about flapping airfoils using finite element incompressible flow solver. AIAA journal, 39(2):253–260, 2001.
35.Zhengyong Ren and Jingtian Tang. 3d direct current resistivity modeling with unstructured mesh by adaptive finite-element method. Geophysics, 75(1):H7–H17, 2010.
36.Alvaro Sanchez-Gonzalez, Nicolas Heess, Jost Tobias Springenberg, Josh Merel, Martin Riedmiller, Raia Hadsell, and Peter Battaglia. Graph networks as learnable physics engines for inference and control. In Proceedings of the 35th International Conference on Machine Learning, ICML, pp. 4467–4476, 2018.
37.Alvaro Sanchez-Gonzalez, Jonathan Godwin, Tobias Pfaff, Rex Ying, Jure Leskovec, and Peter W. Battaglia. Learning to simulate complex physics with graph networks. In Proceedings of the 37th International Conference on Machine Learning ICML 2020, 2020.
38.Franco Scarselli, Marco Gori, Ah Chung Tsoi, Markus Hagenbuchner, and Gabriele Monfardini. The graph neural network model. IEEE Transactions on Neural Networks, 20(1):61–80, 2008.
39.Christoph Schwarzbach, Ralph-Uwe Börner, and Klaus Spitzer. Three-dimensional adaptive higher order finite element simulation for geo-electromagnetics—a marine csem example. Geophysical Journal International, 187(1):63–74, 2011.
40.Nils Thuerey, Konstantin Weißenow, Lukas Prantl, and Xiangyu Hu. Deep learning methods for reynolds-averaged navier–stokes simulations of airfoil flows. AIAA Journal, 58(1):25–36, 2020.
41.Kiwon Um, Xiangyu Hu, and Nils Thuerey. Liquid splash modeling with neural networks. In Computer Graphics Forum, volume 37, pp. 171–182. Wiley Online Library, 2018.
42.Benjamin Ummenhofer, Lukas Prantl, Nils Thürey, and Vladlen Koltun. Lagrangian fluid ¨ simulation with continuous convolutions. In International Conference on Learning Representations, 2020.
43.Rui Wang, Karthik Kashinath, Mustafa Mustafa, Adrian Albert, and Rose Yu. Towards physics-informed deep learning for turbulent flow prediction. In ACM SIGKDD international conference on knowledge discovery and data mining, 2020.
44.Emo Welzl. Smallest enclosing disks (balls and ellipsoids). In New results and new trends in computer science, pp. 359–370. Springer, 1991.
45.Martin Wicke, Daniel Ritchie, Bryan M. Klingner, Sebastian Burke, Jonathan R. Shewchuk, and James F. O’Brien. Dynamic local remeshing for elastoplastic simulation. ACM Trans. Graph., 29(4), 2010.
46.Steffen Wiewel, Moritz Becher, and Nils Thuerey. Latent space physics: Towards learning the temporal evolution of fluid flow. In Computer Graphics Forum, pp. 71–82. Wiley Online Library, 2019.
47.You Xie, Erik Franz, Mengyu Chu, and Nils Thuerey. Tempogan: A temporally coherent, volumetric gan for super-resolution fluid flow. ACM Trans. Graph., 37(4), July 2018.
48.Abdelaziz Yazid, Nabbou Abdelkader, and Hamouine Abdelmadjid. A state-of-the-art review of the x-fem for computational fracture mechanics. Applied Mathematical Modelling, 33(12): 4269–4282, 2009.
49.Yao Zhang, Woong Je Sung, and Dimitri N Mavris. Application of convolutional neural network to predict airfoil lift coefficient. In 2018 AIAA/ASCE/AHS/ASC Structures, Structural Dynamics, and Materials Conference, pp. 1903, 2018.

Citation

MLA

Pfaff, T., et al. “Learning Mesh-Based Simulation with Graph Networks”. International Conference on Learning Representations (ICLR), 2021, 2020, http://arxiv.org/abs/2010.03409v4.

APA

Pfaff, T., Fortunato, M., Sanchez-Gonzalez, A., & Battaglia, P. W. (2020). Learning Mesh-Based Simulation with Graph Networks. International Conference on Learning Representations (ICLR), 2021. http://arxiv.org/abs/2010.03409v4

Chicago

Pfaff, T., M. Fortunato, A. Sanchez-Gonzalez, and P. W. Battaglia. 2020. “Learning Mesh-Based Simulation with Graph Networks”. International Conference on Learning Representations (ICLR), 2021. http://arxiv.org/abs/2010.03409v4.

Harvard

Pfaff, T. et al. (2020) “Learning Mesh-Based Simulation with Graph Networks”, International Conference on Learning Representations (ICLR), 2021 [Preprint]. Available at: http://arxiv.org/abs/2010.03409v4.

Vancouver

1. Pfaff T, Fortunato M, Sanchez-Gonzalez A, Battaglia PW (2020) Learning Mesh-Based Simulation with Graph Networks. International Conference on Learning Representations (ICLR), 2021

BibTeX

@article{pfaff2020learning,
  title = {Learning Mesh-Based Simulation with Graph Networks},
  author = {Pfaff, Tobias and Fortunato, Meire and Sanchez-Gonzalez, Alvaro and Battaglia, Peter W.},
  year = {2020},
  journal = {International Conference on Learning Representations (ICLR), 2021},
  url = {http://arxiv.org/abs/2010.03409v4},
  eprint = {2010.03409}
}

Metadata:arXiv

Source Code

This paper has an official code repository available. Click below to access the source code.

View Repository

Access the Paper

This paper is available from its original source. Click below to access the PDF.

Open PDF

License: Published with permission

Learning Mesh-Based Simulation with Graph Networks

Abstract

Topics

Keywords

Table of Contents

Knowls

Knowl 1 — MeshGraphNets Architecture for Learned Physical Simulation

Knowl 2 — Adaptive Remeshing via Learned Sizing Fields

Knowl 3 — Domain-Independent Local Remeshing Algorithm for Triangular Meshes

Knowl 4 — Target Sizing Field Estimation via Minimum Enclosing Ellipsoids

Knowl 5 — Training Noise Injection and Target Adjustment for Stable Rollouts