This involves solving ODEs (ordinary differential equations) that are considered to be ‘stiff’. We will see why we qualify such ODEs as ‘stiff’ and how we should approach solving for these types of ODEs by using implicit numerical methods such as the Backwards Euler implicit method.
⚠️ Pixar’s resource advises us to avoid an stiff ODE by reformulating our dynamic problem. We’ll be focusing on the cases in which this is not possible.
After having scoured the Internet for a definition of the term ‘stiff ordinary differential equation’, I ended up on Wikipedia’s entry which, admittedly for me, is not very sufficient but I will give it to you anyway:
A stiff differential equation is a differential equation whose sensitivity to parameters will make it difficult to solve by explicit numerical methods.
In short: stiff ODEs are difficult to solve with explicit numerical methods (we talked about explicit methods a few weeks ago).
Definition aside, I find that Pixar Physics Simulation Animation Course gives us a fun example that we will work on to better visualize the Wikipedia definition… Let’s imagine that we want to simulate the dynamics of a particle whose change of position is described by the following differential equation:
where k is a positive and large constant. If k is large enough, the particle will never stray too far from since will constrain back to the origin. We also see that the x position of the particle is freer to move around, as described by the absence of this large and positive constant k.
In this example, this ODE would therefore be ‘stiff’ if the variable k is so large that the particle stays close to the line . As we will see in the next part, explicit methods will have a hard time simulating this expected behavior.
Recall that the equation of the explicit Euler method is described as follows:
and in this example, and . Then, after the substitution, we have:
Which produces the following:
We learned in Part 1 of Numerical Methods that in order to find a solution, we must take small steps in time to approach the solution as massive steps could very well make the system unstable. A quick rearrangement of terms will show us that these conditions must be met in order for the position of the particle described in our example to converge to (0,0):
🚨 If we take k equal to 1000: the maximum permitted step is calculated to be . If we surpass this limit, the particle’s y position will never be able to converge towards 0!
Solving for y by plugging in parameters h = 0.0015 and k = 1000.0 into a forward Euler solver that I wrote, we can visualize the particle’s y position as it oscillates around zero:
Now, let’s take larger steps in time, where h > 0.002 (h = 0.003 and k = 1000.0). Notice how the solution diverges from 0:
OK, so we could use a very small step like h = 0.0015, right? Maybe… however, we would quickly realize that the x position converges to 0 very slowly, which will make our simulation slow, and expensive!
Can we do better? Could we use a more stable method to converge faster? Yes - with the Backwards Euler implicit method!
Backwards Euler is the easiest of the implicit methods to understand and that’s why I’m going to focus on it.
Here is the equation:
If you had been an observant person, you would have seen that the difference between the implicit Euler equation and the explicit Euler equation is that the change in X is defined as in the implicit Euler equation. We must therefore solve this change by calculating … to finally calculate .
In fact, it’s like walking backwards.
In other words, it’s as if we were at position and wanted to move backwards to get to position … Hence the name: ‘Backwards Euler’.
It’s a little awkward to solve , since we need to find … which is also unknown. Let’s see if we can rewrite this into something we can solve.
We start by providing the equation of the Backward Euler method:
where . We can write it as follows:
💡 is unknown, and also (because contains which is unknown). So we have to approximate using the Taylor series as follows:
See this resource to learn more about the Taylor Series and this exact derivation.
Using the last equation, we can rewrite our equation for
💡 To continue, remember that is a vector and is a matrix. This is the case thanks to vector calculus:
The derivation is called the Jacobian matrix. We’ll take a closer look at this in a later part.
We can multiply everything by an identity matrix to isolate our variable .
After having isolated , it is now possible to solve . We will see how to do it with C code in the next part.
Here is the code that I will refer to in this section.
As a reminder, we want to converge this stiff ODE:
And we know is the Jacobian matrix:
Let’s go back to the equation . We calculate as follows:
What’s interesting is that you can take a step with any magnitude! If we calculated the limit of as it approaches infinity, we would see that:
So as _h* approaches infinity!
Now we can use the program I wrote to see this example. after navigating to the folder where you downloaded the code, run the following:
make ./out 0.2 1000.0 100.0 100.0
where h=0.2, k=1000.0, x0=100.0 and **y0 **=100.0. You should see two files
explicit.txt added to the folder. In
implicit.txt we see that y converges to zero!
explicit.txt it’s a completely different story:
We will see how to solve stiff second order differential equations! See you next time!