This is the last article in the series titled Abaqus Tips and Tricks

Should I use Abaqus Standard or Abaqus Explicit?

This article explains the difference between the Standard and Explicit Abaqus solvers, particularly with respect to non-linear dynamic analyses. The goal is to help the user decide which solver may be better to use under various conditions.

When running dynamic finite element analyses in Abaqus, you need to decide which type of solver to use. For structural applications, Abaqus has two solvers - Abaqus/Standard and Abaqus/Explicit. This may not be immediately evident to you in the graphical user-interface (Abaqus/CAE), but when you create a step of type "Explicit", you are actually telling the software to use the Explicit solver rather than the Standard one. So, for instance, a "Dynamic, Explicit" procedure uses the Explicit solver, whereas a "Dynamic, Implicit" procedure or a "Static, General" procedure uses the Standard solver.

Jobs that require the Abaqus/Explicit solver

So, why would you choose a "Dynamic, Explicit" step rather than a "Dynamic, Implicit" one. Which one is better? The answer is - it depends. Each solver is better suited to certain types of simulations, and we will explore what that means here. 

When does this dilemma arise?

Before we go further though, note  that the topic of which solver to use only arises in some situations. For instance, if you are interested in linear dynamics, such as finding the natural frequencies and mode shapes of a structure, you would most likely run a "Linear Perturbation" procedure, which is only available with the Standard solver. Or if you are interested in understanding the stress distribution in a statically loaded structure, such as the legs of a table, you would most likely run a "Static, General" analysis, which again automatically uses the Standard solver. On the other hand if you were interested in running a Coupled Eulerian-Lagrangian (CEL) analysis, you would have to use the Explicit solver since only it has the CEL functionality. Therefore in most cases you don't need to think about which solver to use, you only need to think about what procedure type represents the problem you are trying to solve. Usually you end up with the Standard solver since Abaqus/Standard it is a general-purpose finite element program.

The dilemma about which solver to use generally arises 2 situations:

  1. You have a truly dynamic non-linear problem, where you have to choose between a "Dynamic, Implicit" procedure, which uses the Standard solver, or a "Dynamic, Explicit" procedure, which uses the Explicit solver.
  2. You are solving a problem which you would normally associate with one of the solvers, but you are facing convergence difficulties or your simulations are taking a long time, and you are now curious if maybe the other solver might be a better choice.

In this article I will will talk about the various differences in the solver techniques as well as the known strengths and weaknesses of each solver, so that you can make an educated decision in either situation.

Effect of difference in solver techniques

It helps to know the difference between how the two solvers work to understand why one is preferable to the other in certain situations. I will do a high level overview of the subject here, since you shouldn't require a PhD in computational mechanics to use Abaqus (and I don't have one either!). 

Abaqus/Standard uses a second-order accurate, implicit scheme called the Hilber-Hughes-Taylor (HHT) rule and solves it using an incremental-iterative solution technique based on the Newton-Rhapson method. It starts off by computing the stiffness of the structure in its initial state. Then, in the case of a static analysis the total load is broken down into smaller load increments, whereas in a dynamic analysis the total time is broken down into time increments. The reason for breaking it down into these increments is that as the load is applied the geometry is likely to change, the material properties might change (in case of non-linear materials) and the boundary conditions might also be changing in response to the deformation, and breaking the solution into increments allows this non-linear solution path to be followed rather than basing the entire computation on the initial state. At each increment the load is applied and the displacements are computed using the stiffness, after which the new stiffness is computed, and the residual force is computed as the difference between the external forces and the internal forces on the nodes. This is the first iteration of the increment. In the case of a static analysis this residual force needs to be zero (within tolerance), whereas in the case of a dynamic analysis it needs to be equal to the inertial force (mass * acceleration); if not, the solver iterates again, and then again many more times if necessary, using the newly computed stiffnesses at the end of each iteration until the residual force condition is met. This point is known as convergence. Subsequently the solver moves to the next increment, or if convergence could not be achieved it does a cut-back i.e., it reduces the increment size, and repeats the process. 

If this all sounds too complicated, your main takeaway from the above paragraph should be that Abaqus/Standard solves the problem by running multiple increments and iterations, establishing equilibrium at each of them. Additionally at each iteration a system of simultaneous equations must be solved, which includes matrix inversion that can be computationally expensive. So each increment is expensive.

