Lagrangian Fluid Simulation with Continuous Convolutions
Authors: Benjamin Ummenhofer
Lukas Prantl
Nils Thuerey
Vladlen Koltun
Venue:  (2020)
Keywords: particle-based physics
fluid mechanics
continuous convolutions
material estimation

Abstract: We present an approach to Lagrangian fluid simulation with a new type of convolutional network. Our networks process sets of moving particles, which describe fluids in space and time. Unlike previous approaches, we do not build an explicit graph structure to connect the particles but use spatial convolutions as the main differentiable operation that relates particles to their neighbors. To this end we present a simple, novel, and effective extension of N-D convolutions to the continuous domain. We show that our network architecture can simulate different materials, generalizes to arbitrary collision geometries, and can be used for inverse problems. In addition, we demonstrate that our continuous convolutions outperform prior formulations in terms of accuracy and speed.


Published as a conference paper at ICLR 2020
LAGRANGIAN FLUID SIMULATION WITH CONTINUOUS CONVOLUTIONS
Benjamin Ummenhofer Intel Labs
Lukas Prantl & Nils Thuerey Technical University of Munich
Vladlen Koltun Intel Labs
ABSTRACT
We present an approach to Lagrangian fluid simulation with new type of convo- lutional network. Our networks process sets of moving particles, which describe fluids in space and time. Unlike previous approaches, we do not build an ex- plicit graph structure to connect the particles but use spatial convolutions as the main differentiable operation that relates particles to their neighbors. To this end we present a simple, novel, and effective extension of N-D convolutions to the continuous domain. We show that network architecture ent materials, generalizes to arbitrary collision geometries, and can used for inverse problems. In addition, we demonstrate that our continuous convolutions outperform prior formulations in terms of accuracy and speed.
simulate differ-
INTRODUCTION
Understanding physics help reasoning about environment and interacting with it. Neural networks have emerged as a particularly promising approach to capture the complexity of natural phenomena from data (Ling al.) 2016) Tompson al., 2017 Morton et al., 2018). An impor- lant aspect of learning physics with neural networks is the choice of representation. Lagrangian representations based on particles are particularly popular and have supported recent results with rigid bodies, deformable solids, and fluids (Battaglia et al. [016 Mrowca et al.] 2018 Li et al.) 2019). Many of these approaches use graph structures to define interactions; the existence of an edge determines in binary fashion whether two particles interact.
However, wide range of physical processes such as fluid mechanies are described by continuous partial differential equations rather than discrete graph structures. The continuous, volumetric, and tightly coupled nature of these processes causes inherent difficulties for graph-based approaches, such large number of edge connections that must be established, tracked, and disengaged as the particles move. In this work, instead of using graphs as the underlying representation, we adopt a continuous viewpoint. We propose volutions on particles for learning fluid mechanics. We treat fluids as spatially continuous functions sampled at finite set of (continuously evolving) positions and process them with novel continuous convolution layer. This matches the continuous nature of the problem more closely and simplifies the definition of neural networks by abstracting the underlying particle representation.
convolutional networks (ConvNets) with continuous
We extend the grid- filter representation commonly used for discrete convolutions to the con- tinuous domain by simple linear interpolation. Linear interpolation of the filters allows efficient lookup of spatially varying filter values at arbitrary positions while retaining the compactness and efficiency of the grid representation. In addition, we use window function define the support of the filters and ball-to-cube mapping to support spherical receptive fields. We show that our convolutions, despite their simplicity, perform better than more sophisticated representations (Wang al. 2018 Schenck & Fox] 2018).
With the presented continuous convolution layer, we develop an efficient ConvNet architecture for learning fluid mechanics. The network processes sets of particles. We use dynamic particles to represent the fluid and static particles to describe the boundary of the scene. Modeling the scene boundary with particles makes it easy to apply network to new scenes and allows the network to learn collision handling in a unified framework. Our network generalizes to arbitrary obstacle configurations and can simulate range of material behavior. To demonstrate the usefulness of

---

