betaFeedback

WorksPhysics and Astronomy

JAX-SPH: A Differentiable Smoothed Particle Hydrodynamics Framework

Abstract

Particle-based fluid simulations have emerged as a powerful tool for solving the Navier-Stokes equations, especially in cases that include intricate physics and free surfaces. The recent addition of machine learning methods to the toolbox for solving such problems is pushing the boundary of the quality vs. speed tradeoff of such numerical simulations. In this work, we lead the way to Lagrangian fluid simulators compatible with deep learning frameworks, and propose JAX-SPH - a Smoothed Particle Hydrodynamics (SPH) framework implemented in JAX. JAX-SPH builds on the code for dataset generation from the LagrangeBench project (Toshev et al., 2023) and extends this code in multiple ways: (a) integration of further key SPH algorithms, (b) restructuring the code toward a Python package, (c) verification of the gradients through the solver, and (d) demonstration of the utility of the gradients for solving inverse problems as well as a Solver-in-the-Loop application. Our code is available at https://github.com/tumaer/jax-sph.

Introduction

Partial differential equations (PDEs) are the mathematical tools developed to describe natural phenomena ranging from engineering and physics to social sciences. Various numerical methods have been developed to solve these PDEs, as analytical solutions are only available for toy examples, with the most recent class of PDE solvers being the machine learning-based ones [40, 11]. One particular class of machine learning (ML) approaches called hybrid solvers refers to combining ideas (or full algorithmic blocks) from classical numerical solvers and machine learning [38, 45, 22, 19, 26, 20, 25, 44].

This has been one of the main reasons for the development of differentiable fluid mechanics solvers like PhiFlow [18], JAX-CFD [22], and JAX-Fluids [7]. However, these three frameworks implement Eulerian, i.e., grid-based, solvers, and we lead the way to a JAX-based Lagrangian CFD solver. Eulerian solvers refer to numerical methods that discretize space into static volume elements and then track the evolution of the fluid properties at these positions, while Lagrangian solvers discretize individual material elements, which are then shifted in space following the local velocity field.

Algorithmically, grid-based and particle-based methods are very different. While grid-based solvers rely on stencil akin to kernels in Convolutional Neural Networks (CNNs) [24], particle-based solvers rely on kernel approximations akin to Graph Neural Networks (GNNs) [37, 6] operating on a radial distance-based graph. The main overhead of Lagrangian over Eulerian approaches is updating the connectivity between discretization elements at every autoregressive solver step. Even if an Eulerian scheme operates on an irregular mesh, the connectivity prescribed by this mesh can be precomputed, while by moving particles in space in Lagrangian methods, their neighbors constantly vary in time.

As SPH techniques advance, various software packages have arisen in the past few years. However, most of them are designed for high-performance computing (HPC) applications and are typically implemented in low-level languages like C++ or Fortran [14, 23, 50], with two notable exceptions: PySPH [35] in Python and juSPH [27] in Julia. Nevertheless, hardly an SPH implementation exists which is out-of-the-box compatible with modern deep learning frameworks like TensorFlow [1], PyTorch1 [33] or JAX [10], i.e., leverages automatic differentiation to power differentiable solvers like PhiFlow [18]. Upon identifying the lack of an ML-ready SPH solver, we choose JAX for the framework implementation for two reasons: (a) JAX tends to be faster for operations on graphs even after PyTorch 2.0 has been introduced (see Appendix F in Toshev et al. [42]), and (b) we can use the cell list-based neighbor search routine of the JAX-MD library [39]. We note that with our solver, we target the easier integration of SPH with ML workflows rather than developing a parallel HPC code, and we exclusively use the AD routine grad by JAX. We leave the implementation of better custom adjoints along the lines of Ma et al. [28], Kidger [21], Nadarajah & Jameson [32] to future work.

In this work, we significantly extend the codebase used for dataset generation within LagrangeBench2 [42] and demonstrate the utility of the obtained gradients in multiple ways. Our contributions are:

  • The addition and validation of Transport Velocity [3], Riemann SPH [49], and thermal diffusion effects [12].

  • Validating the accuracy of the automatic differentiation-based gradients [17] over 5 solver steps.

  • An open-source Python package at pypi.org/project/jax-sph.

  • A demonstration of how to use these gradients on (a) an inverse problem over 100 SPH solver steps, and (b) using the SPH solver in a Solver-in-the-Loop fashion [45].

SPH Solver

