Difference Between Implicit vs Explicit Analysis

Picture this: You are making a presentation of your Ph.D. thesis on stability at one of the seminars. Everything goes smoothly, and finally, it’s question time! And someone out of the blue asks: “what is the difference between implicit and explicit approach?”! And since you are doing static stability… you never even heard those terms! Yeah… been there done that! Now, I’m a bit wiser, so let’s take a closer look at the differences between Implicit and Explicit analysis

Implicit and Explicit analysis differ in the approach to time incrementation. In Implicit analysis each time increment has to converge, but you can set pretty long time increments. Explicit on the other hand doesn’t have to converge each increment, but for the solution to be accurate time increments must be super small.

This sounds pretty simple, right? Unless you start to think about things like “which one should I use” or “how small should the explicit time increment be”, and things like that. No worries, I’ve got you covered!

Let’s dive in!

Dynamics at its best – Implicit/Explicit!

You will use Implicit and Explicit solvers to solve dynamic problems. This means that you won’t need to know this stuff if you are doing static analysis. If you are unsure about the difference between static and dynamic analysis, please read this post first – it will make things easier to understand!

Dynamic analysis in a nutshell:

Dynamic analysis solves problems involving inertia effects. Those appear, when things change fast in your model (quickly applied loads, impacts, etc.). Engineers usually reffer to this as “nonlinear dynamic”.

It should be noted, that often engineers call other analysis “dynamic” as well. Things like Modal analysis or Forced Response analysis that deal with vibrations. Sometimes those are called “linear dynamic”, but it is usually a good idea to make sure what someone means when they use such a phrase. While “linear dynamic” problems are really interesting, I won’t discuss those here. You can learn more about them reading this post!

The first thing I really feel I have to stress is that implicit and explicit solvers solve THE SAME problems! Think about it not as “different solvers” but rather as two different ways of solving the same problem.

In many cases, you can use both implicit and explicit solvers, and they will produce the same outcome. And I think this is where we need to start!

How dynamic analysis works?

Both of the analyses are solving a problem where the speed of things is important. This mostly means that the load is applied very fast. In such cases, you will always “iterate” your load in time. Basically, you will use the time to tell the solver “what is happening” and how the load is changing.

Firstly, you have to define how the load is changing in time. You usually do this using charts, like the one below:

In nonlinear dynamic analysis, the time has 2 roles. Firstly, it allows you to tell the solver, when how much load should be applied. You simply have to implement each load with a time-dependent chart. Secondly… time is time! It tells the solver how fast things are going!

Imagine you want to have such a load sequence:

In static this would be a 3 “steps” analysis (those are called subcases in NX Nastran, but I think Abaqus actually used “step” as a name, can’t recall this for sure though!). The idea would be simple, you have to apply the 100kN of load in step 1, then remove 50kN of the load in step 2, and remove 50kN in step 3. There is no way to include the “plateau” of load after step 2 into the analysis, and it will be omitted. Logic is simple: no changes in load = nothing changes in static!

Load increments in static

If the problem would be highly nonlinear, the load would be “incremented”. It is rare to be able to apply “full load” into nonlinear analysis at “one go”! Usually, solver would apply i.e. 1kN each “increment”. This means that after 100 increments, a full load of step 1 would be applied. This makes it easier for the solver to converge a correct answer.

As a user, you get to define how big increments solver should use. There are also some algorythms to modify load incrementation during analysis. Different solvers want you to set this in differnet ways. Usually FEA packages use load multipliers for this. This means, that you can say something like: “in each increment apply additional 0.01 of all the load”.

Awesome… but let’s get to dynamics, shall we? In dynamic analysis you can get the load distribution as above with such a load definition:

Instantly, there are a few things you can notice:

• There are no steps! This is because in dynamic analysis you won’t increment load. You will increment the time! And since time goes “constantly” from zero to the prescribed value, you can increment it in “one step”.
• Time is of the essence! When it comes to the values of the load, the above charts are the same. But this is not the same dynamic case! The chart on the right applies the load 1000x quicker! This isn’t something you can just ignore in dynamic analysis!

In general, when you want to solve a dynamic problem, you are asking your solver to do one thing. You ask it to calculate the series of time increments, to see what is going on in the model. In each of those increments, time slightly increases. This of course also changes the load in the model. This is why you need to have a time-dependent chart for the load. So the solver “knows” what load should be applied at which time increment. To this extent, it works the same as load incrementation in static analysis. The bonus is, that since you are incrementing time, inertia effects can be taken into account when things are happening fast enough.

To this extent, both implicit and explicit analysis does more or less the same thing. They divide the “analysis time” into small increments, and then analyze what is going on in your model one increment of time after another. But here is where the similarities end! You see, there are distinct approaches to time incrementation you may have!