Published as a conference paper at ICLR 2020
learned and hence differentiable fluid simulator, show that material properties can be estimated from observed simulation data. Experimental results indicate that the presented approach outperforms state-of- -fate-of-the-ar the-art graph-based framework (Li et al. 2019).
RELATED WORK
Fluids encompass range of materials that are important in everyday life and throughout science and engineering (Wilcox) 2006). A prominent set of methods, known as Smoothed Particle Hydro- dynamics (SPH), employs Lagrangian viewpoint to simulate these phenomena. SPH originated in particle-based models for astrophysics (Gingold & Monaghan 1977) and has become extremely popular for simulating complex flows in many fields of science (Monaghan, 1988). Among others, it has been highly successful for modeling interface flows (Colagrossi & Landrini (2003), complex multi-phase phenomena (Hu & Adams, 2006), and even magnetohydrodynamiis (Price) 2012).
SPH and its variants have been widely used to model complex real-world phenomena for visual effects. Following the earlier development of physics-based fluid simulation for special effects by Foster & Metaxas (1996), the introduction of SPH (Müller al. 22003) has led to large class of powerful algorithms (Solenthaler & Pajarola 2009 Bender & Koschier 2015). These applications
often involve complex geometries at large scales, and extensions such FleX (Macklin al. 2014) and pressure-ave aware rigid-body coupling (Gissler et al. 2018)) broaden the framework to encompass
many physical phenomena.
Lagrangian flows have also been considered in machine learning. The pioneering work of Ladicky et al. (2015) demonstrated that flow representations can be learned with regression forests. CNNs were used by [Tompson et al. (2017) to accelerate the expensive pressure correction step of grid- based solvers, while other works have focused on super-resolution (Xie et al., 2018), learning time evolution via the Koopman operator (Morton et al. 2018), and learning reduced representations (Wiewel al., 2019 Kim et al. 2019). Differentiable SPH solvers were proposed solve control tasks for robotic applications (Schenck & Fox 2018). Generic physics simulations for Lagrangian rigid and deformable bodies were considered a series of works that developed graph- repre- sentations (Battaglia et al. (016) (0066]/anchez-CCCC Sanchez-Gonzaleer et al. 2018). 8). Such graph-based representations were recently applied directly to fluid simulation (Mrowca et al. [2018] Li al.) 2019). We share with these recent works the goal of modeling Lagrangian fluids with differentiable neural networks, but take a different tack: rather than using graph-based representations, we work with point clouds and continuous convolutions over the spatial domain.
From a technical perspective, our approach is also related to existing works that apply convolutions on point clouds. A number of methods transferred the convolution concept point clouds in the context of semantic classification and segmentation of 3D objects (Hua et al. 2018 Atzmon et al., 2018 Hermosilla et al., 2018 Li al. 2018 Su et al.) 2018 Wu et al. 2019 Xu et al.) 2018 Lei et al. 2019). Particularly notable in our context is the work of WWan et al (2018). who used con- tinuous convolutions work of [Schenck & Fox (2018), who used convolutions to implement a differentiable version of position- based fluids (Macklin & Müller 2013). Both works define continuous convolution opera- tors that can support regression tasks and we compare to them directly in Section 6 Most closely related to our filter representation is the work of Fey et al. (2018). They use B-splines to define continuous filters and propose to use spherical coordinates to implement spherical receptive fields. Spherical coordinates are problematic due to singularities and require special treatment, which we avoid with ball-to-cube mapping. Furthermore, the output of the operator oey al. (2018) can be discontinuous. We show in our ablation study in Section that applying a window function to guarantee continuous output is advantageous for our task.
compute the scene flow between two point clouds, and the aforementioned
BASICS
Fluids have been studied for centuries, and the Navier-Stokes equations for incompressible fluids are well established (Batchelor 1967):
dv Øt
+v Vv ----'p++V+ S.L. V
(1)
2

---

Published as a conference paper at ICLR 2020
A common approach to solve these partial differential equations is to approximate the fluid with set of smooth particles (Monaghan 1988). Each particle corresponds to a continuous blob of matter and carries the local properties of the fluid, such velocity and density, which move with the flow. This is motivated by the fact that a function (xx) can be represented by an integral interpolation
A(x) = f A(x')o(1Ix xx xx2))x
where 8(x) denotes the Dirac delta function. This equation can be discretized
A(x)= ~ Σ (IA xx112,)),
(3)
where V; is the volume at the given point in space and
lim W([x 1, - =[[x x').
(4)
h-0
Here (1x, h) is smooth kernel convolution with radius h, usually in the form of Gaussian distribution, but more complex functions can also be used. In practice, the kernel is finite and yields localized neighborhoods of particles that interact via interactions weighted by the kernel of its derivatives. In this way, the continuous description for fluids from Equation can be discretized in Lagrangian fashion and solved numerically. Typically, internal forces are calculated based on the local pressure, viscosity, and surface tension, which give update for the position of each particle. Below, we adopt the position-base based fluids (PBF) method (Macklin & Müller, 2013) Macklin al.] 2014), which likewise is based on SPH, but reformulates the updates constraints on the positions.
4 CONTINUOUS CONVOLUTIONS
The discrete convolution operator as commonly used in ConvNets is defined as
(f g)(x)
Σ + +)g(T) TER
(5)
where if and are the input and the filter function, X is the position. T is the shift vector, and Ω is the set of shift vectors that defines the support of the filter function. On regular data such images, the positions x range over a regular grid and the shift vectors T are integer-valued, i.e. x, 7 E zd for some dimensionality d. Analogously in the continuous domain, this convolution is defined
/ f(x + +))(T)d)
g))g)(x)=
where and real-valued vectors, i.e. x, E Rdd
We now adapt this definition to unstructured point clouds. In this setting we have a finite number of points that sample the function f but do not lie grid. For point cloud with 1,.., N points with values fi at positions x,, we define the convolution at position x as
(S gx)) (x)
a(x;,x) Sa g(A(x; - -)). (xN(X.R)
Σ
(7)
(x,, R) is the of points within radius R around density normalization specific to the points x; and x as in /Hermosilla et (2018). In the simplest case, can be constant: 1. our case we want to ensure a smooth response of our convolution under varying particle neighborhoods, therefore we define a as a window function:
is scalar function that can be used for
a(x;, x) = {(6
xx x R
for |x;
x||2 < R
(8)
else.
similar function has been used by Müller et al. (2003) in the SPH framework. e another scalar function for normalization, which can be set in implementation as either
(x)
((x)=
Σ
a(x;, x).
(9)
(EN(X.R)
3

---

Published as a conference paper at ICLR 2020
00
A
R
Figure I: We use spherical filter shapes for our continuous convolutions but use regular grids to store the filter values. The left part the figure shows a spherical region with radius R and a point with relative coordinates with respect the center. We transform via mapping A to normalized coordinates in a regular grid. The thin dotted lines illustrate the distortion of the mapping. To look up the final filter value use trilinear interpolation in the regular grid.
We use (x) = 1, since changes in the density of particles are an important feature for simulating fluids.
For the filter function we simply use regular grid to store the filter values but use linear interpola- tion make g a continuous function. In addition, we use mapping (r) of unit ball unit cube to implement spherical filters shown in Figure]] [ We use the mapping described by Griepentrog al. (2008) and give the detailed function the appendix. The intermediate coordinate mapping A provides the flexibility implement different spatial shapes while keeping the advantages of regular grid for the storage and lookup of filter values.
Note that Equation Juses similar approximation in the SPH framework (Equation 3) Assuming that each point represents the same volume, V, is a constant factor in Equation which we drop in definition.
5 LEARNING FLUID MECHANICS WITH CONVOLUTIONAL NETWORKS
Our goal is to learn fluid mechanics from observing the motion of particles. The input to our ConvNet is set of particles with corresponding features. Since position itself is not feature but simply defines the particle's position in space, we must assign feature vector to each particle. The feature vector we use is constant scalar 1 accompanied by the velocity v and the viscosity v. A particle p at timestep n with its position and input feature vector is thus tuple (x.", [L. 2/]). Defining the velocity explicitly as an input feature allows us to compute intermediate velocities and positions as in Ladický et al. (2015) and to apply external forces and pass this information to the network. We compute the intermediate positions x with Heun's 's method as
and velocities vin beginning with timestep n
V = V
+
At agxt
(10)
At V +
x!-
(11)
The vector acx is an acceleration through which we can apply external forces to control the fluid or to simply apply gravity. The intermediate positions and velocities lack any interactions between particles or the scene, which we are going implement with a ConvNet. To enable the network
to handle collisions with the environment we define second set of static particles 8j. We sample particles on the boundaries of the scene with normals n, as the feature vectors, i.e. 8j = (x,, [n,]). Our network implements the function
AAx Axx] = Coo PR
(st....,, SMr)),
(12)
which uses convolutions to combine features from both particle sets. Ax is correction of the position which accounts for all particle interactions including the collision handling with the scene. Finally, we apply the correction to update positions and velocities for + 1 as
+ Ax;
(13)
(14)
A
Note that the updated position x depends on the output vector Ax, and allows to directly define our learning objective on the particle positions.
4

---

Published as a conference paper at ICLR 2020
n
CConv
32
11
CConv
CConv
V
32 96
64
64
3
FC
v
32
FC
FC
FC
Ax
V
Figure 2: Schematic of our network with depth of four. In the first depth level we compute convo- lutions at each dynamic particle location with the of static particles that defines the environment as well as the dynamic particle set. We also directly process the features of each particle via a fully-connected stream. In the following levels, we compute convolutions only on the dynamic particles. At each level we use addition to aggregate the features computed by convolutions and fully-connected layers. Between the second and third level we also include residual connection. The final level generates the position correction Ax. Operations annotated with a are followed by the ReLU activation function. All CConv and FC operations use an additive bias.
5.1 NETWORK ARCHITECTURE
We use simple convolutional architecture with effective depth of four. An overview of the network is shown in Figure Since we want to compute the correction for all dynamic particles in our scene, we compute convolutions for the intermediate positions defined in Equation [I Our network is sequence of continuous convolutions (CConv), which are defined by an input particle set, the positions which we want to evaluate the convolution, its filters G, and the radius R. For instance, to describe a convolution on the static particles at intermediate positions x we can write
(15) where f, are the computed output features for each position x," G is a 5D array storing all filters in the layout [width, height, depth, cha, chaui] In contrast to discrete convolutions a regular grid, the spatial filter dimensions here do not define the receptive field but the resolution of the filters. The receptive field depends only the radius R, which specifies the spatial extent. Throughout our network we use filters with spatial resolution of [4, 4, 4] and a radius of 4.5 times the particle radius.
ff...., fw] CConv((s }, [x] ..... [x]"....,, X
G, R),
For convolutions within the dynamic particles we exclude the particle at which we evaluate the convolution and instead process the particle's own features stream of fully-connected layers. After each depth level we then combine the result from the convolutions and the fully-connected layers by addition. This can interpreted as convolution with spatial resolution of 4x4x4 + 1. We found that this design improves accuracy and allows us to use smaller filters with even sizes (see Table 2)
5.2 TRAINING PROCEDURE
We train fluid simulation network in supervised fashion based particle trajectories produced by classic ("ground-truth") physics simulation. Our loss defined as follows:
N
cn+1
de
x n+l
27-1117 112
(16)
The ground-truth position at timestep n + 1 is denoted by X xXT+1 and the predicted position from the network is denoted by x11 x!" + Ax., where Ax; is provided by the network. &; is an individual weight for each point. We use d: = exp(- (x(""))) - particles with fewer neighbors. We choose = 40, which corresponds the average number of
which emphasizes the loss for
5

---

Published as a conference paper at ICLR 2020
Ours
DFSPH
Figure 3: Comparison to ground-truth -ruth physics simulation. Two fluid bodies collide. Top: simulation by our trained network. Bottom: simulation of the same scenario by DFSPH (Bender & Koschier 2013), a high-fidelity solver that was executed with small timesteps (down 0.00Ts). Despite using much larger timestep (0.02s), our convolutional network produces results of comparable visual fidelity. Note that our particles are falling slightly more slowly due to differences the integration of positions and the much larger timestep. See the supplementary video.
neighbors across our experiments. Particles with few neighbors are close to the surface or interact with the scene boundary. Both cases are important for fluid simulation because particles near the surface define the liquid-air interface, which is particularly salient, and particles near the scene boundary require collision handling. The parameter y 0.5 makes our loss function more sensitive to small particle motions, which is important for increasing the accuracy and visual fidelity for small fluid flows. During training predict particle positions for two future timesteps, namely and n + The combined loss L is
L= C=+++ L
(17)
We found that optimizing loss defined over two frames improves the overall quality of the simu- lation. (Optimization for three frames did not result in further improvements.) We optimize L over 50,000 iterations with Adam (Kingma Ba 2015) and a learning rate decay with multiple steps, starting with a learning rate of 0.001 and stopping with 1.56 10-5
5.3 DATASETS
We have trained our network on multiple datasets. For quantitative comparisons with prior work we trained our network the dam break data from Li et al. (2019). The scene simulates the behavior of a randomly placed fluid block in a static box. We generate 2000 scenes for training and 300 for testing. The data generated with FleX, which is a position-based simulator that targets real-time applications (Macklin et al. 2014).
We also trained network 2013), which prioritizes simulation fidelity over runtime. DFSPH can generate accurate fluid flows with very low volume compression: a desired property. We generate ground-truth data by randomly placing multiple bodies of fluid in 10 different box-like scenes and simulating them for 16 seconds each with an adaptive timestep of up to 1 kHz. The time resolution the generated data is 50 Hz. We show qualitative comparison of our method to the ground truth in Figure We generate 200 scenes for training and 20 scenes for the test additionally generate 200 scenes with fluids of varying viscosity. For estimating material properties, we generate test scenes that only differ in the viscosity parameter.
challenging data generated with DFSPH (Bender & Koschier
To train networks that can deal with multiple materials, we
EVALUATION
Baselines. We compare our method to DPI-Nets (Li et al. 2019), which were previously shown to significantly outperform prior formulations such as hierarchical relation networks (Mrowca et al.) 2018). Figure providess provides qualitative comparison. Quantitative results are reported in Table To analyze the accuracy of the forward step for each method, compute the average particle positions with respect to the ground truth. We use every 5th frame for initialization and compute the deviation from the ground truth for two subsequent frames, denoted n and
of the

---

Published as a conference paper at ICLR 2020
DPI-Nets
Ours
GT
Figure 4: Qualitative comparison with DPI-Nets on a test sequence from our dataset. Two fluid bodies collide inside container. DPI-Nets works well on data with little variance but has problems with more complex scenes and high particle velocities. The DPI-Nets simulation becomes unstable immediately after the fluid hits the box. The fluid behavior predicted by our network matches the ground truth more closely and remains stable for the whole sequence. The two networks have been trained on the same data. Test sequences are distinct from training sequences. See the supplementary video.
In addition, we report the average distance from the ground-truth particles to the closest particle in the prediction for the whole sequence, to measure long-ter term similarity. We compute the distance for frame 72 as
d"
min EX"
||
x"112
(18)
where X is the set of predicted particle positions for frame n, x; is the ground-truth position for particle i, and N is the number of particles.
We also compare our continuous convolution formulation to continuous convolution representations used in SPNets (Schenck & Fox| 2018). PCNN (Wang al., 2018), KPConv (Thomas al.) 2019), and SplineCNN (Fey et al.] 2018). To this end, we plug the respective convolution operators into our network architecture as shown in Figure 2 This facilitates controlled comparisons in which the overall architecture and simulation setup are fixed and only the convolution operators are varied. As shown in Table [ our method outperforms all baselines with respect to both accuracy and inference time.
We have trained and tested all methods on the dam break dataset from Li et al. 2019) as well as our data (generated with high-fidelity simulator (Bender & Koschier 2015)). To facilitate the training on our data for all methods, we generated simplified version with a constant number of particles (6,000) and single box environment (as shown in Figure 4 We train DPI-Nets for 5 epochs and all other networks for 50,000 iterations, which corresponds to 2.7 epochs for the dam break data and epochs for our data. Training takes about a day for our method with our convolutions on an NVIDIA RTX 2080Ti. Training with PCNN convolutions (Wang et al. (018)) takes about 2 days on 4 GPUs. Note that our reimplementation of PCNN convolutions uses Tensorflow's built-in functions, which consume lot of memory and necessitate multi- training. The DPI-Nets model trains in about one day. Training with SplineCNN Convs takes 3 4 days on a single GPU. We got the best results for this method with spherical kernel coordinates and closed splines. For KPConvs we used a Quadro RTX 6000 with GB of RAM due the higher memory requirements. Training took about day with 15 kernel points. For SPNets convolutions, than 29 days with 3x3 filters by extrapolating from timing of a smaller number of iterations. We thus only report inference time for this method. Note that the convolutions of SPNets were designed to implement the position-based fluids algorithm, while we use them here in a more general network architecture with much larger number of channels, which explains the very long runtime.
estimated a training time of more
Ablation study, We perform an ablation study to evaluate our decisions in the design of the continu- convolution operator and the network. We study the importance of the interpolation, the window

---

Published as a conference paper at ICLR 2020
Average pos enror (mm)
Average distance
Method
Frame inference time (ms)
closest point d' (mm)
DPI-Nets
12.73
25.38
22.07
202.56
DPI Dunlireak
SPNets Convs
1058.46
PCNN Convs
0.72
1.67
19.79
187.34
SplineCNN Convs
0.71
1.65
170.20 20
67.67
KPConv
2.49
7.05
unstable
47.96
Ours
0.62
1.49
16.98
12.01
deza (6K purtides)
DPI-Nets
26.19
51.77
unstable
305.55
SPNets Convs
784.35
PCNN Convs
0.67
1.87
32.51
319.17
SplineCNN Convs
0.68
1.93
unstable unstable
281.92
KPConv
1.65
4.54
57.89
Ours
0.56
1.51
29.50
16.47
Table I: Accuracy and runtime analysis. We compare the average error between the ground-truth particle positions and two predicted future frames on the test set. Additionally, we report the average distance from the ground truth to the prediction over the whole sequence. In this test mode some methods become unstable after few frames. In the last column report the average inference time per frame.
function, the loss design, and the architecture choice. The results are reported in Table 2 reports error measures (averaged over the test sequences) that were used in Table and also reports the errors for two predicted frames initialized with the frames at the end of each sequence to measure the errors for small flow velocities. Large errors for small velocities can yield perceptually salient artifacts: rather than being still, fluid particles jitter churn.
This table
Average error (mm)
Seq. end error (mm)
Average distance to
Method
T
+
n
+
n +
n n++ 2
closest point d" (mm)
Ours
0.67
1.87
0.25
0.74
30.63 32.39
Ours w/o interpolation
0.79
2.24
0.30
0.89
Ours w/o window
0.77
2.21
0.30
0.89
31.77
Ours w/ naive loss
0.69
1.86
0.27
0.77
30.35
Ours w/o FC
0.75
2.17
0.27
32.49
Table 2: Ablation study. We compare the average error between the ground-truth particle positions and two predicted future frames on the test set, evaluated over whole test sequences (left) and just on the final frames of each test sequence (middle; this focuses on frames with small motion). The rightmost column shows the average distance from the ground truth to the predicted point set over whole test sequences. Ours w/o interpolation uses nearest-neight neighbor instead of trilinear interpolation for the convolution filters. Ours w/o window uses axx, x) = in Equation 7 Ours w/ naive loss uses Fuclidean distance the loss, i.e. set 7 and uses only convolutions and includes the central particle in the convolution (rather than separately processing its features via an FC layer).
1 in Equation 16 Ours w/o FC
Generalization. Figure we show that our network generalizes well to scenes with drastically different geometry than seen during training. (The training set uses only box-like containers. See the appendix for visualization.) These scenarios demonstrate that we can emit particles during sim- ulation, which can be costly for methods that build and maintain explicit graph structures, We com- pare generalization performance quantitatively to DFPSH on a complex scene in Figure 6 Figure demonstrates generalization along different dimension. Here show that of the fluid test time to a value not seen during training. The fluid shape used in this example was also seen during training.
set the viscosity
8

