https://raw.githubusercontent.com/InteractiveComputerGraphics/SPlisHSPlasH/master/doc/images/logo_small.jpg

https://raw.githubusercontent.com/InteractiveComputerGraphics/SPlisHSPlasH/master/doc/images/logo_small.jpg

About SPlisHSPlasH

SPlisHSPlasH is an open-source library for the physically-based simulation of fluids. The simulation in this library is based on the Smoothed Particle Hydrodynamics (SPH) method which is a popular meshless Lagrangian approach to simulate complex fluid effects. The SPH formalism allows an efficient computation of a certain quantity of a fluid particle by considering only a finite set of neighboring particles. One of the most important research topics in the field of SPH methods is the simulation of incompressible fluids. SPlisHSPlasH implements current state-of-the-art pressure solvers (WCSPH, PCISPH, PBF, IISPH, DFSPH, PF) to simulate incompressibility. Moreover, the library provides different methods to simulate viscosity, surface tension and vorticity.

Main features

  • open-source SPH fluid simulation (2D & 3D)

  • neighborhood search on CPU or GPU

  • supports vectorization using AVX

  • Python binding (thanks to Stefan Jeske)

  • several implicit pressure solvers (WCSPH, PCISPH, PBF, IISPH, DFSPH, PF)

  • explicit and implicit viscosity methods

  • current surface tension approaches

  • different vorticity methods

  • computation of drag forces

  • support for multi-phase simulations

  • simulation of deformable solids

  • rigid-fluid coupling with static and dynamic bodies

  • two-way coupling with deformable solids

  • fluid emitters

  • scripted animation fields

  • a json-based scene file importer

  • automatic surface sampling

  • a tool for volume sampling of closed geometries

  • partio file export of all particle data

  • VTK file export of all particle data (enables the data import in ParaView)

  • rigid body export

  • a Maya plugin to model and generate scene files

License

The MIT License (MIT)

Copyright (c) 2016-present, SPlisHSPlasH contributors

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Getting started

This page should give you a short overview of SPlisHSPlasH.

SPlisHSPlasH currently consists of a simulators and different tools which are introduced in the following:

SPHSimulator

This application reads a SPlisHSPlasH scene file and performs a simulation of the scene.

The scene file format is explained here.

Command line options:

  • -h, –help: Print help text.

  • -v, –version: Print version.

  • –no-cache: Disable caching of boundary samples/maps.

  • –state-file: Load a simulation state of the corresponding scene.

  • –output-dir: Output directory for log file and partio files.

  • –no-initial-pause: Disable caching of boundary samples/maps.

  • –no-gui: Disable graphical user interface. The simulation is run only in the command line without graphical output. The “stopAt” option must be set in the scene file or by the next parameter.

  • –stopAt arg: Sets or overwrites the stopAt parameter of the scene.

  • –param arg: Sets or overwrites a parameter of the scene.

    • Setting a fluid parameter: ::

      • Example: –param Fluid:viscosity:0.01

    • Setting a configuration parameter: :

      • Example: –param cflMethod:1

Hotkeys

  • Space: pause/contiunue simulation

  • r: reset simulation

  • w: wireframe rendering of meshes

  • m: recompute min and max values for color-coding the color field in the rendering process

  • i: print all field information of the selected particles to the console

  • s: save current simulation state

  • l: load simulation state (currently only Windows)

  • ESC: exit

Python bindings

SPlisHSPlasH implements bindings for python using pybind11. See the getting started guide.

Impatient installation guide

In order to install, simply clone the repository and run pip install on the repository. It is recommended, that you set up a virtual environment for this, because cache files will be stored in the directory of the python installation along with models and scene files.

git clone https://github.com/InteractiveComputerGraphics/SPlisHSPlasH.git
pip install SPlisHSPlasH/

Tools

partio2vtk

A tool to convert partion files in vtk files. In this way the particle data which is exported from SPlisHSPlasH can be converted to the vtk format. This is useful to import the data in ParaView for visualization.

PartioViewer

The simulators can export the particle simulation data using the partio file format. The PartioViewer can read such a file and render the particle data using OpenGL. This tool is able to handle multiphase data and rigid body data. It can create image sequences and movies (using ffmpeg).

To visualize a sequence of partio files or a single file, call (the index in the file name is used for the sequence):

PartioViewer fluid_data_1.bgeo

This tool is also able to read a complete output directory:

PartioViewer output/DamBreakModel

In this case the tool searches for the partio files of multiple phases in the subdirectory “partio” and for rigid body data in “rigid_bodies”.

Note: To generate videos you must tell PartioViewer where it can find the ffmpeg executable.

Command line options:

  • -h, –help: Print help

  • –renderSequence: Render a sequence from startFrame to endFrame as jpeg.

  • –renderVideo: Render a sequence from startFrame to endFrame as video.This function requires ffmpeg which must be in the PATH or the ffmpegPath parameter must be set.

  • –noOverwrite: Do not overwrite existing frames when using –renderSequence option. Existing frames are not loaded at all which accelerates the image sequence generation.

  • -o, –outdir arg: Output directory for images

  • –rbData arg: Rigid body data to visualize (bin file)

  • –ffmpegPath arg: Path of the ffmpeg excutable.

  • –width arg: Width of the image in pixels. (default: 1024)

  • –height arg: Height of the image in pixels. (default: 768)

  • –fps arg: Frame rate of video. (default: 25)

  • -r, –radius arg: Particle radius (default: 0.025)

  • -s, –startFrame arg: Start frame (only used if value is >= 0) (default: -1)

  • -e, –endFrame arg: End frame (only used if value is >= 0) (default: -1)

  • –colorField arg: Name of field that is used for the color. (default: velocity)

  • –colorMapType arg: Color map (0=None, 1=Jet, 2=Plasma) (default: 1)

  • –renderMinValue arg: Min value of field. (default: 0.0)

  • –renderMaxValue arg: Max value of field. (default: 10.0)

  • –camPos arg: Camera position (e.g. –camPos “0 1 5”) (default: 0 3 10)

  • –camLookat arg: Camera lookat (e.g. –camLookat “0 0 0”) (default: 0 0 0)

Hotkeys

  • Space: pause/contiunue simulation

  • r: reset simulation

  • w: wireframe rendering of meshes

  • i: print all field information of the selected particles to the console

  • s: save current frame as jpg image

  • v: generate video

  • j: generate image sequence

  • +: step to next frame

  • -: step to previous frame

  • ESC: exit

SurfaceSampling

A popular boundary handling method which is also implemented in SPlisHSPlasH uses a particle sampling of the surfaces of all boundary objects. This command line tool can generate such a surface sampling. Note that the same surface sampling is also integrated in the simulators and the samplings are generated automatically if they are required. However, if you want to generate a surface sampling manually, then you can use this tool.

VolumeSampling

The simulators can load particle data from partio files. This particle data then defines the initial configuration of the particles in the simulation. The VolumeSampling tool allows you to sample a volumetric object with particle data. This means you can load an OBJ file with a closed surface geometry and sample the interior with particles.

SPlisHSPlasH Scene Files

A SPlisHSPlasH scene file is a json file which can contain the following blocks:

  • Configuration

  • FluidBlocks

  • FluidModels

  • Emitters

  • RigidBodies

  • Fluid parameter block

  • Animation fields

Configuration

This part contains the general settings of the simulation and the pressure solver.

Example code:

"Configuration": 
{
    "pause": true,
    "sim2D": false, 
    "timeStepSize": 0.001,
    "numberOfStepsPerRenderUpdate": 2,
    "particleRadius": 0.025, 
    "simulationMethod": 4,
    "gravitation": [0.0,-9.81,0], 
    "cflMethod": 1, 
    "cflFactor": 1,
    "cflMaxTimeStepSize": 0.005,
    "maxIterations": 100,
    "maxError": 0.01,
    "maxIterationsV": 100,
    "maxErrorV": 0.1,		
    "stiffness": 50000,
    "exponent": 7,
    "velocityUpdateMethod": 0,
    "enableDivergenceSolver": true
}

General:

  • pause (bool): Pause simulation at beginning.

  • pauseAt (float): Pause simulation at the given time. When the value is negative, the simulation is not paused.

  • stopAt (float): Stop simulation at the given time and exit. When the value is negative, the simulation is not stopped.

  • cameraPosition (vec3): Initial position of the camera.

  • cameraLookat (vec3): Lookat point of the camera.

Visualization:

  • numberOfStepsPerRenderUpdate (int): Number of simulation steps per rendered frame

  • renderWalls (int):

    • 0: None

    • 1: Particles (all)

    • 2: Particles (no walls)

    • 3: Geometry (all)

    • 4: Geometry (no walls)

Export

  • enablePartioExport (bool): Enable/disable partio export (default: false).

  • enableVTKExport (bool): Enable/disable VTK export (default: false).

  • enableRigidBodyExport (bool): Enable/disable rigid body export (default: false).

  • enableRigidBodyVTKExport (bool): Enable/disable rigid body VTK export (default: false).

  • dataExportFPS (float): Frame rate of particle and rigid body export (default: 25).

  • particleAttributes (string): A list of attribute names separated by “;” that should be exported in the particle files (e.g. “velocity;density”) (default: “velocity”).

  • enableStateExport (bool): Enable/disable export of complete simulation state (default: false).

  • stateExportFPS (float): Frame rate of simulation state export (default: 1).

Simulation:

  • timeStepSize (float): The initial time step size used for the time integration. If you use an adaptive time stepping, this size will change during the simulation (default: 0.001).

  • particleRadius (float): The radius of the particles in the simulation (all have the same radius) (default: 0.025).

  • sim2D (bool): If this parameter is set to true, a 2D simulation is performend instead of a 3D simulation (default: false).

  • enableZSort (bool): Enable z-sort to improve cache hits and therefore to improve the performance (default: true).

  • gravitation (vec3): Vector to define the gravitational acceleration (default: [0,-9.81,0]).

  • maxIterations (int): Maximal number of iterations of the pressure solver (default: 100).

  • maxError (float): Maximal density error in percent which the pressure solver tolerates (default: 0.01).

  • boundaryHandlingMethod (int): The boundary handling method that is used in the simulation (default: 2, Volume Maps):

    • 0: particle-based boundaries (Akinci et al. 2012)

    • 1: density maps (Koschier et al. 2017)

    • 2: volume maps (Bender et al. 2019)

  • simulationMethod (int): The pressure solver method used in the simulation (default: 4, DFSPH):

    • 0: Weakly compressible SPH for free surface flows (WCSPH)

    • 1: Predictive-corrective incompressible SPH (PCISPH)

    • 2: Position based fluids (PBF)

    • 3: Implicit incompressible SPH (IISPH)

    • 4: Divergence-free smoothed particle hydrodynamics (DFSPH)

    • 5: Projective Fluids (dynamic boundaries not supported yet)

WCSPH parameters:

  • stiffness (float): Stiffness coefficient of the equation of state.

  • exponent (float): Exponent in the equation of state.

PBF parameters:

  • velocityUpdateMethod (int):

    • 0: First Order Update

    • 1: Second Order Update

DFSPH parameters:

  • enableDivergenceSolver (bool): Turn divergence solver on/off.

  • maxIterationsV (int): Maximal number of iterations of the divergence solver.

  • maxErrorV (float): Maximal divergence error in percent which the pressure solver tolerates.

Projective Fluids parameters:

  • stiffness (float): Stiffness coefficient used by the pressure solver.

Kernel:

  • kernel (int): Kernel function used in the SPH model.

    • For a 3D simulation:

      • 0: Cubic spline

      • 1: Wendland quintic C2

      • 2: Poly6

      • 3: Spiky

      • 4: Precomputed cubic spline (faster than cubic spline)

    • For a 2D simulation:

      • 0: Cubic spline

      • 1: Wendland quintic C2

  • gradKernel (int): Gradient of the kernel function used in the SPH model.

    • For a 3D simulation:

      • 0: Cubic spline

      • 1: Wendland quintic C2

      • 2: Poly6

      • 3: Spiky

      • 4: Precomputed cubic spline (faster than cubic spline)

    • For a 2D simulation:

      • 0: Cubic spline

      • 1: Wendland quintic C2

CFL:

  • cflMethod (int): CFL method used for adaptive time stepping.

    • 0: No adaptive time stepping

    • 1: Use CFL condition

    • 2: Use CFL condition and consider number of pressure solver iterations

  • cflFactor (float): Factor to scale the CFL time step size.

  • cflMinTimeStepSize (float): Min. allowed time step size.

  • cflMaxTimeStepSize (float): Max. allowed time step size.

FluidBlocks

In this part the user can define multiple axis-aligned blocks of fluid particles.

Example code:

"FluidBlocks": [
    {
        "denseMode": 0,
        "start": [-2.0, 0.0, -1],
        "end": [-0.5, 1.5, 1],
        "translation": [1.0, 0.0, 0.0],
        "scale": [1, 1, 1]
    }
]

  • start (vec3): Minimum coordinate of the box which defines the fluid block.

  • end (vec3): Maximum coordinate of the box which defines the fluid block.

  • translation (vec3): Translation vector of the block.

  • scale (vec3): Scaling vector of the block.

  • denseMode (int):

    • 0: regular sampling

    • 1: more dense sampling

    • 2: dense sampling

  • initialVelocity (vec3): The initial velocity is set for all particles in the block.

  • id (string): This id is used in the “Fluid parameter block” (see below) to define the properties of the fluid block. If no id is defined, then the standard id “Fluid” is used.

FluidModels

This part can be used to import one or more partio particle files in the scene.

Example code:

"FluidModels": [
    {
        "particleFile": "../models/bunny.bgeo",
        "translation": [-2.0, 0.1, 0.0],
        "rotationAxis": [0, 1, 0],
        "rotationAngle": 3.14159265359,
        "scale": 1
    }
]

  • particleFile (string): Path of the partio file which contains the particle data.

  • translation (vec3): Translation vector of the fluid model.

  • scale (vec3): Scaling vector of the fluid model.

  • rotationAxis (vec3): Axis used to rotate the particle data after loading.

  • rotationAngle (float): Rotation angle for the initial rotation of the particle data.

  • id: This id is used in the “Fluid parameter block” (see below) to define the properties of the fluid block. If no id is defined, then the standard id “Fluid” is used.

Emitters

In this part the user can define one or more emitters which generate fluid particles.

Example code:

"Emitters": [
    {
        "width": 5, 
        "height": 5, 
        "translation": [-1,0.75,0.0],
        "rotationAxis": [0, 1, 0],
		"rotationAngle": 3.1415926535897932384626433832795,
        "velocity": 2,	
        "emitStartTime": 2,
		"emitEndTime": 6,
        "type": 0
    }
]

  • type (int): Defines the shape of the emitter (default: 0).

    • 0: box

    • 1: circle

  • width (int): Width of the box or radius of the circle emitter in number of particles (default: 5).

  • height (int): Height of the box in number of particles (is only used for type 0) (default: 5).

  • translation (vec3): Translation vector of the emitter (default: [0,0,0]).

  • rotationAxis (vec3): Axis used to rotate the emitter. Note that in 2D simulations the axis is always set to [0,0,1] (default: [0,0,1]).

  • rotationAngle (float): Rotation angle for the initial rotation of the emitter (default: 0).

  • velocity (float): Initial velocity of the emitted particles in direction of the emitter (default: 1).

  • id: This id is used in the “Fluid parameter block” (see below) to define the properties of the fluid block. If no id is defined, then the standard id “Fluid” is used (default: “Fluid”).

  • emitStartTime (float): Start time of the emitter (default: 0).

  • emitEndTime (float): End time of the emitter (default: REAL_MAX).

RigidBodies

Here, the static and dynamic rigid bodies are defined which define the boundary in the scene. In case of dynamic rigid bodies, the PositionBasedDynamics library is used for their simulation. Note that in this case the PositionBasedDynamics library also reads this json scene files and picks out the relevant parts. That means if you want to define for example a hinge joint or a motor, then just use the json format of PositionBasedDynamics in this scene file.

Example code:

"RigidBodies": [
    {
        "geometryFile": "../models/UnitBox.obj",
        "translation": [0,2,0],
        "rotationAxis": [1, 0, 0],
        "rotationAngle": 0,
        "scale": [2.5, 4, 1.0],
        "color": [0.1, 0.4, 0.6, 1.0], 
        "isDynamic": false,
        "isWall": true,
        "mapInvert": true, 
		"mapThickness": 0.0,
		"mapResolution": [20,20,20],
        "samplingMode": 1
    }
]

  • geometryFile (string): Path to a OBJ file which contains the geometry of the body.

  • particleFile (string): Path to a partio file which contains a surface sampling of the body. Note that the surface sampling is done automatically if this parameter is missing.

  • translation (vec3): Translation vector of the rigid body.

  • scale (vec3): Scaling vector of the rigid body.

  • rotationAxis (vec3): Axis used to rotate the rigid body after loading.

  • rotationAngle (float): Rotation angle for the initial rotation of the rigid body.

  • isDynamic (bool): Defines if the body is static or dynamic.

  • isWall (bool): Defines if this is a wall. Walls are typically not rendered. This is the only difference.

  • color (vec4): RGBA color of the body.

  • mapInvert (bool): Invert the map when using density or volume maps, flips inside/outside (default: false)

  • mapThickness (float): Additional thickness of a volume or density map (default: 0.0)

  • mapResolution (vec3): Resolution of a volume or density map (defaut: [20,20,20])

  • samplingMode (int): Surface sampling mode. 0 Poisson disk sampling, 1 Regular triangle sampling (default: 0).

Materials

"Materials": [
	{
        "id": "Fluid",
        "density0": 1000, 
        "colorField": "velocity",
        "colorMapType": 1,
        "renderMinValue": 0.0,
        "renderMaxValue": 5.0,
        "surfaceTension": 0.2,
        "surfaceTensionMethod": 0,		
        "viscosity": 0.01,
        "viscosityMethod": 1, 
        "vorticityMethod": 1, 
        "vorticity": 0.15, 
        "viscosityOmega": 0.05,
        "inertiaInverse": 0.5,
        "maxEmitterParticles": 1000,
        "emitterReuseParticles": false,
        "emitterBoxMin": [-4.0,-1.0,-4.0],
        "emitterBoxMax": [0.0,4,4.0]
	}
]

General

  • id (string): Defines the id of the material. You have to give the same id to a FluidBlock, a FluidModel or an Emitter if they should have the defined material behavior.

  • density0 (float): Rest density of the corresponding fluid.

Particle Coloring

  • colorField (string): Choose vector or scalar field for particle coloring.

  • colorMapType (int): Selection of a color map for coloring the scalar/vector field.

    • 0: None

    • 1: Jet

    • 2: Plasma

    • 3: CoolWarm

    • 4: BlueWhiteRed

    • 5: Seismic

  • renderMinValue (float): Minimal value used for color-coding the color field in the rendering process.

  • renderMaxValue (float): Maximal value used for color-coding the color field in the rendering process.

Viscosity

  • viscosityMethod (int): Viscosity method

    • 0: None

    • 1: Standard

    • 2: XSPH

    • 3: Bender and Koschier 2017

    • 4: Peer et al. 2015

    • 5: Peer et al. 2016

    • 6: Takahashi et al. 2015 (improved)

    • 7: Weiler et al. 2018

  • viscosity (float): Coefficient for the viscosity force computation

  • viscoMaxIter (int): (Implicit solvers) Max. iterations of the viscosity solver.

  • viscoMaxError (float): (Implicit solvers) Max. error of the viscosity solver.

  • viscoMaxIterOmega (int): (Peer et al. 2016) Max. iterations of the vorticity diffusion solver.

  • viscoMaxErrorOmega (float): (Peer et al. 2016) Max. error of the vorticity diffusion solver.

  • viscosityBoundary (float): (Weiler et al. 2018) Coefficient for the viscosity force computation at the boundary.

Vorticity

  • vorticityMethod (int): Vorticity method

    • 0: None

    • 1: Micropolar model

    • 2: Vorticity confinement

  • vorticity (float): Coefficient for the vorticity force computation

  • viscosityOmega (float): (Micropolar model) Viscosity coefficient for the angular velocity field.

  • inertiaInverse (float): (Micropolar model) Inverse microinertia used in the micropolar model.

Drag force

  • dragMethod (int): Drag force method

    • 0: None

    • 1: Macklin et al. 2014

    • 2: Gissler et al. 2017

  • drag (float): Coefficient for the drag force computation

Surface tension

  • surfaceTensionMethod (int): Surface tension method

    • 0: None

    • 1: Becker & Teschner 2007

    • 2: Akinci et al. 2013

    • 3: He et al. 2014

  • surfaceTension (float): Coefficient for the surface tension computation

Elasticity

  • elasticityMethod (int): Elasticity method

    • 0: None

    • 1: Becker et al. 2009

    • 2: Peer et al. 2018

  • youngsModulus (float): Young’s modulus - coefficient for the stiffness of the material (default: 100000.0)

  • poissonsRatio (float): Poisson’s ratio - measure of the Poisson effect (default: 0.3)

  • alpha (float): Coefficent for zero-energy modes suppression method (default: 0.0)

  • elasticityMaxIter (int): (Peer et al. 2018) Maximum solver iterations (default: 100)

  • elasticityMaxError (float): (Peer et al. 2019) Maximum elasticity error allowed by the solver (default: 1.0e-4)

Emitters

  • maxEmitterParticles (int): Maximum number of particles the emitter generates. Note that reused particles (see below) are not counted here.

  • emitterReuseParticles (bool): Reuse particles if they are outside of the bounding box defined by emitterBoxMin, emitterBoxMax

  • emitterBoxMin (vec3): Minimum coordinates of an axis-aligned box (used in combination with emitterReuseParticles)

  • emitterBoxMax (vec3): Maximum coordinates of an axis-aligned box (used in combination with emitterReuseParticles)

Animation fields

In this part the user can define one or more animation fields which animate fluid particles. The user can define math expressions for the components of the field quantity. The typical math terms like cos,sin,… can be used.

Available expression variables:

  • t: Current time.

  • dt: Current time step size.

  • x, y, z: Position of the particle which is in the animation field.

  • vx, vy, vz: Velocity of the particle which is in the animation field.

  • valuex, valuey, valuez: Value of the field quantity of the particle which is in the animation field.

Example:

"particleField": "angular velocity",
"expression_x": "valuex + cos(2*t)"

This means that in each step we add cos(2*t) to the x-component of the angular velocity.

Example code:

"AnimationFields": [
    {
        "particleField": "velocity",
        "translation": [-0.5, -0.5, 0],
        "rotationAxis": [0, 0, 1],
        "rotationAngle": 0.0,
        "scale": [0.5, 0.25, 0.8],
        "shapeType": 0,
        "expression_x": "cos(2*t)*0.1",
        "expression_y": "",
        "expression_z": ""
    }
]

  • shapeType (int): Defines the shape of the animation field (default: 0).

    • 0: box

    • 1: sphere

    • 2: cylinder

  • particleField (string): Defines the field quantity that should be modified by the field (e.g. velocity, angular velocity, position) (default: velocity)

  • translation (vec3): Translation vector of the animation field (default: [0,0,0]).

  • rotationAxis (vec3): Axis used to rotate the animation field (default: [0,0,1]).

  • rotationAngle (float): Rotation angle for the initial rotation of the animation field (default: 0).

  • scale (vec3): Scaling vector of the animation field.

    • shapeType=0 (box): This vector defines the width, height, depth of the box.

    • shapeType=1 (sphere): The x-component of the vector defines the radius of the sphere. The other components are ignored.

    • shapeType=2 (cylinder): The x- and y-component of the vector defines the height and radius of the cylinder, repectively. The z-component is ignored.

  • expression_x (string): Math expression for the x-component of the field quantity (default=””).

  • expression_y (string): Math expression for the y-component of the field quantity (default=””).

  • expression_z (string): Math expression for the z-component of the field quantity (default=””).

Replicability

The SPlisHSPlasH library implements the SPH methods developed by our and other research groups (build instructions can be found here). This allows to reproduce the research results of the corresponding publications. Inspired by the Graphics Replicability Stamp Initiative we started to add scenes to the repository to reproduce some of the results in our papers:

Jan Bender, Tassilo Kugelstadt, Marcel Weiler, Dan Koschier, “Implicit Frictional Boundary Handling for SPH”, IEEE Transactions on Visualization and Computer Graphics, 2020

  • Figure 7.a) can be replicated by loading the scene: data/Scenes/GridModel_Akinci2012.json

  • Figure 7.b) can be replicated by loading the scene: data/Scenes/GridModel_Bender2019.json

Installation Instructions - Linux

Ubuntu Fresh Install

Installation List

sudo apt install git cmake xorg-dev freeglut3-dev build-essential

Python Bindings

If you plan on using the python bindings by specifying -DUSE_PYTHON_BINDINGS=On, then you should also have a working python installation in your path. This installs an additional tool pipx, which allows the installation of packages as executables in virtualized environments.

sudo apt install python3-dev python3-pip python3-venv
python3 -m pip install pipx
python3 -m pipx ensurepath

Alternatively to this you may also install other Python Distributions such as Anaconda (personal preference).

Building Instructions

git clone https://github.com/InteractiveComputerGraphics/SPlisHSPlasH.git
cd SPlisHSPlasH
mkdir build && cd build
cmake -DCMAKE_BUILD_TYPE=Release -DUSE_PYTHON_BINDINGS=<On|Off> ..
make -j 4

Run Executable

cd ../bin
./SPHSimulator ../data/Scenes/DoubleDamBreak.json

On some systems it may be necessary to define an OpenGL override like so

cd ../bin
MESA_GL_VERSION_OVERRIDE=3.3 ./SPHSimulator ../data/Scenes/DoubleDamBreak.json

The command loads the selected scene. To start the simulation disable the pause mode by clicking the checkbox or pressing [Space]. More hotkeys are listed here.

Using Bindings

Assuming that the python bindings were generated in the default location Project Root/build/lib/pysplishsplash.cpython-38-x86_64-linux-gnu.so, you can use the bindings by adding this path to sys.path within your python script, or by calling your scripts within the directory containing the .so file. You can test that the bindings work using the following command.

cd lib
python3 -c "import pysplishsplash"

Installing Bindings

If you followed the above instructions for building SPlisHSPlasH using CMake and generated the python bindings, then these commands should work automatically.

Note: You don’t have to clone the repository again. This only shows, that the command should be run in the project root directory. It is also recommended, that you create and activate a virtual environment before installing, so that your base python installation is not affected by any new generated files.

