Dynamical simulation

From Wikipedia, the free encyclopedia

Dynamical simulation, in computational physics, is the simulation of systems of objects that are free to move, usually in three dimensions according to Newton's laws of dynamics, or approximations thereto. Dynamical simulation is used in computer animation to assist animators to produce realistic motion, in industrial design (for example to simulate crashes as an early step in crash testing), and in video games. Body movement is calculated using time integration methods.

Contents

[edit] Physics Engines

Main article: Physics engines

In Computer graphics, we use a program called a Physics engine to model the behaviors of objects in space. These engines allow us to simulate the way bodies of many types are affected by a variety of physical stimuli. They also allow us to create Dynamical simulations without having to know anything about physics. We use Physics engines throughout the video game and movie industry, but not all physics engines are alike. Physics engines are generally broken into the real-time and the high precision but these are not the only options. Most real-time physics engines are inaccurate and yield only the barest approximation of the real world, whereas most high-precision engines are far to slow for use in everyday applications. To understand how these Physics engines are built, we must first understand some basic physics. Physics engines are based on the actual behaviors of the world as described by Classical mechanics. Engines do not typically account for Modern Mechanics (see Theory of relativity) because most visualization deals with large bodies moving relatively slowly, but the most complicated engines perform calculations for Modern Mechanics as well as Classical. The models used in Dynamical simulations detirmine how accurate these simulations are.

[edit] Particle Model

Main article: Newton's laws

The first model which may be used in Physics engines governs the motion of infinitesimal objects with finite mass called “particles.” This equation, called Newton’s Second law (see Newton's laws) or the definition of force, is the fundamental behavior governing all motion:


\vec{F} = m \vec{a}


This equation will allow us to fully model the behavior of particles, but this is not sufficient for most simulations because it does not account for asymmetric bodies or for spin. For particles, these things are irrelevant because particles are symmetric. This non-spinning model is the simplest model that can be used in a physics engine and was used extensively in early video games.

[edit] Inertial Model

Main articles: Rigid body dynamics & Moment of inertia

Bodies in the real world deform as forces are applied to them so we call them “soft,” but these are very complicated to model and only the most sophisticated Physics engines deal with them. We will apply this particle model to bodies that do not deform. This motion, Rigid body dynamics, deals with objects that cannot change shape, size, or mass but can change orientation and position.

As long as bodies are rigid, we can assume that their motion is described the same way as a particle; however, we now have to account for rotation. When we deal with complex shapes, we cannot assume that forces (excepting Gravitation) are applied evenly or on a vector through the center of mass. These assumptions simplify our engine but do not look realistic. Therefore, to account for rotational energy and momentum, we must describe both the manner in which force is applied to the object and its shape. We describe these complex interactions with an equation somewhat similar to the definition of force above:


\frac{\mathrm{d}(\mathbf{I}\boldsymbol{\omega})}{\mathrm{d}t} = \sum_{j=1}^N \tau_{O,j}


where I is the Moment of inertia tensor and \vec{\omega} is the angular velocity vector:


\mathbf{I} = \begin{pmatrix} \int y^2+z^2\, \mathrm{d}m & -\int xy\, \mathrm{d}m & -\int xz\, \mathrm{d}m\\ -\int xy\, \mathrm{d}m & \int x^2+z^2\, \mathrm{d}m & -\int yz\, \mathrm{d}m \\ -\int xz\, \mathrm{d}m & -\int yz\, \mathrm{d}m & \int x^2+y^2\, \mathrm{d}m \end{pmatrix} \quad \hbox{and} \quad \boldsymbol{\omega} = \begin{pmatrix} \omega_x \\ \omega_y \\ \omega_z \end{pmatrix}.


The Moment of inertia tensor describes the location of each particle of mass in a given object in relation to the object's center of mass. This allows us to determine how an object will spin dependent on the forces applied to it. This spin is quantified by the angular velocity \vec{\omega}. This allows us the translate any torque into a specific frame of reference we call the “Principle Axes.” These axes can be chosen arbitrarily but must remain constant in terms of the body itself. This allows us to calculate \vec{\omega} but it is much more complex than the particle model. This model is the most complex model typically used for Dynamical simulation.

This model is the most applicable for most scientific simulations and other applications in which real time simulation doesn’t matter, because at this level of complexity we account for all of Newton’s laws. As long as we stay below relativistic speeds (see Relativistic dynamics), this model will accurately simulate all relevant behavior. As simple as this is, however, it still requires the Physics engine to solve three very complex partial differential equations at every instant we want to render. This is even more difficult when we are simulating Non-linear forces or a Force field (physics).

[edit] Euler Model

Main article: Euler's equations

The inertial model is much more complex than we typically need but it is the most simple to use. In this model, we do not need to change our forces or constrain our system. However, if we make a few intelligent changes to our system, simulation will become much easier, and our calculation time will decrease. The first constraint will be to put each torque in terms of the principle axes. This makes each torque much more difficult to program, but it simplifies our equations significantly. When we apply this constraint, we diagonalize the moment of inertia tensor, which simplifies our three equations into a special set of equations called Euler's equations. These equations describe all rotational momentum in terms of the principal axes:


\begin{matrix} I_1\dot{\omega}_{1}+(I_3-I_2)\omega_2\omega_3 &=& N_{1}\\ I_2\dot{\omega}_{2}+(I_1-I_3)\omega_3\omega_1 &=& N_{2}\\ I_3\dot{\omega}_{3}+(I_2-I_1)\omega_1\omega_2 &=& N_{3} \end{matrix}


  • The N terms are applied torques about the principle axes
  • The I terms are the principle moments of inertia
  • The ω terms are angular velocities about the principal axes


The drawback to this model is that all the computation is on the front end, so it is still slower than we would like. The real usefulness is not apparent because it still relies on a system of non-linear differential equations. To alleviate this problem, we have to find a method that can remove the second term from the equation. This will allow us to integrate much more easily. The easiest way to do this is to assume a certain amount of symmetry.

[edit] Symmetric/Torque Model

The two types of symmetric objects that will simplify Euler's equations are “symmetric tops” and “symmetric spheres.” The first assumes one degree of symmetry, this makes two of the I terms equal. These objects, like cylinders and tops, can be expressed with one very simple equation and two slightly simpler equations. This does not do us much good, because with one more symmetry we can get a large jump in speed with almost no change in appearance. The symmetric sphere makes all of the I terms equal (the Moment of inertia scalar), which makes all of these equations simple:


\begin{matrix} I\dot{\omega}_{1} &=& N_{1}\\ I\dot{\omega}_{2} &=& N_{2}\\ I\dot{\omega}_{3} &=& N_{3} \end{matrix}


  • The N terms are applied torques about the principal axes
  • The ω terms are angular velocities about the principal axes
  • The I term is the scalar Moment of inertia:
I \ \stackrel{\mathrm{def}}{=}\ \int_V l^2(m)\,dm = \iiint_V l^2(v)\,\rho(v)\,dv = \iiint_V l^2(x,y,z)\,\rho(x,y,z)\,dx\,dy\,dz \!
where
    • V is the volume region of the object,
    • r is the distance from the axis of rotation,
    • m is mass,
    • v is volume,
    • ρ is the pointwise density function of the object,
    • x, y, z are the Cartesian coordinates.


These equations allow us to simulate the behavior of an object that can spin in a way very close to the method simulate motion without spin. This is a simple model but it is accurate enough to produce realistic output in real-time Dynamical simulations. It also allows a Physics engine to focus on the changing forces and torques rather than varying inertia.

[edit] See also

Retrieved from "http://en.wikipedia.org../../../d/y/n/Dynamical_simulation.html"