---

Published as a conference paper at ICLR 2020
Figure 5: Generalization to environments with drastically different geometry than seen during train- ing. Top: we use an emitter to fill up virtual river with fluid particles, demonstrating generalization with respect scene geometry and the number of particles. Bottom: a waterfall scene showing the fluid particles and the particle representation of the environment. See the supplementary video.
100
Ours At = 20ms
DESPH 5ms
error d' (mm)
100
300
500
700
800
frame
50
100
200
400
800
Figure 6: Average distance from the ground-truth particles to the predicted particles complex scene. Top: error over time for our trained network and DFSPH. We use timestep of A ms for DFSPH and At 20 ms for our method, which also corresponds to the frame sampling rate. The ground truth was generated with DFSPH and a timestep of Ims. Bottom: simulation produced by network. Large errors concentrated in the beginning of the sequence when the fluid initially collides with the environment and the fluid behavior is most chaotic. During this phase the error is higher for our method than DFSPH. After 200 frames the error levels become similar.
0.04
0.27
Figure 7: We can control the viscosity of the simulated fluid at test time by changing the input parameter in the input feature vector.

---

Published as a conference paper at ICLR 2020
Material estimation. In this experiment we apply network inverse problem: material estimation from observation. We use our network to estimate the viscosity parameter of fluid from the particle movement. The training data for this experiment contains 200 sequences with random viscosity parameters between 0.01 and 0.3. For testing we generate 5 new sequences with 100 frames and random viscosity within the same range used during training and use initial fluid shape not present in the training data. To test generalization we generate two sequences with viscosity values outside the training range, namely 0.35 and 0.4. To estimate the viscosity we backpropagate through the trained network and optimize y with gradient descent. Table Breports the results, which indicate that our network can be used estimate material properties from observed data.
GT viscosity
0.044
0.127
0.174
0.233
0.269
0.350
0.400
Mean
Avg. estimated viscosity Avg. relative error (%)
0.027
0,150
0.202
0.255
0.277
0.322
0.336
38.377
18.542
15.604
9.568
3.235
7.954
16.016
15.614
Table 3: Application to an inverse problem: material estimation from observed fluid motion. To estimate the viscosity backpropagate through our network and optimize with gradient descent. For each scene, we run the procedure 10 times, each time with random initialization, and report the average. Viscosity values 0.350 and 0.400 are outside the range that was used during training and are used to test generalization.
CONCLUSION
We have developed continuous convolutional networks for Lagrangian fluid simulation. We have introduced a simple formulation for continuous convolutions and demonstrated its accuracy and speed. Our model captures wide range of complex material behavior, offers long-term stability, and generalizes to new situations such as varying particle counts, domain geometries, and material properties. There are numerous directions for future work, such as extending the framework to incorporate rigid and deformable solids. We will release the code to facilitate such development. Our continuous convolution implementation will be made available as part of Open3l (Zhou al., 2018).
Acknowledgements.
We thank Jan Bender for his support with the SPlisHSPlasH framework.
REFERENCES
Matan Atzmon, Haggai Maron, and Yaron Lipman. Point convolutional neural networks by exten- sion operators. ACM Trans. Graph., 37(4), 2018.
George K. Batchelor. An Introduction Fluid Dynamics. Cambridge University Press, 1967.
Peter W. Battaglia, Razvan Pascanu, Matthew Lai, Danilo Rezende, and Koray Kavukcuoglu. Inter- action networks for learning about objects, relations and physics. In Advances in Neural Infor- mation Processing Systems, 2016.
Jan Bender and Dan Koschier. Divergence-free smoothed particle hydrodynamics. In Symposium on Computer Animation, 2015.
Andrea Colagrossi and Maurizio Landrini. Numerical simulation of interfacial flows by smoothed particle hydrodynamics. Journal of Computational Physics, 121(2), 2003.
Matthias Fey, Jan Eric Lenssen, Frank Weichert, and Heinrich Müller. SplineCNN: Fast geometric
deep learning with continuous B-spline kernels. In CVPR, 2018.
Nick Foster and Dimitris N. Metaxas. Realistic animation of liquids. Graphical Models and Image Processing, 58(5), 1996.
Robert A Gingold and Joseph Monaghan. Smoothed particle hydrodynamics: Theory and appli- cation non-spherical stars. Monthly Notices of the Royal Astronomical Society, 18 181(3), 1977.
10