In this section, we introduce the components included in our solver code. The validation of these can be found in Appendix § 7, for which we include various solver validation cases.

Weakly compressible SPH. We follow the weakly compressible SPH approach [29, 31] to evolve the dynamics of incompressible fluids. The equations governing such systems are the mass and momentum conservation equations

ddt(ρ)=−ρ(∇⋅u)(1)\frac{\mathrm{d}}{\mathrm{d}t}(\rho) = -\rho\left(\nabla\cdot\mathbf{u}\right) \tag*{(1)}
ddt(u)=−1ρ∇p+1Re∇2u+f(2)\frac{\mathrm{d}}{\mathrm{d}t}(\mathbf{u}) = -\frac{1}{\rho}\nabla p + \frac{1}{Re}\nabla^2\mathbf{u} + \mathbf{f} \tag*{(2)}

with density ρ\rho, velocity u\mathbf{u}, pressure pp, Reynolds number ReRe, and external force f\mathbf{f}. To numerically solve these equations, SPH applies a distance-based kernel WW that averages over the properties of the fluid. The default kernel in our codebase is the Quintic spline [31], but we also include the 5th order Wendland kernel [46].

The preferred way of estimating the density [30] is through density summation ρi=∑jmjW(rij,h)\rho_i = \sum_j m_j W(r_{ij},h), with mjm_j being the mass of the adjacent particles jj, hh the smoothing length of the kernel, and rijr_{ij} the interparticle distance. However, this approach leads to unphysically low densities at free surfaces, forcing the use of density evolution, i.e., numerically integrating the mass conservation Eq. (1). We also implement a density field reinitialization method [48] to mitigate errors arising from density evolution [13]. In weakly compressible SPH, the pressure is defined as a function of density through an equation of state, and in our code, we choose the formulation by Monaghan [29] for standard and transport velocity formulation SPH. The equation of state used for the Riemann SPH formulation is the one proposed by Zhang et al. [49].

Transport velocity. The observation that tensile instabilities in standard SPH can cause particle clumping and void regions [34] has led to the development of advanced shifting schemes like the transport velocity formulation of SPH [3, 48]. We add the shifting velocity proposed by Adami et al. [3] as an optional feature in our codebase.

Riemann SPH. We also add the Riemann SPH solver formulation by Zhang et al. [49], which is based on the idea of introducing a simple low dissipation limiter to a classical Riemann solver, resulting in decreased numerical dissipation. We construct a one-dimensional linear inter-particle Riemann problem along a unit vector pointing from particle ii to particle jj, which implicitly regularizes both the momentum equation and the mass conservation. We implement the dissipation limiter as proposed by Zhang et al. [49].

Wall boundaries. We follow the generalized wall boundary condition approach by Adami et al. [2] to enforce different boundary conditions for the standard SPH and the transport velocity SPH formulation. This approach, in essence, implements two physical constraints: (a) impermeability of walls and (b) viscous effects at walls. For impermeability, the pressure of the adjacent fluid particles is assigned to the dummy wall particles, which leads to a zero pressure gradient in the wall-normal direction at the wall surface, and, thus prevents the penetration of fluid particles into the wall. Regarding viscosity, there are two cases to distinguish: (b1) no-slip enforces the no-slip boundary condition, i.e., the fluid must have zero velocity directly at the wall surface, and (b2) free-slip, i.e., the fluid must have a zero velocity normal to a wall, but might have any velocity tangentially. These two conditions are implemented by assigning the inverted velocity of the fluid to the wall particles, either fully for (b1) or only in the wall-normal direction for (b2). See Adami et al. [2] for more details.

For the Riemann SPH wall boundary implementation, we solve a one-sided Riemann problem as proposed by Zhang et al. [49]. Unlike the generalized wall boundary condition, this method avoids interpolating and then extrapolating the fluid states for the wall boundary particles. Here, these wall particles are assigned the individual Riemann states depending on the current particle-particle interaction. For a more in-depth explanation, see [49, 47].

Thermal diffusion. Thermal diffusion in weakly compressible SPH involves the transfer of heat between neighboring particles governed by Fourier’s law of heat [12]. This diffusion smoothens the temperature field by applying an SPH kernel interpolation over adjacent particles to compute the rate of temperature change. As we deal with incompressible fluids, the dynamics are not influenced by thermal effects, and the pressure or velocity fields do not directly influence the temperature field. Thus, the addition of temperature does not interfere with the previously presented SPH algorithms and allows us to study thermal effects which are governed by diffusion (by our explicit diffusion modeling) and convection (as Lagrangian particles are shifted in space). For an example of a channel flow with a hot wall, see Appendix C.

