Accurately Solving Rod Dynamics with Graph Learning
Authors: Han Shao
Tassilo Kugelstadt
Torsten Hädrich
Wojtek Palubicki
Jan Bender
Soren Pirk
Dominik Michels
Venue: NeurIPS 2021 Poster (2021)
Keywords: Dynamical Systems
Representation Learning

Abstract: Iterative solvers are widely used to accurately simulate physical systems. These solvers require initial guesses to generate a sequence of improving approximate solutions. In this contribution, we introduce a novel method to accelerate iterative solvers for rod dynamics with graph networks (GNs) by predicting the initial guesses to reduce the number of iterations. Unlike existing methods that aim to learn physical systems in an end-to-end manner, our approach guarantees long-term stability and therefore leads to more accurate solutions. Furthermore, our method improves the run time performance of traditional iterative solvers for rod dynamics. To explore our method we make use of position-based dynamics (PBD) as a common solver for physical systems and evaluate it by simulating the dynamics of elastic rods. Our approach is able to generalize across different initial conditions, discretizations, and realistic material properties. We demonstrate that it also performs well when taking discontinuous effects into account such as collisions between individual rods. Finally, to illustrate the scalability of our approach, we simulate complex 3D tree models composed of over a thousand individual branch segments swaying in wind fields.

