Stanford CS348C: Prog. Assignment #1: Position Based Fluids

CS 348C Position Based Fluids in Houdini

Professor: Doug James
Due date: Wed, Feb 26, 2020

In this assignment, you will implement a simple particle-based fluid simulator related to smoothed particle hydrodynamics (SPH). Specifically you will implement the "Position Based Fluids" (PBF) approach described in [Macklin and Muller 2013]. Although it doesn't achieve high accuracy, it is simple to implement and parallelizes well on the GPU. As the title suggests, this assignment will be done in Houdini, which should make your task a lot easier since you can use it to find particle neighbors, surface the fluid, render, etc., thereby allowing you to spend more time on the algorithm while getting visually nice results.

Groups: Work on your own, or in a group of at most two people. Additional work is expected from a group submission, such as a more elaborate creative artifact or modeled phenomena. PhD students are encouraged to work alone, and pursue a more challenging creative artifact.

Starter Code: There is no starter code for this Houdini assignment, however you may use the earlier "particles in a box" example for inspiration. You have a lot of flexibility in how to implement things, e.g., use VEX, or python, or even a C++ plug-in if you want (although it's more work). (In case it needs to be said, you should not use any Houdini fluid simulation assets to implement this assignment. )

Assignment Steps:

Getting started: Study the position-based time-stepping scheme described in the PBF paper. You will implement these steps. In your implementation, each particle is just a point with attributes for its position (P), velocity (v), mass and size (m and pscale -- the same for all particles), color (Cd), etc.

TIP: Visual debugging: Throughout the assignment, you can use Houdini to visualize and debug the state of the simulation in multiple ways. First, you can set the color field (Cd) to display information, e.g., density. Second, you can always output by creating debugging fields (e.g., f@debug) that you can inspect in the Geometry Spreadsheet, or with a Visualizer node.

Handling collisions: To keep the particles from leaving the container, you need to implement position-based collision response with the computational cell boundaries. The basic functionality of the assignment is to simulate fluid in a convex box of fixed size. For now, modify the inner position-correction iteration so that the particle positions are kept from leaving the box when bouncing around under the influence of gravity. You can start from the earlier particle simulation example code.
Finding particle neighbors: Each fluid particle i will need to know a list of neighbors N_i in order to compute interactions (pressure, viscosity, etc.). To get started quickly, you can just loop over all particles to find ones that are close enough (e.g., at distance r < h), but since this is an O(N^2) computation it will quickly become impractical for even a few hundred particles. Houdini already provides some methods for point-cloud neighbor finding, using spatial acceleration structures. For starters, you can use the "nearpoints" method to find all particles on an input stream that are close to a specified point. Check out some examples over at the helpful CGWiki page (example1, example2).
XSPH viscosity: As your first particle-particle interaction, try implementing the simple velocity-based XSPH viscosity filter. This filter will update the particle velocity field, v. You should observe more dissipative behavior, but without the major volume loss. Note that this non-gradient based kernel makes use of the poly6 kernel--which you should implement a VEX function for. This velocity filter performs a poly6-weighted average of neighboring velocities.
Position-based density constraints: Next implement the the position-based relaxation of particle positions to approximate each particle's density constraint. Each step of the relaxation is implemented as a two-pass algorithm. First, iterate over the particles to estimate their lambda values. Second, iterate over the particles to estimate the position corrections, then update the positions. Each pass can be implemented using a Point Wrangle, with neighbors found using nearpoints, or cached from earlier (optional speedup). Note that you will need to adjust the positive-valued epsilon parameter to avoid problems when particles have insufficient neighbors.

Finally, make sure that your iterations play nice with the rigid boundary conditions by performing collision detection and response with the corrected particle positions.

"Surface tension" correction: To approximate the effects of surface tension and avoid particle clumping, implement the surface-tension "s_{corr}" correction described in the PBF paper. Compare the results you get before/after implementing this correction by comparing a single frame of the animation at a specific time.
Vorticity confinement (VC) should be implemented to avoid excessive energy loss. See the class notes for implementation details, and the video for a demonstration of the resulting effect. You will need to tweak the strength of the VC force for best visual results.

Tuning parameters can be a real pain in physics-based animation, and this simulation model, which has many parameters to adjust, is no different. Fortunately you can use Houdini to expose parameters in the top level node to allow you to interactively adjust values. There are many sets of parameters that will produce decent results (but also many bad ones) since the parameters in this paper are coupled, e.g., since the paper uses m=1 for all particles, changing the particle size/resolution will affect the density. A student from a previous class asked Miles Macklin about suggestions for parameters, and here was his feedback:

"Here are the parameters I would recommend for a traditional dam-break style scenario, similar to the ones in the paper:

Particle mass: 1.0kg

Kernel radius (h): 0.1m

Rest density (rho): 6378.0kg/m^3

Density Iterations: 4

Time step (dt): 0.0083s (2 substeps of a 60hz frame time)

CFM Parameter (epsilon): 600

Artificial Pressure Strength (s_corr): 0.0001

Artificial Pressure Radius (delta q): 0.03m

Artificial Pressure Power (n): 4

Artificial Viscosity (c): <= 0.01"

Tips: It's worth pointing out that the particle mass, radius and fluid density are all coupled, so if you use a finer sampling of particles, you will want to adjust these parameters. To make your examples, I suggest fixing the fluid density, then adjusting the particle mass and radius depending on the resolution you use. You may also need to add a slight fudge factor depending on how closely particles pack together in the fluid volume. Other students received good results with very different parameters depending on resolution, and you can also adjust the Artificial Pressure values and still achieve good effects. In practice, try introducing things one at a time to test parts separately.

After you get the basic simulator working, here are some things to help you make an interesting animation:

Surfacing and rendering your fluid: This is relatively easy to do using the tools in Houdini. To get a mesh surface from the particles, you can use the Particle Fluid Surface geometry node (or its SDF replacement, VDB from Particle Fluid geometry node)--these pages contain a lot of suggestions on how to improve the surface result, and coherence. Render your final animation using Mantra (if possible) using a water shader, and a Sunlight node. (here are some tips that may help).
Create an asset that can be reused to simulate multiple examples.
More interesting scenes: Dropping particles in a convex box is only so much fun. Some things you might try:

Try implementing more complex rigid environments, such as rigid obstacles (like a Stanford bunny) placed in the box. You will need to collide particles with the mesh geometry to keep them outside, or you can rasterize the geometry and normals to approximate boundaries. One useful tool here is to use a signed distance field (SDF) to define the scene geometry, and help you push particles around.

For example, you can use a "VDB from Polygons" SOP with "Distance VDB" surface enabled, then you can use an Attribute Wrangle to volumesample(geo, 0, pos) the distance field to see if you are inside (<0) or outside (>0) the surface. You can also use volumegradient(geo, 0, pos) to get you to the surface. You could then push inside points out, or set a group tag for later processing, e.g., setpointgroup(geo, "inside", @ptnum, isinsideInt, "set").

Add a wave tank effect by adjusting the location of wall boundaries.
Try adding foam particles that are created in agitated regions, e.g., of high particle deceleration, and gradually decay over time.
Try to simulate rigid bodies that are pushed around by the particles. One way to do this is to sample the bodies using many particles, and project the rigid particles using rigid body shape matching (see the paper on unified particle physics [Macklin et al. 2014]).

Hand-in using Canvas:

A brief written document (in txt or PDF) that explains what you did, your findings, and who you discussed the assignment with, etc.

Include comparisons or analysis/results demonstrating the behavior of your implementation.
Citation:

Include the names of everyone that you discussed the assignment with.
Include citations of external resources (books, webpages, etc.) that you used in your R&D.

Your Houdini implementation. Please add "Post-It" notes to help explain any non-obvious steps you've taken.
Your creative simulation artifacts, videos, images, etc.

We will run your software to evaluate your implementation, and/or ask you to provide a demo. However including videos that demonstrate the requested features, and interesting behavior are strongly encouraged.

If you are working with a partner, be sure to form a two-person group, and submit your zip file as a group.
Regarding requests for extensions because "I have another deadline on that day" or "I think I may have to use the bathroom at midnight": Please start early, and budget your time to do the many things you need to do. The deadline is not when you do your work, it's when you should be done by.

Start early. Ask questions. Have fun!!!

On collaboration and academic integrity: You are allowed to collaborate on the assignments to the extent of formulating ideas as a group, and derivation of physical equations. However, you must conduct your programming and write up completely on your own (or with your partner), and understand what you are writing. Please also list the names of everyone that you discussed the assignment with. (You are expected to maintain the utmost level of academic integrity in the course.)

References:

Liu, G. Gui-Rong, and M. B. Liu. Smoothed particle hydrodynamics: a meshfree particle method. World Scientific, 2003.
Matthias Müller, David Charypar, Markus Gross, Particle-based fluid simulation for interactive applications, 2003 ACM SIGGRAPH / Eurographics Symposium on Computer Animation (SCA 2003), August 2003, pp. 154-159. [Video]
Wikipedia
Takahiro Harada, Seiichi Koshizuka, Yoichiro Kawaguchi, Smoothed Particle Hydrodynamics on GPUs, Computer Graphics International, pp. 63-70, 2007.
B. Solenthaler, R. Pajarola, Predictive-Corrective Incompressible SPH, ACM Transactions on Graphics, 28(3), July 2009, pp. 40:1-40:6. [PDF] [YouTube Video]
Miles Macklin and Matthias Müller. Position Based Fluids. ACM Trans. Graph. 32, 4, Article 104 (July 2013), 12 pages. (other videos)
Miles Macklin, Matthias Müller, Nuttapong Chentanez, Tae-Yong Kim, Unified Particle Physics for Real-Time Applications, ACM Transactions on Graphics (SIGGRAPH 2014), 33(4) [Slides] [PDF] [Video] [Project Page]
Bridson, R., Fedkiw, R., and Muller-Fischer, M. 2006. Fluid simulation: SIGGRAPH 2006 course notes, In ACM SIGGRAPH 2006 Courses (Boston, Massachusetts, July 30 - August 03, 2006). SIGGRAPH '06. ACM Press, New York, NY, 1-87. [Slides, Notes] [SPH pages (pp. 83-86)]
Robert Bridson, Fluid Simulation for Computer Graphics, A K Peters, 2008. [Book format]