---

Published as a conference paper at ICLR 2020
Christoph Gissler, Andreas Peer, Stefan Band, Jan Bender, and Matthias Teschner. Interlinked SPH pressure solvers for strong fluid-rigid coupling. ACM Trans. Graph., 38(1), 2018.
Jens André Griepentrog, Wolfgang Höppner, Mans-Christoph Kaiser, and Joachim Rehberg. A bi- Lipschitz continuous, volume preserving map from the unit ball onto a cube. Note di Matematica, 28, 2008.
Pedro Hermosilla, Tobias Ritschel, Pere-Pau Vázquez, Alvar Vinacua, and Timo Ropinski. Monte Carlo convolution for learning on non-uniformly sampled point clouds. ACM Trans. Graph., 37 (6), 2018.
Xiang Yu Hu and Nikolaus A Adams. A multi-phase SPH method for macroscopic and mesoscopic flows. Journal of Computational Physics, 213(2), 2006.
Binh-Son Hua, Minh-Khoi Tran, and Sai-Kit Yeung. Pointwise convolutional neural networks. In CVPR, 2018.
Byungsoo Kim, Vinicius C. Azevedo, Nils Thuerey, Theodore Kim, Markus Gross, and Barbara Solenthaler. Deep fluids: A generative network for parameterized fluid simulations. Computer Graphics Forum, 38(2), 2019.
Diederik Kingma and Jimmy Ba. Adam: A method for stochastic optimization. In ICLR, 2015.
L'ubor Ladický, SoHyeon Jeong, Barbara Solenthaler, Mare Pollefeys, and Markus Gross. Data- driven fluid simulations using regression forests. ACM Trans. Graph., 34(6), 2015.
Huan Lei, Naveed Akhtar, and Ajmal Mian. Octree guided CNN with spherical kernels for 3D point clouds. In CVPR, 2019.
Yangyan Li, Rui Bu, Mingchao Sun, Wei Wu, Xinhan Di, and Baoquan Chen. PointCNN: Convo- lution on X- X-transformed points. In Advances in Neural Information Processing Systems, 2018.
Yunzhu Li, Jiajun Wu, Russ Tedrake, Joshua B. Tenenbaum, and Antonio Torralba. Learning particle dynamics for manipulating rigid bodies, deformable objects, and fluids. In ICLR, 2019.
Julia Ling, Andrew Kurzawski, and Jeremy Templeton. Reynolds averaged turbulence modelling using deep neural networks with embedded invariance. Journal of Fluid Mechanics, 807, 2016.
Miles Macklin and Matthias Müller. Position based fluids. ACM Trans. Graph., 32(4), 2013.
Miles Macklin, Matthias Müller, Nuttapong Chentanez, and Tae- Yong Kim. Unified particle physics for real-time applications. ACM Trans. Graph., 33(4), 2014.
J Monaghan. An introduction to SPH. Computer Physics Communications, 48(1), 1988.
Jeremy Morton, Antony Jameson, Mykel J Kochenderfer, and Freddie Witherden. Deep dynamical modeling and control unsteady fluid flows. In Advances in Neural Information Processing Systems, 2018.
Damian Mrowca, Chengxu Zhuang, Elias Wang, Nick Haber, Li F Fei-Fei, Josh Tenenbaum, and Daniel L Yamins. Flexible neural representation for physics prediction. In Advances in Neural Information Processing Systems, 2018.
Matthias Müller, David Charypar, and Markus Gross. Particle-based fluid simulation for interactive applications. In Symposium on Computer Animation, 2003.
Daniel Price. Smoothed particle hydrodynamics and magnetohydrodynamies. Journal of Compu- tational Physics, (3). 2012.
Alvaro Sanchez-Gonzale Nicolas Heess, Jost Tobias Springenberg, Josh Merel, Martin A. Ried- miller, Raia Hadsell, and Peter W. Battaglia. Graph networks as learnable physics engines for inference and control. In ICML, 2018
Connor Schenck and Dieter Fox. SPNets: Differentiable fluid dynamics for deep neural networks. In Conference Robot Learning, 2018.
11