Experiments

Gradient validation. To test the validity of the gradients obtained through our differentiable solver, we compute analytical solver gradients via automatic differentiation and compare those to numerical gradients from finite difference schemes [17]. In our setup, gradients are accumulated over 5 solver steps, preceded by 10 (forward only) warm-up steps. Epsilon for finite differences is picked as 0.001dx=5e−50.001dx = 5e-5, as smaller values lead to instabilities. Figure 1 shows the scalar gradients of kinetic energy over position changes dEkindr\frac{dE_{kin}}{dr} when using 2-dimensional Taylor-Green vortex (TGV) [8, 9] and lid-driven cavity (LDC) [16] as initial states.

Figure 1. Gradient magnitudes with JAX Autograd and with finite differences on Taylor-Green vortex (left) and lid-driven cavity (right).

Inverse problem. Our first application case is an inverse problem, representing the class of inverse design and flow control problems that are successfully tackled by differentiable solvers [18] as well as differentiable learned solver surrogates [5]. The scenario involves a 2D box containing a water cube, discretized by 36 particles, which undergoes acceleration due to gravity across 100 solver steps. The task is to find the initial coordinates of the cube given its final state; see Figure 2.

Inverse problems of finding the initial coordinates given the final coordinates of a falling water cube simulation

Figure 2. Inverse problems of finding the initial coordinates (light blue) given the final coordinates (blue) of a falling water cube simulation spanning 100 SPH steps. The optimization spans 15 gradient descent steps from orange to red. Free fall case (left) and wall-interactions (right).

The inverse problem is formulated by computing the mean squared error of coordinates between the target final state and the end of a simulation with randomly placed initial particles. After as few as 15 gradient descent steps, we reach a state closely resembling the original one, up to some loss of information during the deformation of the water cube while interacting with the wall.

Solver-in-the-loop. As a second experiment to showcase the solver differentiability, we adapt the popular ”Solver-in-the-Loop” (SitL) [45] training scheme to SPH. Initially developed to tackle spatial coarsening on grids, SitL interleaves a solver operating on a coarse spatial and/or temporal discretization with a learnable correction function. The solver manages coarse, low-frequency components, while the learnable function adjusts high-frequency details. Due to the inherent difficulties of spatial coarse-graining in particle systems, our objective is to implement SitL only for temporal coarsening. This significantly differs from the original application of SitL and mandates a series of design changes to the original architecture, mainly related to the normalization and training procedure, see Appendix § 8.

Figure 3 shows the time evolution of a 2D reverse Poiseuille flow (RPF) [15] dataset similar to the one in Toshev et al. [42] but consisting of positions sampled every 20th ground truth SPH step. Figure 3 compares only employing the coarse SPH solver with L=3L = 3 intermediate steps (left), a fully learned GNS model [36] without intermediate steps (middle), and SitL using the same GNS model, but having three intermediate steps of GNS and SPH (right). More details on the training and quantitative results can be found in Appendix § 8.§ 2.

Figure 3. (a) Solver only (L=3L = 3) (b) Learned only (L=1L = 1) (c) SitL (L=3L = 3). Evolution of the velocity magnitude in reverse Poiseuille flow. The stamps in each image refer to the respective step of the original SPH simulation, i.e., 500 means 10 000 SPH steps.

Conclusion

We have developed JAX-SPH, a framework for simulating Lagrangian fluid problems, which can be easily integrated into design/control problems as well as hybrid solver approaches. By building our code on the high-performance library JAX and validating the simulation results of our solver, we offer a fast and reliable SPH solver in Python. With our work, we hope to accelerate the development of more hybrid Lagrangian solvers, e.g., Toshev et al. [41], and we leave the addition of more SPH algorithms and simulation cases to future work. One particularly exciting future direction is developing foundation models for PDEs that can operate on both Eulerian and Lagrangian data [4], potentially combined with encoded symmetries [43].

Acknowledgements

The authors thank Fabian Fritz for providing an initial JAX implementation of the 3D Taylor-Green vortex simulated with the transport velocity SPH formulation by Adami et al. [3]. The authors also thank Xiangyu Hu and Christopher Zoller for helpful discussions on SPH, and Ludger Paehler for discussions on gradient validation.

Author Contributions