git clone https://github.com/InteractiveComputerGraphics/SPlisHSPlasH.git
cd SPlisHSPlasH
python setup.py bdist_wheel
pip install build/dist/*.whl

If you specified any additional CMake variables in the form of -DVAR_NAME=Value, you can just append them after bdist_wheel

Alternatively you may also run the following command, which essentially combines all of the above commands into a single command.

pip install git+https://github.com/InteractiveComputerGraphics/SPlisHSPlasH.git

Drawbacks: You lose the ability for incremental rebuilds, i.e. if you want to modify the source code and build the bindings anew, you would have to build the entire project every time.

Installation Instructions - Windows

Visual Studio

Dependencies

To build SPlisHSPlasH on Windows you need to install CMake and git.

Python Bindings

If you plan on using the python bindings by specifying -DUSE_PYTHON_BINDINGS=On, then you should also have a working Python installation in your path. Moreover, you require the Python Package Installer (pip).

Building Instructions

First, clone the repository by

git clone https://github.com/InteractiveComputerGraphics/SPlisHSPlasH.git

Then run cmake-gui and set “Where is the source code:” to the [SPlisHSPlasH-dir] and “Where to build the binaries:” to [SPlisHSPlasH-dir]/build.

Now run Configure and select the correct Visual Studio version. Ensure that you choose a x64 build on a 64bit system. Finally, run Generate and open the project. Now you can build the project in Visual Studio. Note that you have to select the “Release” build, if you want to have an optimized executable.

Run Executable

Execute “bin/SPHSimulator.exe” to start the simulator and select a scene file to run the simulation. Alternatively, you can start the simulation in the command line:

./SPHSimulator ../data/Scenes/DoubleDamBreak.json

The command loads the selected scene. To start the simulation disable the pause mode by clicking the checkbox or pressing [Space]. More hotkeys are listed here.

Using Bindings

Assuming that the python bindings were generated in the default location [SPlisHSPlasH-dir]/build/lib/pysplishsplash.cp37-win_amd64.pyd, you can use the bindings by adding this path to sys.path within your python script, or by calling your scripts within the directory containing the .pyd file. You can test that the bindings work using the following command.

cd lib
python3 -c "import pysplishsplash"

Installing Bindings

If you followed the above instructions for building SPlisHSPlasH using CMake and generated the python bindings, then these commands should work automatically.

Note: You don’t have to clone the repository again. This only shows, that the command should be run in the project root directory. It is also recommended, that you create and activate a virtual environment before installing, so that your base python installation is not affected by any new generated files.

git clone https://github.com/InteractiveComputerGraphics/SPlisHSPlasH.git
cd SPlisHSPlasH
python setup.py bdist_wheel
pip install build/dist/pySPlisHSPlasH-2.8.3-cp37-cp37m-win_amd64.whl

If you specified any additional CMake variables in the form of -DVAR_NAME=Value, you can just append them after bdist_wheel

Alternatively you may also run the following command, which essentially combines all of the above commands into a single command.

pip install git+https://github.com/InteractiveComputerGraphics/SPlisHSPlasH.git

Drawbacks: You lose the ability for incremental rebuilds, i.e. if you want to modify the source code and build the bindings anew, you would have to build the entire project every time.

CMake Options

This page should give you a short overview over the CMake options of SPlisHSPlasH.

USE_DOUBLE_PRECISION

If this flag is enabled, then all computations with floating point values are performed using double precision (double). Otherwise single precision (float) is used.

USE_AVX

SPlishSPlasH supports the usage of AVX (Advanced Vector Extensions) which is an extension of modern CPUs to perform a single instruction on multiple data. The extension allows to perform eight floating point operations in parallel. Enabling AVX significantly improves the performance of the simulator. Currently, the following methods have AVS support:

  • DFSPH

  • the micropolar vorticity model

  • the standard viscosity model

  • the viscosity model of Weiler et al.

USE_OpenMP

Enable the OpenMP parallelization which lets the simulation run in parallel on all available cores of the CPU.

USE_IMGUI

We just reimplemented the GUI using imgui instead of AntTweakBar. If you want to try out the new GUI, enable this flag.

USE_PYTHON_BINDINGS

Generate a shared library object which can be imported into python scripts and exposes C++ functionality to the python interpreter. Default:On Options:<On|Off>

USE_DEBUG_TOOLS

Adds a debug tools tab to the graphical user interface which allows to generate additional particle data for debugging. Note that generating the additional data will slightly decrease the performance of the simulation.

Software Architecture

https://raw.githubusercontent.com/InteractiveComputerGraphics/SPlisHSPlasH/master/doc/images/SoftwareArchitechture.jpg

SPlisHSPlasH follows a very intuitive and modular design approach. We want to illustrate part of the software architecture in conjunction with the simplified class diagram above. Note, that this documentation only covers the simulation part of SPlisHSPlasH. The whole software architecture follows a similar design pattern as the Model View Controller.

The Simulation class

The simulation class is the main part of the software. It contains the currently used simulation method (TimeStep), all fluids (FluidModel), all boundaries (BoundaryModel), and a AnimationFieldSystem. It is defined as a singleton, thus only one simulation instance exists during the runtime. The simulation instance contains:

  • exactly one TimeStep instance, which defines the simulation loop and contains the pressure solver

  • any number of FluidModel instances each defining a different fluid phase

  • any number of BoundaryModel instances representing either dynamic rigid bodies or static boundaries

  • exactly one AnimationFieldSystem instance which allows to animate particles in a predefined area

The simulation class also implements the following:

  • evaluation of the SPH kernel methods

  • update of the time step size using a CFL condition

  • uniform invocation of all EmitterSystem instances

  • invocation of AnimationFieldSystem instance

  • saving & loading the current simulation state

Lastly, the simulation class also contains a well defined interface for the neighborhood search functionalities defined in CompactNSearch or cuNSearch, which are further needed in the respective algorithm implementations in e.g. the TimeStep or NonPressureForces.

The TimeStep class

The TimeStep class is a abstract base class for any subsequent derived simulation method one wants to implement. It implements the required interface for the simulation class, noteably the step() function containing the simulation algorithm called in the main loop. During execution there exists exactly one instance of a TimeStep class. By default SPlisHSPlasH currently implements the following pressure solvers and the corresponding simulation algorithms:

  • WCSPH

  • PCISPH

  • PBF

  • IISPH

  • DFSPH

  • Projective Fluids

The FluidModel class

A FluidModel instance represents a fluid phase with its respective properties and applied effects to it. SPlisHSPlasH allows for arbitrary many FluidModels inside a simulation as long as there is at least one and they all have a different id (see scene file format). One FluidModel contains the following:

  • Physical parameters like rest density, mass, position, velocity, acceleration and current density

  • Simulation parameters like the number of particles, their state and ID

  • References to the applied non-pressure effects, one for each:

    • Drag

    • Elasticity

    • Surface tension

    • Viscosity

    • Vorticity

  • Emitter systems

Concerning the non-pressure effects, each FluidModel can only utilize up to one method per non-pressure effect, which will be directly included in the computation inside the computeNonPressureForces() method of the Simulation class. Thus having e.g. two different surface tension algorithms inside one FluidModel is not possible. However, it is possible to define e.g. two phases, which have a different viscosity model and only one regarding surface tension effects.

The emitters are only stored inside the FluidModels since they are assigned to a fixed FluidModel. Their functionalities are uniformly executed by the Simulation class in the emitParticles() step usually invoked at the end of the simulation loop of the current TimeStep instance.

The BoundaryModel class

The BoundaryModel class provides a useful base class for any boundary handling methods. It stores a RigidBodyObject reference representing the object of the boundary. This can be a stationary or dynamic rigid body, whose coupling effects are handled uniformly. Note that RigidBodyObject is an abstract class providing an interface for the two derived classes StaticRigidBody and PBDRigidBody. The first is handled internally and represent stationary objects. The latter describes a moving rigid body which is simulated externally by the PositionBasedDynamics library. SPlisHSPlasH implements three different boundary models:

  • Particle-based rigid-fluid coupling [Akinci et al. 2012]

  • Density maps [Koschier and Bender 2017]

  • Volume maps [Bender et al. 2019]

Finally, SPlisHSPlasH defines a boundary as a list of rigid bodies in conjunction with a rigid-fluid coupling algorithm.

Implementing a new non-pressure force method

Non-pressure forces (e.g. viscosity, vorticity, surface tension or drag forces) are all implemented in the same way in SPlisHSPlasH. In the following we explain the implementation of such a method using as example a new viscosity method.

SPlisHSPlasH organizes the viscosities in /SPlisHSPlasH/Viscosity/ and thus any changes or additions are intended to take place in this directory. The user can add new viscosity methods by creating new or copying and modifying exisiting viscosity class files and registering these inside the build system and the source code.

Creating a new class

If you want to create a new viscosity class from scratch, you should consider reading the doxygen documentation on the ViscosityBase class and several of its derived classes. In short, every viscosity method inherits from the base class ViscosityBase, which itself inherits from NonPressureForceBase. A minimal working derived class would look like this:

MyViscosity.h

#ifndef __MyViscosity_h__
#define __MyViscosity_h__

#include "SPlisHSPlasH/Common.h"
#include "SPlisHSPlasH/FluidModel.h"
#include "ViscosityBase.h"

namespace SPH 
{
	class MyViscosity : public ViscosityBase
	{
	protected:
		virtual void initParameters();

	public:
		MyViscosity(FluidModel *model);
		virtual ~MyViscosity(void);

		virtual void step();
		virtual void reset();
	};
}

#endif

MyViscosity.cpp

#include "MyViscosity.h"

MyViscosity::MyViscosity(FluidModel *model) :
	ViscosityBase(model)
{
	[...]
}

MyViscosity::~MyViscosity(void)
{
	[...]
}

void MyViscosity::initParameters()
{
	ViscosityBase::initParameters();

	[...]
}

void MyViscosity::step()
{
	[...]
}

void MyViscosity::reset()
{
	[...]
}

including the following:

  • a constructor with FluidModel* as the sole parameter MyViscosity(FluidModel *model)

  • a initParameters() method calling the base class method for parameter setup

  • a step function void step() called in each timestep for the associated fluid

  • a reset function void reset() called on every reset of the simulation

Customizing your class

The user is also free to add and save additional per particle data inside the viscosity method, but has to ensure that these are also included in the neighborhood search sort. Sorting is required if the data is used over multiple simulations steps. The neighborhood search performs a z-sort every n steps to improve the number of cache hits. Since all particles are resorted, also their data must be resorted. For this, the user has to override the performNeighborhoodSearchSort() method. A minimal example would look like the following:

void MyViscosity::performNeighborhoodSearchSort()
{
	Simulation *sim = Simulation::getCurrent();
	auto const& d = sim->getNeighborhoodSearch()->point_set(m_model->getPointSetIndex());
	d.sort_field(&m_myParticleViscosityData[0]);
}

For visualization and/or debugging purposes, the user may also want to subject the particle data to SPlisHSPlasH’s particle informations. To do this, the user has to add the particle data field to the list of fields inside each FluidModel. This can be for example done in the constructor by adding the addField(const FieldDescription &field) of the corresponding FluidModel. The fields can be used to define the color of a particle, they can be exported to bgeo or ParaView and in the simulator the user can output the field data of the selected particles by pressing “i”.

For more information, please refer to the doxygen documentation and maybe take a look at the already existing implementations. Adding a field has the following form:

model->addField({ "myFieldName", <FieldType>, <lambda expression returning reference to the data field>}, <save state (boolean)>);

Here is an example:

model->addField({ "myFieldName", FieldType::Vector3, [&](const unsigned int i) -> Real* { return &m_myFieldValues[i][0]; }, true });

The field name is used in the GUI and when exporting the data. The boolean at the end determines if this field should be stored when the simulation state is saved. This should only be done if the value is not recomputed in each simulation step so that the value of the last step is required.

Also don’t forget to remove the field, when the instance of the viscosity method is destroyed:

m_model->removeFiledByName("myFieldName");

Registering the viscosity method

To add our new viscosity method, we have to integrate it into the build process and the source code.

Adding to the build process

Simply add the class files MyViscosity.h and MyViscosity.cpp to the CMakeLists.txt in the /SPlisHSPlasH/ directory. This can be done by adding the relative file paths to the respective variables VISCOSITY_HEADER_FILES and VISCOSITY_SOURCE_FILES:

set(VISCOSITY_HEADER_FILES
	[...]
	Viscosity/MyViscosity.h
)

set(VISCOSITY_SOURCE_FILES
	[...]
	Viscosity/MyViscosity.cpp
)

Integration in the source code

Any viscosity method is registered in the FluidModel.h and FluidModel.cpp files, which can be found in the /SPlisHSPlasH/ directory. Adding our new viscosity method comprises of the following steps:

  • adding a new enum element in ViscosityMethods for our method

  • creating a new static variable static int ENUM_VISCOSITY_MYVISCOSITY for the GenericParameter system and initializing it in FluidModel.cpp

  • including Viscosity/MyViscosity.h in FluidModel.cpp

  • adding a new enum value for VISCOSITY_METHOD inside FluidModel::initParameters() using the following line:

enumParam->addEnumValue("MyViscosityName", ENUM_VISCOSITY_MYVISCOSITY);

  • adding your viscosity method to FluidModel::setViscosityMethod(), thus making it available for the simulation using the following:

else if (m_viscosityMethod == ViscosityMethods::MyViscosity)
		m_viscosity = new MyViscosity(this);

After these additions and building SPlisHSPlasH, our new viscosity method is available inside the simulation.

Creating Pressure Solvers

SPlisHSPlasH organizes the pressure solvers in their respective folders inside the /SPlisHSPlasH/ directory. For example DFSPH can be found inside /SPlisHSPlasH/DFSPH/. We highly suggest the user to follow our file organization scheme. The user can also add new pressure solvers by by creating new or copying and modifying existing classes and then adding them to the build system plus additionally registering in the source code.

Note that we do not strictly distinguish the pressure solver from the simulation algorithm. Each TimeStep class implements a whole time step including the pressure solver. The non-pressure forces are decoupled in their respective classes and only implicitly called. Thus for implementing a new pressure solver, we suggest copying the files from for example WCSPH and replacing the pressure solver by your own one. Note further, that we usually decouple data from the algorithm with the SimulationData classes. We strongly recommend doing the same with your implementation.

Creating a new class

Again, we want to stress that copying and modifying existent methods is easier than writing a new class from scratch. However, if you want to do so, be sure to implement every abstract method inherited from TimeStep. These include:

  • void step(), the simulation step function

  • void resize(), a method to initialize and resize any used field

Albeit being not necessary, the user may also want to override/redefine the following methods:

  • void init(), the initialization method. It is important to call TimeStep::init() inside this method

  • void reset(), the method invoked on every reset command

  • void computeDensities(), if the user does not want to utilize the given density computation

A minimal working example of a derive class is shown below:

TimeStepMyPressureSolver.h

#ifndef __TimeStepMyPressureSolver_h__
#define __TimeStepMyPressureSolver_h__

#include "SPlisHSPlasH/Common.h"
#include "SPlisHSPlasH/TimeStep.h"
#include "SPlisHSPlasH/SPHKernels.h"

namespace SPH
{
	class TimeStepMyPressureSolver : public TimeStep
	{
    public:
        TimeStepMyPressureSolver();
        virtual ~TimeStepMyPressureSolver();

        virtual void step();
        
        virtual void resize();
    };
}

#endif

TimeStepMyPressureSolve.cpp

#include "TimeStepMyPressureSolve.h"

using namespace SPH;
using namespace GenParam;

TimeStepMyPressureSolve::TimeStepMyPressureSolve() :
    TimeStep()
{
    [...]
}

TimeStepMyPressureSolve::~TimeStepMyPressureSolve(void)
{
    [...]
}

void TimeStepMyPressureSolve::step()
{
    [...]
}

void TimeStepMyPressureSolve::resize()
{
    [...]
}

SPlisHSPlasH assumes your simulation method allows for operator splitting, thus usually dividing the simulation into non-pressure forces and the pressure solver plus advection. The latter is subject of the TimeStep class. It is still possible to implement these together inside your own TimeStep class, but it contradicts SPlisHSPlasH’s design principles. Since the step() method is forwarded to the main loop by the simulation class, its purpose is to define the simulation algorithm. For guidance, we also provide a simple SPH simulation algorithm outline:

void TimeStepWCSPH::step()
{
	Simulation *sim = Simulation::getCurrent();
	const unsigned int nModels = sim->numberOfFluidModels();
	TimeManager *tm = TimeManager::getCurrent ();
	const Real h = tm->getTimeStepSize();

    // 1. Perform a neighborhood search
	performNeighborhoodSearch();

    // 2. Compute non-pressure forces and SPH densities
	for (unsigned int fluidModelIndex = 0; fluidModelIndex < nModels; fluidModelIndex++)
	{
		clearAccelerations(fluidModelIndex);
		computeDensities(fluidModelIndex);
	}
	sim->computeNonPressureForces();

    // 3. Compute pressure forces
	computePressureForces();

    // 4. Update time step tize with CFL condition
	sim->updateTimeStepSize();

    // 5. Advect particles
	advectParticles();

    // 6. Emit and/or animate particles if necessary
	sim->emitParticles();
	sim->animateParticles();

    // 7. Advect time
	tm->setTime(tm->getTime() + h);
}

where computeDensities(...) and clearAcceleration(...) are already defined by the base class.

We recommend the user to split the simulation algorithm and its data into two separate classes as it is the case for our already implemented ones.

Registering the pressure solver

To add our new simulation method, we have to integrate it into the build process and the source code.

Adding to the build process

Simply add all of your class files to the CMakeLists.txt in the /SPlisHSPlasH/ directory. We suggest creating new variables for the header and source files and adding these to the add_library() as well as to new source_group() calls. A possible implementation following our class file conventions would look like the following:

set(MYPRESSURESOLVER_HEADER_FILES
    MyPressureSolver/SimulationDataMyPressureSolver.h
    MyPressureSolver/TimeStepMyPressureSolver.h
)

set(MYPRESSURESOLVER_SOURCE_FILES
    MyPressureSolver/SimulationDataMyPressureSolver.cpp
    MyPressureSolver/TimeStepMyPressureSolver.cpp
)

add_library(SPlisHPlasH

    [...]

    ${MYPRESSURESOLVER_HEADER_FILES}
    ${MYPRESSURESOLVER_SOURCE_FILES}
)

source_group("Header Files\\MyPressureSolver" FILES ${MYPRESSURESOLVER_HEADER_FILES})
source_group("Source Files\\MyPressureSolver" FILES ${MYPRESSURESOLVER_SOURCE_FILES})

Integration in the source code

Any timestep method and thus any pressure solver is registered in the Simulation.h and Simulation.cpp files, which can be found in the /SPlisHSPlasH/ directory. Adding a new method comprises of the following steps:

  • Adding a new enum in SimulationMethods

  • Creating a new static variable static int ENUM_SIMULATION_MYPRESSURESOLVER for the GenericParameter system and initializing it in Simulation.cpp

  • Including SPlisHSPlasH/MyPressureSolver/TimeStepMyPressureSolver.h in Simulation.cpp

  • Adding a new enum value for SIMULATION_METHOD inside Simulation::initParameters() using the following line:

enumParam->addEnumValue("MyPressureSolverName", ENUM_SIMULATION_MYPRESSURESOLVER);

  • Adding the pressure solver to Simulation::setSimulationMethod(...), thus making it available for the simulation using the following:

else if (method == SimulationMethods::MyPressureSolver)
{
    m_timeStep = new TimeStepMyPressureSolver();
    m_timeStep->init();
    setValue(Simulation::KERNEL_METHOD, <desired standard SPH kernel>);
    setValue(Simulation::GRAD_KERNEL_METHOD, <desired standard SPH gradient kernel>);
}

After these additions and building SPlisHSPlasH, our new pressure solver is available inside the simulation.

Macros

SPlisHSPlasH defines useful macros to e.g. iterate over all neighboring particles inside the neighborhood of the current one. These can be found in Simulation.h. In the following, we want to give a short overview over these macros. For further information, please refer to the api documentation.

Looping over fluid neighbors

An essential part of SPH computation is to use the properties of neighboring particles to compute the desired value. SPlisHSPlasH provides macros iterating over every fluid neighbor, which can be used like predefined for-loop constructs. These include the following:

forall_fluid_neigbors

#define forall_fluid_neighbors(code) \
	for (unsigned int pid = 0; pid < nFluids; pid++) \
	{ \
		FluidModel *fm_neighbor = sim->getFluidModelFromPointSet(pid); \
		for (unsigned int j = 0; j < sim->numberOfNeighbors(fluidModelIndex, pid, i); j++) \
		{ \
			const unsigned int neighborIndex = sim->getNeighbor(fluidModelIndex, pid, i, j); \
			const Vector3r &xj = fm_neighbor->getPosition(neighborIndex); \
			code \
		} \
	}

forall_fluid_neigbors loops over every fluid particle (in all fluid phases) in the neighborhood region of the current one. Note that this does not include boundary particles. The user can use this macro by writing the desired code inside the brackets. For the usage of most of the macros, some additional variables have to be predefined. These include in this case:

  • Simulation *sim = Simulation::getCurrent(), the current simulation instance

  • unsigned int nFluids, the amount of FluidModel instances

  • unsigned int fluidModelIndex, the index of the FluidModel of the current particle

  • unsigned int i, the index of the current particle inside the FluidModel with index fluidModelIndex

Further, this macro also defines certain variables, which can be accessed inside the code given to the macro:

  • unsigned int pid, the index of the FluidModel of the neighboring particle

  • FluidModel *fm_neighbor, the FluidModel reference of the neighboring particle

  • const unsigned int neighborIndex, the particle index of the neighboring particle

  • const Vector3r &xj, the position of the neighboring particle

Henceforth, we denote the required additional variables by Requires and the by the macro defined ones by Defines.

forall_fluid_neighbors_in_same_phase

#define forall_fluid_neighbors_in_same_phase(code) \
	for (unsigned int j = 0; j < sim->numberOfNeighbors(fluidModelIndex, fluidModelIndex, i); j++) \
	{ \
		const unsigned int neighborIndex = sim->getNeighbor(fluidModelIndex, fluidModelIndex, i, j); \
		const Vector3r &xj = model->getPosition(neighborIndex); \
		code \
	}

forall_fluid_neighbors_in_same_phase loops over every fluid particle in the neighborhood region considering only neighbors from the same FluidModel as the current one.

  • Requires:

    • Simulation *sim = Simulation::getCurrent()

    • unsigned int fluidModelIndex

    • unsigned int i

  • Defines:

    • const unsigned int neighborIndex

    • const Vector3r &xj

Looping over boundaries

forall_boundary_neighbors

#define forall_boundary_neighbors(code) \
    for (unsigned int pid = nFluids; pid < sim->numberOfPointSets(); pid++) \
    { \
	    BoundaryModel_Akinci2012 *bm_neighbor = static_cast<BoundaryModel_Akinci2012*>(sim->getBoundaryModelFromPointSet(pid)); \
	    for (unsigned int j = 0; j < sim->numberOfNeighbors(fluidModelIndex, pid, i); j++) \
	    { \
	    	const unsigned int neighborIndex = sim->getNeighbor(fluidModelIndex, pid, i, j); \
	    	const Vector3r &xj = bm_neighbor->getPosition(neighborIndex); \
	    	code \
	    } \
    }

forall_boundary_neighbors loops over all boundary neighbors casting them to the Akinci 2012 boundary model.

  • Requires:

    • Simulation *sim = Simulation::getCurrent()

    • unsigned int nFluids

    • unsigned int fluidModelIndex

    • unsigned int i

  • Defines:

    • unsigned int pid, the index of the FluidModel associated with the BoundaryModel

    • BoundaryModel_Akinci2012 *bm_neighbor, the BoundaryModel reference of the neighboring particle

    • const unsigned int neighborIndex, the particle index of the neighboring particle

    • const Vector3r &xj, the position of the neigboring particle

forall_density_maps

#define forall_density_maps(code) \
for (unsigned int pid = 0; pid < nBoundaries; pid++) \
{ \
	BoundaryModel_Koschier2017 *bm_neighbor = static_cast<BoundaryModel_Koschier2017*>(sim->getBoundaryModel(pid)); \
	const Real rho = bm_neighbor->getBoundaryDensity(fluidModelIndex, i); \
	if (rho != 0.0) \
	{ \
		const Vector3r &gradRho = bm_neighbor->getBoundaryDensityGradient(fluidModelIndex, i).cast<Real>(); \
		const Vector3r &xj = bm_neighbor->getBoundaryXj(fluidModelIndex, i); \
		code \
	} \
}

forall_density_maps loops over all boundary neighbors casting them to the Koschier 2017 boundary model.

  • Requires:

    • Simulation *sim = Simulation::getCurrent()

    • unsigned int nBoundaries

    • unsigned int fluidModelIndex

    • unsigned int i

  • Defines:

    • unsigned int pid

    • BoundaryModel_Koschier2017 *bm_neighbor

    • const Real rho, the boundary density given by the density map

    • const Vector3r &gradRho, the boundary density gradient

    • const Vector3r &xj

forall_volume_maps

#define forall_volume_maps(code) \
    for (unsigned int pid = 0; pid < nBoundaries; pid++) \
    { \
    	BoundaryModel_Bender2019 *bm_neighbor = static_cast<BoundaryModel_Bender2019*>(sim->getBoundaryModel(pid)); \
    	const Real Vj = bm_neighbor->getBoundaryVolume(fluidModelIndex, i);  \
    	if (Vj > 0.0) \
    	{ \
    		const Vector3r &xj = bm_neighbor->getBoundaryXj(fluidModelIndex, i); \
    		code \
    	} \
    }

forall_volume_maps loops over all boundary neighbors casting them to the Bender 2019 boundary model.

  • Requires:

    • Simulation *sim = Simulation::getCurrent()

    • unsigned int nBoundaries

    • unsigned int fluidModelIndex

    • unsigned int i

  • Defines:

    • unsigned int pid

    • BoundaryModel_Koschier2019 *bm_neighbor

    • const Real Vj, the boundary volume given by the volume map

    • const Vector3r &xj

AVX variants

SPlisHSPlasH also defines versions using AVX optimizations for some of the macros. These can be used if the respective CMake option is set in the building process. Note that many of the aforementioned by the macro defined variables are given in AVX compatible data types, if you choose to use the AVX version of these macros.

pySPlisHSPlasH

Python bindings for the SPlisHSPlasH library

Requirements

Currently the generation of python bindings is only tested on

  • Linux Debian, gcc 8.3, Python 3.7/3.8 (Anaconda), CMake 3.13

  • Windows 10, Visual Studio 15/17/19, Python 3.7/3.8 (Anaconda), CMake 3.13

Note that the compiler, the python installation as well as cmake have to be available from the command line for the installation process to work. MacOS builds should work but have not been tested.

Installation

In order to install it is advised that you create a new virtual environment so that any faults during installation can not mess up your python installation. This is done as follows for

conda

conda create --name venv python=3.7
conda activate venv

virtualenv

python3 -m virtualenv venv --python=python3.7
source venv/bin/activate

Now you can clone the repository by

git clone https://github.com/InteractiveComputerGraphics/SPlisHSPlasH.git

And finally you should be able to install SPlisHSPlasH using pip. The trailing slash is important otherwise pip will try to download the package, which is not supported yet at least. Also note, that pip install SPlisHSPlasH should be called from one directory above the cloned source directory and not within the directory itself.

pip install SPlisHSPlasH/

While pip install is useful if SPlisHSPlasH should only be installed once, for development purposes it might be more sensible to build differently. Change into the SPlisHSPlasH directory and build a python wheel file as follows

cd SPlisHSPlasH
python setup.py bdist_wheel
pip install -I build/dist/*.whl

When building a new version of SPlisHSPlasH simply run these commands again and the installation will be updated. The compile times will be lower, because the build files from previous installations remain. If you are getting compile errors please try to compile the pysplishsplash target of the CMake project separately.

Now check your installation by running

python -c "import pysplishsplash"

Note: You may have to install numpy. Future releases may already contain numpy as a dependency.

pip install numpy

I want to see something very very quickly

If you’re very impatient, just run the following command after installing

splash

You will be prompted to select a preconfigured scene file which will then be run in a User Interface. For more options and functionality run. The keybindings in the GUI are the same as for the regular SPlisHSPlasH version.

splash --help

Minimal working example

The following examples should work, if SPlisHSPlasH was installed correctly. If you want to load other scene files, be sure to place them into the SPlisHSPlasH data directory structure.

With GUI

import pysplishsplash as sph

def main():
    base = sph.Exec.SimulatorBase()
    base.init()
    gui = sph.GUI.Simulator_GUI_TweakBar(base)
    base.setGui(gui)
    base.run()

if __name__ == "__main__":
    main()

Without GUI

import pysplishsplash as sph

def main():
    base = sph.Exec.SimulatorBase()
    base.init(useGui=False)
    base.setValueFloat(base.STOP_AT, 10.0) # Important to have the dot to denote a float
    base.run()

if __name__ == "__main__":
    main()

Outputting the results to a specific directory without GUI

import pysplishsplash as sph
from pysplishsplash.Extras import Scenes
import os

def main():
    base = sph.Exec.SimulatorBase()
    output_dir = os.path.abspath("where/you/want/the/data")
    base.init(useGui=False, outputDir=output_dir, sceneFile=Scenes.DoubleDamBreak)
    base.setValueFloat(base.STOP_AT, 20.0) # Important to have the dot to denote a float
    base.setValueBool(base.VTK_EXPORT, True)
    # Uncomment the next line to set the output FPS value (must be float)
    # base.setValueFloat(base.DATA_EXPORT_FPS, 10000.) 
    base.run()

if __name__ == "__main__":
    main()

SPHSimulator.py

If you want to start the simulator in the same way as the C++ version, just use the SPHSimulator.py in the examples directory.

Modifying other properties

The bindings cover most of the public interface of the SPlisHSPlasH library. As such, it is possible to change components of the simulation dynamically. In the following example, the second cube in the well known double dam break scenario is replaced with a slightly larger cube.

import pysplishsplash
import pysplishsplash.Utilities.SceneLoaderStructs as Scene

def main():
    base = pysplishsplash.Exec.SimulatorBase()
    args = base.init()
    gui = pysplishsplash.GUI.Simulator_GUI_TweakBar(base)
    base.setGui(gui)
    scene = base.getScene()
    add_block = Scene.FluidBlock('Fluid', Scene.Box([0.0, 0.0, 0.0], [1.0, 1.0, 1.0]), 0, [0.0, 0.0, 0.0])
    scene.fluidBlocks[1] = add_block # In Place construction not supported yet
    base.run()

if __name__ == "__main__":
    main()

Creating Scenes

Loading the empty scene

Right now the easiest way to create a custom scene without specifying a Scene.json file, is to load the predefined empty scene.

import pysplishsplash as sph
import pysplishsplash.Utilities.SceneLoaderStructs as Scenes

base = sph.Exec.SimulatorBase()
base.init(sceneFile=Scenes.Empty)

This scene will set the default simulation method to be DFSPH and some other default values, which can all be changed later on.

Recreating the double dam break scenario

In order to recreate the double dam break scenario, we need to add a bounding box as well as two fluid cubes. The bounding box can be added as follows

scene = base.getScene()
scene.boundaryModels.append(Scenes.BoundaryData(meshFile="../models/UnitBox.obj", translation=[0., 3.0, 0.], scale=[4., 6., 4.], color=[0.1, 0.4, 0.5, 1.0], isWall=True, mapInvert=True, mapResolution=[25, 25, 25]))

The two fluid blocks can at the end be added using

scene.fluidBlocks.append(Scenes.FluidBlock(id='Fluid', box=Scenes.Box([-1.5, 0.0, -1.5], [-0.5, 2.0, -0.5]), mode=0, initialVelocity=[0.0, 0.0, 0.0]))
scene.fluidBlocks.append(Scenes.FluidBlock(id='Fluid', box=Scenes.Box([0.5, 0.0, 0.5], [1.5, 2.0, 1.5]), mode=0, initialVelocity=[0.0, 0.0, 0.0]))

This will recreate a somewhat larger scene than the default double dam break

Putting it all together

The following shows a script detailing how to build and run a custom double dam break. Follow the instruction from before to activate/ deactivate the GUI.

import pysplishsplash as sph
import pysplishsplash.Utilities.SceneLoaderStructs as Scenes

def main():
    # Set up the simulator
    base = sph.Exec.SimulatorBase()
    base.init(useGui=True,  sceneFile=sph.Extras.Scenes.Empty)

    # Create a tweak bar simulator
    gui = sph.GUI.Simulator_GUI_TweakBar(base)
    base.setGui(gui)

    # Get the scene and add objects
    scene = base.getScene()
    scene.boundaryModels.append(Scenes.BoundaryData(meshFile="../models/UnitBox.obj", translation=[0., 3.0, 0.], scale=[4., 6., 4.], color=[0.1, 0.4, 0.5, 1.0], isWall=True, mapInvert=True, mapResolution=[25, 25, 25]))
    scene.fluidBlocks.append(Scenes.FluidBlock(id='Fluid', box=Scenes.Box([-1.5, 0.0, -1.5], [-0.5, 2.0, -0.5]), mode=0, initialVelocity=[0.0, 0.0, 0.0]))
    scene.fluidBlocks.append(Scenes.FluidBlock(id='Fluid', box=Scenes.Box([0.5, 0.0, 0.5], [1.5, 2.0, 1.5]), mode=0, initialVelocity=[0.0, 0.0, 0.0]))

    # Run the GUI
    base.run()

if __name__ == "__main__":
    main()

Loading a scene from file

Loading a scene from a file is as simple as simply specifying a custom scene file in the init function. This must be an absolute path!

custom_scene = os.path.abspath("scene.json")
base.init(sceneFile=custom_scene)

If you want to use a gui to locate the scene file you may want to use tkinter

import tkinter as tk
from tkinter import filedialog

tk.Tk().withdraw() # Dont show main window
custom_scene = filedialog.askopenfilename()
base.init(sceneFile=custom_scene)

Restrictions

  • When modifying simulation parameters this is the recommended structure, as modification will only work after base.initSimulation() has been called.

base.initSimulation()
sim = sph.Simulation.getCurrent()
sim.setValue...()
base.runSimulation()
base.cleanup()

  • setValue...() and getValue...() functions cannot accept vectors as arguments yet

Library API

Class Hierarchy

File Hierarchy

Full API

Namespaces

Namespace @54

Namespace Eigen

Contents

Namespace GenParam

Namespace SPH

Classes

Namespace std

Classes and Structs

Template Struct generic_product_impl< MatrixReplacement, Rhs, SparseShape, DenseShape, GemvProduct >

Inheritance Relationships
Base Type

  • public generic_product_impl_base< MatrixReplacement, Rhs, generic_product_impl< MatrixReplacement, Rhs > >

Struct Documentation
template<typename Rhs>
struct Eigen::internal::generic_product_impl<MatrixReplacement, Rhs, SparseShape, DenseShape, GemvProduct> : public generic_product_impl_base<MatrixReplacement, Rhs, generic_product_impl<MatrixReplacement, Rhs>>

Implementation of the matrix-free matrix vector product

Public Types

typedef Product<MatrixReplacement, Rhs>::Scalar Scalar

Public Static Functions

template<typename Dest>
void scaleAndAddTo(Dest &dst, const MatrixReplacement &lhs, const Rhs &rhs, const Scalar &alpha)

Template Struct traits< SPH::MatrixReplacement >

Inheritance Relationships
Base Type

  • public Eigen::internal::traits< SystemMatrixType >

Struct Documentation
template<>
struct traits<SPH::MatrixReplacement> : public Eigen::internal::traits<SystemMatrixType>

Struct FieldDescription

Struct Documentation
struct SPH::FieldDescription

Public Functions

FieldDescription(const std::string &n, const FieldType &t, const std::function<void*(const unsigned int)> &fct, const bool s = false, )

Public Members

std::string name
FieldType type
std::function<void*(const unsigned int)> getFct
bool storeData

Struct PoissonDiskSampling::CellPosHasher

Nested Relationships

This struct is a nested type of Class PoissonDiskSampling.

Struct Documentation
struct SPH::PoissonDiskSampling::CellPosHasher

Public Functions

std::size_t operator()(const CellPos &k) const

Struct PoissonDiskSampling::HashEntry

Nested Relationships

This struct is a nested type of Class PoissonDiskSampling.

Struct Documentation
struct SPH::PoissonDiskSampling::HashEntry

Struct to store the hash entry (spatial hashing)

Public Functions

HashEntry()

Public Members

std::vector<unsigned int> samples
unsigned int startIndex

Struct PoissonDiskSampling::InitialPointInfo

Nested Relationships

This struct is a nested type of Class PoissonDiskSampling.

Struct Documentation
struct SPH::PoissonDiskSampling::InitialPointInfo

Struct to store the information of the initial points.

Public Members

CellPos cP
Vector3r pos
unsigned int ID

Struct AverageCount

Struct Documentation
struct Utilities::AverageCount

Public Members

Real sum
unsigned int numberOfCalls

Struct AverageTime

Struct Documentation
struct Utilities::AverageTime

Struct to store the total time and the number of steps in order to compute the average time.

Public Members

double totalTime
unsigned int counter
std::string name

Struct MeshFaceIndices

Struct Documentation
struct Utilities::MeshFaceIndices

Struct to store the position and normal indices.

Public Members

int posIndices[3]
int texIndices[3]
int normalIndices[3]

Struct SceneLoader::AnimationFieldData

Nested Relationships

This struct is a nested type of Class SceneLoader.

Struct Documentation
struct Utilities::SceneLoader::AnimationFieldData

Struct to store an animation field object.

Public Members

std::string particleFieldName
std::string expression[3]
unsigned int shapeType
Vector3r x
Matrix3r rotation
Vector3r scale
Real startTime
Real endTime

Struct SceneLoader::BoundaryData

Nested Relationships

This struct is a nested type of Class SceneLoader.

Struct Documentation
struct Utilities::SceneLoader::BoundaryData

Struct to store a boundary object.

Public Members

std::string samplesFile
std::string meshFile
Vector3r translation
Matrix3r rotation
Vector3r scale
Real density
bool dynamic
bool isWall
Eigen::Matrix<float, 4, 1, Eigen::DontAlign> color
void *rigidBody
std::string mapFile
bool mapInvert
Real mapThickness
Eigen::Matrix<unsigned int, 3, 1, Eigen::DontAlign> mapResolution
unsigned int samplingMode

Struct SceneLoader::Box

Nested Relationships

This struct is a nested type of Class SceneLoader.

Struct Documentation
struct Utilities::SceneLoader::Box

Struct for an AABB.

Public Members

Vector3r m_minX
Vector3r m_maxX

Struct SceneLoader::EmitterData

Nested Relationships

This struct is a nested type of Class SceneLoader.

Struct Documentation
struct Utilities::SceneLoader::EmitterData

Struct to store an emitter object.

Public Members

std::string id
unsigned int width
unsigned int height
Vector3r x
Real velocity
Matrix3r rotation
Real emitStartTime
Real emitEndTime
unsigned int type

Struct SceneLoader::FluidBlock

Nested Relationships

This struct is a nested type of Class SceneLoader.

Struct Documentation
struct Utilities::SceneLoader::FluidBlock

Struct to store a fluid block.

Public Members

std::string id
Box box
unsigned char mode
Vector3r initialVelocity

Struct SceneLoader::FluidData

Nested Relationships

This struct is a nested type of Class SceneLoader.

Struct Documentation
struct Utilities::SceneLoader::FluidData

Struct to store a fluid object.

Public Members

std::string id
std::string samplesFile
Vector3r translation
Matrix3r rotation
Vector3r scale
Vector3r initialVelocity
unsigned char mode
bool invert
std::array<unsigned int, 3> resolutionSDF

Struct SceneLoader::MaterialData

Nested Relationships

This struct is a nested type of Class SceneLoader.

Struct Documentation
struct Utilities::SceneLoader::MaterialData

Struct to store particle coloring information.

Public Members

std::string id
std::string colorField
unsigned int colorMapType
Real minVal
Real maxVal
unsigned int maxEmitterParticles
bool emitterReuseParticles
Vector3r emitterBoxMin
Vector3r emitterBoxMax

Struct SceneLoader::Scene

Nested Relationships

This struct is a nested type of Class SceneLoader.

Struct Documentation
struct Utilities::SceneLoader::Scene

Struct to store scene information.

Public Members

std::vector<BoundaryData*> boundaryModels
std::vector<FluidData*> fluidModels
std::vector<FluidBlock*> fluidBlocks
std::vector<EmitterData*> emitters
std::vector<AnimationFieldData*> animatedFields
std::vector<MaterialData*> materials
Real particleRadius
bool sim2D
Real timeStepSize
Vector3r camPosition
Vector3r camLookat

Struct TimingHelper

Struct Documentation
struct Utilities::TimingHelper

Struct to store a time measurement.

Public Members

std::chrono::time_point<std::chrono::high_resolution_clock> start
std::string name

Class Matrix3f8

Class Documentation
class Matrix3f8

Public Functions

Matrix3f8()
Matrix3f8(const Vector3f8 &m1, const Vector3f8 &m2, const Vector3f8 &m3)
void setZero()
Scalarf8 &operator()(int i, int j)
void setCol(int i, const Vector3f8 &v)
void setCol(int i, const Scalarf8 &x, const Scalarf8 &y, const Scalarf8 &z)
Matrix3f8 operator*(const Scalarf8 &b) const
Vector3f8 operator*(const Vector3f8 &b) const
Matrix3f8 operator*(const Matrix3f8 &b) const
Matrix3f8 &operator+=(const Matrix3f8 &a)
Matrix3f8 transpose() const
Scalarf8 determinant() const
void store(std::vector<Matrix3r> &Mf) const
Matrix3r reduce() const

Public Members

Scalarf8 m[3][3]

Class Quaternion8f

Class Documentation
class Quaternion8f

Public Functions

Quaternion8f()
Quaternion8f(Scalarf8 x, Scalarf8 y, Scalarf8 z, Scalarf8 w)
Quaternion8f(Vector3f8 &v)
Scalarf8 &operator[](int i)
Scalarf8 operator[](int i) const
Scalarf8 &x()
Scalarf8 &y()
Scalarf8 &z()
Scalarf8 &w()
Scalarf8 x() const
Scalarf8 y() const
Scalarf8 z() const
Scalarf8 w() const
const Quaternion8f operator*(const Quaternion8f &a) const
void toRotationMatrix(Matrix3f8 &R)
void toRotationMatrix(Vector3f8 &R1, Vector3f8 &R2, Vector3f8 &R3)
void store(std::vector<Quaternionr> &qf) const
void set(const std::vector<Quaternionr> &qf)

Public Members

Scalarf8 q[4]

Class Scalarf8

Class Documentation
class Scalarf8

Public Functions

Scalarf8()
Scalarf8(float f)
Scalarf8(Real f0, Real f1, Real f2, Real f3, Real f4, Real f5, Real f6, Real f7)
Scalarf8(float const *p)
Scalarf8(__m256 const &x)
void setZero()
Scalarf8 &operator=(__m256 const &x)
Scalarf8 sqrt() const
Scalarf8 rsqrt() const
Scalarf8 &load(float const *p)
void store(float *p) const
float reduce() const

Public Members

__m256 v

Class AdhesionKernel

Class Documentation
class SPH::AdhesionKernel

Adhesion kernel used for the surface tension method of Akinci el al. [ATT13].

References:

  • [AAT13] Nadir Akinci, Gizem Akinci, and Matthias Teschner. Versatile surface tension and adhesion for sph fluids. ACM Trans. Graph., 32(6):182:1-182:8, November 2013. URL: http://doi.acm.org/10.1145/2508363.2508395

Public Static Functions

Real getRadius()
void setRadius(Real val)
Real W(const Real r)

W(r,h) = (0.007/h^3.25)(-4r^2/h + 6r -2h)^0.25 if h/2 < r <= h

Real W(const Vector3r &r)
Real W_zero()

Protected Static Attributes

Real m_radius
Real m_k
Real m_W_zero

Class AnimationField

Class Documentation
class SPH::AnimationField

Public Functions

AnimationField(const std::string &particleFieldName, const Vector3r &pos, const Matrix3r &rotation, const Vector3r &scale, const std::string expression[3], const unsigned int type = 0)
~AnimationField()
void setStartTime(Real val)
void setEndTime(Real val)
void step()
void reset()

Protected Functions

FORCE_INLINE bool inBox (const Vector3r &x, const Vector3r &xBox, const Matrix3r &rotBox, const Vector3r &scaleBox)
FORCE_INLINE bool inCylinder (const Vector3r &x, const Vector3r &xCyl, const Matrix3r &rotCyl, const Real h, const Real r2)
FORCE_INLINE bool inSphere (const Vector3r &x, const Vector3r &pos, const Matrix3r &rot, const Real radius)
FORCE_INLINE bool inShape (const int type, const Vector3r &x, const Vector3r &pos, const Matrix3r &rot, const Vector3r &scale)

Protected Attributes

std::string m_particleFieldName
Vector3r m_x
Matrix3r m_rotation
Vector3r m_scale
std::string m_expression[3]
unsigned int m_type
Real m_startTime
Real m_endTime

Class AnimationFieldSystem

Class Documentation
class SPH::AnimationFieldSystem

Public Functions

AnimationFieldSystem()
~AnimationFieldSystem()
void addAnimationField(const std::string &particleFieldName, const Vector3r &pos, const Matrix3r &rotation, const Vector3r &scale, const std::string expression[3], const unsigned int type)
unsigned int numAnimationFields() const
std::vector<AnimationField*> &getAnimationFields()
void step()
void reset()

Protected Attributes

std::vector<AnimationField*> m_fields

Class BinaryFileReader

Class Documentation
class SPH::BinaryFileReader

Public Functions

bool openFile(const std::string &fileName)
void closeFile()
void readBuffer(char *buffer, size_t size)
template<typename T>
void read(T &v)
void read(std::string &str)
template<typename T>
void readMatrix(T &m)

Public Members

std::ifstream m_file

Class BinaryFileWriter

Class Documentation
class SPH::BinaryFileWriter

Public Functions

bool openFile(const std::string &fileName)
void closeFile()
void writeBuffer(const char *buffer, size_t size)
template<typename T>
void write(const T &v)
void write(const std::string &str)
template<typename T>
void writeMatrix(const T &m)

Public Members

std::ofstream m_file

Class BlockJacobiPreconditioner3D

Class Documentation
class SPH::BlockJacobiPreconditioner3D

Matrix-free 3x3 block Jacobi preconditioner

Public Types

enum [anonymous]

Values:

enumerator ColsAtCompileTime
enumerator MaxColsAtCompileTime
typedef SystemMatrixType::StorageIndex StorageIndex
typedef void (*DiagonalMatrixElementFct)(const unsigned int, Matrix3r&, void*)

Public Functions

BlockJacobiPreconditioner3D()
void init(const unsigned int dim, DiagonalMatrixElementFct fct, void *userData)
Eigen::Index rows() const
Eigen::Index cols() const
Eigen::ComputationInfo info()
template<typename MatType>
BlockJacobiPreconditioner3D &analyzePattern(const MatType&)
template<typename MatType>
BlockJacobiPreconditioner3D &factorize(const MatType &mat)
template<typename MatType>
BlockJacobiPreconditioner3D &compute(const MatType &mat)
template<typename Rhs, typename Dest>
void _solve_impl(const Rhs &b, Dest &x) const
template<typename Rhs>
const Eigen::Solve<BlockJacobiPreconditioner3D, Rhs> solve(const Eigen::MatrixBase<Rhs> &b) const

Protected Attributes

unsigned int m_dim
DiagonalMatrixElementFct m_diagonalElementFct

diagonal matrix element callback

void *m_userData
std::vector<Matrix3r> m_invDiag

Class BoundaryModel

Inheritance Relationships
Derived Types
Class Documentation
class SPH::BoundaryModel

The boundary model stores the information required for boundary handling.

Subclassed by SPH::BoundaryModel_Akinci2012, SPH::BoundaryModel_Bender2019, SPH::BoundaryModel_Koschier2017

Public Functions

BoundaryModel()
~BoundaryModel()
void reset()
void performNeighborhoodSearchSort()
void saveState(BinaryFileWriter &binWriter)
void loadState(BinaryFileReader &binReader)
RigidBodyObject *getRigidBodyObject()
FORCE_INLINE void addForce (const Vector3r &pos, const Vector3r &f)
FORCE_INLINE void getPointVelocity (const Vector3r &x, Vector3r &res)
void getForceAndTorque(Vector3r &force, Vector3r &torque)
void clearForceAndTorque()

Protected Attributes

RigidBodyObject *m_rigidBody
std::vector<Vector3r> m_forcePerThread
std::vector<Vector3r> m_torquePerThread

Class BoundaryModel_Akinci2012

Inheritance Relationships
Base Type
Class Documentation
class SPH::BoundaryModel_Akinci2012 : public SPH::BoundaryModel

The boundary model stores the information required for boundary handling using the approach of Akinci et al. 2012 [AIA+12].

References:

  • [AIA+12] Nadir Akinci, Markus Ihmsen, Gizem Akinci, Barbara Solenthaler, and Matthias Teschner. Versatile rigid-fluid coupling for incompressible SPH. ACM Trans. Graph., 31(4):62:1-62:8, July 2012. URL: http://doi.acm.org/10.1145/2185520.2185558

Public Functions

BoundaryModel_Akinci2012()
~BoundaryModel_Akinci2012()
unsigned int numberOfParticles() const
unsigned int getPointSetIndex() const
void computeBoundaryVolume()
void resize(const unsigned int numBoundaryParticles)
void reset()
void performNeighborhoodSearchSort()
void saveState(BinaryFileWriter &binWriter)
void loadState(BinaryFileReader &binReader)
void initModel(RigidBodyObject *rbo, const unsigned int numBoundaryParticles, Vector3r *boundaryParticles)
FORCE_INLINE Vector3r & getPosition0 (const unsigned int i)
FORCE_INLINE const Vector3r & getPosition0 (const unsigned int i) const
FORCE_INLINE void setPosition0 (const unsigned int i, const Vector3r &pos)
FORCE_INLINE Vector3r & getPosition (const unsigned int i)
FORCE_INLINE const Vector3r & getPosition (const unsigned int i) const
FORCE_INLINE void setPosition (const unsigned int i, const Vector3r &pos)
FORCE_INLINE Vector3r & getVelocity (const unsigned int i)
FORCE_INLINE const Vector3r & getVelocity (const unsigned int i) const
FORCE_INLINE void setVelocity (const unsigned int i, const Vector3r &vel)
FORCE_INLINE const Real & getVolume (const unsigned int i) const
FORCE_INLINE Real & getVolume (const unsigned int i)
FORCE_INLINE void setVolume (const unsigned int i, const Real &val)

Protected Attributes

bool m_sorted
unsigned int m_pointSetIndex
std::vector<Vector3r> m_x0
std::vector<Vector3r> m_x
std::vector<Vector3r> m_v
std::vector<Real> m_V

Class BoundaryModel_Bender2019

Inheritance Relationships
Base Type
Class Documentation
class SPH::BoundaryModel_Bender2019 : public SPH::BoundaryModel

The boundary model stores the information required for boundary handling using the approach of Bender et al. 2019 [BKWK19].

References:

  • [BKWK19] Jan Bender, Tassilo Kugelstadt, Marcel Weiler, and Dan Koschier. Volume maps: an implicit boundary representation for SPH. In Proceedings of ACM SIGGRAPH Conference on Motion, Interaction and Games, MIG ‘19. ACM, 2019. URL: https://dl.acm.org/doi/10.1145/3359566.3360077

Public Functions

BoundaryModel_Bender2019()
~BoundaryModel_Bender2019()
void initModel(RigidBodyObject *rbo)
void reset()
Discregrid::DiscreteGrid *getMap()
void setMap(Discregrid::DiscreteGrid *map)
Real getMaxDist() const
void setMaxDist(Real val)
Real getMaxVel() const
void setMaxVel(Real val)
FORCE_INLINE const Real & getBoundaryVolume (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE Real & getBoundaryVolume (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE void setBoundaryVolume (const unsigned int fluidIndex, const unsigned int i, const Real &val)
FORCE_INLINE Vector3r & getBoundaryXj (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE const Vector3r & getBoundaryXj (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE void setBoundaryXj (const unsigned int fluidIndex, const unsigned int i, const Vector3r &val)

Protected Attributes

Discregrid::DiscreteGrid *m_map
std::vector<std::vector<Real>> m_boundaryVolume
std::vector<std::vector<Vector3r>> m_boundaryXj
Real m_maxDist
Real m_maxVel

Class BoundaryModel_Koschier2017

Inheritance Relationships
Base Type
Class Documentation
class SPH::BoundaryModel_Koschier2017 : public SPH::BoundaryModel

The boundary model stores the information required for boundary handling using the approach of Koschier and Bender 2017 [KB17].

References:

  • [KB17] Dan Koschier and Jan Bender. Density maps for improved SPH boundary handling. In ACM SIGGRAPH/Eurographics Symposium on Computer Animation, 1-10. July 2017. URL: http://dx.doi.org/10.1145/3099564.3099565

Public Functions

BoundaryModel_Koschier2017()
~BoundaryModel_Koschier2017()
void initModel(RigidBodyObject *rbo)
void reset()
Discregrid::DiscreteGrid *getMap()
void setMap(Discregrid::DiscreteGrid *map)
Real getMaxDist() const
void setMaxDist(Real val)
Real getMaxVel() const
void setMaxVel(Real val)
FORCE_INLINE const Real & getBoundaryDensity (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE Real & getBoundaryDensity (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE void setBoundaryDensity (const unsigned int fluidIndex, const unsigned int i, const Real &val)
FORCE_INLINE Vector3r & getBoundaryDensityGradient (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE const Vector3r & getBoundaryDensityGradient (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE void setBoundaryDensityGradient (const unsigned int fluidIndex, const unsigned int i, const Vector3r &val)
FORCE_INLINE Vector3r & getBoundaryXj (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE const Vector3r & getBoundaryXj (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE void setBoundaryXj (const unsigned int fluidIndex, const unsigned int i, const Vector3r &val)

Protected Attributes

Discregrid::DiscreteGrid *m_map
std::vector<std::vector<Real>> m_boundaryDensity
std::vector<std::vector<Vector3r>> m_boundaryDensityGradient
std::vector<std::vector<Vector3r>> m_boundaryXj
Real m_maxDist
Real m_maxVel

Class CohesionKernel

Class Documentation
class SPH::CohesionKernel

Cohesion kernel used for the surface tension method of Akinci el al. [ATT13].

References:

  • [AAT13] Nadir Akinci, Gizem Akinci, and Matthias Teschner. Versatile surface tension and adhesion for sph fluids. ACM Trans. Graph., 32(6):182:1-182:8, November 2013. URL: http://doi.acm.org/10.1145/2508363.2508395

Public Static Functions

Real getRadius()
void setRadius(Real val)
Real W(const Real r)

W(r,h) = (32/(pi h^9))(h-r)^3*r^3 if h/2 < r <= h (32/(pi h^9))(2*(h-r)^3*r^3 - h^6/64 if 0 < r <= h/2

Real W(const Vector3r &r)
Real W_zero()

Protected Static Attributes

Real m_radius
Real m_k
Real m_c
Real m_W_zero

Class CubicKernel

Class Documentation
class SPH::CubicKernel

Cubic spline kernel.

Public Static Functions

Real getRadius()
void setRadius(Real val)
Real W(const Real r)
Real W(const Vector3r &r)
Vector3r gradW(const Vector3r &r)
Real W_zero()

Protected Static Attributes

Real m_radius
Real m_k
Real m_l
Real m_W_zero

Class CubicKernel2D

Class Documentation
class SPH::CubicKernel2D

Cubic spline kernel (2D).

Public Static Functions

Real getRadius()
void setRadius(Real val)
Real W(const Real r)
Real W(const Vector3r &r)
Vector3r gradW(const Vector3r &r)
Real W_zero()

Protected Static Attributes

Real m_radius
Real m_k
Real m_l
Real m_W_zero

Class DebugTools

Inheritance Relationships
Base Type

  • public ParameterObject

Class Documentation
class SPH::DebugTools : public ParameterObject

Public Functions

DebugTools()
~DebugTools()
void init()
void cleanup()
void step()
void reset()
void performNeighborhoodSearchSort()
void emittedParticles(FluidModel *model, const unsigned int startIndex)

Public Static Attributes

int DETERMINE_THREAD_IDS = -1
int DETERMINE_NUM_NEIGHBORS = -1
int DETERMINE_VELOCITY_CHANGES = -1

Protected Functions

void initParameters()
void determineThreadIds()
void determineNumNeighbors()
void determineVelocityChanges()

Protected Attributes

bool m_determineThreadIds
std::vector<std::vector<unsigned int>> m_threadIds
bool m_determineNumNeighbors
std::vector<std::vector<unsigned int>> m_numNeighbors
bool m_determineVelocityChanges
std::vector<std::vector<Vector3r>> m_vOld
std::vector<std::vector<Vector3r>> m_velocityChanges

Class DragBase

Inheritance Relationships
Base Type
Derived Types
Class Documentation
class SPH::DragBase : public SPH::NonPressureForceBase

Base class for all drag force methods.

Subclassed by SPH::DragForce_Gissler2017, SPH::DragForce_Macklin2014

Public Functions

DragBase(FluidModel *model)
~DragBase(void)

Public Static Attributes

int DRAG_COEFFICIENT = -1

Protected Functions

void initParameters()

Protected Attributes

Real m_dragCoefficient

Class DragForce_Gissler2017

Inheritance Relationships
Base Type
Class Documentation
class SPH::DragForce_Gissler2017 : public SPH::DragBase

This class implements the drag force computation introduced by Gissler et al. [GBP+17].

References:

  • [GPB+17] Christoph Gissler, Stefan Band, Andreas Peer, Markus Ihmsen, and Matthias Teschner. Approximate air-fluid interactions for SPH. In Virtual Reality Interactions and Physical Simulations, 1-10. April 2017. URL: http://dx.doi.org/10.2312/vriphys.20171081

Public Functions

DragForce_Gissler2017(FluidModel *model)
~DragForce_Gissler2017(void)
void step()
void reset()

Protected Attributes

const Real rho_a = static_cast<Real>(1.2041)
const Real sigma = static_cast<Real>(0.0724)
const Real mu_l = static_cast<Real>(0.00102)
const Real C_F = static_cast<Real>(1.0 / 3.0)
const Real C_k = static_cast<Real>(8.0)
const Real C_d = static_cast<Real>(5.0)
const Real C_b = static_cast<Real>(0.5)
const Real mu_a = static_cast<Real>(0.00001845)

Class DragForce_Macklin2014

Inheritance Relationships
Base Type
Class Documentation
class SPH::DragForce_Macklin2014 : public SPH::DragBase

This class implements the drag force computation introduced by Macklin et al. [MMCK14].

References:

  • [MMCK14] Miles Macklin, Matthias Müller, Nuttapong Chentanez, and Tae-Yong Kim. Unified Particle Physics for Real-Time Applications. ACM Trans. Graph., 33(4):1-12, 2014. URL: http://doi.acm.org/10.1145/2601097.2601152

Public Functions

DragForce_Macklin2014(FluidModel *model)
~DragForce_Macklin2014(void)
void step()
void reset()

Class Elasticity_Becker2009

Inheritance Relationships
Base Type
Class Documentation
class SPH::Elasticity_Becker2009 : public SPH::ElasticityBase

This class implements the corotated SPH method for deformable solids introduced by Becker et al. [BIT09].

References:

Public Functions

Elasticity_Becker2009(FluidModel *model)
~Elasticity_Becker2009(void)
void step()
void reset()
void performNeighborhoodSearchSort()
void saveState(BinaryFileWriter &binWriter)
void loadState(BinaryFileReader &binReader)

Public Static Attributes

int ALPHA = -1

Protected Functions

void initValues()
void computeRotations()
void computeStress()
void computeForces()
void initParameters()
FORCE_INLINE void symMatTimesVec (const Vector6r &M, const Vector3r &v, Vector3r &res)

Protected Attributes

std::vector<unsigned int> m_current_to_initial_index
std::vector<unsigned int> m_initial_to_current_index
std::vector<std::vector<unsigned int>> m_initialNeighbors
std::vector<Real> m_restVolumes
std::vector<Matrix3r> m_rotations
std::vector<Vector6r> m_stress
std::vector<Matrix3r> m_F
Real m_alpha

Class Elasticity_Peer2018

Inheritance Relationships
Base Type
Class Documentation
class SPH::Elasticity_Peer2018 : public SPH::ElasticityBase

This class implements the implicit SPH formulation for incompressible linearly elastic solids introduced by Peer et al. [PGBT17].

References:

  • [PGBT17] Andreas Peer, Christoph Gissler, Stefan Band, and Matthias Teschner. An implicit SPH formulation for incompressible linearly elastic solids. Computer Graphics Forum, 2017. URL: http://dx.doi.org/10.1111/cgf.13317

Public Functions

Elasticity_Peer2018(FluidModel *model)
~Elasticity_Peer2018(void)
void step()
void reset()
void performNeighborhoodSearchSort()
void saveState(BinaryFileWriter &binWriter)
void loadState(BinaryFileReader &binReader)

Public Static Functions

void matrixVecProd(const Real *vec, Real *result, void *userData)

Public Static Attributes

int ITERATIONS = -1
int MAX_ITERATIONS = -1
int MAX_ERROR = -1
int ALPHA = -1

Protected Types

typedef Eigen::ConjugateGradient<MatrixReplacement, Eigen::Lower | Eigen::Upper, Eigen::IdentityPreconditioner> Solver

Protected Functions

void initValues()
void computeMatrixL()
void computeRotations()
void computeRHS(VectorXr &rhs)
void initParameters()
FORCE_INLINE void symMatTimesVec (const Vector6r &M, const Vector3r &v, Vector3r &res)

Protected Attributes

std::vector<unsigned int> m_current_to_initial_index
std::vector<unsigned int> m_initial_to_current_index
std::vector<std::vector<unsigned int>> m_initialNeighbors
std::vector<Real> m_restVolumes
std::vector<Matrix3r> m_rotations
std::vector<Vector6r> m_stress
std::vector<Matrix3r> m_L
std::vector<Matrix3r> m_RL
std::vector<Matrix3r> m_F
unsigned int m_iterations
unsigned int m_maxIter
Real m_maxError
Real m_alpha
Solver m_solver

Class ElasticityBase

Inheritance Relationships
Base Type
Derived Types
Class Documentation
class SPH::ElasticityBase : public SPH::NonPressureForceBase

Base class for all elasticity methods.

Subclassed by SPH::Elasticity_Becker2009, SPH::Elasticity_Peer2018

Public Functions

ElasticityBase(FluidModel *model)
~ElasticityBase(void)

Public Static Attributes

int YOUNGS_MODULUS = -1
int POISSON_RATIO = -1

Protected Functions

void initParameters()

Protected Attributes

Real m_youngsModulus
Real m_poissonRatio

Class Emitter

Class Documentation
class SPH::Emitter

Public Functions

Emitter(FluidModel *model, const unsigned int width, const unsigned int height, const Vector3r &pos, const Matrix3r &rotation, const Real velocity, const unsigned int type = 0)
~Emitter()
void emitParticles(std::vector<unsigned int> &reusedParticles, unsigned int &indexReuse, unsigned int &numEmittedParticles)
void emitParticlesCircle(std::vector<unsigned int> &reusedParticles, unsigned int &indexReuse, unsigned int &numEmittedParticles)
Real getNextEmitTime() const
void setNextEmitTime(Real val)
void setEmitStartTime(Real val)
void setEmitEndTime(Real val)
void step(std::vector<unsigned int> &reusedParticles, unsigned int &indexReuse, unsigned int &numEmittedParticles)
void reset()
void saveState(BinaryFileWriter &binWriter)
void loadState(BinaryFileReader &binReader)
const Vector3r &getPosition() const
void setPosition(const Vector3r &x)
const Matrix3r &getRotation() const
void setRotation(const Matrix3r &r)
const Real getVelocity() const
void setVelocity(const Real v)

Public Static Functions

Vector3r getSize(const Real width, const Real height, const int type)

Protected Functions

FORCE_INLINE bool inBox (const Vector3r &x, const Vector3r &xBox, const Matrix3r &rotBox, const Vector3r &scaleBox)
FORCE_INLINE bool inCylinder (const Vector3r &x, const Vector3r &xCyl, const Matrix3r &rotCyl, const Real h, const Real r2)

Protected Attributes

FluidModel *m_model
unsigned int m_width
unsigned int m_height
Vector3r m_x
Matrix3r m_rotation
Real m_velocity
unsigned int m_type
Real m_nextEmitTime
Real m_emitStartTime
Real m_emitEndTime
unsigned int m_emitCounter

Class EmitterSystem

Class Documentation
class SPH::EmitterSystem

Public Functions

EmitterSystem(FluidModel *model)
~EmitterSystem()
void enableReuseParticles(const Vector3r &boxMin = Vector3r(-1, -1, -1), const Vector3r &boxMax = Vector3r(1, 1, 1))
void disableReuseParticles()
void addEmitter(const unsigned int width, const unsigned int height, const Vector3r &pos, const Matrix3r &rotation, const Real velocity, const unsigned int type)
unsigned int numEmitters() const
std::vector<Emitter*> &getEmitters()
unsigned int numReusedParticles() const
unsigned int numEmittedParticles() const
void step()
void reset()
void saveState(BinaryFileWriter &binWriter)
void loadState(BinaryFileReader &binReader)

Protected Functions

void reuseParticles()

Protected Attributes

FluidModel *m_model
bool m_reuseParticles
Vector3r m_boxMin
Vector3r m_boxMax
unsigned int m_numberOfEmittedParticles
unsigned int m_numReusedParticles
std::vector<unsigned int> m_reusedParticles
std::vector<Emitter*> m_emitters

Protected Static Attributes

const unsigned int m_maxParticlesToReusePerStep = 50000

Class FluidModel

Inheritance Relationships
Base Type

  • public ParameterObject

Class Documentation
class SPH::FluidModel : public ParameterObject

The fluid model stores the particle and simulation information.

Public Functions

FluidModel()
FluidModel(const FluidModel&) = delete
FluidModel &operator=(const FluidModel&) = delete
~FluidModel()
void init()
std::string getId() const
FORCE_INLINE Real getDensity0 () const
void setDensity0(const Real v)
unsigned int getPointSetIndex() const
void addField(const FieldDescription &field)
const std::vector<FieldDescription> &getFields()
const FieldDescription &getField(const unsigned int i)
const FieldDescription &getField(const std::string &name)
const unsigned int numberOfFields()
void removeFieldByName(const std::string &fieldName)
void setNumActiveParticles(const unsigned int num)
unsigned int numberOfParticles() const
EmitterSystem *getEmitterSystem()
void reset()
void performNeighborhoodSearchSort()
void initModel(const std::string &id, const unsigned int nFluidParticles, Vector3r *fluidParticles, Vector3r *fluidVelocities, const unsigned int nMaxEmitterParticles)
const unsigned int numParticles() const
unsigned int numActiveParticles() const
unsigned int getNumActiveParticles0() const
void setNumActiveParticles0(unsigned int val)
void emittedParticles(const unsigned int startIndex)
int getSurfaceTensionMethod() const
void setSurfaceTensionMethod(const int val)
int getViscosityMethod() const
void setViscosityMethod(const int val)
int getVorticityMethod() const
void setVorticityMethod(const int val)
int getDragMethod() const
void setDragMethod(const int val)
int getElasticityMethod() const
void setElasticityMethod(const int val)
SurfaceTensionBase *getSurfaceTensionBase()
ViscosityBase *getViscosityBase()
VorticityBase *getVorticityBase()
DragBase *getDragBase()
ElasticityBase *getElasticityBase()
void setDragMethodChangedCallback(std::function<void()> const &callBackFct)
void setSurfaceMethodChangedCallback(std::function<void()> const &callBackFct)
void setViscosityMethodChangedCallback(std::function<void()> const &callBackFct)
void setVorticityMethodChangedCallback(std::function<void()> const &callBackFct)
void setElasticityMethodChangedCallback(std::function<void()> const &callBackFct)
void computeSurfaceTension()
void computeViscosity()
void computeVorticity()
void computeDragForce()
void computeElasticity()
void saveState(BinaryFileWriter &binWriter)
void loadState(BinaryFileReader &binReader)
FORCE_INLINE Vector3r & getPosition0 (const unsigned int i)
FORCE_INLINE const Vector3r & getPosition0 (const unsigned int i) const
FORCE_INLINE void setPosition0 (const unsigned int i, const Vector3r &pos)
FORCE_INLINE Vector3r & getPosition (const unsigned int i)
FORCE_INLINE const Vector3r & getPosition (const unsigned int i) const
FORCE_INLINE void setPosition (const unsigned int i, const Vector3r &pos)
FORCE_INLINE Vector3r & getVelocity (const unsigned int i)
FORCE_INLINE const Vector3r & getVelocity (const unsigned int i) const
FORCE_INLINE void setVelocity (const unsigned int i, const Vector3r &vel)
FORCE_INLINE Vector3r & getVelocity0 (const unsigned int i)
FORCE_INLINE const Vector3r & getVelocity0 (const unsigned int i) const
FORCE_INLINE void setVelocity0 (const unsigned int i, const Vector3r &vel)
FORCE_INLINE Vector3r & getAcceleration (const unsigned int i)
FORCE_INLINE const Vector3r & getAcceleration (const unsigned int i) const
FORCE_INLINE void setAcceleration (const unsigned int i, const Vector3r &accel)
FORCE_INLINE const Real getMass (const unsigned int i) const
FORCE_INLINE Real & getMass (const unsigned int i)
FORCE_INLINE void setMass (const unsigned int i, const Real mass)
FORCE_INLINE const Real & getDensity (const unsigned int i) const
FORCE_INLINE Real & getDensity (const unsigned int i)
FORCE_INLINE void setDensity (const unsigned int i, const Real &val)
FORCE_INLINE unsigned int & getParticleId (const unsigned int i)
FORCE_INLINE const unsigned int & getParticleId (const unsigned int i) const
FORCE_INLINE const ParticleState & getParticleState (const unsigned int i) const
FORCE_INLINE ParticleState & getParticleState (const unsigned int i)
FORCE_INLINE void setParticleState (const unsigned int i, const ParticleState &val)
FORCE_INLINE const Real getVolume (const unsigned int i) const
FORCE_INLINE Real & getVolume (const unsigned int i)

Public Static Attributes

int NUM_PARTICLES = -1
int NUM_REUSED_PARTICLES = -1
int DENSITY0 = -1
int DRAG_METHOD = -1
int SURFACE_TENSION_METHOD = -1
int VISCOSITY_METHOD = -1
int VORTICITY_METHOD = -1
int ELASTICITY_METHOD = -1
int ENUM_DRAG_NONE = -1
int ENUM_DRAG_MACKLIN2014 = -1
int ENUM_DRAG_GISSLER2017 = -1
int ENUM_SURFACETENSION_NONE = -1
int ENUM_SURFACETENSION_BECKER2007 = -1
int ENUM_SURFACETENSION_AKINCI2013 = -1
int ENUM_SURFACETENSION_HE2014 = -1
int ENUM_VISCOSITY_NONE = -1
int ENUM_VISCOSITY_STANDARD = -1
int ENUM_VISCOSITY_XSPH = -1
int ENUM_VISCOSITY_BENDER2017 = -1
int ENUM_VISCOSITY_PEER2015 = -1
int ENUM_VISCOSITY_PEER2016 = -1
int ENUM_VISCOSITY_TAKAHASHI2015 = -1
int ENUM_VISCOSITY_WEILER2018 = -1
int ENUM_VORTICITY_NONE = -1
int ENUM_VORTICITY_MICROPOLAR = -1
int ENUM_VORTICITY_VC = -1
int ENUM_ELASTICITY_NONE = -1
int ENUM_ELASTICITY_BECKER2009 = -1
int ENUM_ELASTICITY_PEER2018 = -1

Protected Functions

void initParameters()
void initMasses()
void resizeFluidParticles(const unsigned int newSize)

Resize the arrays containing the particle data.

void releaseFluidParticles()

Release the arrays containing the particle data.

Protected Attributes

std::string m_id
EmitterSystem *m_emitterSystem
std::vector<Real> m_masses
std::vector<Vector3r> m_a
std::vector<Vector3r> m_v0
std::vector<Vector3r> m_x0
std::vector<Vector3r> m_x
std::vector<Vector3r> m_v
std::vector<Real> m_density
std::vector<unsigned int> m_particleId
std::vector<ParticleState> m_particleState
Real m_V
SurfaceTensionMethods m_surfaceTensionMethod
SurfaceTensionBase *m_surfaceTension
ViscosityMethods m_viscosityMethod
ViscosityBase *m_viscosity
VorticityMethods m_vorticityMethod
VorticityBase *m_vorticity
DragMethods m_dragMethod
DragBase *m_drag
ElasticityMethods m_elasticityMethod
ElasticityBase *m_elasticity
std::vector<FieldDescription> m_fields
std::function<void()> m_dragMethodChanged
std::function<void()> m_surfaceTensionMethodChanged
std::function<void()> m_viscosityMethodChanged
std::function<void()> m_vorticityMethodChanged
std::function<void()> m_elasticityMethodChanged
Real m_density0
unsigned int m_pointSetIndex
unsigned int m_numActiveParticles
unsigned int m_numActiveParticles0

Class GaussQuadrature

Class Documentation
class SPH::GaussQuadrature

Public Types

using Integrand = std::function<double(Eigen::Vector3d const&)>
using Domain = Eigen::AlignedBox3d

Public Static Functions

double integrate(Integrand integrand, Domain const &domain, unsigned int p)
void exportSamples(unsigned int p)

Class JacobiPreconditioner1D

Class Documentation
class SPH::JacobiPreconditioner1D

Matrix-free Jacobi preconditioner

Public Types

enum [anonymous]

Values:

enumerator ColsAtCompileTime
enumerator MaxColsAtCompileTime
typedef SystemMatrixType::StorageIndex StorageIndex
typedef void (*DiagonalMatrixElementFct)(const unsigned int, Real&, void*)

Public Functions

JacobiPreconditioner1D()
void init(const unsigned int dim, DiagonalMatrixElementFct fct, void *userData)
Eigen::Index rows() const
Eigen::Index cols() const
Eigen::ComputationInfo info()
template<typename MatType>
JacobiPreconditioner1D &analyzePattern(const MatType&)
template<typename MatType>
JacobiPreconditioner1D &factorize(const MatType &mat)
template<typename MatType>
JacobiPreconditioner1D &compute(const MatType &mat)
template<typename Rhs, typename Dest>
void _solve_impl(const Rhs &b, Dest &x) const
template<typename Rhs>
const Eigen::Solve<JacobiPreconditioner1D, Rhs> solve(const Eigen::MatrixBase<Rhs> &b) const

Protected Attributes

unsigned int m_dim
DiagonalMatrixElementFct m_diagonalElementFct

diagonal matrix element callback

void *m_userData
VectorXr m_invDiag

Class JacobiPreconditioner3D

Class Documentation
class SPH::JacobiPreconditioner3D

Matrix-free Jacobi preconditioner

Public Types

enum [anonymous]

Values:

enumerator ColsAtCompileTime
enumerator MaxColsAtCompileTime
typedef SystemMatrixType::StorageIndex StorageIndex
typedef void (*DiagonalMatrixElementFct)(const unsigned int, Vector3r&, void*)

Public Functions

JacobiPreconditioner3D()
void init(const unsigned int dim, DiagonalMatrixElementFct fct, void *userData)
Eigen::Index rows() const
Eigen::Index cols() const
Eigen::ComputationInfo info()
template<typename MatType>
JacobiPreconditioner3D &analyzePattern(const MatType&)
template<typename MatType>
JacobiPreconditioner3D &factorize(const MatType &mat)
template<typename MatType>
JacobiPreconditioner3D &compute(const MatType &mat)
template<typename Rhs, typename Dest>
void _solve_impl(const Rhs &b, Dest &x) const
template<typename Rhs>
const Eigen::Solve<JacobiPreconditioner3D, Rhs> solve(const Eigen::MatrixBase<Rhs> &b) const

Protected Attributes

unsigned int m_dim
DiagonalMatrixElementFct m_diagonalElementFct

diagonal matrix element callback

void *m_userData
VectorXr m_invDiag

Class MathFunctions

Class Documentation
class SPH::MathFunctions

Public Static Functions

void extractRotation(const Matrix3r &A, Quaternionr &q, const unsigned int maxIter)

Implementation of the paper:

Matthias Müller, Jan Bender, Nuttapong Chentanez and Miles Macklin, “A Robust Method to Extract the Rotational Part of Deformations”, ACM SIGGRAPH Motion in Games, 2016

void pseudoInverse(const Matrix3r &a, Matrix3r &res)
void svdWithInversionHandling(const Matrix3r &A, Vector3r &sigma, Matrix3r &U, Matrix3r &VT)

Perform a singular value decomposition of matrix A: A = U * sigma * V^T. This function returns two proper rotation matrices U and V^T which do not contain a reflection. Reflections are corrected by the inversion handling proposed by Irving et al. 2004.

void eigenDecomposition(const Matrix3r &A, Matrix3r &eigenVecs, Vector3r &eigenVals)
void jacobiRotate(Matrix3r &A, Matrix3r &R, int p, int q)
void getOrthogonalVectors(const Vector3r &vec, Vector3r &x, Vector3r &y)

Returns two orthogonal vectors to vec which are also orthogonal to each other.

Class MatrixReplacement

Inheritance Relationships
Base Type

  • public Eigen::EigenBase< MatrixReplacement >

Class Documentation
class SPH::MatrixReplacement : public Eigen::EigenBase<MatrixReplacement>

Replacement of the matrix in the linear system which is required for a matrix-free solver.

Public Types

enum [anonymous]

Values:

enumerator ColsAtCompileTime
enumerator MaxColsAtCompileTime
enumerator IsRowMajor
typedef Real Scalar
typedef Real RealScalar
typedef int StorageIndex
typedef void (*MatrixVecProdFct)(const Real*, Real*, void*)

Public Functions

Index rows() const
Index cols() const
template<typename Rhs>
Eigen::Product<MatrixReplacement, Rhs, Eigen::AliasFreeProduct> operator*(const Eigen::MatrixBase<Rhs> &x) const
MatrixReplacement(const unsigned int dim, MatrixVecProdFct fct, void *userData)
void *getUserData()
MatrixVecProdFct getMatrixVecProdFct()

Protected Attributes

unsigned int m_dim
void *m_userData
MatrixVecProdFct m_matrixVecProdFct

matrix vector product callback

Class MicropolarModel_Bender2017

Inheritance Relationships
Base Type
Class Documentation
class SPH::MicropolarModel_Bender2017 : public SPH::VorticityBase

This class implements the micropolar material model introduced by Bender et al. [BKKW17].

References:

  • [BKKW17] Jan Bender, Dan Koschier, Tassilo Kugelstadt, and Marcel Weiler. A micropolar material model for turbulent SPH fluids. In ACM SIGGRAPH / Eurographics Symposium on Computer Animation, SCA ‘17. ACM, 2017. URL: http://doi.acm.org/10.1145/3099564.3099578

Public Functions

MicropolarModel_Bender2017(FluidModel *model)
~MicropolarModel_Bender2017(void)
void step()
void reset()
void performNeighborhoodSearchSort()
FORCE_INLINE const Vector3r & getAngularAcceleration (const unsigned int i) const
FORCE_INLINE Vector3r & getAngularAcceleration (const unsigned int i)
FORCE_INLINE void setAngularAcceleration (const unsigned int i, const Vector3r &val)
FORCE_INLINE const Vector3r & getAngularVelocity (const unsigned int i) const
FORCE_INLINE Vector3r & getAngularVelocity (const unsigned int i)
FORCE_INLINE void setAngularVelocity (const unsigned int i, const Vector3r &val)

Public Static Attributes

int VISCOSITY_OMEGA = -1
int INERTIA_INVERSE = -1

Protected Functions

void initParameters()

Protected Attributes

std::vector<Vector3r> m_angularAcceleration
std::vector<Vector3r> m_omega
Real m_viscosityOmega
Real m_inertiaInverse

Class NonPressureForceBase

Inheritance Relationships
Base Type

  • public ParameterObject

Derived Types
Class Documentation
class SPH::NonPressureForceBase : public ParameterObject

Base class for all non-pressure force methods.

Subclassed by SPH::DragBase, SPH::ElasticityBase, SPH::SurfaceTensionBase, SPH::ViscosityBase, SPH::VorticityBase

Public Functions

NonPressureForceBase(FluidModel *model)
NonPressureForceBase(const NonPressureForceBase&) = delete
NonPressureForceBase &operator=(const NonPressureForceBase&) = delete
~NonPressureForceBase(void)
void step() = 0
void reset()
void performNeighborhoodSearchSort()
void emittedParticles(const unsigned int startIndex)
void saveState(BinaryFileWriter &binWriter)
void loadState(BinaryFileReader &binReader)
FluidModel *getModel()
void init()

Protected Attributes

FluidModel *m_model

Class PoissonDiskSampling

Class Documentation
class SPH::PoissonDiskSampling

This class implements a Poisson disk sampling for the surface of 3D models.

Public Functions

PoissonDiskSampling()
void sampleMesh(const unsigned int numVertices, const Vector3r *vertices, const unsigned int numFaces, const unsigned int *faces, const Real minRadius, const unsigned int numTrials, unsigned int distanceNorm, std::vector<Vector3r> &samples)

Performs the poisson sampling with the respective parameters. Compare http://graphics.cs.umass.edu/pubs/sa_2010.pdf

Parameters

  • mesh: mesh data of sampled body

  • vertices: vertex data of sampled data

  • sampledVertices: sampled vertices that will be returned

  • minRadius: minimal distance of sampled vertices

  • numTestpointsPerFace: # of generated test points per face of body

  • distanceNorm: 0: euclidean norm, 1: approx geodesic distance

  • numTrials: # of iterations used to find samples

Public Static Functions

FORCE_INLINE int floor (const Real v)
struct HashEntry

Struct to store the hash entry (spatial hashing)

Public Functions

HashEntry()

Public Members

std::vector<unsigned int> samples
unsigned int startIndex
struct InitialPointInfo

Struct to store the information of the initial points.

Public Members

CellPos cP
Vector3r pos
unsigned int ID

Class Poly6Kernel

Class Documentation
class SPH::Poly6Kernel

Poly6 kernel.

Public Static Functions

Real getRadius()
void setRadius(Real val)
Real W(const Real r)

W(r,h) = (315/(64 pi h^9))(h^2-|r|^2)^3 = (315/(64 pi h^9))(h^2-r*r)^3

Real W(const Vector3r &r)
Vector3r gradW(const Vector3r &r)

grad(W(r,h)) = r(-945/(32 pi h^9))(h^2-|r|^2)^2 = r(-945/(32 pi h^9))(h^2-r*r)^2

Real laplacianW(const Vector3r &r)

laplacian(W(r,h)) = (-945/(32 pi h^9))(h^2-|r|^2)(-7|r|^2+3h^2) = (-945/(32 pi h^9))(h^2-r*r)(3 h^2-7 r*r)

Real W_zero()

Protected Static Attributes

Real m_radius
Real m_k
Real m_l
Real m_m
Real m_W_zero

Template Class PrecomputedKernel

Class Documentation
template<typename KernelType, unsigned int resolution = 10000u>
class SPH::PrecomputedKernel

Precomputed kernel which is based on a lookup table as described by Bender and Koschier [BK15,BK17].

The lookup tables can be used in combination with any kernel.

References:

  • [BK15] Jan Bender and Dan Koschier. Divergence-free smoothed particle hydrodynamics. In ACM SIGGRAPH / Eurographics Symposium on Computer Animation, SCA ‘15, 147-155. New York, NY, USA, 2015. ACM. URL: http://doi.acm.org/10.1145/2786784.2786796

  • [BK17] Jan Bender and Dan Koschier. Divergence-free SPH for incompressible and viscous fluids. IEEE Transactions on Visualization and Computer Graphics, 23(3):1193-1206, 2017. URL: http://dx.doi.org/10.1109/TVCG.2016.2578335

Public Static Functions

Real getRadius()
void setRadius(Real val)
Real W(const Vector3r &r)
Real W(const Real r)
Vector3r gradW(const Vector3r &r)
Real W_zero()

Protected Static Attributes

Real m_W[resolution]
Real m_gradW[resolution + 1]
Real m_radius
Real m_radius2
Real m_invStepSize
Real m_W_zero

Class RegularSampling2D

Class Documentation
class SPH::RegularSampling2D

This class implements a per-triangle regular sampling for the surface of 3D models.

Public Functions

RegularSampling2D()

Public Static Functions

void sampleMesh(const Matrix3r &rotation, const Vector3r &translation, const unsigned numVertices, const Vector3r *vertices, const unsigned int numFaces, const unsigned int *faces, const Real maxDistance, std::vector<Vector3r> &samples)

Performs the poisson sampling with the respective parameters. Compare http://graphics.cs.umass.edu/pubs/sa_2010.pdf

Parameters

  • rotation: rotation of the mesh

  • translation: translation of the mesh

  • numVertices: number of mesh vertices

  • vertices: vertex data of sampled data

  • numFaces: number of faces in the mesh

  • faces: face data of sampled mesh

  • maxDistance: maximal distance of sampled vertices

  • samples: vector to store the samples

Class RegularTriangleSampling

Class Documentation
class SPH::RegularTriangleSampling

This class implements a per-triangle regular sampling for the surface of 3D models.

Public Functions

RegularTriangleSampling()

Public Static Functions

void sampleMesh(const unsigned int numVertices, const Vector3r *vertices, const unsigned int numFaces, const unsigned int *faces, const Real maxDistance, std::vector<Vector3r> &samples)

Performs the poisson sampling with the respective parameters. Compare http://graphics.cs.umass.edu/pubs/sa_2010.pdf

Parameters

  • numVertices: number of mesh vertices

  • vertices: vertex data of sampled data

  • numFaces: number of faces in the mesh

  • faces: face data of sampled mesh

  • maxDistance: maximal distance of sampled vertices

  • samples: vector to store the samples

Class RigidBodyObject

Inheritance Relationships
Derived Type
Class Documentation
class SPH::RigidBodyObject

Base class for rigid body objects.

Subclassed by SPH::StaticRigidBody

Public Functions

~RigidBodyObject()
bool isDynamic() const = 0
Real const getMass() const = 0
Vector3r const &getPosition() const = 0
void setPosition(const Vector3r &x) = 0
Vector3r getWorldSpacePosition() const = 0
Vector3r const &getVelocity() const = 0
void setVelocity(const Vector3r &v) = 0
Matrix3r const &getRotation() const = 0
void setRotation(const Matrix3r &r) = 0
Matrix3r getWorldSpaceRotation() const = 0
Vector3r const &getAngularVelocity() const = 0
void setAngularVelocity(const Vector3r &v) = 0
void addForce(const Vector3r &f) = 0
void addTorque(const Vector3r &t) = 0
const std::vector<Vector3r> &getVertices() const = 0
const std::vector<Vector3r> &getVertexNormals() const = 0
const std::vector<unsigned int> &getFaces() const = 0

Class SimpleQuadrature

Class Documentation
class SPH::SimpleQuadrature

Public Types

using Integrand = std::function<double(Eigen::Vector3d const&)>
using Domain = Eigen::AlignedBox3d

Public Static Functions

void determineSamplePointsInSphere(const double radius, unsigned int p)
void determineSamplePointsInCircle(const double radius, unsigned int p)
double integrate(Integrand integrand)

Public Static Attributes

std::vector<Eigen::Vector3d> m_samplePoints
double m_volume = 0.0

Class Simulation

Inheritance Relationships
Base Type

  • public ParameterObject

Class Documentation
class SPH::Simulation : public ParameterObject

Class to manage the current simulation time and the time step size. This class is a singleton.

Public Types

typedef PrecomputedKernel<CubicKernel, 10000> PrecomputedCubicKernel

Public Functions

Simulation()
Simulation(const Simulation&) = delete
Simulation &operator=(const Simulation&) = delete
~Simulation()
void init(const Real particleRadius, const bool sim2D)
void reset()
void addFluidModel(const std::string &id, const unsigned int nFluidParticles, Vector3r *fluidParticles, Vector3r *fluidVelocities, const unsigned int nMaxEmitterParticles)
FluidModel *getFluidModel(const unsigned int index)
FluidModel *getFluidModelFromPointSet(const unsigned int pointSetIndex)
const unsigned int numberOfFluidModels() const
void addBoundaryModel(BoundaryModel *bm)
BoundaryModel *getBoundaryModel(const unsigned int index)
BoundaryModel *getBoundaryModelFromPointSet(const unsigned int pointSetIndex)
const unsigned int numberOfBoundaryModels() const
void updateBoundaryVolume()
AnimationFieldSystem *getAnimationFieldSystem()
BoundaryHandlingMethods getBoundaryHandlingMethod() const
void setBoundaryHandlingMethod(BoundaryHandlingMethods val)
int getKernel() const
void setKernel(int val)
int getGradKernel() const
void setGradKernel(int val)
FORCE_INLINE Real W_zero () const
FORCE_INLINE Real W (const Vector3r &r) const
FORCE_INLINE Vector3r gradW (const Vector3r &r)
int getSimulationMethod() const
void setSimulationMethod(const int val)
void setSimulationMethodChangedCallback(std::function<void()> const &callBackFct)
TimeStep *getTimeStep()
bool is2DSimulation()
bool zSortEnabled()
void setParticleRadius(Real val)
Real getParticleRadius() const
Real getSupportRadius() const
void updateTimeStepSize()

Update time step size depending on the chosen method.

void updateTimeStepSizeCFL()

Update time step size by CFL condition.

void performNeighborhoodSearch()

Perform the neighborhood search for all fluid particles.

void performNeighborhoodSearchSort()
void computeNonPressureForces()
void animateParticles()
void emitParticles()
void emittedParticles(FluidModel *model, const unsigned int startIndex)
NeighborhoodSearch *getNeighborhoodSearch()
void saveState(BinaryFileWriter &binWriter)
void loadState(BinaryFileReader &binReader)
FORCE_INLINE unsigned int numberOfPointSets () const
FORCE_INLINE unsigned int numberOfNeighbors (const unsigned int pointSetIndex, const unsigned int neighborPointSetIndex, const unsigned int index) const
FORCE_INLINE unsigned int getNeighbor (const unsigned int pointSetIndex, const unsigned int neighborPointSetIndex, const unsigned int index, const unsigned int k) const
FORCE_INLINE const unsigned int * getNeighborList (const unsigned int pointSetIndex, const unsigned int neighborPointSetIndex, const unsigned int index) const

Public Static Functions

Simulation *getCurrent()
void setCurrent(Simulation *tm)
bool hasCurrent()

Public Static Attributes

int SIM_2D = -1
int PARTICLE_RADIUS = -1
int GRAVITATION = -1
int CFL_METHOD = -1
int CFL_FACTOR = -1
int CFL_MIN_TIMESTEPSIZE = -1
int CFL_MAX_TIMESTEPSIZE = -1
int ENABLE_Z_SORT = -1
int KERNEL_METHOD = -1
int GRAD_KERNEL_METHOD = -1
int ENUM_KERNEL_CUBIC = -1
int ENUM_KERNEL_WENDLANDQUINTICC2 = -1
int ENUM_KERNEL_POLY6 = -1
int ENUM_KERNEL_SPIKY = -1
int ENUM_KERNEL_PRECOMPUTED_CUBIC = -1
int ENUM_KERNEL_CUBIC_2D = -1
int ENUM_KERNEL_WENDLANDQUINTICC2_2D = -1
int ENUM_GRADKERNEL_CUBIC = -1
int ENUM_GRADKERNEL_WENDLANDQUINTICC2 = -1
int ENUM_GRADKERNEL_POLY6 = -1
int ENUM_GRADKERNEL_SPIKY = -1
int ENUM_GRADKERNEL_PRECOMPUTED_CUBIC = -1
int ENUM_GRADKERNEL_CUBIC_2D = -1
int ENUM_GRADKERNEL_WENDLANDQUINTICC2_2D = -1
int SIMULATION_METHOD = -1
int ENUM_CFL_NONE = -1
int ENUM_CFL_STANDARD = -1
int ENUM_CFL_ITER = -1
int ENUM_SIMULATION_WCSPH = -1
int ENUM_SIMULATION_PCISPH = -1
int ENUM_SIMULATION_PBF = -1
int ENUM_SIMULATION_IISPH = -1
int ENUM_SIMULATION_DFSPH = -1
int ENUM_SIMULATION_PF = -1
int BOUNDARY_HANDLING_METHOD = -1
int ENUM_AKINCI2012 = -1
int ENUM_KOSCHIER2017 = -1
int ENUM_BENDER2019 = -1

Protected Functions

void initParameters()

Protected Attributes

std::vector<FluidModel*> m_fluidModels
std::vector<BoundaryModel*> m_boundaryModels
NeighborhoodSearch *m_neighborhoodSearch
AnimationFieldSystem *m_animationFieldSystem
int m_cflMethod
Real m_cflFactor
Real m_cflMinTimeStepSize
Real m_cflMaxTimeStepSize
int m_kernelMethod
int m_gradKernelMethod
Real m_W_zero
Real (*m_kernelFct)(const Vector3r&)
Vector3r (*m_gradKernelFct)(const Vector3r &r)
SimulationMethods m_simulationMethod
TimeStep *m_timeStep
Vector3r m_gravitation
Real m_particleRadius
Real m_supportRadius
bool m_sim2D
bool m_enableZSort
std::function<void()> m_simulationMethodChanged
int m_boundaryHandlingMethod

Class SimulationDataDFSPH

Class Documentation
class SPH::SimulationDataDFSPH

Simulation data which is required by the method Divergence-free Smoothed Particle Hydrodynamics introduced by Bender and Koschier [BK15,BK17].

References:

  • [BK15] Jan Bender and Dan Koschier. Divergence-free smoothed particle hydrodynamics. In ACM SIGGRAPH / Eurographics Symposium on Computer Animation, SCA ‘15, 147-155. New York, NY, USA, 2015. ACM. URL: http://doi.acm.org/10.1145/2786784.2786796

  • [BK17] Jan Bender and Dan Koschier. Divergence-free SPH for incompressible and viscous fluids. IEEE Transactions on Visualization and Computer Graphics, 23(3):1193-1206, 2017. URL: http://dx.doi.org/10.1109/TVCG.2016.2578335

Public Functions

SimulationDataDFSPH()
~SimulationDataDFSPH()
void init()

Initialize the arrays containing the particle data.

void cleanup()

Release the arrays containing the particle data.

void reset()

Reset the particle data.

void performNeighborhoodSearchSort()

Important: First call m_model->performNeighborhoodSearchSort() to call the z_sort of the neighborhood search.

void emittedParticles(FluidModel *model, const unsigned int startIndex)
FORCE_INLINE const Real getFactor (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE Real & getFactor (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE void setFactor (const unsigned int fluidIndex, const unsigned int i, const Real p)
FORCE_INLINE const Real getKappa (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE Real & getKappa (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE void setKappa (const unsigned int fluidIndex, const unsigned int i, const Real p)
FORCE_INLINE const Real getKappaV (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE Real & getKappaV (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE void setKappaV (const unsigned int fluidIndex, const unsigned int i, const Real p)
FORCE_INLINE const Real getDensityAdv (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE Real & getDensityAdv (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE void setDensityAdv (const unsigned int fluidIndex, const unsigned int i, const Real d)

Protected Attributes

std::vector<std::vector<Real>> m_factor

factor \(\alpha_i\)

std::vector<std::vector<Real>> m_kappa

stores \(\kappa\) value of last time step for a warm start of the pressure solver

std::vector<std::vector<Real>> m_kappaV

stores \(\kappa^v\) value of last time step for a warm start of the divergence solver

std::vector<std::vector<Real>> m_density_adv

advected density

Class SimulationDataIISPH

Class Documentation
class SPH::SimulationDataIISPH

Simulation data which is required by the method Implicit Incompressible SPH introduced by Ihmsen et al. [ICS+14].

References:

  • [ICS+14] Markus Ihmsen, Jens Cornelis, Barbara Solenthaler, Christopher Horvath, and Matthias Teschner. Implicit incompressible SPH. IEEE Transactions on Visualization and Computer Graphics, 20(3):426-435, March 2014. URL: http://dx.doi.org/10.1109/TVCG.2013.105

Public Functions

SimulationDataIISPH()
~SimulationDataIISPH()
void init()

Initialize the arrays containing the particle data.

void cleanup()

Release the arrays containing the particle data.

void reset()

Reset the particle data.

void performNeighborhoodSearchSort()

Important: First call m_model->performNeighborhoodSearchSort() to call the z_sort of the neighborhood search.

void emittedParticles(FluidModel *model, const unsigned int startIndex)
FORCE_INLINE const Real getAii (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE Real & getAii (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE void setAii (const unsigned int fluidIndex, const unsigned int i, const Real aii)
FORCE_INLINE Vector3r & getDii (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE const Vector3r & getDii (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE void setDii (const unsigned int fluidIndex, const unsigned int i, const Vector3r &val)
FORCE_INLINE Vector3r & getDij_pj (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE const Vector3r & getDij_pj (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE void setDij_pj (const unsigned int fluidIndex, const unsigned int i, const Vector3r &val)
FORCE_INLINE const Real getDensityAdv (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE Real & getDensityAdv (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE void setDensityAdv (const unsigned int fluidIndex, const unsigned int i, const Real d)
FORCE_INLINE const Real getPressure (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE Real & getPressure (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE void setPressure (const unsigned int fluidIndex, const unsigned int i, const Real p)
FORCE_INLINE const Real getLastPressure (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE Real & getLastPressure (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE void setLastPressure (const unsigned int fluidIndex, const unsigned int i, const Real p)
FORCE_INLINE Vector3r & getPressureAccel (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE const Vector3r & getPressureAccel (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE void setPressureAccel (const unsigned int fluidIndex, const unsigned int i, const Vector3r &val)

Protected Attributes

std::vector<std::vector<Real>> m_aii
std::vector<std::vector<Vector3r>> m_dii
std::vector<std::vector<Vector3r>> m_dij_pj
std::vector<std::vector<Real>> m_density_adv
std::vector<std::vector<Real>> m_pressure
std::vector<std::vector<Real>> m_lastPressure
std::vector<std::vector<Vector3r>> m_pressureAccel

Class SimulationDataPBF

Class Documentation
class SPH::SimulationDataPBF

Simulation data which is required by the method Position-Based Fluids introduced by Macklin and Mueller [MM13,BMO+14,BMM15].

References:

  • [MM13] Miles Macklin and Matthias Müller. Position based fluids. ACM Trans. Graph., 32(4):104:1-104:12, July 2013. URL: http://doi.acm.org/10.1145/2461912.2461984

  • [BMO+14] 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, 2014. URL: http://dx.doi.org/10.1111/cgf.12346

  • [BMM15] Jan Bender, Matthias Müller, and Miles Macklin. Position-based simulation methods in computer graphics. In EUROGRAPHICS 2015 Tutorials. Eurographics Association, 2015. URL: http://dx.doi.org/10.2312/egt.20151045

Public Functions

SimulationDataPBF()
~SimulationDataPBF()
void init()

Initialize the arrays containing the particle data.

void cleanup()

Release the arrays containing the particle data.

void reset()

Reset the particle data.

void performNeighborhoodSearchSort()

Important: First call m_model->performNeighborhoodSearchSort() to call the z_sort of the neighborhood search.

void emittedParticles(FluidModel *model, const unsigned int startIndex)
FORCE_INLINE const Real & getLambda (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE Real & getLambda (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE void setLambda (const unsigned int fluidIndex, const unsigned int i, const Real &val)
FORCE_INLINE Vector3r & getDeltaX (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE const Vector3r & getDeltaX (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE void setDeltaX (const unsigned int fluidIndex, const unsigned int i, const Vector3r &val)
FORCE_INLINE Vector3r & getLastPosition (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE const Vector3r & getLastPosition (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE void setLastPosition (const unsigned int fluidIndex, const unsigned int i, const Vector3r &pos)
FORCE_INLINE Vector3r & getOldPosition (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE const Vector3r & getOldPosition (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE void setOldPosition (const unsigned int fluidIndex, const unsigned int i, const Vector3r &pos)

Protected Attributes

std::vector<std::vector<Real>> m_lambda
std::vector<std::vector<Vector3r>> m_deltaX
std::vector<std::vector<Vector3r>> m_oldX
std::vector<std::vector<Vector3r>> m_lastX

Class SimulationDataPCISPH

Class Documentation
class SPH::SimulationDataPCISPH

Simulation data which is required by the method Predictive-corrective Incompressible SPH introduced by Solenthaler and Pajarola [SP09].

References:

Public Functions

SimulationDataPCISPH()
~SimulationDataPCISPH()
void init()

Initialize the arrays containing the particle data.

void cleanup()

Release the arrays containing the particle data.

void reset()

Reset the particle data.

void performNeighborhoodSearchSort()

Important: First call m_model->performNeighborhoodSearchSort() to call the z_sort of the neighborhood search.

Real getPCISPH_ScalingFactor(const unsigned int fluidIndex)
void emittedParticles(FluidModel *model, const unsigned int startIndex)
FORCE_INLINE Vector3r & getLastPosition (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE const Vector3r & getLastPosition (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE void setLastPosition (const unsigned int fluidIndex, const unsigned int i, const Vector3r &pos)
FORCE_INLINE Vector3r & getLastVelocity (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE const Vector3r & getLastVelocity (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE void setLastVelocity (const unsigned int fluidIndex, const unsigned int i, const Vector3r &vel)
FORCE_INLINE const Real getDensityAdv (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE Real & getDensityAdv (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE void setDensityAdv (const unsigned int fluidIndex, const unsigned int i, const Real d)
FORCE_INLINE const Real getPressure (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE Real & getPressure (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE void setPressure (const unsigned int fluidIndex, const unsigned int i, const Real p)
FORCE_INLINE Vector3r & getPressureAccel (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE const Vector3r & getPressureAccel (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE void setPressureAccel (const unsigned int fluidIndex, const unsigned int i, const Vector3r &val)

Protected Attributes

std::vector<Real> m_pcisph_factor
std::vector<std::vector<Vector3r>> m_lastX
std::vector<std::vector<Vector3r>> m_lastV
std::vector<std::vector<Real>> m_densityAdv
std::vector<std::vector<Real>> m_pressure
std::vector<std::vector<Vector3r>> m_pressureAccel

Class SimulationDataPF

Class Documentation
class SPH::SimulationDataPF

Simulation data which is required by the method Projective Fluids introduced by Weiler, Koschier and Bender [WKB16].

References:

  • [WKB16] Marcel Weiler, Dan Koschier, and Jan Bender. Projective fluids. In Proceedings of the 9th International Conference on Motion in Games, MIG ‘16, 79-84. New York, NY, USA, 2016. ACM. URL: http://doi.acm.org/10.1145/2994258.2994282

Public Functions

SimulationDataPF()
~SimulationDataPF()
void init()

Initialize the arrays containing the particle data.

void cleanup()

Release the arrays containing the particle data.

void reset()

Reset the particle data.

void performNeighborhoodSearchSort()

Important: First call m_model->performNeighborhoodSearchSort() to call the z_sort of the neighborhood search.

void emittedParticles(FluidModel *model, const unsigned int startIndex)
FORCE_INLINE const Vector3r getOldPosition (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE Vector3r & getOldPosition (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE void setOldPosition (const unsigned int fluidIndex, const unsigned int i, const Vector3r p)
FORCE_INLINE const unsigned int getNumFluidNeighbors (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE unsigned int & getNumFluidNeighbors (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE void setNumFluidNeighbors (const unsigned int fluidIndex, const unsigned int i, const unsigned int n)
FORCE_INLINE const Vector3r & getS (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE Vector3r & getS (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE void setS (const unsigned int fluidIndex, const unsigned int i, const Vector3r &s)
FORCE_INLINE const Vector3r & getDiag (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE Vector3r & getDiag (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE void setDiag (const unsigned int fluidIndex, const unsigned int i, const Vector3r &s)
FORCE_INLINE const unsigned int & getParticleOffset (const unsigned int fluidIndex) const

Protected Attributes

std::vector<std::vector<Vector3r>> m_old_position

particle position from last timestep

std::vector<std::vector<unsigned int>> m_num_fluid_neighbors

number of neighbors that are fluid particles

std::vector<std::vector<Vector3r>> m_s

positions predicted from momentum

std::vector<std::vector<Vector3r>> m_mat_diag

diagonal of system matrix, used by preconditioner

std::vector<unsigned int> m_particleOffset

Class SimulationDataWCSPH

Class Documentation
class SPH::SimulationDataWCSPH

Simulation data which is required by the method Weakly Compressible SPH for Free Surface Flows introduced by Becker and Teschner [BT07].

References:

  • [BT07] Markus Becker and Matthias Teschner. Weakly compressible SPH for free surface flows. In ACM SIGGRAPH/Eurographics Symposium on Computer Animation, SCA ‘07, 209-217. Aire-la-Ville, Switzerland, Switzerland, 2007. Eurographics Association. URL: http://dl.acm.org/citation.cfm?id=1272690.1272719

Public Functions

SimulationDataWCSPH()
~SimulationDataWCSPH()
void init()

Initialize the arrays containing the particle data.

void cleanup()

Release the arrays containing the particle data.

void reset()

Reset the particle data.

void performNeighborhoodSearchSort()

Important: First call m_model->performNeighborhoodSearchSort() to call the z_sort of the neighborhood search.

void emittedParticles(FluidModel *model, const unsigned int startIndex)
FORCE_INLINE const Real getPressure (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE Real & getPressure (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE void setPressure (const unsigned int fluidIndex, const unsigned int i, const Real p)
FORCE_INLINE Vector3r & getPressureAccel (const unsigned int fluidIndex, const unsigned int i)
FORCE_INLINE const Vector3r & getPressureAccel (const unsigned int fluidIndex, const unsigned int i) const
FORCE_INLINE void setPressureAccel (const unsigned int fluidIndex, const unsigned int i, const Vector3r &val)

Protected Attributes

std::vector<std::vector<Real>> m_pressure
std::vector<std::vector<Vector3r>> m_pressureAccel

Class SpikyKernel

Class Documentation
class SPH::SpikyKernel

Spiky kernel.

Public Static Functions

Real getRadius()
void setRadius(Real val)
Real W(const Real r)

W(r,h) = 15/(pi*h^6) * (h-r)^3

Real W(const Vector3r &r)
Vector3r gradW(const Vector3r &r)

grad(W(r,h)) = -r(45/(pi*h^6) * (h-r)^2)

Real W_zero()

Protected Static Attributes

Real m_radius
Real m_k
Real m_l
Real m_W_zero

Class StaticRigidBody

Inheritance Relationships
Base Type
Class Documentation
class SPH::StaticRigidBody : public SPH::RigidBodyObject

This class stores the information of a static rigid body which is not part of a rigid body simulation.

Public Functions

StaticRigidBody()
bool isDynamic() const
Real const getMass() const
Vector3r const &getPosition() const
void setPosition(const Vector3r &x)
Vector3r getWorldSpacePosition() const
Vector3r const &getVelocity() const
void setVelocity(const Vector3r &v)
Matrix3r const &getRotation() const
void setRotation(const Matrix3r &r)
Matrix3r getWorldSpaceRotation() const
Vector3r const &getAngularVelocity() const
void setAngularVelocity(const Vector3r &v)
void addForce(const Vector3r &f)
void addTorque(const Vector3r &t)
const std::vector<Vector3r> &getVertices() const
const std::vector<Vector3r> &getVertexNormals() const
const std::vector<unsigned int> &getFaces() const
void setWorldSpacePosition(const Vector3r &x)
void setWorldSpaceRotation(const Matrix3r &r)
TriangleMesh &getGeometry()

Protected Attributes

Vector3r m_x
Vector3r m_x_world
Vector3r m_zero
Matrix3r m_R
Matrix3r m_R_world
TriangleMesh m_geometry

Class SurfaceTension_Akinci2013

Inheritance Relationships
Base Type
Class Documentation
class SPH::SurfaceTension_Akinci2013 : public SPH::SurfaceTensionBase

This class implements the surface tension method introduced by Akinci et al. [ATT13].

References:

  • [AAT13] Nadir Akinci, Gizem Akinci, and Matthias Teschner. Versatile surface tension and adhesion for sph fluids. ACM Trans. Graph., 32(6):182:1-182:8, November 2013. URL: http://doi.acm.org/10.1145/2508363.2508395

Public Functions

SurfaceTension_Akinci2013(FluidModel *model)
~SurfaceTension_Akinci2013(void)
void step()
void reset()
void computeNormals()
void performNeighborhoodSearchSort()
FORCE_INLINE Vector3r & getNormal (const unsigned int i)
FORCE_INLINE const Vector3r & getNormal (const unsigned int i) const
FORCE_INLINE void setNormal (const unsigned int i, const Vector3r &val)

Protected Attributes

std::vector<Vector3r> m_normals

Class SurfaceTension_Becker2007

Inheritance Relationships
Base Type
Class Documentation
class SPH::SurfaceTension_Becker2007 : public SPH::SurfaceTensionBase

This class implements the surface tension method introduced by Becker and Teschner [BT07].

References:

  • [BT07] Markus Becker and Matthias Teschner. Weakly compressible SPH for free surface flows. In ACM SIGGRAPH/Eurographics Symposium on Computer Animation, SCA ‘07, 209-217. Aire-la-Ville, Switzerland, Switzerland, 2007. Eurographics Association. URL: http://dl.acm.org/citation.cfm?id=1272690.1272719

Public Functions

SurfaceTension_Becker2007(FluidModel *model)
~SurfaceTension_Becker2007(void)
void step()
void reset()

Class SurfaceTension_He2014

Inheritance Relationships
Base Type
Class Documentation
class SPH::SurfaceTension_He2014 : public SPH::SurfaceTensionBase

This class implements the surface tension method introduced by He et al. [HWZ+14].

References:

  • [HWZ+14] Xiaowei He, Huamin Wang, Fengjun Zhang, Hongan Wang, Guoping Wang, and Kun Zhou. Robust simulation of sparsely sampled thin features in SPH-based free surface flows. ACM Trans. Graph., 34(1):7:1-7:9, December 2014. URL: http://doi.acm.org/10.1145/2682630

Public Functions

SurfaceTension_He2014(FluidModel *model)
~SurfaceTension_He2014(void)
void step()
void reset()
void performNeighborhoodSearchSort()
FORCE_INLINE const Real getColor (const unsigned int i) const
FORCE_INLINE Real & getColor (const unsigned int i)
FORCE_INLINE void setColor (const unsigned int i, const Real p)
FORCE_INLINE const Real getGradC2 (const unsigned int i) const
FORCE_INLINE Real & getGradC2 (const unsigned int i)
FORCE_INLINE void setGradC2 (const unsigned int i, const Real p)

Protected Attributes

std::vector<Real> m_color
std::vector<Real> m_gradC2

Class SurfaceTensionBase

Inheritance Relationships
Base Type
Derived Types
Class Documentation
class SPH::SurfaceTensionBase : public SPH::NonPressureForceBase

Base class for all surface tension methods.

Subclassed by SPH::SurfaceTension_Akinci2013, SPH::SurfaceTension_Becker2007, SPH::SurfaceTension_He2014

Public Functions

SurfaceTensionBase(FluidModel *model)
~SurfaceTensionBase(void)

Public Static Attributes

int SURFACE_TENSION = -1
int SURFACE_TENSION_BOUNDARY = -1

Protected Functions

void initParameters()

Protected Attributes

Real m_surfaceTension
Real m_surfaceTensionBoundary

Class TimeIntegration

Class Documentation
class SPH::TimeIntegration

Class for the position-based fluids time integration.

Public Static Functions

void semiImplicitEuler(const Real h, const Real mass, Vector3r &position, Vector3r &velocity, const Vector3r &acceleration)

Perform an integration step for a particle using the semi-implicit Euler (symplectic Euler) method:

\[\begin{split}\begin{align*} \mathbf{v}(t+h) &= \mathbf{v}(t) + \mathbf{a}(t) h\\ \mathbf{x}(t+h) &= \mathbf{x}(t) + \mathbf{v}(t+h) h \end{align*}\end{split}\]

Parameters

  • h: time step size

  • mass: mass of the particle

  • position: position of the particle

  • velocity: velocity of the particle

  • acceleration: acceleration of the particle

void velocityUpdateFirstOrder(const Real h, const Real mass, const Vector3r &position, const Vector3r &oldPosition, Vector3r &velocity)

Perform a velocity update (first order) for the linear velocity:

\[\begin{equation*} \mathbf{v}(t+h) = \frac{1}{h} (\mathbf{p}(t+h) - \mathbf{p}(t) \end{equation*}\]

Parameters

  • h: time step size

  • mass: mass of the particle

  • position: new position \(\mathbf{p}(t+h)\) of the particle

  • oldPosition: position \(\mathbf{p}(t)\) of the particle before the time step

  • velocity: resulting velocity of the particle

void velocityUpdateSecondOrder(const Real h, const Real mass, const Vector3r &position, const Vector3r &oldPosition, const Vector3r &positionOfLastStep, Vector3r &velocity)

Class TimeManager

Class Documentation
class SPH::TimeManager

Class to manage the current simulation time and the time step size. This class is a singleton.

Public Functions

TimeManager()
~TimeManager()
Real getTime()
void setTime(Real t)
Real getTimeStepSize()
void setTimeStepSize(Real tss)
void saveState(BinaryFileWriter &binWriter)
void loadState(BinaryFileReader &binReader)

Public Static Functions

TimeManager *getCurrent()
void setCurrent(TimeManager *tm)
bool hasCurrent()

Class TimeStep

Inheritance Relationships
Base Type

  • public ParameterObject

Derived Types
Class Documentation
class SPH::TimeStep : public ParameterObject

Base class for the simulation methods.

Subclassed by SPH::TimeStepDFSPH, SPH::TimeStepIISPH, SPH::TimeStepPBF, SPH::TimeStepPCISPH, SPH::TimeStepPF, SPH::TimeStepWCSPH

Public Functions

TimeStep()
~TimeStep(void)
void step() = 0
void reset()
void init()
void resize() = 0
void emittedParticles(FluidModel *model, const unsigned int startIndex)
void saveState(BinaryFileWriter &binWriter)
void loadState(BinaryFileReader &binReader)

Public Static Attributes

int SOLVER_ITERATIONS = -1
int MIN_ITERATIONS = -1
int MAX_ITERATIONS = -1
int MAX_ERROR = -1

Protected Functions

void clearAccelerations(const unsigned int fluidModelIndex)

Clear accelerations and add gravitation.

void computeDensities(const unsigned int fluidModelIndex)

Determine densities of all fluid particles.

void initParameters()
void approximateNormal(Discregrid::DiscreteGrid *map, const Eigen::Vector3d &x, Vector3r &n, const unsigned int dim)
void computeVolumeAndBoundaryX(const unsigned int fluidModelIndex, const unsigned int i, const Vector3r &xi)
void computeVolumeAndBoundaryX()
void computeDensityAndGradient(const unsigned int fluidModelIndex, const unsigned int i, const Vector3r &xi)
void computeDensityAndGradient()

Protected Attributes

unsigned int m_iterations
Real m_maxError
unsigned int m_minIterations
unsigned int m_maxIterations

Class TimeStepDFSPH

Inheritance Relationships
Base Type
Class Documentation
class SPH::TimeStepDFSPH : public SPH::TimeStep

This class implements the Divergence-free Smoothed Particle Hydrodynamics approach introduced by Bender and Koschier [BK15,BK17,KBST19].

References:

  • [BK15] Jan Bender and Dan Koschier. Divergence-free smoothed particle hydrodynamics. In ACM SIGGRAPH / Eurographics Symposium on Computer Animation, SCA ‘15, 147-155. New York, NY, USA, 2015. ACM. URL: http://doi.acm.org/10.1145/2786784.2786796

  • [BK17] Jan Bender and Dan Koschier. Divergence-free SPH for incompressible and viscous fluids. IEEE Transactions on Visualization and Computer Graphics, 23(3):1193-1206, 2017. URL: http://dx.doi.org/10.1109/TVCG.2016.2578335

  • [KBST19] Dan Koschier, Jan Bender, Barbara Solenthaler, and Matthias Teschner. Smoothed particle hydrodynamics for physically-based simulation of fluids and solids. In Eurographics 2019 - Tutorials. Eurographics Association, 2019. URL: https://interactivecomputergraphics.github.io/SPH-Tutorial

Public Functions

TimeStepDFSPH()
~TimeStepDFSPH(void)
void step()
void reset()
void resize()

Public Static Attributes

int SOLVER_ITERATIONS_V = -1
int MAX_ITERATIONS_V = -1
int MAX_ERROR_V = -1
int USE_DIVERGENCE_SOLVER = -1

Protected Functions

void computeDFSPHFactor(const unsigned int fluidModelIndex)
void pressureSolve()
void pressureSolveIteration(const unsigned int fluidModelIndex, Real &avg_density_err)
void divergenceSolve()
void divergenceSolveIteration(const unsigned int fluidModelIndex, Real &avg_density_err)
void computeDensityAdv(const unsigned int fluidModelIndex, const unsigned int index, const int numParticles, const Real h, const Real density0)
void computeDensityChange(const unsigned int fluidModelIndex, const unsigned int index, const Real h)
void warmstartDivergenceSolve(const unsigned int fluidModelIndex)
void warmstartPressureSolve(const unsigned int fluidModelIndex)
void performNeighborhoodSearch()

Perform the neighborhood search for all fluid particles.

void emittedParticles(FluidModel *model, const unsigned int startIndex)
void initParameters()

Protected Attributes

SimulationDataDFSPH m_simulationData
unsigned int m_counter
const Real m_eps = static_cast<Real>(1.0e-5)
bool m_enableDivergenceSolver
unsigned int m_iterationsV
Real m_maxErrorV
unsigned int m_maxIterationsV

Class TimeStepIISPH

Inheritance Relationships
Base Type
Class Documentation
class SPH::TimeStepIISPH : public SPH::TimeStep

This class implements the Implicit Incompressible SPH approach introduced by Ihmsen et al. [ICS+14].

References:

  • [ICS+14] Markus Ihmsen, Jens Cornelis, Barbara Solenthaler, Christopher Horvath, and Matthias Teschner. Implicit incompressible SPH. IEEE Transactions on Visualization and Computer Graphics, 20(3):426-435, March 2014. URL: http://dx.doi.org/10.1109/TVCG.2013.105

Public Functions

TimeStepIISPH()
~TimeStepIISPH(void)
void step()
void reset()
void resize()
const SimulationDataIISPH &getSimulationData()

Protected Functions

void predictAdvection(const unsigned int fluidModelIndex)
void pressureSolve()
void pressureSolveIteration(const unsigned int fluidModelIndex, Real &avg_density_err)
void integration(const unsigned int fluidModelIndex)
void computePressureAccels(const unsigned int fluidModelIndex)

Determine the pressure accelerations when the pressure is already known.

void performNeighborhoodSearch()

Perform the neighborhood search for all fluid particles.

void emittedParticles(FluidModel *model, const unsigned int startIndex)

Protected Attributes

SimulationDataIISPH m_simulationData
unsigned int m_counter

Class TimeStepPBF

Inheritance Relationships
Base Type
Class Documentation
class SPH::TimeStepPBF : public SPH::TimeStep

This class implements the position-based fluids approach introduced by Macklin and Mueller [MM13,BMO+14,BMM15].

References:

  • [MM13] Miles Macklin and Matthias Müller. Position based fluids. ACM Trans. Graph., 32(4):104:1-104:12, July 2013. URL: http://doi.acm.org/10.1145/2461912.2461984

  • [BMO+14] 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, 2014. URL: http://dx.doi.org/10.1111/cgf.12346

  • [BMM15] Jan Bender, Matthias Müller, and Miles Macklin. Position-based simulation methods in computer graphics. In EUROGRAPHICS 2015 Tutorials. Eurographics Association, 2015. URL: http://dx.doi.org/10.2312/egt.20151045

Public Functions

TimeStepPBF()

Initialize the simulation data required for this method.

~TimeStepPBF(void)
void step()

Perform a simulation step.

void reset()

Reset the simulation method.

void resize()

Public Static Attributes

int VELOCITY_UPDATE_METHOD = -1
int ENUM_PBF_FIRST_ORDER = -1
int ENUM_PBF_SECOND_ORDER = -1

Protected Functions

void pressureSolve()

Perform a position-based correction step for the following density constraint:\(C(\mathbf{x}) = \left (\frac{\rho_i}{\rho_0} - 1 \right )= 0\)

void pressureSolveIteration(const unsigned int fluidModelIndex, Real &avg_density_err)
void performNeighborhoodSearch()

Perform the neighborhood search for all fluid particles.

void emittedParticles(FluidModel *model, const unsigned int startIndex)
void initParameters()

Protected Attributes

SimulationDataPBF m_simulationData
unsigned int m_counter
int m_velocityUpdateMethod

Class TimeStepPCISPH

Inheritance Relationships
Base Type
Class Documentation
class SPH::TimeStepPCISPH : public SPH::TimeStep

This class implements the Predictive-corrective Incompressible SPH approach introduced by Solenthaler and Pajarola [SP09].

References:

Public Functions

TimeStepPCISPH()
~TimeStepPCISPH(void)
void step()
void reset()
void resize()

Protected Functions

void pressureSolve()
void pressureSolveIteration(const unsigned int fluidModelIndex, Real &avg_density_err)
void performNeighborhoodSearch()

Perform the neighborhood search for all fluid particles.

void emittedParticles(FluidModel *model, const unsigned int startIndex)

Protected Attributes

SimulationDataPCISPH m_simulationData
unsigned int m_counter

Class TimeStepPF

Inheritance Relationships
Base Type
Class Documentation
class SPH::TimeStepPF : public SPH::TimeStep

This class implements the Projective Fluids approach introduced by Weiler, Koschier and Bender [WKB16].

References:

  • [WKB16] Marcel Weiler, Dan Koschier, and Jan Bender. Projective fluids. In Proceedings of the 9th International Conference on Motion in Games, MIG ‘16, 79-84. New York, NY, USA, 2016. ACM. URL: http://doi.acm.org/10.1145/2994258.2994282

Public Functions

TimeStepPF()
~TimeStepPF(void)
void step() override
void reset() override
void resize() override

Public Static Functions

void matrixVecProd(const Real *vec, Real *result, void *userData)

Public Static Attributes

int STIFFNESS = -1

Protected Types

using VectorXr = Eigen::Matrix<Real, -1, 1>
using VectorXrMap = Eigen::Map<VectorXr>
using Solver = Eigen::ConjugateGradient<MatrixReplacement, Eigen::Lower | Eigen::Upper, JacobiPreconditioner3D>

Protected Functions

void preparePreconditioner()
void initialGuessForPositions(const unsigned int fluidModelIndex)
void solvePDConstraints()
void updatePositionsAndVelocity(const VectorXr &x)
void addAccellerationToVelocity()
void matrixFreeRHS(const VectorXr &x, VectorXr &result)

compute the right hand side of the system in a matrix-free fashion and store the result in result

void performNeighborhoodSearch()

Perform the neighborhood search for all fluid particles.

void emittedParticles(FluidModel *model, const unsigned int startIndex) override
void initParameters() override

Protected Attributes

SimulationDataPF m_simulationData
Solver m_solver
Real m_stiffness
unsigned int m_counter
unsigned int m_numActiveParticlesTotal

Protected Static Functions

FORCE_INLINE void diagonalMatrixElement (const unsigned int row, Vector3r &result, void *userData)

Class TimeStepWCSPH

Inheritance Relationships
Base Type
Class Documentation
class SPH::TimeStepWCSPH : public SPH::TimeStep

This class implements the Weakly Compressible SPH for Free Surface Flows approach introduced by Becker and Teschner [BT07].

References:

  • [BT07] Markus Becker and Matthias Teschner. Weakly compressible SPH for free surface flows. In ACM SIGGRAPH/Eurographics Symposium on Computer Animation, SCA ‘07, 209-217. Aire-la-Ville, Switzerland, Switzerland, 2007. Eurographics Association. URL: http://dl.acm.org/citation.cfm?id=1272690.1272719

Public Functions

TimeStepWCSPH()
~TimeStepWCSPH(void)
void step()
void reset()
void resize()

Public Static Attributes

int STIFFNESS = -1
int EXPONENT = -1

Protected Functions

void computePressureAccels(const unsigned int fluidModelIndex)

Determine the pressure accelerations when the pressure is already known.

void performNeighborhoodSearch()

Perform the neighborhood search for all fluid particles.

void emittedParticles(FluidModel *model, const unsigned int startIndex)
void initParameters()

Protected Attributes

Real m_stiffness
Real m_exponent
SimulationDataWCSPH m_simulationData
unsigned int m_counter

Class TriangleMesh

Class Documentation
class SPH::TriangleMesh

Data structure for a triangle mesh with normals and vertex normals.

Public Types

typedef std::vector<unsigned int> Faces
typedef std::vector<Vector3r> Normals
typedef std::vector<Vector3r> Vertices

Public Functions

TriangleMesh()
~TriangleMesh()
void release()
void initMesh(const unsigned int nPoints, const unsigned int nFaces)
void addFace(const unsigned int *const indices)

Add a new face.

void addFace(const int *const indices)

Add a new face.

void addVertex(const Vector3r &vertex)

Add new vertex.

const Faces &getFaces() const
Faces &getFaces()
const Normals &getFaceNormals() const
Normals &getFaceNormals()
const Normals &getVertexNormals() const
Normals &getVertexNormals()
const Vertices &getVertices() const
Vertices &getVertices()
unsigned int numVertices() const
unsigned int numFaces() const
void updateNormals()
void updateVertexNormals()

Protected Attributes

Vertices m_x
Faces m_indices
Normals m_normals
Normals m_vertexNormals

Class Viscosity_Bender2017

Inheritance Relationships
Base Type
Class Documentation
class SPH::Viscosity_Bender2017 : public SPH::ViscosityBase

This class implements the implicit simulation method for viscous fluids introduced by Bender and Koschier [BK17].

References:

  • [BK17] Jan Bender and Dan Koschier. Divergence-free SPH for incompressible and viscous fluids. IEEE Transactions on Visualization and Computer Graphics, 23(3):1193-1206, 2017. URL: http://dx.doi.org/10.1109/TVCG.2016.2578335

Public Functions

Viscosity_Bender2017(FluidModel *model)
~Viscosity_Bender2017(void)
void step()
void reset()
void performNeighborhoodSearchSort()
void computeTargetStrainRate()
void computeViscosityFactor()
FORCE_INLINE void viscoGradientMultTransposeRightOpt (const Eigen::Matrix< Real, 6, 3 > &a, const Eigen::Matrix< Real, 6, 3 > &b, Matrix6r &c)

Matrix product

FORCE_INLINE const Vector6r & getTargetStrainRate (const unsigned int i) const
FORCE_INLINE Vector6r & getTargetStrainRate (const unsigned int i)
FORCE_INLINE void setTargetStrainRate (const unsigned int i, const Vector6r &val)
FORCE_INLINE const Matrix6r & getViscosityFactor (const unsigned int i) const
FORCE_INLINE Matrix6r & getViscosityFactor (const unsigned int i)
FORCE_INLINE void setViscosityFactor (const unsigned int i, const Matrix6r &val)
FORCE_INLINE const Vector6r & getViscosityLambda (const unsigned int i) const
FORCE_INLINE Vector6r & getViscosityLambda (const unsigned int i)
FORCE_INLINE void setViscosityLambda (const unsigned int i, const Vector6r &val)

Public Static Attributes

int ITERATIONS = -1
int MAX_ITERATIONS = -1
int MAX_ERROR = -1

Protected Functions

void initParameters()

Protected Attributes

std::vector<Vector6r> m_targetStrainRate
std::vector<Matrix6r> m_viscosityFactor
std::vector<Vector6r> m_viscosityLambda
unsigned int m_iterations
unsigned int m_maxIter
Real m_maxError

Class Viscosity_Peer2015

Inheritance Relationships
Base Type
Class Documentation
class SPH::Viscosity_Peer2015 : public SPH::ViscosityBase

This class implements the implicit simulation method for viscous fluids introduced by Peer et al. [PICT15].

References:

  • [PICT15] A. Peer, M. Ihmsen, J. Cornelis, and M. Teschner. An Implicit Viscosity Formulation for SPH Fluids. ACM Trans. Graph., 34(4):1-10, 2015. URL: http://doi.acm.org/10.1145/2766925

Public Functions

Viscosity_Peer2015(FluidModel *model)
~Viscosity_Peer2015(void)
void step()
void reset()
void performNeighborhoodSearchSort()
FORCE_INLINE const Matrix3r & getTargetNablaV (const unsigned int i) const
FORCE_INLINE Matrix3r & getTargetNablaV (const unsigned int i)
FORCE_INLINE void setTargetNablaV (const unsigned int i, const Matrix3r &val)

Public Static Functions

void matrixVecProd(const Real *vec, Real *result, void *userData)
FORCE_INLINE void diagonalMatrixElement (const unsigned int row, Real &result, void *userData)

Public Static Attributes

int ITERATIONS = -1
int MAX_ITERATIONS = -1
int MAX_ERROR = -1

Protected Types

typedef Eigen::ConjugateGradient<MatrixReplacement, Eigen::Lower | Eigen::Upper, JacobiPreconditioner1D> Solver

Protected Functions

void initParameters()
void computeDensities()

Protected Attributes

std::vector<Real> m_density
std::vector<Matrix3r> m_targetNablaV
Solver m_solver
unsigned int m_iterations
unsigned int m_maxIter
Real m_maxError

Class Viscosity_Peer2016

Inheritance Relationships
Base Type
Class Documentation
class SPH::Viscosity_Peer2016 : public SPH::ViscosityBase

This class implements the implicit simulation method for viscous fluids introduced by Peer and Teschner [PGBT17].

References:

  • [PGBT17] Andreas Peer, Christoph Gissler, Stefan Band, and Matthias Teschner. An implicit SPH formulation for incompressible linearly elastic solids. Computer Graphics Forum, 2017. URL: http://dx.doi.org/10.1111/cgf.13317

Public Functions

Viscosity_Peer2016(FluidModel *model)
~Viscosity_Peer2016(void)
void step()
void reset()
void performNeighborhoodSearchSort()
FORCE_INLINE const Matrix3r & getTargetNablaV (const unsigned int i) const
FORCE_INLINE Matrix3r & getTargetNablaV (const unsigned int i)
FORCE_INLINE void setTargetNablaV (const unsigned int i, const Matrix3r &val)
FORCE_INLINE const Vector3r & getOmega (const unsigned int i) const
FORCE_INLINE Vector3r & getOmega (const unsigned int i)
FORCE_INLINE void setOmega (const unsigned int i, const Vector3r &val)

Public Static Functions

void matrixVecProdV(const Real *vec, Real *result, void *userData)
FORCE_INLINE void diagonalMatrixElementV (const unsigned int row, Real &result, void *userData)
void matrixVecProdOmega(const Real *vec, Real *result, void *userData)
FORCE_INLINE void diagonalMatrixElementOmega (const unsigned int row, Real &result, void *userData)

Public Static Attributes

int ITERATIONS_V = -1
int ITERATIONS_OMEGA = -1
int MAX_ITERATIONS_V = -1
int MAX_ERROR_V = -1
int MAX_ITERATIONS_OMEGA = -1
int MAX_ERROR_OMEGA = -1

Protected Types

typedef Eigen::ConjugateGradient<MatrixReplacement, Eigen::Lower | Eigen::Upper, JacobiPreconditioner1D> Solver

Protected Functions

void initParameters()
void computeDensities()

Protected Attributes

std::vector<Real> m_density
std::vector<Matrix3r> m_targetNablaV
std::vector<Vector3r> m_omega
Solver m_solverV
Solver m_solverOmega
unsigned int m_iterationsV
unsigned int m_iterationsOmega
unsigned int m_maxIterV
Real m_maxErrorV
unsigned int m_maxIterOmega
Real m_maxErrorOmega

Class Viscosity_Standard

Inheritance Relationships
Base Type
Class Documentation
class SPH::Viscosity_Standard : public SPH::ViscosityBase

This class implements the standard method for viscosity descibed e.g. by Ihmsen et al. [IOS+14].

The method evaluates the term

\(\nu \nabla^2 \mathbf{v}\) and uses an approximation of the kernel Laplacian to improve the stability. This approximation is given in [IOS+14].

References:

  • [IOS+14] Markus Ihmsen, Jens Orthmann, Barbara Solenthaler, Andreas Kolb, and Matthias Teschner. SPH Fluids in Computer Graphics. In Sylvain Lefebvre and Michela Spagnuolo, editors, Eurographics 2014 - State of the Art Reports. The Eurographics Association, 2014. URL: http://dx.doi.org/10.2312/egst.20141034

Public Functions

Viscosity_Standard(FluidModel *model)
~Viscosity_Standard(void)
void step()
void reset()

Public Static Attributes

int VISCOSITY_COEFFICIENT_BOUNDARY = -1

Protected Functions

void initParameters()

Protected Attributes

Real m_boundaryViscosity

Class Viscosity_Takahashi2015

Inheritance Relationships
Base Type
Class Documentation
class SPH::Viscosity_Takahashi2015 : public SPH::ViscosityBase

This class implements a variant of the implicit simulation method for viscous fluids introduced by Takahashi et al. [TDF+15]. In the original work of Takahashi et al. the second-ring neighbors are required to create the matrix of the linear system. In contrast we use a meshless conjugate gradient solver which performs the required matrix-vector multiplication in two sequential loops. In this way only the one-ring neighbors are required in each loop which increases the performance significantly.

Thanks to Anreas Peer who helped us with the implementation.

References:

  • [TDF+15] T. Takahashi, Y. Dobashi, I. Fujishiro, T. Nishita, and M.C. Lin. Implicit Formulation for SPH-based Viscous Fluids. Computer Graphics Forum, 34(2):493-502, 2015. URL: http://dx.doi.org/10.1111/cgf.12578

Public Functions

Viscosity_Takahashi2015(FluidModel *model)
~Viscosity_Takahashi2015(void)
void step()
void reset()
void performNeighborhoodSearchSort()
FORCE_INLINE const Matrix3r & getViscousStress (const unsigned int i) const
FORCE_INLINE Matrix3r & getViscousStress (const unsigned int i)
FORCE_INLINE void setViscousStress (const unsigned int i, const Matrix3r &val)
FORCE_INLINE const Vector3r & getAccel (const unsigned int i) const
FORCE_INLINE Vector3r & getAccel (const unsigned int i)
FORCE_INLINE void setAccel (const unsigned int i, const Vector3r &val)

Public Static Functions

void matrixVecProd(const Real *vec, Real *result, void *userData)
FORCE_INLINE void diagonalMatrixElement (const unsigned int row, Real &result, void *userData)

Public Static Attributes

int ITERATIONS = -1
int MAX_ITERATIONS = -1
int MAX_ERROR = -1

Protected Types

typedef Eigen::ConjugateGradient<MatrixReplacement, Eigen::Lower | Eigen::Upper, Eigen::IdentityPreconditioner> Solver

Protected Functions

void initParameters()

Protected Attributes

std::vector<Vector3r> m_accel
std::vector<Matrix3r> m_viscousStress
Solver m_solver
unsigned int m_iterations
unsigned int m_maxIter
Real m_maxError

Protected Static Functions

void computeViscosityAcceleration(Viscosity_Takahashi2015 *visco, const Real *v)

Class Viscosity_Weiler2018

Inheritance Relationships
Base Type
Class Documentation
class SPH::Viscosity_Weiler2018 : public SPH::ViscosityBase

This class implements the implicit Laplace viscosity method introduced by Weiler et al. 2018 [WKBB18].

References:

  • [WKBB18] Marcel Weiler, Dan Koschier, Magnus Brand, and Jan Bender. A physically consistent implicit viscosity solver for SPH fluids. Computer Graphics Forum (Eurographics), 2018. URL: https://doi.org/10.1111/cgf.13349

Public Functions

Viscosity_Weiler2018(FluidModel *model)
~Viscosity_Weiler2018(void)
void step()
void reset()
void performNeighborhoodSearchSort()

Public Static Functions

void matrixVecProd(const Real *vec, Real *result, void *userData)

Public Static Attributes

int ITERATIONS = -1
int MAX_ITERATIONS = -1
int MAX_ERROR = -1
int VISCOSITY_COEFFICIENT_BOUNDARY = -1

Protected Types

typedef Eigen::ConjugateGradient<MatrixReplacement, Eigen::Lower | Eigen::Upper, BlockJacobiPreconditioner3D> Solver

Protected Functions

void initParameters()

Protected Attributes

Real m_boundaryViscosity
unsigned int m_maxIter
Real m_maxError
unsigned int m_iterations
std::vector<Vector3r> m_vDiff
Real m_tangentialDistanceFactor
Solver m_solver

Protected Static Functions

FORCE_INLINE void diagonalMatrixElement (const unsigned int row, Matrix3r &result, void *userData)

Class Viscosity_XSPH

Inheritance Relationships
Base Type
Class Documentation
class SPH::Viscosity_XSPH : public SPH::ViscosityBase

This class implements the XSPH method descibed by Schechter and Bridson [SB12].

References:

Public Functions

Viscosity_XSPH(FluidModel *model)
~Viscosity_XSPH(void)
void step()
void reset()

Public Static Attributes

int VISCOSITY_COEFFICIENT_BOUNDARY = -1

Protected Functions

void initParameters()

Protected Attributes

Real m_boundaryViscosity

Class ViscosityBase

Inheritance Relationships
Base Type
Derived Types
Class Documentation
class SPH::ViscosityBase : public SPH::NonPressureForceBase

Base class for all viscosity methods.

Subclassed by SPH::Viscosity_Bender2017, SPH::Viscosity_Peer2015, SPH::Viscosity_Peer2016, SPH::Viscosity_Standard, SPH::Viscosity_Takahashi2015, SPH::Viscosity_Weiler2018, SPH::Viscosity_XSPH

Public Functions

ViscosityBase(FluidModel *model)
~ViscosityBase(void)

Public Static Attributes

int VISCOSITY_COEFFICIENT = -1

Protected Functions

void initParameters()

Protected Attributes

Real m_viscosity

Class VorticityBase

Inheritance Relationships
Base Type
Derived Types
Class Documentation
class SPH::VorticityBase : public SPH::NonPressureForceBase

Base class for all vorticity methods.

Subclassed by SPH::MicropolarModel_Bender2017, SPH::VorticityConfinement

Public Functions

VorticityBase(FluidModel *model)
~VorticityBase(void)

Public Static Attributes

int VORTICITY_COEFFICIENT = -1

Protected Functions

void initParameters()

Protected Attributes

Real m_vorticityCoeff

Class VorticityConfinement

Inheritance Relationships
Base Type
Class Documentation
class SPH::VorticityConfinement : public SPH::VorticityBase

This class implements the vorticity confinement method introduced by Macklin and Mueller [MM13].

References:

Public Functions

VorticityConfinement(FluidModel *model)
~VorticityConfinement(void)
void step()
void reset()
void performNeighborhoodSearchSort()
FORCE_INLINE const Vector3r & getAngularVelocity (const unsigned int i) const
FORCE_INLINE Vector3r & getAngularVelocity (const unsigned int i)
FORCE_INLINE void setAngularVelocity (const unsigned int i, const Vector3r &val)

Protected Attributes

std::vector<Vector3r> m_omega
std::vector<Real> m_normOmega

Class WendlandQuinticC2Kernel

Class Documentation
class SPH::WendlandQuinticC2Kernel

quintic Wendland C2 kernel.

Public Static Functions

Real getRadius()
void setRadius(Real val)
Real W(const Real r)
Real W(const Vector3r &r)
Vector3r gradW(const Vector3r &r)
Real W_zero()

Protected Static Attributes

Real m_radius
Real m_k
Real m_l
Real m_W_zero

Class WendlandQuinticC2Kernel2D

Class Documentation
class SPH::WendlandQuinticC2Kernel2D

Wendland Quintic C2 spline kernel (2D).

Public Static Functions

Real getRadius()
void setRadius(Real val)
Real W(const Real r)
Real W(const Vector3r &r)
Vector3r gradW(const Vector3r &r)
Real W_zero()

Protected Static Attributes

Real m_radius
Real m_k
Real m_l
Real m_W_zero

Class ConsoleSink

Inheritance Relationships
Base Type
Class Documentation
class Utilities::ConsoleSink : public Utilities::LogSink

Public Functions

ConsoleSink(const LogLevel minLevel)
void write(const LogLevel level, const std::string &str)

Class Counting

Class Documentation
class Utilities::Counting

Public Static Functions

void reset()
FORCE_INLINE void increaseCounter (const std::string &name, const Real increaseBy)
FORCE_INLINE void printAverageCounts ()
FORCE_INLINE void printCounterSums ()

Public Static Attributes

std::unordered_map<std::string, AverageCount> m_averageCounts

Class FileSink

Inheritance Relationships
Base Type
Class Documentation
class Utilities::FileSink : public Utilities::LogSink

Public Functions

FileSink(const LogLevel minLevel, const std::string &fileName)
~FileSink()
void write(const LogLevel level, const std::string &str)

Protected Attributes

std::ofstream m_file

Class FileSystem

Class Documentation
class Utilities::FileSystem

This class implements different file system functions.

Public Static Functions

std::string getFilePath(const std::string &path)
std::string getFileName(const std::string &path)
std::string getFileNameWithExt(const std::string &path)
std::string getFileExt(const std::string &path)
bool isRelativePath(const std::string &path)
int makeDir(const std::string &path)
int makeDirs(const std::string &path)

Make all subdirectories.

std::string normalizePath(const std::string &path)
bool fileExists(const std::string &fileName)
std::string getProgramPath()
bool copyFile(const std::string &source, const std::string &dest)
bool isFile(const std::string &path)
bool isDirectory(const std::string &path)
bool getFilesInDirectory(const std::string &path, std::vector<std::string> &res)
std::string getFileMD5(const std::string &filename)

Compute the MD5 hash of a file.

bool writeMD5File(const std::string &fileName, const std::string &md5File)

Write the MD5 hash of a file to the md5File.

bool checkMD5(const std::string &md5Hash, const std::string &md5File)

Compare an MD5 hash with the hash stored in an MD5 file.

Class IDFactory

Class Documentation
class Utilities::IDFactory

Factory for unique ids.

Public Static Functions

int getId()

Class Logger

Class Documentation
class Utilities::Logger

Public Functions

Logger()
~Logger()
void addSink(std::unique_ptr<LogSink> sink)
void write(const LogLevel level, const std::string &str)

Protected Attributes

std::vector<std::unique_ptr<LogSink>> m_sinks

Class LogSink

Inheritance Relationships
Derived Types
Class Documentation
class Utilities::LogSink

Subclassed by Utilities::ConsoleSink, Utilities::FileSink

Public Functions

LogSink(const LogLevel minLevel)
~LogSink()
void write(const LogLevel level, const std::string &str) = 0

Protected Attributes

LogLevel m_minLevel

Class LogStream

Class Documentation
class Utilities::LogStream

Public Functions

LogStream(Logger *logger, const LogLevel level)
template<typename T>
LogStream &operator<<(T const &value)
~LogStream()

Protected Attributes

LogLevel m_level
Logger *m_logger
std::ostringstream m_buffer

Class OBJLoader

Class Documentation
class Utilities::OBJLoader

Read for OBJ files.

Public Types

using Vec3f = std::array<float, 3>
using Vec2f = std::array<float, 2>

Public Static Functions

void loadObj(const std::string &filename, std::vector<Vec3f> *x, std::vector<MeshFaceIndices> *faces, std::vector<Vec3f> *normals, std::vector<Vec2f> *texcoords, const Vec3f &scale)

This function loads an OBJ file. Only triangulated meshes are supported.

Class PartioReaderWriter

Class Documentation
class Utilities::PartioReaderWriter

Class for reading and writing partio files.

Public Static Functions

bool readParticles(const std::string &fileName, const Vector3r &translation, const Matrix3r &rotation, const Real scale, std::vector<Vector3r> &pos, std::vector<Vector3r> &vel)
bool readParticles(const std::string &fileName, const Vector3r &translation, const Matrix3r &rotation, const Real scale, std::vector<Vector3r> &positions, std::vector<Vector3r> &velocities, Real &particleRadius)
bool readParticles(const std::string &fileName, const Vector3r &translation, const Matrix3r &rotation, const Real scale, std::vector<Vector3r> &pos)
void writeParticles(const std::string &fileName, const unsigned int numParticles, const Vector3r *particlePositions, const Vector3r *particleVelocities, const Real particleRadius)

Class SceneLoader

Class Documentation
class Utilities::SceneLoader

Importer of SPlisHSPlasH scene files.

Public Functions

void readScene(const char *fileName, Scene &scene)
template<typename T>
bool readValue(const nlohmann::json &j, T &v)
template<typename T, int size>
bool readVector(const nlohmann::json &j, Eigen::Matrix<T, size, 1, Eigen::DontAlign> &vec)
template<typename T>
bool readValue(const std::string &section, const std::string &key, T &v)
template<typename T, int size>
bool readVector(const std::string &section, const std::string &key, Eigen::Matrix<T, size, 1, Eigen::DontAlign> &vec)
void readMaterialParameterObject(const std::string &key, GenParam::ParameterObject *paramObj)
void readParameterObject(const std::string &key, GenParam::ParameterObject *paramObj)
template<>
bool readValue(const nlohmann::json &j, bool &v)
template<>
bool readValue(const nlohmann::json &j, bool &v)

Protected Functions

void readParameterObject(nlohmann::json &config, GenParam::ParameterObject *paramObj)

Protected Attributes

nlohmann::json m_jsonData
struct AnimationFieldData

Struct to store an animation field object.

Public Members

std::string particleFieldName
std::string expression[3]
unsigned int shapeType
Vector3r x
Matrix3r rotation
Vector3r scale
Real startTime
Real endTime
struct BoundaryData

Struct to store a boundary object.

Public Members

std::string samplesFile
std::string meshFile
Vector3r translation
Matrix3r rotation
Vector3r scale
Real density
bool dynamic
bool isWall
Eigen::Matrix<float, 4, 1, Eigen::DontAlign> color
void *rigidBody
std::string mapFile
bool mapInvert
Real mapThickness
Eigen::Matrix<unsigned int, 3, 1, Eigen::DontAlign> mapResolution
unsigned int samplingMode
struct Box

Struct for an AABB.

Public Members

Vector3r m_minX
Vector3r m_maxX
struct EmitterData

Struct to store an emitter object.

Public Members

std::string id
unsigned int width
unsigned int height
Vector3r x
Real velocity
Matrix3r rotation
Real emitStartTime
Real emitEndTime
unsigned int type
struct FluidBlock

Struct to store a fluid block.

Public Members

std::string id
Box box
unsigned char mode
Vector3r initialVelocity
struct FluidData

Struct to store a fluid object.

Public Members

std::string id
std::string samplesFile
Vector3r translation
Matrix3r rotation
Vector3r scale
Vector3r initialVelocity
unsigned char mode
bool invert
std::array<unsigned int, 3> resolutionSDF
struct MaterialData

Struct to store particle coloring information.

Public Members

std::string id
std::string colorField
unsigned int colorMapType
Real minVal
Real maxVal
unsigned int maxEmitterParticles
bool emitterReuseParticles
Vector3r emitterBoxMin
Vector3r emitterBoxMax
struct Scene

Struct to store scene information.

Public Members

std::vector<BoundaryData*> boundaryModels
std::vector<FluidData*> fluidModels
std::vector<FluidBlock*> fluidBlocks
std::vector<EmitterData*> emitters
std::vector<AnimationFieldData*> animatedFields
std::vector<MaterialData*> materials
Real particleRadius
bool sim2D
Real timeStepSize
Vector3r camPosition
Vector3r camLookat

Class SDFFunctions

Class Documentation
class Utilities::SDFFunctions

Functions for generating and querying an SDF.

Public Static Functions

Discregrid::CubicLagrangeDiscreteGrid *generateSDF(const unsigned int numVertices, const Vector3r *vertices, const unsigned int numFaces, const unsigned int *faces, const AlignedBox3r &bbox, const std::array<unsigned int, 3> &resolution, const bool invert = false)

Generate SDF from mesh.

AlignedBox3r computeBoundingBox(const unsigned int numVertices, const Vector3r *vertices)

Compute the bounding box of a mesh.

double distance(Discregrid::CubicLagrangeDiscreteGrid *sdf, const Vector3r &x, const Real thickness, Vector3r &normal, Vector3r &nextSurfacePoint)

Determine distance of a point x to the surface represented by the SDF and corresponding surface normal and next point on the surface.

double distance(Discregrid::CubicLagrangeDiscreteGrid *sdf, const Vector3r &x, const Real thickness)

Determine distance of a point x to the surface represented by the SDF.

Class StringTools

Class Documentation
class Utilities::StringTools

Tools to handle std::string objects.

Public Static Functions

void tokenize(const std::string &str, std::vector<std::string> &tokens, const std::string &delimiters = " ")

Class SystemInfo

Class Documentation
class Utilities::SystemInfo

Public Static Functions

std::string getHostName()

Class Timing

Class Documentation
class Utilities::Timing

Class for time measurements.

Public Static Functions

void reset()
FORCE_INLINE void startTiming (const std::string &name=std::string(""))
FORCE_INLINE double stopTiming (bool print=true)
FORCE_INLINE double stopTiming (bool print, int &id)
FORCE_INLINE void printAverageTimes ()
FORCE_INLINE void printTimeSums ()

Public Static Attributes

bool m_dontPrintTimes
unsigned int m_startCounter
unsigned int m_stopCounter
std::stack<TimingHelper> m_timingStack
std::unordered_map<int, AverageTime> m_averageTimes

Class VolumeSampling

Class Documentation
class Utilities::VolumeSampling

This class implements a volume sampling of 3D models.

Public Static Functions

void sampleMesh(const unsigned int numVertices, const Vector3r *vertices, const unsigned int numFaces, const unsigned int *faces, const Real radius, const AlignedBox3r *region, const std::array<unsigned int, 3> &resolution, const bool invert, const unsigned int sampleMode, std::vector<Vector3r> &samples)

Performs the volume sampling with the respective parameters.

Parameters

  • numVertices: number of vertices

  • vertices: vertex data

  • numFaces: number of faces

  • faces: index list of faces

  • radius: radius of sampled particles

  • region: defines a subregion of the mesh to be sampled (nullptr if not used)

  • resolution: resolution of the used SDF

  • invert: defines if the mesh should be inverted and the outside is sampled

  • sampleMode: 0=regular, 1=almost dense, 2=dense

  • samples: sampled vertices that will be returned

Class WindingNumbers

Class Documentation
class Utilities::WindingNumbers

Public Static Functions

Real computeGeneralizedWindingNumber(const Vector3r &p, const Vector3r &a, const Vector3r &b, const Vector3r &c)

Determine the winding number for a point p and a triangle abc.

Real computeGeneralizedWindingNumber(const Vector3r &p, const SPH::TriangleMesh &mesh)

Determine the winding number of a point p in a triangle mesh.

Class Vector3f8

Class Documentation
class Vector3f8

Public Functions

Vector3f8()
Vector3f8(const bool)
Vector3f8(const Scalarf8 &x, const Scalarf8 &y, const Scalarf8 &z)
Vector3f8(const Scalarf8 &x)
Vector3f8(const Vector3f &x)
Vector3f8(const Vector3f &v0, const Vector3f &v1, const Vector3f &v2, const Vector3f &v3, const Vector3f &v4, const Vector3f &v5, const Vector3f &v6, const Vector3f &v7)
Vector3f8(Vector3f const *x)
void setZero()
Scalarf8 &operator[](int i)
const Scalarf8 &operator[](int i) const
Scalarf8 &x()
Scalarf8 &y()
Scalarf8 &z()
const Scalarf8 &x() const
const Scalarf8 &y() const
const Scalarf8 &z() const
Scalarf8 dot(const Vector3f8 &a) const
Scalarf8 operator*(const Vector3f8 &a) const
void cross(const Vector3f8 &a, const Vector3f8 &b)
const Vector3f8 operator%(const Vector3f8 &a) const
Vector3f8 &operator*=(const Scalarf8 &s)
const Vector3f8 operator/(const Scalarf8 &s) const
Vector3f8 &operator/=(const Scalarf8 &s)
Vector3f8 &operator-=(const Vector3f8 &a)
const Vector3f8 operator-() const
Scalarf8 squaredNorm() const
Scalarf8 norm() const
void normalize()
void store(std::vector<Vector3r> &Vf) const
void store(Vector3r *Vf) const

Public Members

Scalarf8 v[3]

Public Static Functions

Vector3f8 blend(Scalarf8 const &c, Vector3f8 const &a, Vector3f8 const &b)

Enums

Enum BoundaryHandlingMethods

Enum Documentation
enum SPH::BoundaryHandlingMethods

Values:

enumerator Akinci2012
enumerator Koschier2017
enumerator Bender2019
enumerator NumSimulationMethods

Enum DragMethods

Enum Documentation
enum SPH::DragMethods

Values:

enumerator None
enumerator Macklin2014
enumerator Gissler2017
enumerator NumDragMethods

Enum ElasticityMethods

Enum Documentation
enum SPH::ElasticityMethods

Values:

enumerator None
enumerator Becker2009
enumerator Peer2018
enumerator NumElasticityMethods

Enum FieldType

Enum Documentation
enum SPH::FieldType

Values:

enumerator Scalar
enumerator Vector3
enumerator Vector6
enumerator Matrix3
enumerator Matrix6
enumerator UInt

Enum ParticleState

Enum Documentation
enum SPH::ParticleState

Values:

enumerator Active
enumerator AnimatedByEmitter
enumerator AnimatedByVM

Enum SimulationMethods

Enum Documentation
enum SPH::SimulationMethods

Values:

enumerator WCSPH
enumerator PCISPH
enumerator PBF
enumerator IISPH
enumerator DFSPH
enumerator PF
enumerator NumSimulationMethods

Enum SurfaceSamplingMode

Enum Documentation
enum SPH::SurfaceSamplingMode

Values:

enumerator PoissonDisk
enumerator RegularTriangle
enumerator Regular2D

Enum SurfaceTensionMethods

Enum Documentation
enum SPH::SurfaceTensionMethods

Values:

enumerator None
enumerator Becker2007
enumerator Akinci2013
enumerator He2014
enumerator NumSurfaceTensionMethods

Enum ViscosityMethods

Enum Documentation
enum SPH::ViscosityMethods

Values:

enumerator None
enumerator Standard
enumerator XSPH
enumerator Bender2017
enumerator Peer2015
enumerator Peer2016
enumerator Takahashi2015
enumerator Weiler2018
enumerator NumViscosityMethods

Enum VorticityMethods

Enum Documentation
enum SPH::VorticityMethods

Values:

enumerator None
enumerator Micropolar
enumerator VorticityConfinement
enumerator NumVorticityMethods

Enum LogLevel

Enum Documentation
enum Utilities::LogLevel

Values:

enumerator DEBUG
enumerator INFO
enumerator WARN
enumerator ERR

Functions

Function abs

Function Documentation
Scalarf8 abs(Scalarf8 const &a)

Function blend

Function Documentation

Warning

doxygenfunction: Unable to resolve multiple matches for function “blend” with arguments (Scalarf8 const&, Scalarf8 const&, Scalarf8 const&) in doxygen xml output for project “SPlisHSPlasH” from directory: ./doxyoutput/xml. Potential matches: 

- Scalarf8 blend(Scalarf8 const &c, Scalarf8 const &a, Scalarf8 const &b)
- Vector3f8 blend(Scalarf8 const &c, Vector3f8 const &a, Vector3f8 const &b)

Template Function constant8f

Function Documentation
template<int i0, int i1, int i2, int i3, int i4, int i5, int i6, int i7>
__m256 constant8f()

Function convert_one

Function Documentation
Scalarf8 convert_one(const unsigned int *idx, const Real *x, const unsigned char count = 8u)

Function convert_zero(const unsigned int *, const Real *, const unsigned char)

Function Documentation

Warning

doxygenfunction: Unable to resolve multiple matches for function “convert_zero” with arguments (const unsigned int *, const Real *, const unsigned char) in doxygen xml output for project “SPlisHSPlasH” from directory: ./doxyoutput/xml. Potential matches: 

- Scalarf8 convert_zero(const Real x, const unsigned char count = 8u)
- Scalarf8 convert_zero(const unsigned int *idx, const Real *x, const unsigned char count = 8u)

Function convert_zero(const Real, const unsigned char)

Function Documentation

Warning

doxygenfunction: Unable to resolve multiple matches for function “convert_zero” with arguments (const Real, const unsigned char) in doxygen xml output for project “SPlisHSPlasH” from directory: ./doxyoutput/xml. Potential matches: 

- Scalarf8 convert_zero(const Real x, const unsigned char count = 8u)
- Scalarf8 convert_zero(const unsigned int *idx, const Real *x, const unsigned char count = 8u)

Function convertVec_zero(const unsigned int *, const Real *, const unsigned char)

Function Documentation

Warning

doxygenfunction: Unable to resolve multiple matches for function “convertVec_zero” with arguments (const unsigned int *, const Real *, const unsigned char) in doxygen xml output for project “SPlisHSPlasH” from directory: ./doxyoutput/xml. Potential matches: 

- Vector3f8 convertVec_zero(const unsigned int *idx, const Real *v, const unsigned char count = 8u)
- Vector3f8 convertVec_zero(const unsigned int *idx, const Vector3r *v, const unsigned char count = 8u)

Function convertVec_zero(const unsigned int *, const Vector3r *, const unsigned char)

Function Documentation

Warning

doxygenfunction: Unable to resolve multiple matches for function “convertVec_zero” with arguments (const unsigned int *, const Vector3r *, const unsigned char) in doxygen xml output for project “SPlisHSPlasH” from directory: ./doxyoutput/xml. Potential matches: 

- Vector3f8 convertVec_zero(const unsigned int *idx, const Real *v, const unsigned char count = 8u)
- Vector3f8 convertVec_zero(const unsigned int *idx, const Vector3r *v, const unsigned char count = 8u)

Function dyadicProduct

Function Documentation
void dyadicProduct(const Vector3f8 &a, const Vector3f8 &b, Matrix3f8 &res)

Function getTime

Function Documentation
Real SPH::TimeManager::getTime()

Function max

Function Documentation
Scalarf8 max(Scalarf8 const &a, Scalarf8 const &b)

Function operator!=

Function Documentation
Scalarf8 operator!=(Scalarf8 const &a, Scalarf8 const &b)

Function operator*(Scalarf8 const&, Scalarf8 const&)

Function Documentation

Warning

doxygenfunction: Unable to resolve multiple matches for function “operator*” with arguments (Scalarf8 const&, Scalarf8 const&) in doxygen xml output for project “SPlisHSPlasH” from directory: ./doxyoutput/xml. Potential matches: 

- Matrix3f8 operator*(const Matrix3f8 &b) const
- Matrix3f8 operator*(const Scalarf8 &b) const
- Scalarf8 operator*(Scalarf8 const &a, Scalarf8 const &b)
- Scalarf8 operator*(const Vector3f8 &a) const
- Vector3f8 operator*(Vector3f8 const &a, const Scalarf8 &s)
- Vector3f8 operator*(const Vector3f8 &b) const
- const Quaternion8f operator*(const Quaternion8f &a) const
- template<typename Rhs> Eigen::Product<MatrixReplacement, Rhs, Eigen::AliasFreeProduct> operator*(const Eigen::MatrixBase<Rhs> &x) const

Function operator*(Vector3f8 const&, const Scalarf8&)

Function Documentation

Warning

doxygenfunction: Unable to resolve multiple matches for function “operator*” with arguments (Vector3f8 const&, const Scalarf8&) in doxygen xml output for project “SPlisHSPlasH” from directory: ./doxyoutput/xml. Potential matches: 

- Matrix3f8 operator*(const Matrix3f8 &b) const
- Matrix3f8 operator*(const Scalarf8 &b) const
- Scalarf8 operator*(Scalarf8 const &a, Scalarf8 const &b)
- Scalarf8 operator*(const Vector3f8 &a) const
- Vector3f8 operator*(Vector3f8 const &a, const Scalarf8 &s)
- Vector3f8 operator*(const Vector3f8 &b) const
- const Quaternion8f operator*(const Quaternion8f &a) const
- template<typename Rhs> Eigen::Product<MatrixReplacement, Rhs, Eigen::AliasFreeProduct> operator*(const Eigen::MatrixBase<Rhs> &x) const

Function operator*=

Function Documentation

Warning

doxygenfunction: Unable to resolve multiple matches for function “operator*=” with arguments (Scalarf8&, Scalarf8 const&) in doxygen xml output for project “SPlisHSPlasH” from directory: ./doxyoutput/xml. Potential matches: 

- Scalarf8 &operator*=(Scalarf8 &a, Scalarf8 const &b)
- Vector3f8 &operator*=(const Scalarf8 &s)

Function operator+(Scalarf8 const&, Scalarf8 const&)

Function Documentation

Warning

doxygenfunction: Unable to resolve multiple matches for function “operator+” with arguments (Scalarf8 const&, Scalarf8 const&) in doxygen xml output for project “SPlisHSPlasH” from directory: ./doxyoutput/xml. Potential matches: 

- Scalarf8 operator+(Scalarf8 const &a, Scalarf8 const &b)
- Vector3f8 operator+(Vector3f8 const &a, Vector3f8 const &b)

Function operator+(Vector3f8 const&, Vector3f8 const&)

Function Documentation

Warning

doxygenfunction: Unable to resolve multiple matches for function “operator+” with arguments (Vector3f8 const&, Vector3f8 const&) in doxygen xml output for project “SPlisHSPlasH” from directory: ./doxyoutput/xml. Potential matches: 

- Scalarf8 operator+(Scalarf8 const &a, Scalarf8 const &b)
- Vector3f8 operator+(Vector3f8 const &a, Vector3f8 const &b)

Function operator+=(Scalarf8&, Scalarf8 const&)

Function Documentation

Warning

doxygenfunction: Unable to resolve multiple matches for function “operator+=” with arguments (Scalarf8&, Scalarf8 const&) in doxygen xml output for project “SPlisHSPlasH” from directory: ./doxyoutput/xml. Potential matches: 

- Matrix3f8 &operator+=(const Matrix3f8 &a)
- Scalarf8 &operator+=(Scalarf8 &a, Scalarf8 const &b)
- Vector3f8 &operator+=(Vector3f8 &a, Vector3f8 const &b)

Function operator+=(Vector3f8&, Vector3f8 const&)

Function Documentation

Warning

doxygenfunction: Unable to resolve multiple matches for function “operator+=” with arguments (Vector3f8&, Vector3f8 const&) in doxygen xml output for project “SPlisHSPlasH” from directory: ./doxyoutput/xml. Potential matches: 

- Matrix3f8 &operator+=(const Matrix3f8 &a)
- Scalarf8 &operator+=(Scalarf8 &a, Scalarf8 const &b)
- Vector3f8 &operator+=(Vector3f8 &a, Vector3f8 const &b)

Function operator-(Scalarf8&)

Function Documentation

Warning

doxygenfunction: Unable to resolve multiple matches for function “operator-” with arguments (Scalarf8&) in doxygen xml output for project “SPlisHSPlasH” from directory: ./doxyoutput/xml. Potential matches: 

- Scalarf8 operator-(Scalarf8 &a)
- Scalarf8 operator-(Scalarf8 const &a, Scalarf8 const &b)
- Vector3f8 operator-(Vector3f8 const &a, Vector3f8 const &b)
- const Vector3f8 operator-() const

Function operator-(Scalarf8 const&, Scalarf8 const&)

Function Documentation

Warning

doxygenfunction: Unable to resolve multiple matches for function “operator-” with arguments (Scalarf8 const&, Scalarf8 const&) in doxygen xml output for project “SPlisHSPlasH” from directory: ./doxyoutput/xml. Potential matches: 

- Scalarf8 operator-(Scalarf8 &a)
- Scalarf8 operator-(Scalarf8 const &a, Scalarf8 const &b)
- Vector3f8 operator-(Vector3f8 const &a, Vector3f8 const &b)
- const Vector3f8 operator-() const

Function operator-(Vector3f8 const&, Vector3f8 const&)

Function Documentation

Warning

doxygenfunction: Unable to resolve multiple matches for function “operator-” with arguments (Vector3f8 const&, Vector3f8 const&) in doxygen xml output for project “SPlisHSPlasH” from directory: ./doxyoutput/xml. Potential matches: 

- Scalarf8 operator-(Scalarf8 &a)
- Scalarf8 operator-(Scalarf8 const &a, Scalarf8 const &b)
- Vector3f8 operator-(Vector3f8 const &a, Vector3f8 const &b)
- const Vector3f8 operator-() const

Function operator-=

Function Documentation

Warning

doxygenfunction: Unable to resolve multiple matches for function “operator-=” with arguments (Scalarf8&, Scalarf8 const&) in doxygen xml output for project “SPlisHSPlasH” from directory: ./doxyoutput/xml. Potential matches: 

- Scalarf8 &operator-=(Scalarf8 &a, Scalarf8 const &b)
- Vector3f8 &operator-=(const Vector3f8 &a)

Function operator/

Function Documentation

Warning

doxygenfunction: Unable to resolve multiple matches for function “operator/” with arguments (Scalarf8 const&, Scalarf8 const&) in doxygen xml output for project “SPlisHSPlasH” from directory: ./doxyoutput/xml. Potential matches: 

- Scalarf8 operator/(Scalarf8 const &a, Scalarf8 const &b)
- const Vector3f8 operator/(const Scalarf8 &s) const

Function operator/=

Function Documentation

Warning

doxygenfunction: Unable to resolve multiple matches for function “operator/=” with arguments (Scalarf8&, Scalarf8 const&) in doxygen xml output for project “SPlisHSPlasH” from directory: ./doxyoutput/xml. Potential matches: 

- Scalarf8 &operator/=(Scalarf8 &a, Scalarf8 const &b)
- Vector3f8 &operator/=(const Scalarf8 &s)

Function operator<

Function Documentation
Scalarf8 operator<(Scalarf8 const &a, Scalarf8 const &b)

Function operator<=

Function Documentation
Scalarf8 operator<=(Scalarf8 const &a, Scalarf8 const &b)

Function operator==

Function Documentation
Scalarf8 operator==(Scalarf8 const &a, Scalarf8 const &b)

Function operator>

Function Documentation
Scalarf8 operator>(Scalarf8 const &a, Scalarf8 const &b)

Function operator>=

Function Documentation
Scalarf8 operator>=(Scalarf8 const &a, Scalarf8 const &b)

Variables

Variable SPH::gaussian_abscissae_1

Variable Documentation
double const SPH::gaussian_abscissae_1[101][51]

Variable SPH::gaussian_n_1

Variable Documentation
unsigned int const SPH::gaussian_n_1[101]

Variable SPH::gaussian_weights_1

Variable Documentation
double const SPH::gaussian_weights_1[101][51]

Variable Utilities::logger

Variable Documentation
Utilities::Logger Utilities::logger

Defines

Define _USE_MATH_DEFINES

Define Documentation
_USE_MATH_DEFINES

Define _USE_MATH_DEFINES

Define Documentation
_USE_MATH_DEFINES

Define _USE_MATH_DEFINES

Define Documentation
_USE_MATH_DEFINES

Define _USE_MATH_DEFINES

Define Documentation
_USE_MATH_DEFINES

Define compute_Vj

Define Documentation
compute_Vj(fm_neighbor)

Define compute_Vj_gradW

Define Documentation
compute_Vj_gradW()

Define compute_Vj_gradW_samephase

Define Documentation
compute_Vj_gradW_samephase()

Define compute_xj

Define Documentation
compute_xj(fm_neighbor, pid)

Define forall_boundary_neighbors

Define Documentation
forall_boundary_neighbors(code)

Loop over the boundary neighbors of all fluid phases. Simulation *sim and unsigned int fluidModelIndex must be defined.

Define forall_density_maps

Define Documentation
forall_density_maps(code)

Loop over the boundary density maps. Simulation *sim, unsigned int nBoundaries and unsigned int fluidModelIndex must be defined.

Define forall_fluid_neighbors

Define Documentation
forall_fluid_neighbors(code)

Loop over the fluid neighbors of all fluid phases. Simulation *sim and unsigned int fluidModelIndex must be defined.

Define forall_fluid_neighbors_in_same_phase

Define Documentation
forall_fluid_neighbors_in_same_phase(code)

Loop over the fluid neighbors of the same fluid phase. Simulation sim, unsigned int fluidModelIndex and FluidModel model must be defined.

Define forall_volume_maps

Define Documentation
forall_volume_maps(code)

Loop over the boundary volume maps. Simulation *sim, unsigned int nBoundaries and unsigned int fluidModelIndex must be defined.

Define FORCE_INLINE

Define Documentation
FORCE_INLINE

Define INCREASE_COUNTER

Define Documentation
INCREASE_COUNTER(counterName, increaseBy)

Define INIT_COUNTING

Define Documentation
INIT_COUNTING

Define INIT_LOGGING

Define Documentation
INIT_LOGGING

Define INIT_TIMING

Define Documentation
INIT_TIMING

Define LOG_DEBUG

Define Documentation
LOG_DEBUG

Define LOG_ERR

Define Documentation
LOG_ERR

Define LOG_INFO

Define Documentation
LOG_INFO

Define LOG_WARN

Define Documentation
LOG_WARN

Define PD_USE_DIAGONAL_PRECONDITIONER

Define Documentation
PD_USE_DIAGONAL_PRECONDITIONER

Define REAL_MAX

Define Documentation
REAL_MAX

Define REAL_MIN

Define Documentation
REAL_MIN

Define RealParameter

Define Documentation
RealParameter

Define RealParameterType

Define Documentation
RealParameterType

Define RealVectorParameter

Define Documentation
RealVectorParameter

Define RealVectorParameterType

Define Documentation
RealVectorParameterType

Define REPORT_MEMORY_LEAKS

Define Documentation
REPORT_MEMORY_LEAKS

Define S_ISDIR

Define Documentation
S_ISDIR(mode)

Define S_ISREG

Define Documentation
S_ISREG(mode)

Define START_TIMING

Define Documentation
START_TIMING(timerName)

Define STOP_TIMING

Define Documentation
STOP_TIMING

Define STOP_TIMING_AVG

Define Documentation
STOP_TIMING_AVG

Define STOP_TIMING_AVG_PRINT

Define Documentation
STOP_TIMING_AVG_PRINT

Define STOP_TIMING_PRINT

Define Documentation
STOP_TIMING_PRINT

Define USE_BLOCKDIAGONAL_PRECONDITIONER

Define Documentation
USE_BLOCKDIAGONAL_PRECONDITIONER

Define USE_WARMSTART

Define Documentation
USE_WARMSTART

Define USE_WARMSTART_V

Define Documentation
USE_WARMSTART_V

Define Vec3Block

Define Documentation

Warning

doxygendefine: Cannot find define “Vec3Block” in doxygen xml output for project “SPlisHSPlasH” from directory: ./doxyoutput/xml

Typedefs

Typedef AlignedBox2r

Typedef Documentation
using AlignedBox2r = Eigen::AlignedBox<Real, 2>

Typedef AlignedBox3r

Typedef Documentation
using AlignedBox3r = Eigen::AlignedBox<Real, 3>

Typedef AngleAxisr

Typedef Documentation
using AngleAxisr = Eigen::AngleAxis<Real>

Typedef AtomicRealVec

Typedef Documentation

Warning

doxygentypedef: Cannot find typedef “AtomicRealVec” in doxygen xml output for project “SPlisHSPlasH” from directory: ./doxyoutput/xml

Typedef Matrix2r

Typedef Documentation
using Matrix2r = Eigen::Matrix<Real, 2, 2, Eigen::DontAlign>

Typedef Matrix3f

Typedef Documentation
using Matrix3f = Eigen::Matrix<float, 3, 3, Eigen::DontAlign>

Typedef Matrix3r

Typedef Documentation
using Matrix3r = Eigen::Matrix<Real, 3, 3, Eigen::DontAlign>

Typedef Matrix4r

Typedef Documentation
using Matrix4r = Eigen::Matrix<Real, 4, 4, Eigen::DontAlign>

Typedef Matrix5r

Typedef Documentation
using Matrix5r = Eigen::Matrix<Real, 5, 5, Eigen::DontAlign>

Typedef Matrix6r

Typedef Documentation
using Matrix6r = Eigen::Matrix<Real, 6, 6, Eigen::DontAlign>

Typedef NeighborhoodSearch

Typedef Documentation
typedef CompactNSearch::NeighborhoodSearch NeighborhoodSearch

Typedef Quaternionr

Typedef Documentation
using Quaternionr = Eigen::Quaternion<Real, Eigen::DontAlign>

Typedef Real

Typedef Documentation
typedef float Real

Typedef SystemMatrixType

Typedef Documentation
using SystemMatrixType = Eigen::SparseMatrix<Real>

Typedef Vector2i

Typedef Documentation
using Vector2i = Eigen::Matrix<int, 2, 1, Eigen::DontAlign>

Typedef Vector2r

Typedef Documentation
using Vector2r = Eigen::Matrix<Real, 2, 1, Eigen::DontAlign>

Typedef Vector3f

Typedef Documentation
using Vector3f = Eigen::Matrix<float, 3, 1, Eigen::DontAlign>

Typedef Vector3r

Typedef Documentation
using Vector3r = Eigen::Matrix<Real, 3, 1, Eigen::DontAlign>

Typedef Vector4f

Typedef Documentation
using Vector4f = Eigen::Matrix<float, 4, 1, Eigen::DontAlign>

Typedef Vector4r

Typedef Documentation
using Vector4r = Eigen::Matrix<Real, 4, 1, Eigen::DontAlign>

Typedef Vector5r

Typedef Documentation
using Vector5r = Eigen::Matrix<Real, 5, 1, Eigen::DontAlign>

Typedef Vector6r

Typedef Documentation
using Vector6r = Eigen::Matrix<Real, 6, 1, Eigen::DontAlign>

Typedef VectorXr

Typedef Documentation
using SPH::TimeStepPF::VectorXr = Eigen::Matrix<Real, -1, 1>

References

AAT13

Nadir Akinci, Gizem Akinci, and Matthias Teschner. Versatile surface tension and adhesion for sph fluids. ACM Trans. Graph., 32(6):182:1–182:8, November 2013. URL: http://doi.acm.org/10.1145/2508363.2508395, doi:10.1145/2508363.2508395.

AIA+12

Nadir Akinci, Markus Ihmsen, Gizem Akinci, Barbara Solenthaler, and Matthias Teschner. Versatile rigid-fluid coupling for incompressible sph. ACM Trans. Graph., 31(4):62:1–62:8, July 2012. URL: http://doi.acm.org/10.1145/2185520.2185558, doi:10.1145/2185520.2185558.

BIT09

Markus Becker, Markus Ihmsen, and Matthias Teschner. Corotated SPH for deformable solids. In Proceedings of Eurographics Conference on Natural Phenomena, 27–34. 2009. URL: http://dx.doi.org/10.2312EG/DL/conf/EG2009/nph/027-034, doi:10.2312EG/DL/conf/EG2009/nph/027-034.

BT07

Markus Becker and Matthias Teschner. Weakly compressible sph for free surface flows. In ACM SIGGRAPH/Eurographics Symposium on Computer Animation, SCA ‘07, 209–217. Aire-la-Ville, Switzerland, Switzerland, 2007. Eurographics Association. URL: http://dl.acm.org/citation.cfm?id=1272690.1272719.

BK15

Jan Bender and Dan Koschier. Divergence-free smoothed particle hydrodynamics. In ACM SIGGRAPH / Eurographics Symposium on Computer Animation, SCA ‘15, 147–155. New York, NY, USA, 2015. ACM. URL: http://doi.acm.org/10.1145/2786784.2786796, doi:10.1145/2786784.2786796.

BK17

Jan Bender and Dan Koschier. Divergence-free sph for incompressible and viscous fluids. IEEE Transactions on Visualization and Computer Graphics, 23(3):1193–1206, 2017. URL: http://dx.doi.org/10.1109/TVCG.2016.2578335, doi:10.1109/TVCG.2016.2578335.

BKKW17

Jan Bender, Dan Koschier, Tassilo Kugelstadt, and Marcel Weiler. A micropolar material model for turbulent sph fluids. In ACM SIGGRAPH / Eurographics Symposium on Computer Animation, SCA ‘17. ACM, 2017. URL: http://doi.acm.org/10.1145/3099564.3099578, doi:10.1145/3099564.3099578.

BKWK19

Jan Bender, Tassilo Kugelstadt, Marcel Weiler, and Dan Koschier. Volume maps: an implicit boundary representation for sph. In Proceedings of ACM SIGGRAPH Conference on Motion, Interaction and Games, MIG ‘19. ACM, 2019. URL: https://dl.acm.org/doi/10.1145/3359566.3360077, doi:10.1145/3359566.3360077.

BMullerM15

Jan Bender, Matthias Müller, and Miles Macklin. Position-based simulation methods in computer graphics. In EUROGRAPHICS 2015 Tutorials. Eurographics Association, 2015. URL: http://dx.doi.org/10.2312/egt.20151045, doi:10.2312/egt.20151045.

BMullerO+14

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, 2014. URL: http://dx.doi.org/10.1111/cgf.12346, doi:10.1111/cgf.12346.

DCB14

Crispin Deul, Patrick Charrier, and Jan Bender. Position-based rigid body dynamics. Computer Animation and Virtual Worlds, 2014. URL: http://dx.doi.org/10.1002/cav.1614, doi:10.1002/cav.1614.

GBP+17

Christoph Gissler, Stefan Band, Andreas Peer, Markus Ihmsen, and Matthias Teschner. Approximate air-fluid interactions for sph. In Virtual Reality Interactions and Physical Simulations, 1–10. April 2017. URL: http://dx.doi.org/10.2312/vriphys.20171081, doi:10.2312/vriphys.20171081.

HWZ+14

Xiaowei He, Huamin Wang, Fengjun Zhang, Hongan Wang, Guoping Wang, and Kun Zhou. Robust simulation of sparsely sampled thin features in sph-based free surface flows. ACM Trans. Graph., 34(1):7:1–7:9, December 2014. URL: http://doi.acm.org/10.1145/2682630, doi:10.1145/2682630.

ICS+14

Markus Ihmsen, Jens Cornelis, Barbara Solenthaler, Christopher Horvath, and Matthias Teschner. Implicit incompressible sph. IEEE Transactions on Visualization and Computer Graphics, 20(3):426–435, March 2014. URL: http://dx.doi.org/10.1109/TVCG.2013.105, doi:10.1109/TVCG.2013.105.

IOS+14

Markus Ihmsen, Jens Orthmann, Barbara Solenthaler, Andreas Kolb, and Matthias Teschner. SPH Fluids in Computer Graphics. In Sylvain Lefebvre and Michela Spagnuolo, editors, Eurographics 2014 - State of the Art Reports. The Eurographics Association, 2014. URL: http://dx.doi.org/10.2312/egst.20141034, doi:10.2312/egst.20141034.

KB17

Dan Koschier and Jan Bender. Density maps for improved sph boundary handling. In ACM SIGGRAPH/Eurographics Symposium on Computer Animation, 1–10. July 2017. URL: http://dx.doi.org/10.1145/3099564.3099565, doi:10.1145/3099564.3099565.

KBST19

Dan Koschier, Jan Bender, Barbara Solenthaler, and Matthias Teschner. Smoothed particle hydrodynamics for physically-based simulation of fluids and solids. In Eurographics 2019 - Tutorials. Eurographics Association, 2019. URL: https://interactivecomputergraphics.github.io/SPH-Tutorial, doi:10.2312/egt.20191035.

MMuller13

Miles Macklin and Matthias Müller. Position based fluids. ACM Trans. Graph., 32(4):104:1–104:12, July 2013. URL: http://doi.acm.org/10.1145/2461912.2461984, doi:10.1145/2461912.2461984.

MMullerCK14

Miles Macklin, Matthias Müller, Nuttapong Chentanez, and Tae-Yong Kim. Unified Particle Physics for Real-Time Applications. ACM Trans. Graph., 33(4):1–12, 2014. URL: http://doi.acm.org/10.1145/2601097.2601152, doi:10.1145/2601097.2601152.

PICT15

A. Peer, M. Ihmsen, J. Cornelis, and M. Teschner. An Implicit Viscosity Formulation for SPH Fluids. ACM Trans. Graph., 34(4):1–10, 2015. URL: http://doi.acm.org/10.1145/2766925, doi:10.1145/2766925.

PGBT17

Andreas Peer, Christoph Gissler, Stefan Band, and Matthias Teschner. An implicit sph formulation for incompressible linearly elastic solids. Computer Graphics Forum, 2017. URL: http://dx.doi.org/10.1111/cgf.13317, doi:10.1111/cgf.13317.

PT16

Andreas Peer and Matthias Teschner. Prescribed velocity gradients for highly viscous SPH fluids with vorticity diffusion. IEEE Transactions on Visualization and Computer Graphics, pages 1–9, 2016. URL: http://dx.doi.org/10.1109/tvcg.2016.2636144, doi:10.1109/tvcg.2016.2636144.

SB12

Hagit Schechter and Robert Bridson. Ghost sph for animating water. ACM Trans. Graph., 31(4):61:1–61:8, July 2012. URL: http://doi.acm.org/10.1145/2185520.2185557, doi:10.1145/2185520.2185557.

SP09

B. Solenthaler and R. Pajarola. Predictive-corrective incompressible sph. ACM Trans. Graph., 28(3):40:1–40:6, July 2009. URL: http://doi.acm.org/10.1145/1531326.1531346, doi:10.1145/1531326.1531346.

TDF+15

T. Takahashi, Y. Dobashi, I. Fujishiro, T. Nishita, and M.C. Lin. Implicit Formulation for SPH-based Viscous Fluids. Computer Graphics Forum, 34(2):493–502, 2015. URL: http://dx.doi.org/10.1111/cgf.12578, doi:10.1111/cgf.12578.

WKB16

Marcel Weiler, Dan Koschier, and Jan Bender. Projective fluids. In Proceedings of the 9th International Conference on Motion in Games, MIG ‘16, 79–84. New York, NY, USA, 2016. ACM. URL: http://doi.acm.org/10.1145/2994258.2994282, doi:10.1145/2994258.2994282.

WKBB18

Marcel Weiler, Dan Koschier, Magnus Brand, and Jan Bender. A physically consistent implicit viscosity solver for sph fluids. Computer Graphics Forum (Eurographics), 2018. URL: https://doi.org/10.1111/cgf.13349, doi:10.1111/cgf.13349.

Indices and tables