---

Published as a conference paper at ICLR 2020
Barbara Solenthaler and Renato Pajarola. Predictive-corrrectvv incompressible SPH. ACM Trans. Graph., 28(3), 2009.
Hang Su, Varun Jampani, Deqing Sun, Subhransu Maji, Evangelos Kalogerakis, Ming- Minn-Hsuan Yang, and Jan Kautz. SPLATNet:: Sparse lattice networks for point cloud processing. In CVPR, 2018.
Matthias Teschner, Bruno Heidelberger, Matthias Müller, Danat Pomerantes, and Markus H. Gross. Optimized spatial hashing for collision detection of deformable objects. In Vision, Modeling, and Visualization (VMV), 2003.
Hugues Thomas, Charles R. Qi. -eaanmemn Deschaud, Beatriz Marcotegui, François Goulette, and Leonidas J. Guibas. KPConv: Flexible and deformable convolution for point clouds. In ICCV, 2019.
Jonathan Tompson, Kristofer Schlachter, Pablo Sprechmann, and Ken Perlin. Accelerating Eulerian fluid simulation with convolutional networks. In ICMI, 2017.
Shenlong Wang, Simon Suo, Wei-Chiu Ma, Andrei Pokrovsky, and Raquel Urtasun. Deep paramet- ric continuous convolutional neural networks. In CVPR, 2018.
Steffen Wiewel, Moritz Becher, and Nils Thuerey. Latent space physics: Towards learning the temporal evolution of fluid flow. Computer Graphics Forum, 38(2), 2019.
David C. Wilcox. Turbulence Modeling for CFD. DCW industries, 3rd edition, 2006.
Wenxuan Wu, Zhongang Qi, and Fuxin Li. PointConv: Deep convolutional networks 3D point clouds. In CVPR, 2019.
You Xie, Erik Franz, Mengyu Chu, and Nils Thuerey. tempoGAN: A temporally coherent, volumet- ric GAN for super-resolution fluid flow. ACM Trans. Graph., 37(4), 2018.
Yifan Xu, Tianqi Fan, Mingye Xu, Long Zeng, and Yu Qiao. SpiderCNN: Deep learning on point sets with parameterized convolutional filters. In ECCV, 2018.
Qian-Yr Yi Zhou, Jaesik Park, and Vladlen Koltun. Open3D: A modern library for 3D data processing. arXiv: 1801.08849777 2018
A APPENDIX
A.1 IMPLEMENTATION DETAILS
To accelerate the computation Equation use existing general matrix multiplication primitives. Similar to standard convolutions in deep learning frameworks we build matrix with patches that we then multiply with the filter matrix. We can account for the linear interpolation by applying the interpolation to the patch matrix instead of the filters. For 3D point clouds single point contributes to up to 8 voxels in patch.
Another crucial part of our implementation is the nearest neighbor search. Since the positions of the fluid particles update with each timestep, we have to rebuild the neighborhood information for every frame. We implement the neighborhood search with spatial hashing (we the hash function proposed in TTschhnrr et al.] (2003)). We explicitly store all particle neighbors a compact list, which allows to reuse the information for multiple convolutions operating on the same point sets. Table 4 compares the average frame runtimes of our method with the baselines.
A.2 DATASET GENERATION
To enable generalization new environments we use 10 different containers (see Figure Sb in our data generation process. During scene generation randomly sample environment and place up to 3 fluid bodies with different shapes and sizes (see Figure g and random initial velocities in the scene. We simulate each generated scene with DFSPH using the SPlisHSPlasH framework for
https://gi tttps::://itthb..omm. wwwpwhww..oom//eeatttttttcmectte hntp:/cteetaccccc www.eraactieeccmppterrrrraaaaaae http://hweeocoooooooooooooooooon cs /31 sss
12

---

Published as a conference paper at ICLR 2020
Method
Frame inference time (ms)
Frame NNS time (ms)
NNS Method
DPI-NetS
202.56
103.26
KD-Tree (SciPy)
DPI DunRreak
SPNets Convs
1058.46
5.24
Spatial hashing on GPU
PCNN Convs
187.34
2.42
*Spatial hashing on GPU
SplineCNN Convs
67.67
41.92
Brute-force on GPU KD- Tree (nanoflann)
KPConv
47.96
28.12
Ours
12.01
2.14
*Spatial hashing on GPU
Our Our (8% partole)
DPI-Nets
305.55
171.22
KD-Tree (SeiPy)
SPNets Convs
784.35
10.19
Spatial hashing on GPU *Spatial hashing on GPU Brute-force on GPU KD-Tree (nanoflann) *Spatial hashing GPU
PCNN Convs
319.17
2.78
SplineCNN Convs
281.92
245.52
KPConv
57.89
34.07
Ours
16.47
2.38
Table 4: Runtime analysis. We compare the average frame inference time and the time used for the nearest neighbor search (NNS). Our convolution achieves the shortest inference times in comparison even if NNS times would be excluded. Irrespective of that, the methods used for finding neighbors can have a significant contribution the total runtime. Since fluid particles are moving, acceleration structures for the neighbor search have to be rebuilt each frame. This affects the KD- Tree methods as well as the methods using spatial hashing. Note that we use the same NNS for PCNN and Ours (denoted with *). For all methods except for SPNets the inference time is shorter on the smaller DPI DamBreak data (3456 particles compared to the 6000 particles our data). We attribute this to higher number of neighbors compared to the average 40 neighbors on our datasets. All runtimes were measured on a system with Intel Core 19-7960 and an NVIDIA RTX 2080Ti.
the DPI DamBreak, which is about 49 on average
16 seconds ensure that each scene contains frames with small particle velocities. To create the particle representation of the box-like containers, we do Poisson-Diss Disc sampling on the mesh surface with the tools provided by DFPSH and add surface normals each particle.
Figure 8: We sample from 10 different box-like containers during data generation. For the simplified version of our dataset used in the quantitative comparison with the baselines we only use the first container (leftmost container in the first row).
13

---

Published as a conference paper at ICLR 2020
Figure 9: We randomly place fluid bodies of different initial shapes in the scene during data gener- ation. We sample from different shapes and vary the size, the orientation and the initial particle velocity. All particles from the same fluid body start with the same initial velocity. The image shows the particles generated from each shape for specific size and orientation.
Average error (mm)
Seq. end error (mm)
Average distance to
Method
TL +++
+
n #++
+ 2
closest point d' (mm)
0.67
1.87
0.25
0.74
30.63
Ours triangular window
0.69
1.94
0.27
0.79
30.28
Ours w/o window
0.77
2.21
0.30
0.89
31.77
Table 5: Comparison of different window functions. Ours uses a window function similar to the poly6 kernel used in Müller et al.] (2003). Ours triangudar window uses triangular window function. Ours w/o window does not use a window function. This case can also be interpreted as rectangular window since we only consider points within a radius R.
A.3 TRAINING DETAILS
We use the Tensorflow framework for implementing the training procedure. We use Adam as op- timizer and train with batch size of 16 and an initial learning rate of 0.001. We half the learning rate at steps 20000, 25000, .... 45000. For the convolutions we use the random uniform initializer with range [-0.05, 0.05]. All other weights are initialized with the respective default initializers of Tensorflow version 1.12. The output of the network is scaled with T28 to roughly adjust the output range to the ground truth position correction of the training data.
The unit of length of the training data is meter. The particle radius used in DFSPH is h = 0.025 m. For our convolutions, we use spherical filters with an empirically determined radius of R = 4.5h.
A.4 WINDOW FUNCTION
We compare 3 different choices for the window function from Equation in Table The results show that enforcing a continuous output with a window function yields better results. Further, using a window function similar kernels used in SPH codes gives better results than a simple triangular window. Learning the window function is therefore a possible direction to extend our framework to further improve the accuracy.
A.5 COORDINATE MAPPING FUNCTION
We use the ball cube mapping described in (Griepentrog et al.) 2008 to map a position within spherical region to the filter values stored in a regular grid. We give here the functions used for the 3-D case used in implementation. For more details see (Griepentrog al. 2008).
14

---

Published as a conference paper at ICLR 2020
The function A is composition of the functions Aball-cyl and Acyl-cabe- which map sphere to cylinder and a cylinder to a cube respectively. We define Aball-eyt for vectors r = (xr, y: 2) as
(0, 0, 0)
if ||||| 0
|
l|rlla
22)
if 2 x² y?
(ball-
9
(19)
2V
||
3 22
VV || sign(>)]|=ll))
3|
else.
The cylinder to cube mapping is defined as
2)) (x) (I v)l,, # sign(>))l(,, 2)1l2 arctan n. 2) Acyl-rcube (rouubberr))))
if 0,
if lll |z||
(20)
# sign(y) (z, y)ll2 arctan ..x sigm(y)]l(z, y)12, 2 else.
We assume that vectors are normalized with the search radius R such that ||r||2 I This yields the following A, which maps from unit ball to the normalized coordinates of cube:
1 1/2 Aoy (Aball (r)) + (0.5, 0.5, 0.5).
Arr)
(21)
2
15