Accurately Solving Rod Dynamics with Graph Learning
Han Shao
Tassilo Kugelstadt
KAUST
RWTH Aachen University kugelstadt@cs rwt.ss.thhaaaaee aachhaaahhen.co de
han. shao@kaust edu,
Torsten Hädrich
Wojeiech Palubicki AMU
Jan Bender
KAUST
RWTH Aachen University
torsten. www.ichkkiiitttttccmmm edu.
wp06@amu. edu, pl
Sender@cs..wthhaaccee rwth-aachen, de
Sören Pirk Google Research pirk@google. com
Dominik L. Michels
KAUST
edu. sa
Abstract
Iterative solvers are widely used accurately simulate physical systems. These solvers require initial guesses to generate a sequence of improving approximate solutions. this contribution, we introduce a novel method to accelerate itera- tive solvers for rod dynamics with graph networks (GNs) by predicting the initial guesses to reduce the number of iterations. Unlike existing methods that aim to learn physical systems in end-to-end manner, our approach guarantees long- term stability and therefore leads to more accurate solutions. Furthermore, our method improves the time performance of traditional iterative solvers for rod dynamics. To explore our method we make use of position-bas based dynamics (PBD) common solver for physical systems and evaluate by simulating the dynam- ics of elastic rods. Our approach is able to generalize across different initial condi- tions, discretizations, and realistic material properties. We demonstrate that it also performs well when taking discontinuous effects into account such as collisions between individual rods. Finally, illustrate the scalability of approach, we simulate complex 3D tree models composed of over thousand individual branch segments swaying in wind fields.
Introduction
The numeric simulation of a dynamic system commonly comprises the derivation of the mathemati- cal model given by the underlying differential equations and their integration forward time. context of physics-based systems, the mathematical model is usually based first principles and depending on the properties the simulated system, the numerical integration of complex sys- tem be very resource demanding (Nealen al. 2006), e.g., hindering interactive applications. Enabled by the success deep neural networks to serve as effective function approximators, re- searchers recently started investigating the applicability of neural networks for simulating dynamic systems. While many physical phenomena can well be described within fixed spatial domains (e.g.. in fluid dynamics) that be learned with convolutional neural network (CNN) architectures (Chu & Thuerey] 2017, Guo el al. 2016 Tompson et al., 2016 Xiao et al. (020). a large range of physical systems more naturally represented graphs. Examples include systems based on connected particles (Müller et al. 2007), coupled oscillators (Michels & Desbrun 2015 Michels et al.
2014
35th Conference on Neural Information Processing Systems (NcurIPS 2021).

---

Figure 1:
Renderings taken from real-time simulations of the elastic deformation of a helix falling down on the ground plane (left) and two rods colliding with each other (right).
or finite elements (Naalen et al. 2006). Existing methods enable learning these systems often in an end-to-end manner and with focus on replacing the entire part of the integration procedure. A. number of methods show initial success in approximating physical systems; however, they often fail reliably simulate the state of system over longer time horizons if significant disadvantages not accepted, such as the use of large datasets containing long-term simulations and the employment of specific memory structures (Sanchez-Gonzalez al. 2020
In this paper, we aim to improve the performance of iterative solvers for physical systems with graph networks (GN). An iterative solver requires an initial guess, and based it generates sequence of improving approximate solutions. The initial guess can be computed by simply using values obtained in the previous iteration or by solving few steps of similar but simpler physical system. The performance of an iterative solver significantly influenced by the calculation of the initial guess, which we aim to replace with the prediction of GN. To demonstrate use positionnbaat of connected vertices (Bender et al. 2017 2014b [Mckllin et al. 2016 Müller al. 2007). To simulate a physical system, PBD first computes updated locations of vertices using symplectic Euler integration then correct the initial position estimates so satisfy
approach, dynamics (PBD) solver that approximates physical phenomena by using sets
of predefined constraints. The correction step is known as construini projection and is commonly solved iteratively, The explicit forward integration for predicting the system's updated state has negligible cost, whereas the projection step is computationally expensive. Our goal is to employ a GN to predict the outcome of the constraint projection step as an initial guess. This way, our approach inherits the long-term stability of a classic PBD solver, while providing better run-time performance.
To showcase the capabilities of our combined PBD solver, aim to simulate the physically plau- sible mechanics elastic rods. Rods play an important role for a variety of application domains, ranging from surgical simulation of sutures (Feess et al. 2016). catheters, and tendons (Pai 2002). to human hair (Michels et al. (013)) and vegetation (Pirk et al. 2017) in animated movies. Furthermore, approaches exist realistically simulate rods sets of connected vertices accurately capturing their mechanical properties (Bergou et al. 2008 Kugelstadt & Schoemer, 2016 Michels et al. 2013 Pai 2002). Our approach is able generalize across different initial conditions, rod discretizations, and realistic material parameters such as Young's 's modulus and torsional modulus (Deul et al. 2018)) Moreover, we demonstrate that our approach can handle discontinuous collisions between individ- ual rods. Figure shows examples of elastic rod deformations of helix falling down (left) and two colliding rods (right). Finally, we show that the data-driven prediction of the initial guesses of the constraint projection leads to decreased number of required iterations, which in turn results in a significant increase performance compared to canonical initial guesses.
In summary, our contributions are: (1) we show how to accelerate iterative solvers with GNs; (2) we show that network-enabled solver ensures long-term stability required for simulating physical systems; (3) we showcase the effectiveness of our method by realistically simulating clastic rods; (4) we demonstrate accuracy and generalizability of our approach by simulating different scenarios and various mechanical properties of rods including collisions and complex topologies (dynamic tree simulations).
2 Related Work
In the following we provide an overview of the related work, which spans from data-driven physics simulations and graph learning to baseed dynamics and elastic rods.

---

Data-driven Physies Simulations. It has been recognized that neural networks can be used as effec- tive function approximators for physical and dynamic systems. To this end, early approaches focus
on emulating the dynamics of physies through learned controllers (Grzes7czuk et al. 1998) by de-
signing subspace integrators (Barbič & James 2005). Today, a range of approaches exist that enable
learning ordinary and partial differential equations (Lagaris et al. 1998 Raissi et al. 2019 Raissi
& Karniadakis 2018). for example, to transform them into optimization problems @Disaaayake
& Phan-TThenn 1994), to accelerate their computation (Mishra 2018 Sirinnnaoo & Spiliopoulos
2018), or to solve for advection and diffusion in complex geometries (Berg & Nyström 2018)
Other methods focus on specific data-driven solutions for non-linear elasticity (Ibañez et al. 2017
for approximating Maxwell's equation in photonic simulations (Trivedi et al., 2019), or for ani- mating cloth (Wang et al. 20IT). partially focusing on interactive applications (Holden al. 2019) More recently, research on data-driven approaches for modeling the intricacies of fluid dynamics has gained momentum (Ladicky al.) 2015 Ummenhoter et al. 2020p. Due to fixed-size spatial rep- resentation of Eulerian fluid solvers, a number of approaches rely on CNN-type architectures (Chhu & &Thuerey 2017 Guo al.) 2016 Tompson et al. 2016 Xiao et al.) 2020 Furthermore, it has been shown that data-driven approaches can even be used to approximate the temporal evolution of fluid flows (Wiewel et al. 2018), to compute liquid splashing (Um et al.) 2017), artistic style- transfer (Kim et al. 2020), or to derive fluid dynamics from reduced sets of parameters (Kim et al., 2019
Graph-based Learning. Graphs have proven to be a powerful representation for learning a wide range of tasks (Battaglia et al., 2018 (Scrselli et al., 2009) In particular, it has been shown that
graphs enable learning knowledge representations (Kipf et al., 2018). message passing (Gilmer encode long-range dependencies, e.g., as found in video processing (Wang et al. 2017p. A variety of methods uses graph-based representations to learn properties of dynamic physical systems, e.g. for climate prediction (Seo & Liu 2019). with an emphasis on individual objects (Chang et al., (2116) and their relations (Sanchez-Gonzale: et al. (018)), for partially ob- servable systems (Li et al., 2018b), the prevalent interactions within physical systems (Kipf et al.) 2018), bierarchically orgaaize particle systems (Mrowca et al. [0118), or - more generally -hyss ical simulation (Sanchez- Gonzalez et al. 2019 2020p. While many of the existing approaches learn the time integration of physical systems in an end-to-end manner, we use graph network to predict the outcome of PBD solver for rod dynamies enable more efficient computations.
et al. 2017).
Position-based Dynamics and Elastic Rods. PBD is a robust and efficient approach for simulating position changes of connected sets of vertices (Bender et al., 2017 2014b MMcklin et al. 2016 Müller et al. 2007). Compared to forced-based methods that compute the force directly, the inter- action between different vertices in PBD is realized by constraint projection step in an iterative manner. To avoid the dependency of the system's stiffness on the number of iterations and the time step size, an extended position- based dynamics approach was introduced (XPBD) (Macklin et al, 2016). A number of methods exist that model the dynamic properties of rods that can even simulate more complicated rod mechanics (Pail 2002). Moreover, particle systems were employed simulate the dynamics of rods (Michels et al.) 2017) and, in particular, for the physically accurate simulation of thin fibers (Michels et al. 2015) such as present human hair or textiles. On a different tra- jectory, it has been recognized that rods can be simulated based on PBD (Umetani et al.) 2014). The initial formulation was improved (Kugelstadt & Schoemer 2016) by including the orientation of rod segments in the system's ss state to account for torsion effects. Later, the XPBD framework was utilized (Deul et al.) 2018) to address the non-physical influence of iteration numbers and steps sizes, which enables the more accurate simulation of elastic rods.
3 Methodology
We propose a novel approach to simulate the temporal evolution of a dynamic system which consists of elastic rods. Each rod is discretized using several rod segments arranged along its centerline (Fig- ure 2 For each rod segment, its state is described by its position, orientation, velocity and angular velocity. The state of the system is given as the set of the individual states of all rod segments. The simulation carried out by employing PBD Muller et al., 2007) directly manipulating the sys- tem's state. Orientations are represented as quaternions allowing for convenient implementation of bending and twisting effects (Kugelstadi Schoemer, 2016). Extended PBD (XPBD) (Macklin) et al. 2016) is implemented to avoid that the rods' stiffnesses depends on the time step size and the
3

---

Pi
Pita
Pi
Ad-a
Ac-1
Discretized Rod
Forward Integration
Constraint Projection
Figure 2: Illustration of the discretization of single rod using several rod segments arranged along its centerline (left). Each rod segment described by its position and orientation within the gener- alized coordinates P;- The Lagrange multipliers X; represent the interaction between rod segments. The forward integration path is illustrated in red (middle) and constraint projection in green (right).
Ap, AA)
Output
A
rollConstaiinndPropectioon
p
Ap
(APP
1 -
secodar
GN
GN
Figure 3: Illustration our approach incorporating a network which consists of M graph networks (GN-blocks) into the position-based dynamics framework.
number iterations (Deul ct al. 2018
The generalized coordinates of rod segment at time i is given by Pi, E R x H. which includes its position X1, E R given in Cartesian coordinates and its orientation described by a quaternion 9r.e E H.. Correspondingly, Vi, E R refers to the generalized velocity of the rod segment, which includes velocity and angular velocity. The system continuously updated during the simulation by applying corrections Ap; = (Ax,, AØ,) E RR66 with position shifts Ax; E TR3 and orientation shifts AΦ; E R representing the integration of the angular velocity |
A single time integration step is presented in Algorithm [ In the beginning (lines 1 to 9. generalized velocity and generalized coordinates are updated by employing symplectic Euler integration step. In this regard, aed denotes the generalized acceleration due to the external net force, e.g., given by gravity. XPBD (Macklin et al., 2016) employs Lagrange multiplier which is initialized as zero (line 5 along with the integrated generalized coordinates p". Collision detection results are stored in Coll,r and Coll,.p (line 6). where Coll,,, includes all the pairs two rod segments that poten- tially collide with each other and Collep includes information of all rod segments that potentially collide with another object such as plane. Within several solver iterations, we alternate between rod constraint projection and the collision constraint projection (lines 7 to 15 The rod constraints include shear-stretch and bend-twist constraints representing the corresponding elastic energy. The Lagrange multiplier represents the interaction between rod segments. Figure 2 illustrates the dis- cretization for single rod into several interacting segments. The correction values Ap and AA in line 9 are computed by constraint projection (Deul et al., 2018 Kugelstadt & Schoemer 2016). The generalized coordinates and Lagrange multipliers are updated for each rod (lines 8 to 12] and rod- rod and rod-plane collisions are addressed update the generalized coordinates. For details about the collision projection procedure, we refer to Macklin et al. (014). For the non-collision case, the steps within line 6 and 13 are not needed.
The most expensive part of Algorithm involves the computation of the corrections generalized coordinates and Lagrange multipliers (line D. This projection step requires the solution of linear system which is a linearization
non-linear one so that the matrix depends on the system's 's state
Please note, that Aq. = G(.) E Rº in which the matrix G(g) E _2x3 describes the relationship between quaternion velocity and angular velocity (Bender al. 2014a

---

Algorithm Numerical integration procedure updating Pi. + Pi and Wi, H Vi.4+-r-
I: for all rod segments do
0r- Vi, + At aeu
3: p; + -P. + At H(qua) of with H(q..) = [1xx3, Osx3; 04x3, G(q.))
4: end for
5: A + 0, p-
6: (Coller; Coll,p) < ge p')
7: for j f- 0 to number of required solver iterations do
8:
for all rods do
9:
(Ap, AA] <- rod[Constrann/Prjecciooo/// x²)
10:
X+11 -
AA
11:
p++1 - p + Ap
12:
end for
13:
p updieeeClliioonncntttraaPeeiiiio Coller, Coll.p)
14:
j+
15:
end for
16: for all rod segments do
Par+ f p.
18: UL+++r - Ptt)/At
19: end for
making it impossible to precompute its inverse. Instead, a new system at every point in time is solved iteratively using the conjugated gradient (CG) solver. Such iterative solvers are widely used in the context of physical simulations and regularly described as the de facto standard (Barrett et al, 1994 Saad 2003) since they often show superior performance and usually scale well allowing for exploiting parallel hardware. However, we would like to point out that also highly efficient direct solvers be found in the literature (Deul al. 2018).
Instead of fully replacing the projection step in an and-to-end learning manner, we follow the strategy of accelerating it by first computing a guess
(Ap", A correctionGuess(p))
for the iterative procedure (line
(Ap, AA) < rodCCosttrinnPProccttoopp X Ap", AA*).
(2)
neural network is employed to compute the initial guess in Eq. for the constraint projection. The motivation for this approach is to reduce the number of iterations required for the convergence of the CG solver which solves the linear system in Eq. 2 compared to the canonical initialization with zeros. We obtain our final framework by replacing line 9 in Algorithm with Eq. ① and Eq. P as illustrated in Figure 3. which inherently as accurate as the traditional PBD method. We name the data-driven part COPINGNer ("COnstraint Projection INitial Guess Network") which learns to compute the correction guess.
3.1 Graph Encoding
COPINGNet graph network based architecture which we apply in order to compute initial guesses for Ap and AX. In this regard, we need to incorporate the rods' state into a graph de- scription (Battaglia et al. 2018 graph G E. usually consists of nodes (or vertices) V. edges E as well as global features U. However, in our framework, global features U are not used. For example, gravity could be a potentially meaningful global feature, but it also can be eas- ily included an external acceleration. Hence, U = 0 and the graph can just be represented as G GVV F). our case, the rods' segments within the scene are represented by the graph's 's nodes while the interactions between the rods' segments represented by the edges. COPINGNet provides a graph-to-grap
mapping: Gn - Cout from an input graph Gin E Gin to an output graph Gout E Gout, Nodes and edges of both graphs equipped with specific features. In the case of the input graph, the node features describe the state of the rods' segments, i.e.
Vin, (Xi, qb, Ts: Pi, l, as, for, f1, f2.)T Vin C CR4
5

---

in which the positions are denoted with x; E R', the orientations with q, E H. the radii with rs R>0 the densities with Ps R=00 and the segment lengths with E E R>0 Moreover,
segment position indicator a; [0, 1] C IR is included corresponding to a parameterization by are length P Binary segment flag fo. E 1), "left" end flag f1; E {0, 1} and "right" end flag f2. E {0. y are set to zero if the specific segment respectively the left or right segment of the rod is fixed and to one otherwise. The nodes of Gin are given as the set of Vnn = ( J. in which
|Vín denotes the number of segments in the scene. The nodes of Gout contain the correction values of the generalized coordinates, i.c.
Yout, Ap; your R and Vout = Ui=r
While rod segments represented as node features, represent constraints between rod segments as edge features:
Gin, = (wi, Yi, T.) E E C IRS,
in which the (rest) Darboux vector w E R3 describes the static angle of two rod segments, and Young's modulus Y E R>0 and torsion modulus T D>0 are corresponding to extension, bending, and twist constraint parameters. The set of edges of the input graph is then given by Fin _ (Cin,i), in which m = Fin denotes the number of interactions between different seg- ments. The correction of the Lagrange multiplier AA; E R is stored in the output edges:
@out, = AA; E IRuu C RR
The set of output edges is then given by Fout - (Couta)) The connectivity information C' of each graph is stored in two vectors Ctd and Ctv containing the sender node index and the receiver node index of each corresponding edge. This concludes the specification of the input graph Gin G(Vin; Ein) and the output graph Gout G(Vout, Eout) with connectivity information C = (Ced. Cru).
3.2 Network Structure
In the following, we describe the structure of COPINGNet after we formalized its input and output in the previous section. As illustrated in Figure the network consists of an encoder network, multiple stacks of GN-blocks, and decoder network. The graph network from Battaglia et al. (2018) is used as a basic element and denoted as GN-block. Residual connection between blocks could improve performance of neural networks in both CNN (He et al., 2013), and graph neural network (Li et al.
[- As in related work (Sanchez-Gonzalez et al. 2020); we employ the residual connection between the GN-blocks, but our cncoder/dccoder network directly deals with the graph. The encoder network performs a mapping: Gin - Glatent and is implemented using two multi-layer perceptrons (MLPs), MLPedge edge ''' - glatent C RR and MLP Vin + ylatent C R in which denotes the latent size. They work separately and thus Een = MLPedge ( (ii)) and Ven = MLP mode mode(Vin (Vin). Edge features En from the input constant for rod during the simulation and this results in constant encoded edge features Een, which could be recorded after the first run and used afterwards during inference. The edge feature ein, contains the material parameters which could vary by different orders of magnitude. Hence, we normalize Young's 's modulus and torsion modulus before feeding them into the network. After encoding, the graph Gen Feen) E Glatent is passed to several GN-blocks with residual connections. Each GN-block also contains two MIPs. However, they use message passing taking advantage of neighbourhood nodes/edges information (Bataglia al.) 2018). A number of M GN-blocks enable the use of neighbourhood information with distances smaller or equal M. The graph network performs mapping within the latent space: Glatent + Glatent and after M GN- we obtain G (V"'. E'.) E Glatent The decoder network performs mapping: Glatent
Gout, which has similar structure as the encoder network. Two MI.Ps [glatett + Igou and MLPnndde yllteet + your compute Eout MLP e and MLPadge :
Vout = MLP (LLPnde (V'))) A tanh-function at the end of MLPedge and MLP is used restricting the output to the interval [] C R. COPINGNet learns the relative correction values. The generated dataset is normalized, and the maximum correction value of the generalized coordinates and the Lagrange multipliers will be recorded norms. The final correction value is achieved by multiplying the relative correction values and the norms. This normalization process damps the
For a single rod in the scene which consists of N segments of equal lengths, for the i-th segment, we obtain as (i 1)/(N 1) for i E (1, nn).

---

Train/Val
#Steps 50
#Nodes N 1a 55)
Young's Modulus 10" Pa, a 24,004
Initial Angle do 21,02 45.0%)
Rod Length é 241.0 m. 5.0 m)
256/100
Train/Val
#Steps 50
#Nodes
Torsion Modulus T 10 Pa, r- (4.00.6.0) (400.4 0.6 m) (0.4 m. 0.6 m)
Helix Radius/ / Height
Winding Number ((200,3.0)
256/100
(45, 105)
Table 1: Specification of training and validation datasets for the two scenarios of an initially straight bending rod (top) and an elastic helix (bottom). The datasets comprised of number of data points (left) each describing the rod's dynamics within t E [O s, 50 discretized with a time step size of At 0.02 The number of nodes N is sampled from discrete uniform distribution Va while the remaining parameters are sampled from a continuous uniform distribution U. We trained network for 5 hours for the bending rod scenario and 6 hours for the helix case.
1.6
0.8
1.4
0.3
Spoctup
1.2
0.2
1.0
CG ratio speedup
0.1
0.8
not secadup
0.0
100
120
140
100
125
150
Number of Nodes
Number of Nodes
Figure 4: Illustration of the ratio of COPINGNet's inference time tinfer and the vanilla CG solver's run time tcg (purple curves; right vertical axis) for the initially straight bending rod (left) and the clastic helix (right) simulations. The black curves show the CG iteration number ratio while the red curves show the total speedup of the constraint projection when taking into account COPINGNet's inference time (left vertical axis). The pink curves show the total speedup of the entire simulations. The orange and green dashed line indicate the lower and upper boundaries of the total number of nodes used the training data, We can observe a speedup even for rods and helices with greater node number than the ones used in the the training dataset. The result is averaged from 50 simulations each running 100 steps.
noise caused by the network and leads to a more stable performance. For simplicity, all the MLPs in different blocks have the same number of layers, and the same width as latent size within the latent layers. The input and output sizes of each MLP are consistent with the corresponding node/edge feature dimensions. The loss L is computed from both parts, nodes and edges,
L = MSE(Vaut: Vouc) + MSE(EEutt Eaut)
in which (Vout: Eout) is the output graph's ground truth contrast to COPINGNet's prediction (Vout, Foot). The mean squared error between and & is denoted with MSE(X, 8)
For evaluation purposes, also incorporated the k--earest neighbor (k-NN) algorithm as described in the supplementary material setting & = 3.
Evaluation
We generate training and validation datasets based on two scenarios: an initially straight bending rod and an elastic helix each fixed at one end oscillating under the influence of gravity. The specification of these datasets is provided in Table ! The PBD code is written in C++, while the COPINGNet is implemented in Py PoTch.. The training is performed on an NVIDIA @ Tesla V100 GPU. The training time varies from 4 to 30 hours for different architecture parameters. A constant learning rate of y 0.001 was used and a mean square loss function was employed. Our approach gen- eralizes across different initial conditions, geometries, discretizations, and material parameters. In the supplementary material we show that it is possible to robustly generate various dynamical re- sults (Figure 9). For discussion on the network architecture please see Figure 11 (supplementary material).
7

---

Realistic biomechanical simulation of 3D tree model composed of over 1 nodes swaying in wind field. Our GN approach performs correctly even under large number of rod segments while increasing performance of the original PBD method.
Figure 5:
2.5
2.5
2.0
CG Iteration
1.5
200
400
800
1000
200
400
800
1000
Time Frame Number
Time Frome Number
Figure 6: The dashed horizontal lines show the benchmark CG solver's constant performance for an initially straight bending rod simulation (left) and an elastic helix simulation (right). We are com- paring our CosiNGNet-assisted PBD approach (orange) to a simplified version in which a k-NN (green) method is used to predict the initial guess. Morcover (left), we added a performance mea- surement in which restricted the solution to be in two-dimensional plane (black). The results are averages over 20 simulations and smoothed with a window of 10 frames. The dashed vertical lines mark the number of 50 frames contained in the training data set. For the helix simulation we observe a speed up of approximately 50% even beyond the training data (50 time frames). For the bending rod simulation we observe speedup that further decreases with increasing time frame number.
Discretization. Our approach addresses the acceleration of the most expensive part within PBD by providing an accurate initial guess of the constraint projection. We measure the system's complexity by the number of nodes in rod. Figure 4 shows the ratio of COPINGNet's inference run time (black and red curves) compared to the run time of the vanilla CG solver (purple curves) for different numbers of nodes. The increasing black and red curves indicate that the speedup of COPINGNet more significant with greater number nodes. With only few nodes the CG solver performs better due the inference overhead. Once the number of nodes is increasing, significant speedup can be obtained of up to 50% for the constraint projection. Surprisingly, our approach also performs well when going far beyond the sampling range (orange green dashed lines). Since the constraint projection is the most time-consuming part of the entire simulation, the speedup converges to that of the whole simulation (pink curves) with increasing number of nodes as shown in Figure !!
Temporal Evolution. addition to the complexity analysis, we also analyze the required number of CG iterations for the vanilla constraint projection compared to the accelerated using COP- INGNet over time as shown in Figure 0 We obtain a significant total speedup compared to the CG solver (dashed blue line). As stated in Table [] our training data contains dynamical simulations of 50 time steps. In this range we observe the highest speedup. As was the case for the complexity analysis, again obtain significant speedup for simulations beyond 50 time steps. Compared to a k-NN (green) method used to predict the initial guess, our COPINGNet-assiseed PBD approach shows the best performance in both scenarios.
Long-term Stability. case the constraint projection is completely replaced by COPINGNet (end- to-end approach), stability of the PBD method decreases error accumulation takes place. This is

---

illustrated in Figure / showing the temporal evolution of the relative change of the total rod length. An initially straight rod bending under the influence of gravity simulated using the parameters do = 09, N = 30, f = 4.0 m, and varying Young's 's modulus Y. In this scenario the rod length is expected to stay constant during the mechanical simulation. In case COPINGNet is used in an end- to-end manner (colored lines), where the whole constraint projection step is replaced, we observe that the rod length changes incorrectly. In fact, the divergence of using COPINGNet to replace the constraint projection step increases exponentially beyond the range of the training data (50 steps). To the contrary, when COPINGNet is used to only estimate the initial guess of the constraint projection (black lines), rod deformation takes place even beyond the training data range.
Collisions. Figure I illustrates a collision of an elastic helix with the ground plane and a collision be- tween two rods. Collision detection is efficiently implemented using the hierarchical spatial hashing scheme according to Fitz Gu (2007). Rod-rod collisions are then treated with line-to-line to-e distance constraints, and collisions with the ground plane using half-space constraints. Moreover, frictional effects are implemented according to Macklin et al. (014). This approach allows us to handle discontinuous events such as collisions between individual rods and other objects. Moreover, for this experiment we use the neural net- works trained on the rod and helix simulations. Em- ploying COPINGNet trained on the helix data to simulate the collision of the ground plane (HR HH 0.5 m, HW = 2.5, G = 1.0 10 Pa, N = 50), we measure a total speedup of approx. 10%. In the case of two collid- ing rods (on = 0-, N E (20, 30), l E [4.0 m, 4.5 m), Y= 1.0 10th Pa), we obtain a speedup of approx. 6%.
10
Y=
Y.0 10" Pg
Y= 5.0--000
Y=1.0 100010
2. 2.0---10
5.5 10000
Y= 1.0-10
0
20
40
G0
80
100
Time Frame Number
Figure 7: Illustration of the relative change of the total rod length (1/1)) for different values of Young's 's moduli (Y). Colored lines show different re- sults for COPINGNet replacing the con- straint projection. The thick black line represent the result for COPINGNet re- placing only the initial guess. This indi- cates that the end-to-end approach does not generalize past the 50 time steps used in preparing the training data.
Complex Scenarios. Our method is also capable to deal with complex scenarios such as 3D tree models swaying in wind fields as shown in Figure S We represent trees using the extended Cosserat rod theory introduced in Pirk ct al. (017). This method allows us to simulate realistic biomechanics of thousands of rod segments interactive rates. We generated 100 different tree topologies using 70 individual rods (average node number: 1056) and simu- late the swaying motions of these tree models with vanilla PBD to generate the training dataset. For the evaluation, 30 different tree topologies have been generated for each of the following four experiments using 10 rods (204 nodes), 20 rods (355 nodes), 40 rods (654 nodes), and 70 rods (1061 nodes). We were able to significantly improve the runtime performance of the method by 17.0% (10 rods). 15.8% (20 rods), 13.0% (40 rods), and 11.1% (70 rods). This takes into account the inference time introduced by the neural network.
Generalization. Figure 7 and Figure 10 (supplementary material) indicate that using COPINGNet in an end-to-end manner does not generalize beyond the training data. Specifically, the end-to-end setup diverges in terms of rod geometry and segment position from the correct solution. This effect increases significantly beyond the training data range. Although, we only use COPINGNet as a benchmark for this evaluation, other GNs are expected perform similarly. Common workarounds to increase the stability of dynamical systems with neural networks are temporal skip-connections, recurrent training, and data augmentation. However, these approaches focus on runtime speed and memory performance rather than stability (Holden et al. 2019). Interestingly, replacing just the ini- tial guess with a GN does not deform the rod or introduces discontinuities at any observed stage of the bending simulation. This means that employing GNs can result in performance increase with- out a loss of stability. Furthermore, a GN that only provides initial guesses seems to also generalize to other scenarios. We observed performance improvements for the collision and complex tree case, although the network was never trained on these different rod discretizations and topologies. This indicates that our method is capable to generalize within a specific physical scenario and to lesser extent to other scenarios.
Limitations. Apart from being useful for accelerating the simulation of mechanical systems, c.g., using iterative methods such as in position-based dynamics, finite elements analysis or in the con-

---

text of linear complementarity problems, we see a broader impact of our work in contributing to the further development of synergy effects of machine learning (e.g. graph learning) and physical sim- ulations. However, in this contribution we do not systematically explore this potential as we have restricted ourselves to rod simulation using position-hased dynamics. study our approach in the context of other iterative procedures in physics- basees--aaeddeee modeling and sim- ulation. With respect to the simulation dynamic rods, the speedup achieved from our framework is reduced in complex case when collisions are involved. Collision handling is another mainstream topic, g.g., within the computer graphics community. We plan to adapt finding from previous work within the graphics community to enhance the degree of sophistication of our approach when it comes to complex collision handling.
future work, we plan to
5 Conclusion
We discovered that applying GNs for replacing the initial guess has fundamental advantages over end-to-end approaches. First, our network-enabled solver ensures long-term stability inherited from traditional solvers for physical systems, while improving runtime performance. Second, our ap- proach is able to generalize across different initial conditions, rod discretizations, and material pa- rameters, and handles discontinuous effects such as collisions. While end-to-end approaches offer more significant speedups, method is superior in cases where stability is essential require- ment.
Our approach to accelerate iterative solvers with GNs opens multiple avenues for future work. For one, would be interesting to explore mechanical systems describing general deformable (e.g. tex- tiles) volumetric objects, which have been simulated with PBD. Second, our approach can be applied to other iterative methods, such as finite elements analysis or in the context of linear complementarity problems (L.CP). This would allow to accelerate physical simulations, when it- erative solvers are applied, without compromising stability. From more general perspective, other learning techniques can also be explored in the context of rod dynamics such as reinforcement or imitation learning (Li et al. 2018a
Müller et al. 2017).
Acknowledgements
This work was supported and funded by KAUST through the baseline funding of the Computa- tional Sciences Group and a Center Partnership Fund of the Visual Computing Center. The valuable comments of the anonymous reviewers that improved the manuscript are gratefully acknowledged.
References
Jernej Barbič and Doug L. James. Real-time subspace integration for st. venant-kirchhoff' de- formable models. ACM Transactions on Graphics, 24(3):982-990 July 2005.
Richard Barrett, Michael Berry, Tony Chan, James Demmel, June Donato, Jack Dongarra, Victor Eijkhout, Roldan Pozo, Charles Romine, and Henk van der Vorst. Templates for the Solution of Linear Systems: Building Blocks for Iterative Methods, 2nd Edition. SIAM, Philadelphia, PA, 1994.
Peter W. Battaglia, Jessica B. Hamrick, Victor Bapst, Alvaro Sanchez-Gonzaler Vinícius Flores Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo. Adam Santoro, Ryan Faulkner, Çaglar Gülçehree H. Francis Song, Andrew J. Ballard, Justin Gilmer, George E. Dahl, Ashish Vaswani, Kelsey R. Allen, Charles Nash, Victoria Langston, Chris Dyer, Nicolas Heess, Daan Wierstra, Pushmeet Kohli, Matthew Botvinick, Oriol Vinyals, Yujia Li, and Razvan Pascanu. Relational inductive biases, deep learning, and graph networks. CoRR, abs/ //5/1800.0122.. 2018.
Jan Bender, Kenny Erleben, and Jeff Trinkle. Interactive Simulation of Rigid Body Dynamics in Computer Graphics. Computer Graphics Forum, 33(1):246-270, 2014a.
Jan Bender, Matthias Müller, Miguel A. Otaduy, Matthias Teschner, and Miles Macklin. A survey on position-based simulation methods in computer graphics. Computer Graphics Forum, 33(6): 228-251, 2014b.
10

---

Jan Bender, Matthias Müller, and Miles Macklin. Position-based simulation methods in computer graphics. In EUROGRAPHICS 2017 Tuttorias. Eurographics Association, 2017.
Jens Berg and Kaj Nyström. A unified deep artificial neural network approach to partial differential equations in complex geometries. Neurocomputing, 317:28 -1,, 2018.
Miklós Bergou, Max Wardetzky, Stephen Robinson, Basile Audoly, and Eitan Grinspun. Discrete elastic rods. ACM Transactions Graphics, 27(3)x631--63:12 2008.
Michael B. Chang, Tomer Ullman, Antonio Torralba, and Joshua B. Tenenbaum. A compositional object-based approach to learning physical dynamics. arXiv preprint arXiv:/612.0034/ 2016.
Mengyu Chu and Nils Thuerey. Data-Driven Synthesis of Smoke Flows with CNN-Based Feature Descriptors. ACM Transactions on Graphics, 36(4), July 2017.
Crispin Deul, Tassilo Kugelstadt, Marcel Weiler, and Jan Bender. Direct position-based solver for stiff rods. Computer Graphics Forum, 37(6):313-3244 2018.
Gamini Dissanayake and Nhan Phan-Thien. Neural-network-basse approximations for solving par- tial differential equations. Communications Numerical Methods in Engineering, 10(3):195- 201, 1994.
Mathias Eitz and Lixu Gu. Hierarchical spatial hashing for real-time collision detection. IEEE International Conference on Shape Modeling and Applications 2007 (SMI '07), pp. 61-70, 2007.
Stefan Feess, Kathrin Kurfiss, and Dominik L.. Michels. Accurate Simulation of Wound Healing and Skin Deformation. In Proceedings of the ACM SICGGAAPH/Fumorraphiis Symposium on Computer Animation, SCA '16, pp. 129-137, Goslar, DEU, 2016. Eurographics Association.
Justin Gilmer, Samuel Schoenholz, Patrick Riley, Oriol Vinyals, and George E. Dahl. Neural message passing for quantum chemistry. CoRR, abs/1704.01212, 2017.
Radek Grzeszezuk, Demetri Terzopoulos, and Geoffrey Hinton. Neuroanimator: Fast neural net- work emulation and control of physics-based models. In Proceedings of the 25th Annual Confer- ence on Computer Graphics and Interactive Techniques, SIGGRAPH '98, pp. 9-20, New York, NY, USA, 1998. Association for Computing Machinery.
Xiaoxiao Guo, Wei Li, and Francesco Iorio. Convolutional neural networks for steady flow ap- proximation. In Proceedings of the 22Nd ACM SIGKDD International Conference on Knowledge Discovery and Data Mining, KDD '16, pp. 4814441480 1-490, New York, NY, USA, 2016. ACM.
Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recog- nition. CORR, abbs/1512.0333 2015.
Daniel Holden, Bang Chi Duong, Sayantan Datta, and Derek Nowrouzezahrai. Subspace neural physics: Fast data-driven interactive simulation. In Proceedings of the 18th Annual ACM SIG- GRAPH//Euroraphicc Symposium on Computer Animation, SCA 19,, New York, NY, USA, 2019. Association for Computing Machinery.
SCA
Ruben Ibañez, Domenico Borzacchiello, Jose Vicente Aguado, Emmanuelle Abisset-Chavanne, Elias Cueto, Pierre Ladeveze, and Francisco Chinesta. Data-driven non-linear elasticity: Con- stitutive manifold construction and problem discretization. Computational Mechanics, 60(5):
813-826, November 2017.
Byungsoo Kim, Vinicius C. Azevedo, Nils Thuerey, Theodore Kim, Markus Gross, and Barbara Solenthaler. Deep fluids: A generative network for parameterized fluid simulations. CGF, 38(2): 59-70, 2019.
Byungsoo Kim, Vinicius C. Azevedo, Markus Gross, and Barbara Solenthaler. Lagrangian neural style transfer for fluids. ACM Transaction on Graphics (SIGGRAPH), 2020.
Thomas Kipf, Ethan Fetaya, Kuan-Chieh Wang, Max Welling, and Richard Zemel. Neural relational inference for interacting systems. arXiv preprint arXiv:1802.04663) 2018.

---

Tassilo Kugelstadt and Elmar Schoemer. Position and orientation based cosserat rods. In Pro- ceedings of the 2016 ACM SIGGRAPH/Eunographis Symposium on Computer Animation. Euro- graphics Association, 2016.
L'ubor Ladicky, SoHyeon Jeong, Barbara Solenthaler, Marc Pollefeys, and Markus Gross. Data- driven fluid simulations using regression forests. ACM Transactions on Graphics, 34(6), 2015.
Isaac E. Lagaris, Aristidis Likas, and Dimitrios I. Fotiadis. Artificial neural networks for solving ordinary and partial differential equations. IEEE Transactions on Neural Networks, 9(5):987- 1000, 1998.
Guohao Li, Matthias Müller, Vincent Casser, Neil Smith, Dominik L. Michels, and Bernard Ghanem. Teaching uavs to race with observational imitation learning. CoRR, abs/ 18030003011111 129, 2018a.
Guohao Li, Matthias Müller, Ali Thabet, and Bernard Ghanem. DeepGCNs: Can GCNs Go Deep as CNNs? In The IEEE International Conference on Computer Vision (ICCV), 2019.
Yunzhu Li, Jiajun Wu, Jun- Yan Zhu, Joshua B. Tenenbaum, Antonio Torralba, and Russ Tedrake. Propagation networks for model-based control under partial observation, 2018b.
Miles Macklin, Matthias Müller, Nuttapong Chentanez, and Tae- Yong Kim. Unified particle physics Tae-Yong for real-time applications. ACM Transactions Graphics, 33(4), July 2014.
Miles Macklin, Matthias Müller, and Nuttapong Chentanez. Xpbd: Position- simulation of compliant constrained dynamics. In Proceedings the 9th International Conference Motion in Games, MIG 16. pp. 49-54, New York, NY, USA, 2016. ACM.
Dominik L. Michels and Mathieu Desbrun. A Semi-analytical Approach to Molecular Dynamics. Journal of Computational Physics, 303:336 354, 2015.
Dominik L. Michels, Gerrit A. Sobottka, and Andreas G. Weber. Exponential Integrators for Stiff Elastodynamic Problems. ACM Transactions on Graphics, 33(1):7:1-7:20, 2014.
Dominik L. Michels, J. Paul T. Mueller, and Gerrit A. Sobottka. A Physically Based Approach to the Accurate Simulation of Stiff Fibers and Stiff Fiber Meshes. Comput. Graph., 53(PB): (1PPB):136-11) 146, December 2015.
Dominik L. Michels, Vu Thai Luan, and Mayya Tokman. Stiffly Accurate Integrator for Elasto- dynamic Problems. ACM Transactions on Graphics, 36(4), July 2017.
Siddhartha Mishra. A machine learning framework for data driven acceleration of computations of differential equations, 2018.
Damian Mrowca, Chengxu Zhuang, Elias Wang, Nick Haber, Li Fei-Fei, Joshua B. Tenenbaum, and Daniel L. K. Yamins. Flexible neural representation for physics prediction, 2018.
Matthias Müller, Vincent Casser, Neil Smith, Dominik L. Michels, and Bernard Ghanem. Teaching uavs race using ue4sim. CoRR, abs/1 708.05884, 2017.
Matthias Müller, Bruno Heidelberger, Mareus Hennix, and John Ratcliff. Position based dynamics. Journal of Visual Communication and Image Representation, 18(2):109 118, 2007.
Andrew Nealen, Matthias Müller, Richard Keiser, Eddy Boxerman, and Mark Carlson. Physically based deformable models in computer graphics. Computer Graphics Forum, 25(4):809-836, 2006.
Dinesh K. Pai. Strands: Interactive simulation of thin solids using cosserat models. Computer Graphics Forum, 21(3):347-352, 2002.
Sören Pirk, Michal Jarzabek, Torsten Hädrich, Dominik L. Michels, and Wojeiech Palubicki. In- teractive wood combustion for botanical tree models. ACM Transactions on Graphics, 36(6): 197:1-197:12, November 2017.
12

---

Maziar Raissi and George Em Karniadakis. Hidden physics models: Machine learning of nonlinear partial differential equations. Journal of Computational Physics, 357:125 141, 2018.
Maziar Raissi, Paris Perdikaris, and George Em Karniadakis. Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations. Journal of Computational Physics, 378:686 2019.
Yousef Saad. Iterative Methods for Sparse Linear Systems. Society for Industrial and Applied Mathematics, USA, 2nd edition, 2003.
Alvaro Sanchez-Gonzalez, Nicolas Heess, Jost Tobias Springenberg, Josh Merel, Martin Riedmiller, Raia Hadsell, and Peter Battaglia. Graph networks as learnable physics engines for inference and control, 2018.
Alvaro Sanchez-Gonzaler Victor Bapst, Kyle Cranmer, and Peter Battaglia. Hamiltonian graph networks with ode integrators, 2019.
Alvaro Sanchez-Gonzalee Jonathan Godwin, Tobias Pfaff, Rex Ying, Jure Leskovec, and Peter W. Battaglia. Learning to simulate complex physics with graph networks, 2020.
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, Jan 2009.
Sungyong Seo and Yan Liu. abs/1902.02250, 2019.
Differentiable physics-informed graph networks.
CoRR,
Justin Sirignano and Konstantinos Spiliopoulos. Dgm: deep learning algorithm for solving partial differential equations. Journal of Computational Physics, 375:1339 1364, 2018.
Jonathan Tompson, Kristofer Schlachter, Pablo Sprechmann, and Ken Perlin. Accelerating eulerian fluid simulation with convolutional networks. CoRR, habs/1607.03597, 2016.
Rahul Trivedi, Logan Su, Jesse Lu, Martin F Schubert, and Jelena Vuckovic. Data-driven accelera- tion of photonic simulations, 2019.
Kiwon Um, Xiangyu Hu, and Nils Thuerey. Liquid splash modeling with neural networks, 2017.
Nobuyuki Umetani, Ryan Schmidt, and Jos Stam. Position-based elastic rods. Proceedings of the ACM SIGCRAPH//anngraphic Symposium on Computer Animation, SCA '14, pp. 21-30, Aire-la- Ville, Switzerland, Switzerland, 2014. Eurographies Association.
Benjamin Ummenhofer, Lukas Prantl, Nils Thuerey, and Vladlen Koltun. Lagrangian fluid simu- lation with continuous convolutions. In International Conference Learning Representations, 2020.
Huamin Wang, James F. O'Brien, and Ravi Ramamoorthi. Data-driven elastic models for cloth: Modeling and measurement. In ACM SIGGRAPH 201 Papers, SIGGRAPH '11, p1: 71:1-71:12, New York, NY, USA, 2011. ACM.
Xiaolong Wang. Ross B. Girshick, Abhinav Gupta, and Kaiming He. Non-local neural networks. CoRR, abs/1711.07971, 2017.
Steffen Wiewel, Moritz Becher, and Nils Thuerey. Latent-space physics: Towards learning the temporal evolution of fluid flow. CoRR, abs/I 10//1802..10 10123, 2018.
Xiangyun Xiao, Yanqing Zhou, Hui Wang. and Xubo Yang. A novel cnn-based poisson solver for fluid simulation. IEEE Transactions on Visualization and Computer Graphics, 2020.
13

---

Checklist
1. For all authors...
(a) Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope? [Yes] These claims are accurate.
(b) Did you describe the limitations of your work? [Yes] Yes, Section contains a sub- section covering limitations.
(c) Did you discuss any potential negative societal impacts of your work? [N/A] There is little potential negative societal impact of our work.
(d) Have you read the ethics review guidelines and ensured that your paper conforms to them? [Yes] We have read it, and we comply the ethics review guidelines.
2. If you are including theoretical results...
(a) Did you state the full set of assumptions of all theoretical results? [Yes] All assump- tion of claims we made are clearly mentioned.
(b) Did you include complete proofs of all theoretical results? [N/A] Does not apply.
3. If you ran experiments..
(a) Did you include the code, data, and instructions needed to reproduce the main exper- imental results (either in the supplemental material or URL)? [Yes] This can be found in the supplement material.
(b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)? [Yes] The training details included.
(c) Did you report error bars (e.g., with respect to random seed after running experi-
ments multiple times)? [N/A] We are not using different random seeds.
(d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)? [Yes] See Section Al
4. If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...
(a) If your work uses existing assets, did you cite the creators? [N/A] We are not using
existing assets.
(b) Did you mention the license of the assets? [N/A] Does not apply.
(c) Did you include any assets either in the supplemental material or URL? [N/A]
Does not apply.
(d) Did you discuss whether and how consent was obtained from people whose data you're using/curating? [N/A] Does not apply.
(e) Did you discuss whether the data you are using/curating contains personally identifi- able information or offensive content? [N/A] Does not apply.
5. If you used crowdsourcing conducted research with human subjects...
(a) Did you include the full text of instructions given to participants and screenshots, applicable? [N/A] Our work does not involve crowdsourcing or human subjects. (b) Did you describe any potential participant risks, with links Institutional Review Board (IRB) approvals, if applicable? [N/A] Does not apply.
(c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] Does not apply.


Reviews:
[{"review_id": "w-e90unbu8P", "reviewer": "Reviewer_ixu1", "summary": "This paper aims to accelerate the iterative physical simulators using graph neural networks, by combining the traditional iterative rod solver and the graph networks. Instead of an end-to-end way, this paper uses the trained GNN to provide the initial guess of the iterative solver to reduce the number of iterations. In the experiments section, this paper shows the improved run time performance compared with the traditional solver and a KKN method. ", "questions": "", "limitations": "", "rating": 6, "confidence": 4, "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": "#### Strengths\n- This paper uses the network output as the initial guess and then performs the iterative solver to correct the position, which is different from other data-driven simulators and the iterative solver can provide better long-term stability compared with the end-to-end methods.\n- Compared with the traditional simulation methods, COPINGNet reduces the number of iterations by providing a better initial guess using GNNs which accelerate the simulation.\n- This paper gives detailed steps about how to build the graph. And the supplementary video is illustrative.  \n\n#### Weaknesses\n- To use this method, all the works of a traditional PBD simulator cannot be avoided, and all the physics properties of the physical systems need to be known. \n\n#### Correctness  \nThe technical content of this paper appears to be correct.\n\n#### Clarity  \nOverall, the exposition of the paper is fairly clear. \n\n#### Relation to prior art  \nThis paper properly discusses the previous work of data-driven physics simulators and graph-based learning.  \nThis work can be seen as a combination of the traditional rod simulator and the GNN-based simulator.  \nCompared with other GNN simulators, the main difference is that COPINGNet uses the output of GNNs as the initial guess for the iterative solver instead of an end-to-end way. Also, different from many other data-driven methods where the physical system is unknown, this paper assumes all the physics constraints are known to the iterative simulator. And many other GNN-based methods use particles as the graph nodes, while this model uses segments.   \nCompared with other traditional solvers, this work uses a neural network to provide an initial guess for the solver.\n\n#### Reproducibility  \nImplementation details and code are provided in the supplementary materials to reproduce this work.\n\n#### Additional Feedback/Questions\n- Figure 4 compares COPINGNet’s inference time and the vanilla CG solver’s run time. Is the CG solver also implemented on GPUs? it would be clearer if the devices used to run the COPINGNet and the CG solver are listed since the run-time improvement may also come from the device or implementation difference.\n- Is COPINGNet also used for generating the initial guess of the collisionConstraintProjection (line 13 in algo 1)?\n- There are other methods that can learn end-to-end simulations using graph networks, is the difference here that the rods simulated in this work are too complicated to get a long-term stable prediction if without using the traditional projection solver to correct the results?\n- It might be clearer if the formula of using λ to update p is given in algo 1.\n- After training, can the model be used for different time steps or for systems with different physical attributes (e.g., rods with different stiffness)?\n", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "The paper properly discusses the limitations that COPINGNet is currently limited to rod simulation using position-based dynamics and mentions the possible future work of applying this method to other iterative methods.", "review_text": "", "extra_scores": {"ethical_concerns": "I didn’t find ethical concerns in this paper.", "needs_ethics_review": "No", "ethics_review_area": "", "time_spent_reviewing": "5"}, "extra_text": {}}, {"review_id": "kxN_xdW7qP", "reviewer": "Reviewer_W28a", "summary": "The authors consider the problem of speeding up a specific form of dynamic simulation - position based dynamics, used as a solver to simulate the dynamic evolution of rods. I believe this is a timely topic, both due to the growing importance of simulations in various communities within AI, and because flexible objects are becoming more relevant in some of these applications.\n\nThe core concern of this paper is to find ways to speed up PBD solvers. To the extent that the iterative process of constraint projection is computationally expensive, there is scope for finding surrogates that could perform something like this computation quicker. The author's proposal is to use a Graph Neural Network to act as a surrogate for the analytical calculation. In contract to some other works that aim at replacing the entire simulator, the authors restrict the scope here to only using the neural network to emulating the specific projection step, which then serves as an initialisation, speeding up subsequent computation. This is a good idea and the empirical data supports its use. The empirical experiments in this paper are simulations of free evolution of a rod and a spring, clamped on one side, after an initial perturbation. It is shown that the proposed method can be more computationally efficient than an alternative which only uses the full conjugate gradient optimization step from a zero initialization.", "questions": "", "limitations": "", "rating": 6, "confidence": 3, "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": "I find the work to be sound, and well motivated. There is a need for efficient solvers, and there is also a need for methods that can provide long-term stability, which motivates modifying rather than replacing existing solvers. \n\nThe proposed approach - to train a network to emulate the optimization step is a good one. However, as already queried by the reviewers of the previous submission, it is certainly interesting to consider what sort of surrogate is needed and how the resulting method behaves. The authors present a comparison against nearest neighbours, which is a natural baseline. The authors show that while this gives a small boost, the neural network does indeed perform better. Also, the authors note that the network alone would not be a good replacement as it performs very poorly outside the training data regime (which is in accordance with findings in other literature too).\n\nAll this raises the question of what can be said about the convergence and error characteristics of such a mixed method, beyond the empirical experiment. To the extent that this is a standard solver with established analysis methods, could one say more about the conditions for long term stability and could that constrain the neural network? Here I have in mind analogies to other numerical methods for speedups of solvers (e.g., the Parareal scheme for time-parallel speedup: https://en.wikipedia.org/wiki/Parareal, which comes with some conditions for stability). \n\nOne reason to ask this question is that I am particularly interested in the behaviour of the network when the dynamics become stiff or otherwise numerically difficult. It is not entirely easy to tell from visual inspection of the variations in the scenarios how the ranges of Young's Modulus and rod lengths map to stiffness and longer time scale dynamic evolution - this is where I'd expect the neural network error characteristics to be less favourable. The current implementation requires normalisation of Young's modulus and torsion modulues in order to stabilise the algorithm. I am curious how all this behaves if the system under consideration were such that the underlying dynamics had slow-fast characteristics (perhaps because of inhomogeneous materials like composites or other phenomena like flutter). The paper would be made stronger by including some discussion of these kinds of issues.\n\nNote added post-response:\nI thank the authors for their response. I would encourage them to provide the additional information they have offered. Based on the discussion so far (including other reviews and the responses), I maintain my score.\n", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "The authors explicitly discuss limitations, and their arguments are on point. Ultimately, this is a methodological contribution to solver technology for dynamic simulation, and the limitations pertain to the balance between simulation and learning.\n\nI do not believe this work raises societal issues that need to be considered specifically.", "review_text": "", "extra_scores": {"ethical_concerns": "-", "needs_ethics_review": "No", "ethics_review_area": "", "time_spent_reviewing": "2"}, "extra_text": {}}, {"review_id": "LSfKymy7piX", "reviewer": "Reviewer_cFjQ", "summary": "This paper presents a learning-based technique to speed up the physics simulation of rod structures using PBD. The key motivation is to notice that solving the nonlinear system using CG is the key bottleneck in the physics simulation. To speed up the CG solver, this paper proposes to train a neural network that predicts a good initial guess for CG in the hope that it will reduce the number of iterations before convergence. This paper presents experiments with tens to over a thousand nodes and shows that the speedup technique reduces the number of iterations used in CG by a factor of at most 2.5 (Fig. 6).", "questions": "", "limitations": "", "rating": 6, "confidence": 3, "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": "Overall, this paper makes an attempt to combine learning-based approaches with classical physics simulation. In particular, the paper intentionally avoids training an end-to-end network that fully replaces simulation in a single time step. Instead, it bases its designs on a good understanding/decomposition of the underlying physics simulation technique (PBD) and chooses to train a network that proposes initial guesses to the numerical solver only. The implication is that their method naturally inherits the physical accuracy and stability of PBD because their method technically should lead to almost the same numerical results as the original PBD method. This gives their learning-based model some transparency and good guarantees on its physical correctness compared to an end-to-end network. I like this way of combining a network with a physics engine, and I think the authors should be given credits for this.\n\nMy scores cannot be higher for the submission in its current status because I still have some concerns regarding the technical methods and the experiments:\n\n- To me, the improvement from their method over a classic CG seems not significant, and the speedup seems diminished especially when the problem scales up: for the first two examples mentioned in Fig. 4 and Fig. 6, the speedup seems to be between 1 and 3, and for the larger tree example, the speedup is reduced to less than 20%. Is there a reason why the performance degrades when the problem scales up? Even for the complex scene, the matrix size (a few thousand by a few thousand if I understand correctly) is not super large for a modern CG solver, so I wonder if the authors could provide the wall-clock time for simulating one time step for both the small and large examples. If these examples can already be simulated very fast (say in real time), then it might be hard to justify why it is still worth spending tens of hours of training to gain this relatively small speedup.\n\n- Following the comment above, I notice the comparison is against a vanilla CG, which I find quite uncommon in modern physics simulators. Typically, modern simulators will at least equip CG with a preconditioner, which can speed up the vanilla CG at least a few times faster (this is also why I mentioned above that the speedup reported in this paper is not very impressive to me) especially for large-scale systems. There are also more advanced techniques like multigrid solvers that can expedite the vanilla solver even further. All these classical numerical methods do not require extra training time, making it difficult for me to appreciate the speedup obtained in this paper. On a side note, I would be much more excited if this paper proposes to learn a proper preconditioner instead of learning an initial guess to CG because a good preconditioner almost always ensures a decreased number of iterations in CG regardless of the initial guesses.\n\n- I think the discussion of the generalizability of their neural network is very crucial to their method (or any methods trying to combine neural networks with physics engines in general) and I wish it could be elaborated in the main paper. In particular, 1) do I need to retrain the network if I switch to a different example with different topologies (e.g., from rods to trees)? The answer seems to be no from what I understand, but it would be good if the authors can confirm. 2) for the same example, if I change the external forces (e.g., removing gravity or adding wind forces in the tree example) or change to a different boundary condition (e.g., stitching an end of a rod to a wall or ground), do I need to retrain the network or does it still generalize well? 3) if I change the time steps used in physics simulation, do I need to retrain the network or does it still generalize well? 4) is the network described in Fig. 3 agnostic to rigid modes applied to the input? In other words, if I rotate and translate the whole rod system and send it to the network again, would I expect some change in its output?\n", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "See the review above.", "review_text": "", "extra_scores": {"ethical_concerns": "None", "needs_ethics_review": "No", "ethics_review_area": "", "time_spent_reviewing": "4.5"}, "extra_text": {}}, {"review_id": "GSyt_AeRyWv", "reviewer": "Reviewer_5qbT", "summary": "This paper proposes to train a graph network to estimate the initial guess of a conjugate gradient solver in a rod dynamics simulation pipeline. By using a better initial position given by the graph network, the CG solver can converge faster than optimizing from zero vectors. The authors show how to construct such a network and demonstrate the accuracy and efficiency of their hybrid method in various simulation settings.", "questions": "", "limitations": "", "rating": 6, "confidence": 3, "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": "Originality: \nYes. This is my first timing reading accelerating the simulation of rod dynamics using graph networks. I remember there are some previous works using graph networks to learn dynamics or using networks to accelerate fluid dynamics. The authors properly cite related works in Section 2.\n\nQuality: \nThe method looks reasonable to me and the rendering looks good. Just some small suggestions,\n1. In the video around 1:30, there are unnatural oscillations. Maybe the collision handling is not perfect.\n2. It might be more convenient for readers if some labels can be added to the plots (Fig. 4, 6).\n3. It would be better to show the standard deviation in the plot.\n\nClarity:\nYes.\n\nSignificance:\nThis might be my main concern about this paper. \n\nFirst, the examples are relatively simple. The topologies are either linear or tree-like. Since graph networks are used, it will be more convincing if the method can simulate more complex graphs, like 2D or 3D nets. I’m also wondering what real-world application can be for this method.\n\nSecond, the performance boost is good but not so significant. If I understand the submitted code correctly, the CG solver is implemented using pytorch cuda tensor at an element-wise level. A C++ simulator might be orders of magnitude faster. If the simulator is implemented using C++, I doubt the performance gain of reducing several iterations in CG solver on the cost of running a graph network.\n\n*** After authors’ response\n\nThe response points out that the acceleration could be more significant in larger-scale applications, which is good for generalization. The idea itself, using GNN to accelerate the solvers in physics problems, is interesting. I’m glad that the authors provide their code. It is understandable to use python implementation as a proof of concept. More efficient C++ implementation could be future work.\n", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "I don’t think there would be serious negative societal impacts in this work. The limitation of this work I think is its significance and real-world use, which I covered in the last part.", "review_text": "", "extra_scores": {"needs_ethics_review": "No", "ethics_review_area": "", "time_spent_reviewing": "4"}, "extra_text": {}}]

Author rebuttal:

Meta-review: This paper considers accelerating the simulation of rod dynamics by training a graph neural network to act as an initialisation for an iterative solver. This is an interesting and original paper.
While reviewers were generally in favour of this paper, they had a number of concerns. The primary question, including after the rebuttal, is around the significance of the results. Despite that, there is value in this contribution.
The authors should make the promised changes to the manuscript.
Decision: Accept (Poster)