Particles are a powerful paradigm for simulation due to their simplicity. There are independent points whose position are updated according to some rules of dynamics. Many different systems are based on particles. You can simply have particles that move with some velocity and bounce off obstacles. Many agent-based models like flocking are essensially particle systems. You can also use particles to model continuum phenomena (smoothed particle hydrodynamics, which we will look at later). We will first look at classic point based mechanics. There are two basic components to this technique. First, computing trajectories based off position, velocity, and acceleration. This element is based on numerical methods for differential equations. The second component is computing the forces that determine acceleration. Classically in physics these forces are springs, gravity, electric fields, or in topics like atomistic modeling there are various approximate potential functions. However, these forces can be anything. They do not have to be based on physical principles or even normal physical space.

• Uses
• Physics
• Graphics
• Design
• Particle System Structure
• Forces
• Springs and Gravity
• Energy and Fields
• Integrators
• Examples - Spring meshes

In physics, one of the standard examples of this technique is the n-body problem, or many points acting with a gravitational force on one another. There is no analytic solution to this problem, so it has been a source of inquery for much of the history of physics and a natural candidate for computational methods. While this may be an interesting topic for physicists and astronomers, it is generally not that exciting for designers.

There is a long history of the use of particle systems in graphics. They are often used to simulate fake fluids, like smoke or water, as well as soft, deformable bodies like hair, cloth, or squishy blobs.

Visual effects or structures in design, such as Axel Kilian's CADenary project.

• Particle System
• particles
• forces
• step()
• constraints (optional)
• Particles
• position
• velocity
• force
• previous values (optional)

Forces are what you can use to control a particle system. There are basic forces which are implemented in many particle systems, such as springs and gravitational attractors. These forces are dependant on the relative positions of particles. There are also magnetic forces, which depend on velocity and position. We can also define our own forces, which can have almost any relation.

Springs are a restorative force. They attempt to keep two particles a certain distance apart. As an equation, the force looks like.

Where k is spring strength and is the vector from one particle to another. We can look at a plot of the strength in one dimension here with Wolfram|Alpha
Gravitation or electrical forces drop off with distance squared.

With a gravitational force, the strength is also proporational to the mass of the particles.

Often, we think of things in terms of potential energy instead of force. Force is a vector, which points in a direction. Potential energy is a scalar. We can get from energy to force with the following equation.

The force equals the gradient of the energy. In other words, the force tries to "roll" down the potential energy hill. Often, it is easier to think in terms of energy because it is a scalar equantity. It can also be a powerful tool for analyzing systems because energy is conserved in a closed system. So instead of talking about defining different forces, we might talk about different potential functions. For instance, often in atomistic modeling, they use a function called the Lennard-Jones potential, which looks like C(a/r^12-a/r^6). This is convenient because it is easier to sketch out functions and have an idea of what they do. It is harder to draw or imagine vector fields in your head. Also, some more advanced integration techniques are derived from energy rather than force, though ultimately you get something similar.

The energy of a spring is

The energy of an attractor is

These forces are based on points, but we can also talk about general force or potential fields. For instance, a height map might be interpreted as a potential map instead. We can take a discrete representation, like an image, and turn it into a continuous representation through interpolation (going inbetween two values).

There is no need for the distance function d(a,b) = |(a-b)| to be sacred. We can imagine different distance functions that would also make our forces act differently. A simple example is simply eliminating a dimension, for instance having a force in 3D act in 2D. We might also try to have a force act in a kind of cylinder instead of rectilinear space. One might also try using city block distance or abs(x1-x2)+abs(y1-y2)+abs(z1-z2).

So how do particle systems actually work? You have a bunch of particles, each particle has a position and a velocity. There are also forces that determine the acceleration of particles. The approach to a lot of simulation problems is discretizing something that is continuous. In this case, we cannot determine where every particle is all the time because that is infinite. We would need an analytic solution that would give us the exact position at all times. Instead we chunk up time into finite time steps. What we want to determine is giving the positions, velocities, and forces in the current time step, what are they in the next time step. We do this using numerical integrators.

Integrators are numerical methods for solving differential equations. In general, with particle systems we are only solving one equation, which is the basic physics equation:

or in the form of a differential equation

Where x is the position vector.

There are many different integration methods. They tend to have names like Euler, Runge-Kutta, or other unhelpful names of people who are generally dead. Mostly, they are based off the same two ideas. The definition of the derivative:

and the Taylor approximation of a function:

Except since we are working with computers, we cannot work with continuous numbers, so instead of the limit as h goes to zero, we take h equal to some small value that we call .

The simplest integrator is called the Euler integrator, but we can call it integrator number 1 or simple integrator. It takes the taylor approximation and truncates it to two terms, so it looks like this:

In code, that would look something like this: Where velocity is the derivative of position, and acceleration, which is force/mass, is the derivative of velocity.