A.T. developed the codebase, selected the SPH algorithms and validated most of them, designed the simulation cases and experiments, ran many of them, and wrote the first version of the manuscript. H.R. implemented thermal diffusion and the inverse problem, and helped in the initial phase of Solver-in-the-Loop. J.E. implemented Riemann SPH, generated the final solver validation results, and contributed to refactoring the core SPH code. G.G. validated the gradients through the solver, implemented Solver-in-the-Loop, and tuned its parameters on the dataset A.T. provided. J.B. contributed to the choice of experiments showcasing the gradients through the solver. N.A. supervised the project from conception to design of experiments and analysis of the results. All authors contributed to the manuscript.

Solver Validation

Taylor Green Vortex 2D

Fig. 4 shows the absolute velocities of each particle at the start and at the end of the Taylor Green vortex [8, 9] simulation at Re=100Re = 100. Here, the transport velocity SPH formulation is used. In Fig. 5, one can see the decay of the maximum velocity and the kinetic energy over time for the different methods, standard SPH (SPH), transport velocity formulation SPH (SPH + tvf), and Riemann SPH (Riemann).

2D Taylor Green vortex velocity magnitudes at the start of the simulation and at t = 5

Figure 4. (a) t=0t = 0 (b) t=5t = 5. 2D Taylor Green vortex velocity magnitudes at the start of the simulation (left) and at t=5t = 5 (right), calculated using transport velocity formulation SPH.

Lid-Driven Cavity 2D

The following figures compare the different methods for a 2D lid-driven cavity [16] simulation at Re=100Re = 100. The reference data for the velocity profiles, i.e., black dots for U (velocity in xx direction at a vertical cut through the middle of the cavity) and black squares for V (velocity in yy direction at a horizontal cut through the middle of the cavity), are from Ghia et al. [16].

Lid-driven cavity with dx = 0.02 showing absolute particle velocities and velocity profiles

Figure 6. Lid-driven cavity with dx=0.02dx = 0.02 showing absolute particle velocities of the Riemann solver (left) and velocity profiles of each SPH method at the midsection for U and V (right)

Lid-driven cavity with dx = 0.01 showing absolute particle velocities and velocity profiles

Figure 7. Lid-driven cavity with dx=0.01dx = 0.01 showing absolute particle velocities of the Riemann solver (left) and velocity profiles of each SPH method at the midsection for U and V (right)

Dam Break 2D

The following Figure 8 shows the nondimensionalized pressure of a Riemann SPH ([49]) dam break ([13]) simulation at different time stamps. The fluid flows from the initial state on the left to the right side, interacts with the wall, and reflects a wave backward throughout the domain. A similar validation plot for the standard SPH formulation of our solver is presented in Appendix § 8 of Toshev et al. [42].

Six-panel dam break simulation showing nondimensionalized pressure at time stamps $T = 1.62$, $T = 2.38$, $T = 4.00$, $T = 5.21$, $T = 6.02$, and $T = 7.23$

Figure 8. Dam break simulation with dx=0.02dx = 0.02 using Riemann SPH at different time stamps T, visualizing the nondimensionalized pressure

Taylor-Green Vortex 3D

Figure 9 shows the comparison between the different SPH methods on the 3D TGV, similar to Figure 5 for 2D. Again, the Reynolds number is set to Re=100Re = 100, and the number of particles in the unit cube is 20320^3, 32332^3, and 50350^3, leading to dx=0.314dx = 0.314, dx=0.196dx = 0.196, and dx=0.126dx = 0.126, respectively. The reference solution is obtained using JAX-Fluids Bezgin et al. [7] with a 1283128^3 grid.

2D Taylor Green vortex SPH method comparison for maximum velocity and kinetic energy

Figure 5. (a) umaxu_{max} (b) EkinE_{kin}. 2D Taylor Green vortex SPH method comparison for umaxu_{max} (left) and EkinE_{kin} (right) between standard SPH, transport velocity formulation SPH, and Riemann SPH at dx=0.02dx = 0.02 and dx=0.01dx = 0.01.

Comparison plots of $dE/dt$ and $E_{\mathrm{kin}}$ for standard SPH, transport velocity formulation SPH, Riemann SPH, and JAX-Fluids

Figure 9. 3D Taylor Green vortex comparison for dE/dtdE/dt (left) and EkinE_{\mathrm{kin}} (right) between standard SPH, transport velocity formulation SPH, and Riemann SPH with dx=0.314dx = 0.314, dx=0.196dx = 0.196, and dx=0.126dx = 0.126