Implicit vs Explicit – When Time Really Matters!

You just learned, that in order to calculate the nonlinear dynamic problem, you will have to incrementally increase “analysis time”. As I already mentioned, this can be done in two ways.

I will start with the implicit approach. I think it’s easier to understand since it works more or less the same as load incrementation in nonlinear static analysis!

How Implicit Analysis Works: 

First of all, implicit seems to be a more “basic” solution. In essence, it works just as you would think it should!

• Firstly, in each time increment the “global equilibrium” in the model is established. This means that each increment has to converge (this is happening in iterations).
• After global equilibrium is ok, solver calculates all the local finite element variables (stresses etc.) for this increment.
• Benefits: Since global equilibrium is verified at each time increments, those increments can be BIG!
• Drawbacks: Each time increment computes slowly, since iterations are needed to get to the global equilibrium.

If you are familiar with the nonlinear static analysis you will feel “at home” with the implicit solver. As a user, you usually get to say how big the time increments you want to have. This is a huge advantage… that is easy to miss. Because an Explicit solver does not offer such a possibility!

Let’s take a look at explicit incrementation next!

How Explicit Analysis Works:

This one is funky. It works in a way, that you don’t have to converge each step! There are no convergence criteria to check and… no iterations! Instead of verifying the “global equilibrium” solver assumes that the equilibrium “simply exists”. This means that the solver goes straight into the calculation of local finite element variables! As such procedure has only one step:

• Calculate all of the local finite element variables for given increment, and move to the next one!
• Benefits: Each increment calculates extremely fast!
• Drawbacks: For this to work, the time step has to be EXTREMELY small. Otherwise, it’s impossible to maintain this equilibrium that is assumed to “simply exist”. To achieve this, user do not have direct control over how big-time increments explicit solver will take. Solver itself calculates how small timesteps are still ok. And those acceptable time increments are SUPER SMALL! This is why explicit problems should last fractions of the second! If they would last seconds… you would need millions of increments!

To quickly sum it up: both implicit and explicit solvers solve the same stuff. The only difference is, how those methods increment time.

Technically, both should produce the same outcome for all cases. After all, you can analyze the same problem with both approaches. Obviously, the answer cannot depend on the method used to solve the problem! But of course, you will only pick one of the approaches for your next problem, so which one? Let’s find out!

What is Better for You: Implicit or Explicit?

We already agreed that you can use both implicit and explicit solvers to solve the same type of problems. The only difference is in the approach to time incrementation. But it is not a trivial thing! If the difference would be small, nobody would care to implement both! So let’s take a look at how this time incrementation influence things!

Both implicit and explicit solvers have some areas where they shine. And there is an overlap in their use:

• The implicit analysis allows you to select how big the time increment should be! This increment will take some time to compute since it has to iterate for global equilibrium first. But you can make it “reasonably big” for your analysis.
• Explicit time increments calculate really fast! Simply because they do not iterate for global equilibrium… but the time increment there is not your choice! Solver simply assumes, that the “acceptable” time increment is “X” and goes with it. Note, that this “X” can easily be something like 5e-7s… This is super small! To solve a problem happening over 1s, you would need 2 000 000 increments!
• And that is it! The speed of computing is exactly the difference between implicit and explicit. Of course, the size of explicit step depends on your model and computing times depends on your hardware. There are however simple observations that we can easily make:

Use implicit for “slow analysis”! 

If the thing you calculate happens over several seconds… there is no sense in using explicit solver. It will take forever to dig through the millions of time increments needed for this to compute! Instead, set a “reasonable” time step for implicit analysis (let’s say 100 equal time increments for your analysis). Sure, each of those implicit time increments will compute much longer than a single explicit increment. But not longer than hundreds of thousands of them!

Use explicit for “fast analysis”! 

This is obvious, right? If what you calculate happens in the small fraction of a second explicit is your friend. In an implicit analysis, your time increment would be super small… maybe even as small as the increment in explicit analysis. In such a case explicit analysis will run MUCH faster since it doesn’t require “global equilibrium” iterations. The implicit analysis does require those iterations (regardless of the time step!).

Inbetween stuff! 

Of course, there are problems that happen in the middle (like an impact with 5m/s speed). Usually you can solve such a problem with both solvers, but it can be annoying.

I hope that this helps you to select a proper approach to your dynamic problems. Of course, in the end, the experience is the best guide! If you are in doubt, run a few of your typical problems in both implicit and explicit. This way, you will be able to compare outcomes (they should be the same). But what is more important, you will be able to compare computing times! This will give you an opportunity to check, what is a better approach for you!

