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 solver, and they will produce the same outcome. And I think this is where we need to start!

**How dynamic analysis works?**

Both of the analysis 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 staticIf 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 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 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 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 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 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 analysis, you can “get away” with 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! Check my FREE online FEA course, where I teach you about the most valuable lessons I learned during my FEA career!

Alvin CheriyanNovember 3, 2019 at 11:47 amHi Lukasz,

Truly insane stuff. I had a mathematical sense of implicit and explicit analysis. But your seems very intuitive and gives a physical understanding of the two.

What do you mean by global equilibrium? I have not heard of that in this context

I have thought of them as below:

Explicit: Depends only on the values of the previous iteration.

Implicit: Depends even on the values in the current iteration.

Thanks,

Alvin.

Łukasz SkotnyNovember 4, 2019 at 4:27 pmHey Alvin!

I’m really glad that you like the post!

By global equilibrium, I mean the state when a given iteration converges. Your solver has a default setup that checks work (sometimes more than that) of forces on deformations and compares it to the work of stresses on strains. Those should be equal – this means that the model is in “equilibrium” in a given step… or that the iteration has converged.

Perhaps I used the “global” too freely, since this may be associated with “global stability” by some people… but I don’t know a better term to describe it!

All the best

Ł

Hassan AliNovember 5, 2019 at 1:01 pmHi Lukasz,

Thanks a lot for your great article, I am a big fan for your blog 🙂

you have explained the difference between explicit and implicit in a pretty way and I like it so much. I have a question, if I am ding a tensile test and the machine speed was 5 mm/min how can I apply that in explicit analysis and is it will effect on results or not?

Thanks,

Hassan

Łukasz SkotnyNovember 5, 2019 at 1:41 pmHey Hassan!

5mm/min is a rather small speed. I don’t recall test speeds (I think those are normalized) but with 1mm/12sec I would guess that you are in the static zone… It’s worth checking that though, as I was never responsible for testing setup myself and I may be off here.

What you would do in explicit though is to apply the load of 5mm (enforced deformation) and tell the solver that this load is applied in 60sec. However, I would strongly suggest Implicit code in such a case… with explicit it will take ages to compute that I think…

Hope this helps!

Ł

ParashuramNovember 5, 2019 at 2:22 pmHi Lukasz,

What is exactly the global equilibrium means…?

Łukasz SkotnyNovember 5, 2019 at 3:03 pmHey Parashuram!

It’s just as I wrote to Alvin above:

By global equilibrium, I mean the state when a given iteration converges. Your solver has a default setup that checks work (sometimes more than that) of forces on deformations and compares it to the work of stresses on strains. Those should be equal – this means that the model is in “equilibrium” in a given step… or that the iteration has converged.

Hope this helps!

Ł

bhavinzaveri9099@gmail.comNovember 5, 2019 at 5:26 pmHey Lukasz,

This is a great post. I had a question related to the material strain-rate effects. In case of blast loads (very short period), materials generally behave a little stronger because of high strain-rate effects. Can you explain how implicit and explicit solvers deal with this?

Thanks.

Łukasz SkotnyNovember 6, 2019 at 8:08 amHey!

Sadly no, I never was involved in such calculations. However, there are material models that take strain-rate into account, so I guess the solver simply uses such material model and be done with it 🙂

All the best

Ł

JakubNovember 5, 2019 at 10:44 pmHi Łukasz,

very nice article. Especially that it’s really hard (or even impossible) to find simple explanations about the differences between implicit and explicit solvers without lots of math. However it would be nice to add a bit on what these methods do (what is their algorithm, what subsequent steps they perform to solve the problem).

Apart from that I would like to share the following short comments:

– Abaqus indeed uses steps and, what’s interesting, it includes step time even in static analyses. Of course this is not real physical time but rather a mean for load incrementation and rate-dependent material behavior but still you can define load amplitudes with respect to this “time”. You just won’t see the difference in results obtained with amplitude ranging from 0 to 1 and amplitude ranging from 0 to 10 (like in your picture with two graphs).

– implicit is not only used in dynamic analysis, static simulations belong there too

– linear dynamics term refers to analyses with linear relationship between forces and displacements. It usually involves modal analysis and modal superposition procedures but these can also be utilized in nonlinear cases. Linear problems can be solved with direct integration methods too so implicit sometimes may be used for linear dynamics.

– mass scaling is usually used in quasi-static explicit simulation (for example metal forming processes) where inertia effects are not important. There’s also another way to increase stable time increment in explicit – you can artificially speed up the simulation (by increasing load rates – basically reducing step time). However both methods have to be used carefully because with too high mass scaling (or too fast load rate) inertia effects start to play important role and quasi-static behavior becomes truly dynamic.

Thanks,

Jakub

Łukasz SkotnyNovember 6, 2019 at 8:10 amThank you Jakub!

Those are great comments, and I really appreciate you finding the time to share those!

Awesome stuff!

Ł

FranciscoNovember 6, 2019 at 4:04 pmHi Łukasz,

I would like to know how to compute the time step for implicit methods.

Thanks in advance!

Łukasz SkotnyNovember 7, 2019 at 9:03 amHey Francisco!