Solver-in-the-Loop

Implementation details

To compute velocities, we apply a finite difference approximation of positions as

u(i+1)M=x(i+1)M−xiM,(3)\mathbf{u}_{(i+1)M} = \mathbf{x}_{(i+1)M} - \mathbf{x}_{iM}, \tag*{(3)}
aiM=u(i+1)M−uiM.(4)\mathbf{a}_{iM} = \mathbf{u}_{(i+1)M} - \mathbf{u}_{iM}. \tag*{(4)}

These properties have normalization statistics over the dataset as σuM\sigma_{u_M} and σaM\sigma_{a_M} (for brevity here, assuming that everything is zero-centered, but we center the data in our code). The values entering and exiting the SitL model should be in normalized space.

Given the number of temporal coarsening steps MM and the number of SitL calls n_sitl, each call accounts for Mnsitl\frac{M}{n_{\mathrm{sitl}}} actual timesteps. This results in two distinct time steps (dtdt), necessitating the transformation of input properties to the SitL physical space.

def sitl_forward(self, r, u_M_norm, dt, M, n_sitl, sigma_uM, sigma_aM):
    """Solver-in-the-loop forward call.

    Args:
        r: current coordinates
        u_M_norm: normalized position difference between M SPH steps.
        dt: physical dt from CFL condition
        M: level of temporal coarsening
        n_sitl: number of Solver-in-the-Loop steps
        sigma_uM: std of u_M over the dataset (= std_dx_M)
        sigma_aM: std of a_M over the dataset (= std_ddx_M)
    """
    # transform initial states
    u_phys = u_M_norm * sigma_uM / (dt * M)  # to physical space
    nbrs_GNN = self.nbrs_GNN_update(r)  # GNN neighbor list
    nbrs_SPH = self.nbrs_SPH_update(r)  # SPH neighbor list
    r0, u0, r_new = r.copy(), u_phys.copy(), r

    for l in range(n_sitl):
        # SPH solver call
        a_SPH = self.SPH(u_phys, nbrs_SPH)

        # learned correction
        a_GNN = self.GNN(u_M_norm, nbrs_GNN)
        a_GNN_phys = a_GNN * sigma_aM / (dt * M) ** 2  # to physical

        # add accelerations (in physical space) and integrate
        a_final = a_SPH + a_GNN_phys
        u_phys += (dt * M) / n_sitl * a_final
        r_new += (dt * M) / n_sitl * u_phys

        # update neighbors to new positions
        nbrs_SPH = self.nbrs_SPH_update(r_new)
        nbrs_GNN = self.nbrs_GNN_update(r_new)

        # normalize updated velocity for next GNN input
        u_M_norm = u_phys * (dt * M) / sigma_uM  # to normalized

    # finite difference to get M-step effective quantities
    dx_M = r_new - r0
    dx_M_norm = dx_M / sigma_uM
    ddx_M = dx_M - u0 * (dt * M)
    ddx_M_norm = ddx_M / sigma_aM

    return {"acc": ddx_M_norm, "vel": dx_M_norm}

Listing 1: Solver-in-the-Loop forward algorithm

Training and results

Solver-in-the-Loop was trained with LagrangeBench [42], with a custom RPF 2D dataset with 20-step temporal coarsening. For SitL, n_sitl=3. Both the corrector model and the reference GNS [36] are message-passing networks with 10 layers and 64 latent dimensions. The starting learning rate is set to 1e−31\mathrm{e}-3 for both, and noise_std is set to 1e−51\mathrm{e}-5 for SitL and to 1e−31\mathrm{e}-3 for GNS. Table 1 shows the LagrangeBench performance metrics on these models. Best models are picked based on the MSE20\mathrm{MSE}_{20} loss on the validation set.

MetricSolver onlyGNSSitL
MSE5\mathrm{MSE}_{5}1.7e−71.7\mathrm{e}-76.7e−96.7\mathrm{e}-93.3e−93.3\mathrm{e}-9
MSE20\mathrm{MSE}_{20}7.9e−67.9\mathrm{e}-61.9e−71.9\mathrm{e}-71.3e−71.3\mathrm{e}-7
MSEEkin\mathrm{MSE}_{E_{kin}}0.130.132.8e−42.8\mathrm{e}-47.4e−57.4\mathrm{e}-5
Sinkhorn3.4e−73.4\mathrm{e}-73.7e−83.7\mathrm{e}-89.3e−99.3\mathrm{e}-9