Abaqus/Explicit on the other uses a second-order accurate explicit integration scheme where the kinematic state is explicitly advanced from the previous increment. The solution is determined without Newton-Rhapson iterations. It also does not require solving simultaneous equations. So each increment is less expensive. 

Difference #1 - Increments in Standard take more compute time than increments in Explicit due to the numerous iterations.

Difference #2 - Solutions with Standard use significantly more compute resources (disk space and memory) than solutions in Explicit due to having to solve a system of simultaneous equations.

The algorithm used by Abaqus/Standard is unconditionally stable, meaning that any size increments can be used, although in dynamic analyses the accuracy is affected by increment size. On the other hand the algorithm used by Abaqus/Explicit is conditionally stable, which means that the time increments need to be less than a certain critical value for it to be stable otherwise the solution will diverge and the results will be incorrect. This is because the algorithm integrates constant accelerations exactly, and so for the method to produce accurate results the time increments must be small enough so that the accelerations are nearly constant during an increment. The critical value that the time increments need to be smaller than is known as the stable time increment. Physically it is related to the highest natural frequencies of the model. Typically this results in very small increments, much smaller than those used by Abaqus/Standard, which means there are many more increments as compared with Standard.

Difference #3 - Standard generally requires fewer time increments than Explicit to complete a simulation. 

The explicit dynamics method was originally developed to analyze high-speed dynamic events. As the solver solves for a state of dynamic equilibrium, the out-of-balance forces in the structure end up getting propagated as stress waves. With the tiny increment size, if output is requested at a high frequency it is even possible to capture the stress wave propagate through the structure in the results. 

Takeaway 1 - Explicit is a good tool for capturing the transient dynamic effects during high-speed dynamic events.

Takeaway 2 - For high-speed dynamic events, which occur over a very short time duration, Explicit is more computationally efficient compared to Standard, both in terms of solution time and computational resources, since even though Explicit will perform more increments, each increment will be much cheaper. On the other hand for longer duration dynamic events Explicit may require too many increments, and although each increment is cheaper than Standard the overall efficiency may become less than in Standard. 

Effect of Mesh Refinement

I mentioned earlier that the algorithm used by Explicit is conditionally stable, and the time increment needs to be less than a certain critical value called the stable time increment which physically is related to the highest natural frequencies of the model. From a simulation standpoint it is related to the size of the smallest element in the entire mesh; it is in fact the minimum time it takes a dilatation wave (volume expansion followed by volume contraction) to travel across any element in the model. The consequence of this is that if you have even a few very tiny elements in any part of your model, the stable time increment will be reduced for the entire model, and the solution will take many more increments. This is very different from Standard where the algorithm is unconditionally stable and therefore not affected in this same way by element size. 

Difference #1 - Individual element sizes can have a big impact on the number of increments in Explicit, but do not directly have an impact on the number of increments in Standard. Explicit therefore performs better with a more uniform mesh, whereas this is less of a concern in Standard.

As a mesh is refined, the number of elements increases, and the number of degrees of freedom increases. Recall that in Standard the solution requires solving a system of simultaneous equations, which also involves an expensive matrix inversion operation, and so if there are more degrees of freedom in the model there will be more simultaneous equations to solve. As per the Abaqus documentation, based on Simulia's own experience, the computational cost in Standard is roughly proportional to the square of the number of degrees of freedom. So, in a 3D model, if the mesh is refined by a factor of 2 in all three dimensions, the computational cost increases by (23)2 = 64 times. Of course even in Explicit this same mesh refinement will cause an increase in computational cost, since there will be more elements,  and also smaller elements (which will reduce the stable time increment), but the cost increase will not be 64x, it will be much less.

Fig. Relative computational cost increase with increase in degrees of freedom (Image from Abaqus documentation)

Difference #2 - Mesh refinement is much more expensive in Standard than in Explicit.

Takeaway 3 - As model size increases due to mesh refinement, Explicit shows greater computational cost savings than Standard, and therefore provides a more efficient solution for large problems. For very large models it can be much more computationally efficient. However it is important that the mesh be relatively uniform, since its stable time increment will depend on the size of the smallest element.

Handling of Discontinuities 

The Explicit solver tends to be better at dealing with discontinuous nonlinearities since it has been designed to solve highly discontinuous problems. 