How explicit guesses time step size?

Well, it’s all nice and dandy so far, but I think it would be nice to address one big issue. And that is… if you are not selecting the time step in your explicit analysis… then who does?

The mathematical explanation would require a discussion about the maximal natural frequency. This is because the maximal “still acceptable” time increment is inversely proportional to the maximal natural frequency. Such calculations can be done, of course. The outcomes depend on the mesh of the model (how many elements are there, etc.). But we won’t go there, and there are 2 reasons why: firstly, I don’t like math (!). Secondly, this is not how solvers do it in the end, even though this is the “proper way”.

The solver can calculate the maximal natural frequency, of course, but this takes quite some time. And since it would have to be done in each explicit time increment (there can be plenty of those!)… yikes! Luckily, there is a way to nicely estimate this value, by analyzing each finite element in the system separately! The physical interpretation of this estimation (commonly used in solvers) is:

Maximal time increment in explicit analysis:

Time increment in explicit analysis is very short. It’s the time in which an elastic wave (i.e. impact wave) can travel through a single finite element of your model. Of course, this is verified for all finite elements in your model, and the smallest time is selected.

As you can see, there are 2 components to the explicit time component:

• Elastic wave speed (aka speed of sound in your material)! This depends only on the material you have in your model (and it’s different for different materials of course!). You will need the Young Modulus E, material density and Poisson Ration (in 2D and 3D problems). It is easy to find tables that list elastic wave speeds in various materials. Just for reference in steel, this is around 5200m/s (many metals are around 4500-5500m/s).
• Element size (and quality)! You have the wave speed, but it’s not enough! To know the time it needs to travel through the element, you need to know the element “length”. While this is super simple in 1D elements (they simply have length) it gets tricky in 2D and 3D. This length isn’t “simply” the shortest of the element edges since elements can have pretty poor geometry. There are things solver does to calculate this. In 2D it could be an element area divided by the maximal edge length. In 3D the can mean that the volume of the element is divided by the maximal side area. This is why not only element size but also elements quality is so important in explicit analysis! After all… all you need is one poor element to really hurt your computing time!

I’ve read somewhere, that while the above is the “precise” solution, solvers often use “safety factors” on this. If you get a higher time increment than the elastic wave “speed limit” mathematical errors occur. Since estimations are used, solvers often reduce the time step “just in case”. Usually, the reduction factor is around 0.9, but this can vary from solver to solver of course.

Mass scaling!

In the end, I want to mention something quickly.

You most likely noticed, that the time step in explicit only depends on the mesh, Young Modulus, and density. Reducing Young Modulus may not be ideal of course, and you often need a small mesh to analyze details. But in “low dynamic” problems you can try to increase the explicit time step by increasing material density.

This is called “mass scaling”. FEA packages even offer solutions where density is increased only in the elements that “decide” about time increment. This means that sometimes only small portions of your model get heavier! In some analyses, you can “get away” by increasing the mass of your model. If that is the case this may be a solution for you. Just be aware, that this does change how your model behaves! When high accelerations are involved, it is best to be careful!

Summary

Nice! You got here, thanks for reading! Let’s wrap this up, so it is easier to remember!

• Dynamic analysis involves time! When you apply loads, those have to be defined in a time function. Often this is a linear relation. But this doesn’t change, that the time in which load is applied plays a significant role (especially if this time is short!).
• 2 flavors of dynamic analysis! You can solve the “real” dynamic problems with implicit and explicit algorithms. Both are fine, and not a single one of them is “better”. But I should say that the explicit solver is a part of fewer FEA packages. Since not every FEA package even has one, the explicit solver is seen as a “more advanced” thing.
• The implicit solver is really good if things in your analysis happen relatively slowly. Let’s say analysis is longer than 1s without any abrupt stuff happening during that time. The advantage is that you can pick how big the time increment you want. Even if the single increment takes longer to compute, there are much fewer of them!
• The explicit solver is great for fast happening things (let’s say faster than 0.1s). You don’t get to choose the time increment here – solver will automatically set it. While they are usually super small, at least they compute much faster than the “implicit ones”. Explicit solver calculates how big the time increment should be. This depends on the sound speed in your material, minimal finite element size (and element quality!). In some cases, you can change density (even automatically only in “deciding elements”!) to adjust this time increment. This works, because the speed of sound in your material depends on its density! This is called “mass scaling”.

Well, I do hope that you find this useful. As always I would love it if you would share your thoughts in the comments below!

Want to learn more about FEA?!

You are in the right place! Below you can check my FREE online FEA course, where I teach you about the most valuable lessons I learned during my FEA career!