Table 1. LagrangeBench metrics on the RPF 2D dataset over 20 steps.

Thermal Diffusion Example

Simulation of channel flow with hot bottom wall at Steps 0, 1000, and 3000

Figure 10. Simulation of channel flow with hot bottom wall using standard SPH and thermal diffusion. The plots show the non-dimensional temperature at different time steps of an SPH simulation.

References

  1. [1]Martín Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Greg S. Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian Goodfellow, Andrew Harp, Geoffrey Irving, Michael Isard, Rafal Jozefowicz, Yangqing Jia, Lukasz Kaiser, Manjunath Kudlur, Josh Levenberg, Dan Mané, Mike Schuster, Rajat Monga, Sherry Moore, Derek Murray, Chris Olah, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda Viégas, Oriol Vinyals, Pete Warden, Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow, Large-scale machine learning on heterogeneous systems, November 2015.arxiv.org/abs/1603.04467
  2. [2]Stefan Adami, Xiangyu Hu, and Nikolaus A Adams. A generalized wall boundary condition for smoothed particle hydrodynamics. Journal of Computational Physics, 231(21):7057–7075, 2012.DOI
  3. [3]Stefan Adami, XY Hu, and Nikolaus A Adams. A transport-velocity formulation for smoothed particle hydrodynamics. Journal of Computational Physics, 241:292–307, 2013.DOI
  4. [4]Benedikt Alkin, Andreas Fürst, Simon Schmid, Lukas Gruber, Markus Holzleitner, and Johannes Brandstetter. Universal physics transformers. arXiv preprint arXiv:2402.12365, 2024.arxiv.org/abs/2402.12365
  5. [5]Kelsey Allen, Tatiana Lopez-Guevara, Kimberly L Stachenfeld, Alvaro Sanchez Gonzalez, Peter Battaglia, Jessica B Hamrick, and Tobias Pfaff. Inverse design for fluid-structure interactions using graph network simulators. Advances in Neural Information Processing Systems, 35:13759–13774, 2022.DOI
  6. [6]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.arxiv.org/abs/1806.01261
  7. [7]Deniz A Bezgin, Aaron B Buhendwa, and Nikolaus A Adams. Jax-fluids: A fully-differentiable high-order computational fluid dynamics solver for compressible two-phase flows. Computer Physics Communications, 282:108527, 2023.DOI
  8. [8]Marc E Brachet, Daniel I Meiron, Steven A Orszag, BG Nickel, Rudolf H Morf, and Uriel Frisch. Small-scale structure of the taylor–green vortex. Journal of Fluid Mechanics, 130:411–452, 1983.DOI
  9. [9]Marc E Brachet, D Meiron, S Orszag, B Nickel, R Morf, and Uriel Frisch. The taylor-green vortex and fully developed turbulence. Journal of Statistical Physics, 34(5):1049–1063, 1984.DOI
  10. [10]James Bradbury, Roy Frostig, Peter Hawkins, Matthew James Johnson, Chris Leary, Dougal Maclaurin, George Necula, Adam Paszke, Jake VanderPlas, Sky VanderWand, and Qiao Zhang. JAX: composable transformations of Python+NumPy programs, 2018. URL http://github.com/google/jax.
  11. [11]Steven L Brunton and J Nathan Kutz. Machine learning for partial differential equations (mar. arXiv preprint arXiv:2303.17078, 2023.arxiv.org/abs/2303.17078
  12. [12]Paul W Cleary. Modelling confined multi-material heat and mass flows using sph. Applied Mathematical Modelling, 22(12):981–993, 1998.DOI
  13. [13]Andrea Colagrossi and Maurizio Landrini. Numerical simulation of interfacial flows by smoothed particle hydrodynamics. Journal of computational physics, 191(2):448–475, 2003.DOI
  14. [14]Alejandro JC Crespo, José M Domínguez, Benedict D Rogers, Moncho Gómez-Gesteira, S Longshaw, RJFB Canelas, Renato Vacondio, Anxo Barreiro, and Orlando García-Feal. Dualsphysics: Open-source parallel cfd solver based on smoothed particle hydrodynamics (sph). Computer Physics Communications, 187:204–216, 2015.DOI
  15. [15]Dmitry A Fedosov, Bruce Caswell, and George Em Karniadakis. Reverse poiseuille flow: the numerical viscometer. In Aip conference proceedings, volume 1027, pp. 1432–1434. American Institute of Physics, 2008.DOI
  16. [16]UKNG Ghia, Kirti N Ghia, and CT Shin. High-re solutions for incompressible flow using the navier-stokes equations and a multigrid method. Journal of computational physics, 48(3):387–411, 1982.DOI
  17. [17]Andreas Griewank and Andrea Walther. Evaluating derivatives: principles and techniques of algorithmic differentiation. SIAM, 2008.
  18. [18]Philipp Holl, Nils Thuerey, and Vladlen Koltun. Learning to control pdes with differentiable physics. In International Conference on Learning Representations, 2020.
  19. [19]Ameya D Jagtap, Zhiping Mao, Nikolaus Adams, and George Em Karniadakis. Physics-informed neural networks for inverse problems in supersonic flows. Journal of Computational Physics, 466:111402, 2022.DOI
  20. [20]Matthias Karlbauer, Timothy Praditia, Sebastian Otte, Sergey Oladyshkin, Wolfgang Nowak, and Martin V Butz. Composing partial differential equations with physics-aware neural networks. In International Conference on Machine Learning, pp. 10773–10801. PMLR, 2022.arxiv.org/abs/2111.11798
  21. [21]Patrick Kidger. On neural differential equations. arXiv preprint arXiv:2202.02435, 2022.arxiv.org/abs/2202.02435
  22. [22]Dmitrii Kochkov, Jamie A Smith, Ayya Alieva, Qing Wang, Michael P Brenner, and Stephan Hoyer. Machine learning–accelerated computational fluid dynamics. Proceedings of the National Academy of Sciences, 118(21):e2101784118, 2021.DOI
  23. [23]Dan Koschier, Jan Bender, Barbara Solenthaler, Matthias Tescher, Michael Bronstein, Leonidas Guibas, Iasonas Kokkinos, Or Litany, Niloy Mitra, Federico Monti, et al. Smoothed particle hydrodynamics techniques for the physics based simulation of fluids and solids. Eurographics 2019-Tutorials, pp. 47–51, 2019.
  24. [24]Yann LeCun, Léon Bottou, Yoshua Bengio, and Patrick Haffner. Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11):2278–2324, 1998.
  25. [25]Zijie Li and Amir Barati Farimani. Graph neural network-accelerated lagrangian fluid simulation. Computers & Graphics, 103:201–211, 2022.DOI
  26. [26]Marten Lienen and Stephan Günnemann. Learning the dynamics of physical systems from sparse observations with finite element networks. In International Conference on Learning Representations (ICLR), 2022.arxiv.org/abs/2203.08852
  27. [27]Mimi Luo, Jiayu Qin, and Gang Mei. jusph: A julia-based open-source package of parallel smoothed particle hydrodynamics (sph) for dam break problems. SoftwareX, 19:101151, 2022.DOI
  28. [28]Yingbo Ma, Vaibhav Dixit, Michael J Innes, Xingjian Guo, and Chris Rackauckas. A comparison of automatic differentiation and continuous sensitivity analysis for derivatives of differential equation solutions. In 2021 IEEE High Performance Extreme Computing Conference (HPEC), pp. 1–9. IEEE, 2021.arxiv.org/abs/1812.01892
  29. [29]Joe J Monaghan. Simulating free surface flows with sph. Journal of computational physics, 110(2):399–406, 1994.DOI
  30. [30]Joe J Monaghan. Smoothed particle hydrodynamics. Reports on progress in physics, 68(8):1703, 2005.
  31. [31]Joseph P Morris, Patrick J Fox, and Yi Zhu. Modeling low reynolds number incompressible flows using sph. Journal of computational physics, 136(1):214–226, 1997.DOI
  32. [32]Siva Nadarajah and Antony Jameson. A comparison of the continuous and discrete adjoint approach to automatic aerodynamic optimization. In 38th Aerospace sciences meeting and exhibit, pp. 667, 2000.DOI
  33. [33]Adam Paszke, Sam Gross, Francisco Massa, Adam Lerer, James Bradbury, Gregory Chanan, Trevor Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, et al. Pytorch: An imperative style, high-performance deep learning library. Advances in neural information processing systems, 32, 2019.arxiv.org/abs/1912.01703
  34. [34]Daniel J Price. Smoothed particle hydrodynamics and magnetohydrodynamics. Journal of Computational Physics, 231(3):759–794, 2012.
  35. [35]Prabhu Ramachandran, Aditya Bhosale, Kunal Puri, Pawan Negi, Abhinav Muta, A Dinesh, Dileep Menon, Rahul Govind, Suraj Sanka, Amal S Sebastian, et al. Pyshp: a python-based framework for smoothed particle hydrodynamics. ACM Transactions on Mathematical Software (TOMS), 47 (4):1–38, 2021.DOI
  36. [36]Alvaro Sanchez-Gonzalez, Jonathan Godwin, Tobias Pfaff, Rex Ying, Jure Leskovec, and Peter Battaglia. Learning to simulate complex physics with graph networks. In International conference on machine learning, pp. 8459–8468. PMLR, 2020.
  37. [37]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.DOI
  38. [38]Connor Schenck and Dieter Fox. Spnets: Differentiable fluid dynamics for deep neural networks. In Conference on Robot Learning, pp. 317–335. PMLR, 2018.arxiv.org/abs/1806.06094
  39. [39]Samuel Schoenholz and Ekin Dogus Cubuk. Jax md: a framework for differentiable physics. Advances in Neural Information Processing Systems, 33:11428–11441, 2020.arxiv.org/abs/1912.04232
  40. [40]Nils Thuerey, Philipp Holl, Maximilian Mueller, Patrick Schnell, Felix Trost, and Kiwon Um. Physics-based deep learning. arXiv preprint arXiv:2109.05237, 2021.
  41. [41]Artur Toshev, Jonas A. Erbesdobler, Nikolaus A. Adams, and Johannes Brandstetter. Neural SPH: Improved neural modeling of lagrangian fluid dynamics. In Forty-first International Conference on Machine Learning, 2024a.arxiv.org/abs/2402.06275
  42. [42]Artur Toshev, Gianluca Galletti, Fabian Fritz, Stefan Adami, and Nikolaus Adams. Lagrangebench: A lagrangian fluid mechanics benchmarking suite. Advances in Neural Information Processing Systems, 36, 2024b.arxiv.org/abs/2309.16342
  43. [43]Artur P Toshev, Gianluca Galletti, Johannes Brandstetter, Stefan Adami, and Nikolaus A Adams. Learning lagrangian fluid mechanics with the (3)-equivariant graph neural networks. In International Conference on Geometric Science of Information, pp. 332–341. Springer, 2023a.arxiv.org/abs/2305.15603
  44. [44]Artur P Toshev, Ludger Paehler, Andrea Panizza, and Nikolaus A Adams. On the relationships between graph neural networks for the simulation of physical systems and classical numerical methods. arXiv preprint arXiv:2304.00146, 2023b.
  45. [45]Kiwon Um, Robert Brand, Yun Fei, Philipp Holl, and Nils Thuerey. Solver-in-the-Loop: Learning from Differentiable Physics to Interact with Iterative PDE-Solvers. Advances in Neural Information Processing Systems, 2020.
  46. [46]Holger Wendland. Piecewise polynomial, positive definite and compactly supported radial functions of minimal degree. Advances in computational Mathematics, 4:389–396, 1995.DOI
  47. [47]Qiuzu Yang, Fei Xu, Yang Yang, and Lu Wang. A multi-phase sph model based on riemann solvers for simulation of jet breakup. Engineering Analysis with Boundary Elements, 111:134–147, 2020. ISSN 0955-7997. doi: https://doi.org/10.1016/j.enganabound.2019.10.015.
  48. [48]Chi Zhang, Xiangyu Y Hu, and Nikolaus A Adams. A generalized transport-velocity formulation for smoothed particle hydrodynamics. Journal of Computational Physics, 337:216–232, 2017a.DOI
  49. [49]Chi Zhang, XY Hu, and Nikolaus A Adams. A weakly compressible sph method based on a low-dissipation riemann solver. Journal of Computational Physics, 335:605–620, 2017b.DOI
  50. [50]Chi Zhang, Massoud Rezavand, Yujie Zhu, Yongchuan Yu, Dong Wu, Wenbin Zhang, Jianhang Wang, and Xiangyu Hu. Sphinxsys: An open-source multi-physics and multi-resolution library based on smoothed particle hydrodynamics. Computer Physics Communications, 267:108066, 2021.DOI

Paper details

vlnc:W_y2v7fk8m
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Physics and Astronomy

Not recorded for this paper

View statement
Looking for related papers…
Contents