Contact - Explicit is specially good at handling contact interactions. Contact is a severe discontinuity, and although Standard has a robust contact algorithm, Explicit excels in this department and can readily analyze problems in which there are multiple contact interactions between multiple independent bodies. Impact problems where the transient dynamic response is important, such as crash tests and drop tests, are best solved in Explicit. 

Material failure - Explicit is also better at handling discontinuities such as material degradation and failure, which often cause convergence difficulties in Standard, such as tensile cracking which causes material stiffness suddenly becomes negative, or ductile failure in which material stiffness gradually reduces to zero. 

Sudden changes in stiffness - Similarly Explicit is very well suited to phenomena such as buckling and post-buckling where the stiffness of the structure can change drastically as loads are applied.

Often machining problems involving complex contact and large deformation are solved using Explicit even when they are essentially static problems. These include forging, rolling, and sheet-forming. These types of analyses are known as quasi-static analyses, since a static problem is being solved using a dynamic procedure. (Quasi-static analyses can also be run using the implicit dynamic solver in Standard, but those tend to be problems with time-dependent material response such as creep, swelling, and viscoelasticity, rather than problems  with complex contact). 

Takeaway 4 - Explicit is better suited for problems with discontinuous nonlinearities such as contact, whereas Standard is a good choice for smooth nonlinear problems. 

Choice of Elements

Explicit's library of elements is smaller than that available to Standard, and are a subset of those available to Standard. For instance, the 20-node quadratic brick element with reduced integration (C3D20R) is available in Standard but not Explicit. Generally the elements offered in Explicit are ones that are considered well suited for an Explicit analyses, so the smaller selection of elements is unlikely to be a problem. However it might be something to keep in mind if you intend to compare the results to previously run analyses with a certain element type, or if you are considering converting a simulation from Standard to Explicit. 

Takeaway 5 - Explicit has a an element library that is a subset of what is available in Standard (but the elements offered are ones that work well in Explicit). 


There is overlap between the types of problems that can be run in Standard and Explicit, but each of the solvers has strengths and weaknesses that make it better suited to one problem over another. 

The Abaqus/Standard solver is a robust general purpose solver which can be used for a variety of analyses ranging from static problems to dynamic ones. The Abaqus/Explicit solver on the other hand is a more specialized tool; it is particularly well suited to highly discontinuous short-duration dynamic non-linear situations which generally involve complex contact, and it is also well suited to problems involving material failure and sudden structural stiffness changes. So, if you are dealing with a static problem, such as finding the stress in the legs of a table, or a smooth dynamic problem, Standard is most likely the better choice, but if you are analyzing a highly dynamic problem with a lot of contact interactions like the drop-test of a phone or a car crash then Explicit is almost certainly the better choice. 

Some static problems with a lot of contact and large deformations run better in Explicit, even though normally one should run static problems in Standard, since these problems can leverage some of the strengths of the Explicit solver such as its ability to deal with discontinuities. These quasi-static analyses are often run by engineers working for machining and manufacturing companies for problems like rolling and sheet metal forming, so if you are analyzing similar problems then Explicit might be the right choice. (However you should first familiarize yourself with quasi-static analyses since these simulations need to be run a certain way).

Additional Notes

Test with both solvers - Although I hope the above article helps you make a more informed choice about which solver to use for different types of problems, the truth is there will still be many situations where the choice is not immediately clear. In such cases it is often a good idea to test your early models with both solvers before taking a decision on which one to proceed with. If the solution time or computational resource usage is much less with one of the solvers, then using that solver can lead to large cost savings over the lifetime of a project.

Import analysis - It is possible to combine the best of both worlds and use different solvers for different stages of your analysis. Abaqus provides the capability to transfer the deformed mesh and associated state from a Standard analysis to an Explicit analysis and vice-versa. This is known as an Import Analysis in Abaqus.

Co-simulation - It is also possible to combine the best of both worlds and use both solvers at the same time, each operating on different parts of the model. This is known as a Co-Simulation in Abaqus. 

This is the last article in the series titled Abaqus Tips and Tricks
Did you find this article interesting?
Get notified when Gautam writes more articles:
This website uses cookies to deliver services, improve usability, and measure performance. By continuing to use this site you opt-in to receive these cookies. You may disable some of them on the Cookie Settings page. You also acknowledge that you have read and understand our Cookie Policy, Privacy Policy, and Terms of Service.