Reviews:
[{"review_id": "rkx3iqf0KH", "reviewer": "AnonReviewer4", "summary": "", "questions": "", "limitations": "", "rating": 6, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "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": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "This paper applies 3D convolutions to the problem of Lagrangian fluid simulation. The primary difficulty in this is that, unlike for Eulerian fluid simulation, which represents the fluid as a grid and adapts nicely to 3D convolutions, in Lagrangian simulations the fluid is represented as an unordered set of particles. It is not straight-forward to apply 3D convolutions on such a data structure, however this paper proposes a method to apply the same regular-grid kernels used in grid-based convolutions to the particle structure. To do this, several points around the kernel are evaluated by first using trilinear interpolation between the particles to get feature values at those points and then convolving those values with the kernel weights. This results in a new particle in the next layer up with those features. In the paper, this method is used to train the weights of the network to reproduce fluid dynamics generated by a simulator. The results show that the proposed method was able to model fluid dynamics over 2 timesteps more accurately than other methods and can do so quickly. \n\nWhile I have some reservations about this paper (detailed below), on the whole I think it is a quality contribution and should be accepted. This paper contributes a novel method for performing 3D convolutions on unordered particle sets, and it shows that the learned fluid dynamics generalize to novel situations. One major hurdle to applying modern convolutional learning techniques to Lagrangian methods is the mismatch between the layout of the data (unordered particles) and the layout of the kernels (regular grid). This paper presents a novel way of bridging that divide, and it shows that the proposed method actually works by applying it to the problem of fluid dynamics and successfully learning it. However, one major concern I had was that it seems all of the training data was generated in box-like environments, which could easily lead to overfitting. This was alleviated by the results showing that although the network was trained only in boxes, it generalized to environments with channels and waterfalls (as seen in the video). This is a powerful result and shows that this method really did learn fluid dynamics and not just a shortcut that only works in boxes.\n\nI do think this paper can be improved in a few aspects however. The biggest issue is that the quantitative analysis of the core functionality (reproducing fluid physics) is lacking. The paper only reports results for error after at most 2 timesteps, which is not nearly long enough to determine if the output is accurate. Furthermore, the results are only reported for the box scenes, not the generalization scenes mentioned above. Qualitatively, from the videos, it is clear that the output does at least somewhat model fluid dynamics, but it would be much better to have hard numbers to back that up. I suspect the authors discovered that Lagrangian systems are sufficiently chaotic that after only a few timesteps the particle positions have diverged significantly. This is not a bug but a feature of such systems. In Lagrangian fluids, the particles are but an approximation of the fluid, and unlike Eulerian systems*, multiple different sets of particles can approximate the same fluid. This makes particle position only useful as a measure of error if the trained model can perfectly reproduce the fluid dynamics. But of course it can't (trained networks aren't ever perfect in practice), and so small errors quickly compound into large particle position disparities. So even though the trained network models the fluid well overall, the particles end up in completely different locations. Instead a better error metric would be something like measuring the difference between the surface of the fluids, or the velocities or densities at various locations. These are agnostic to the particular particle positions, but still measure how well two different sets of particles represent the same fluid. Using a metric like this, it would be nice to see error graphs over time for both the box and generalization scenes.\n\nA couple other smaller points. The chaotic divergence behavior of DPI-Nets seems inconsistent with that paper. Is this possibly a bug in the way it was implemented here? Additionally, the paper states that the convolutions of SPNets were \"specifically designed to implement the position-based fluids algorithm\" but that it was used in the paper with a much larger number of channels. If it was designed only to work for that one algorithm, how were the number of channels increased? That is unclear. Also, the average error for SPNets is not shown in Table 1 and it is not stated why.\n\n*Assuming same grid shape, size, and position.", "extra_scores": {"experience_assessment": "I have published in this field for several years.", "review_assessment:_thoroughness_in_paper_reading": "I read the paper thoroughly.", "review_assessment:_checking_correctness_of_experiments": "I carefully checked the experiments.", "review_assessment:_checking_correctness_of_derivations_and_theory": "I assessed the sensibility of the derivations and theory."}, "extra_text": {}}, {"review_id": "SygIGXDRtB", "reviewer": "AnonReviewer3", "summary": "", "questions": "", "limitations": "", "rating": 8, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "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": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "[Summary]\n\nThis paper proposes to learn fluid dynamics by combining the position-based fluids (PBF) framework and continuous convolution. They use dynamics particles to represent the fluids, and static particles to describe the scene boundaries, and employ continuous convolution to learn the interactions between the particles of different kinds. They have demonstrated the effectiveness of the proposed method by comparing it with several state-of-the-art learning-based and physics-based fluid simulators. Their method outperforms the baselines in terms of both accuracy and efficiency. They have also shown that the model can extrapolate to terrains that are more complex than those used in training, and are useful in estimating physical properties like the viscosity of the fluids.\n\n\n[Major comments]\n\nFor now, I slightly lean towards acceptance, as I like the idea of combining PBF and continuous convolution for fluid simulation, and the method seems to have a much better performance than the baselines. The experiments have also convincingly demonstrated the method's generalization ability to terrains of various geometry and fluids of different viscosity. However, I would still like the authors to address my following questions.\n\nMy primary concern about the proposed method is the scope of its applicability. One of the benefits of using learning-based physics engines is that they directly learn from observations while making very few assumptions towards the underlying dynamics, which gives them the potential to handle complex real-world scenarios. The model in this paper, however, heavily relies on the PBF framework that may limit its ability to simulate objects like rigid bodies and other deformable materials. I would be curious to know the authors' views on how to extend their model to environments with not just fluids, but also other objects of various material properties.\n\n\n[More detailed questions]\n\nWill the method run faster than DFSPH, given that the timestep is much larger than the timestep used by DFSPH, 0.02 ms vs. 0.001 ms? Will the learning-based physics engine have the potential to outperform the physics-based physics engine in terms of efficiency?\n\nFor estimating the viscosity of the fluids, how well does the gradient descent on the learned model perform comparing with black-box optimization, e.g., Bayesian Optimization using the ground truth simulator?\n\nIn the SPNet paper, they have also tried to solve the inverse problem of estimating the viscosity of the fluids. It would be great to include a comparison to see if the proposed method can outperform SPNet in terms of efficiency and accuracy.\n\nEquation 8 smooth out the effect between particles of different distances. How sensitive is the final performance of the model to the specific smoothing formulation? Is it possible to learn a reweighting function instead of hardcoding?\n\nIn figure 3, the model's rollout is a bit slower than the ground truth. The authors explained the phenomenon using the \"differences in the integration of positions and the much larger timestep.\" I do not quite get the point. Could you elaborate more on this? Also, it might be better to include labels for the two columns in figure 3 to make it more clear.\n\nIn the experiment section, the authors claimed that SPNets take \"more than 29 days\" to train. Correct me if I am wrong, but from my understanding, SPNets directly write Position-Based Fluids (PBF) in a differentiable way, where they can extract gradients. Except for the tunable parameters like viscosity, cohesion, etc., I'm not sure if there are any learnable parameters in their model. Could the authors elaborate on what they mean by \"the training time\" of SPNets?\n\nFrom the videos, DPI-Nets does not seem to have a good enough performance in the selected environments. I can see why their model performs not as good since they did not use as much of a structure in the model. But from the videos of DPI-Nets, it seems that they perform reasonably well in scenes like dam break or shake a box of fluids. Would you please provide more details on why they are not as good in the scenes in this paper?\n\nThe data was generated using viscosity varying between 0.01 and 0.3. How well can the model do extrapolate generalization? It would be great to show some error plots indicating its extrapolate performance.\n\nWhy there are no average error numbers for SPNets?\n", "extra_scores": {"experience_assessment": "I have published one or two papers in this area.", "review_assessment:_checking_correctness_of_experiments": "I carefully checked the experiments.", "review_assessment:_thoroughness_in_paper_reading": "I read the paper thoroughly.", "review_assessment:_checking_correctness_of_derivations_and_theory": "I assessed the sensibility of the derivations and theory."}, "extra_text": {}}, {"review_id": "H1li4T0GcS", "reviewer": "AnonReviewer1", "summary": "", "questions": "", "limitations": "", "rating": 6, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "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": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "This paper proposes a novel technique to perform fluid simulations. Specifically, they promote the idea of using spatial convolutions to model how particles interact with nearby particles. Compared to graph-based models, this approach has several advantages and yields a model that can be conveniently trained end-to-end. The authors also develop a specific type of continuous convolution that yield better and faster inference than the benchmark algorithms. \n\nTo main contribution in this paper is the idea of using spatial convolutions to model particle interactions. Even though the obtained results contain significant errors compared to ground truth, the paper indicates a promising strategy others may leverage on to develop even more accurate deep learning based simulators. Considering that they have also plausibly argued that their specific algorithm is already state of the art, I view this as a significant contribution. Having said this, the contribution is really to use a well-known technique (spatial convolutions) on a new problem (fluid simulations). My understanding is that ICLR primarily wants to promote general learning techniques and I am not convinced that this paper contains any significant contributions in this field. \n\nThe authors also develop a specific network architecture that they compare with other deep learning architectures for continuous convolutions. Unfortunately, the design contains a number of questionable choices and I suspect that the main reason that existing architectures for deep learning using continuous convolutions perform worse is that their hyper-parameters have been fine-tuned for a different task. As an example of a questionable choice, why do you “exclude the particle at which we evaluate the convolution” in your convolutions? \n\nMinor remarks: \n* You include a constant 1 in the input feature vectors. Assuming that the neurons in your network have weights and biases, this constant is completely redundant. Of course, this also means that you can include it without ruining your performance, but why would you?\n* I found the explanation of Lambda in Figure 1 too short to be understandable. \n* In (7), you seem to be using convolutions between functions that have not been pre-mirrored, and it would be better to then express (5) and (6) on the same form. ", "extra_scores": {"experience_assessment": "I have read many papers in this area.", "review_assessment:_thoroughness_in_paper_reading": "I read the paper at least twice and used my best judgement in assessing the paper.", "review_assessment:_checking_correctness_of_experiments": "I did not assess the experiments.", "review_assessment:_checking_correctness_of_derivations_and_theory": "I assessed the sensibility of the derivations and theory."}, "extra_text": {}}]

Author rebuttal:

Meta-review: The paper proposes an approach for N-D continuous convolution on unordered particle set and applies it to Lagrangian fluid simulation. All reviewers found the paper to be a novel and useful contribution towards the problem of N-D continuous convolution on unordered particles. I recommend acceptance.  
Decision: Accept (Poster)