In implicit methods, it is you (as a user) who decided that the time step should be. I’m not sure if people “compute” this in any way, never heard of such possibilities. I for one more or less “guess” the proper time step, so let’s call this “experience”. But perhaps there are options in solvers that would “automatically” adjust the time step for you during analysis. If this is what you mean, then sadly I have no idea how they do those estimates. I would assume there is a solver manual that should describe that for you… but it may be quite math-heavy I’m afraid…

Thank you for your comment!

Ł

Shahzer RahmanApril 2, 2020 at 6:17 amHi Lukas

Thanks for these blogs. They are really simple to understand and have explained theories in basic language. Glad that you took the effort to do this. Your blogs are helping me to reignite that lost interest in Physics and Mechanical engineering due to the math involved in it

Please do write a blog about the differences in a linear and a non-linear ‘system’. Haven’t been able to understand that properly yet. Been trying to model the non-linear behaviour of a spring-mass damper arrangement. Maybe your next blog helps me out.

Regards

Rahman

Łukasz SkotnyApril 3, 2020 at 3:40 pmHey!

Thank you for your kind words. I’m not sure what do you have in mind with the linear/nonlinear system… but maybe this will help: https://enterfea.com/difference-between-linear-and-nonlinear-fea/

All the best, and see you around!

Ł

RezaJuly 14, 2020 at 7:23 pmthat was so simple and easy to understand. It helps me to understand physically the differences.

But there was one vague situation. for the explicit simulation, the mesh size ( the element size) is much bigger the simulation runs faster?

Łukasz SkotnyJuly 19, 2020 at 9:49 amHey Reza,

I would say, that this is always the case, that when you have bigger elements (and thus fewer elements in the model) than the same analysis will run faster. Ok, if there are convergence issues etc, this may not be the case, but as a general rule, bigger elements (fewer elements in the model) = faster computing

But perhaps I misunderstood your question – if that is the case, let me know!

All the best!

Ł

SujithAugust 26, 2020 at 4:16 amHi Lukasz,

Great way of delivering content. I would like to know whether the mathematics behind FEA (like weak formulation etc) are really necessary to solve the practical problems? Also I would like to know your method of learning these in this simple way. Please suggest some foundational books on FEA that people with basic mechanical engineering knowledge can understand.

Łukasz SkotnyAugust 26, 2020 at 7:01 amHey Sujith!

I’m really glad that you like the way I teach this 🙂 I get a feeling this is not a super mainstream approach, but I do get some “happy messages” so it works with some folks for sure 🙂

If you wish to know what I think about math in FEA, please watch this: https://enterfea.com/math-in-fea-do-you-really-need-it/

As for the books, I haven’t read a single one I would recommend for such a purpose… this is why I’ve made my online course about FEA (https://enterfea.com/learning-fea/). Maybe this will interest you.

Right now I’m working on a nonlinear course (and a book!) so when the book will “work” nicely, I will definitely get back to the FEA basics to write a book there. I don’t want to commit to that though right now, as this would take a lot of time, and I’m not sure if this time could be “spent” better… testing in progress 🙂

All the best!

Ł

Chetan JCSeptember 21, 2020 at 2:48 pmHey Łukasz Skotny

This is something awesome stuff I read. I am aware of LSDyna even I use it regularly but this open my mind.

Thanks man.

Łukasz SkotnySeptember 21, 2020 at 3:33 pmThank you Chetan!

I’m really glad that you like my work 🙂

All the best!

Ł

Christy ReenuFebruary 19, 2021 at 7:53 pmHi Łukasz,

I really liked your content. I am working on Ls-dyna for my class purposes. In it, i was asked to run a tensile test without time scaling and by using proper time integration method. The actual test took 75 seconds. I cannot determine how to do this without time scaling. Which method shall i use(implicit or explicit)? i know running implicit for 75 seconds will take days, but isnt implicit time independent?, it doesnt matter if i provide 75 s or 1s with proper timestep defined?

Thankyou

Łukasz SkotnyFebruary 22, 2021 at 11:04 amHey Christy!

Thank you for the comment. Of course, I cannot be sure what you should do – that really depends on what the task is, and to be honest, I’m not sure if I understand.

To me, a test that takes 75s is more or less a “static test”, so I wouldn’t bother with time at all, unless LS_Dyna uses “fake time” to simply measure the load progression. But that shouldn’t really be called implicit or explicit… it is just static.

*I need to point out here, that this is a “semantic” thing. People call things in many ways, and to me “problems are just problems, no matter how you will name them”. This also makes me prone to misuse names of things, or misunderstand them – this is why I’m not sure what the “proper time integration” is.

But… assuming that you really need to use time (for whatever reason really… I don’t think it’s necessary), you definitely want to go implicit. Then you will be able to define a “time step” (like 1s for instance) and define how the deformation will change (the load) in this time (something like a linear ramp starting from 0.0 to max elongation from the test at 75s). And then it means that you only do 75 steps (since it’s 75s done in 75 increments 1s each) and you should be fine.

Using explicit in a 75s analysis will take… ages. If this is even doable without some serious setup work…

I hope that my answer will make some sense to you!

All the best!

Ł

RooufMarch 3, 2021 at 3:47 amBrilliant. Thank you so much for the Article

Łukasz SkotnyMarch 3, 2021 at 7:49 amThanks Roouf!

I’m really glad that you like it 🙂