计算力学：显式积分与隐式积分小结

个人小结：

显示和隐式区别在于，求解偏微分方程时所采用的数学策略的区别，具体而言，显示是差分，隐式是牛顿迭代。求解方式的差异，必然会有不同的优缺点。

隐式 / Standard-- 优点是准确，对步长无要求（即，对网格无要求），但存在收敛问题。

显示 / Explicit -- 优点只要计算足够长，肯定能收敛，但是存在累计误差问题，因此对最小步长有要求（即，对网格有要求！）

以下内容转自abaqus版面的总结：

显式一般用于动态问题的分析, 对于大型问题, 或复杂的接触情况可能需要几百万的增量步的计算, 所用时间可能是几天或更长. 而隐式的增量步长要长得多, 一般用于静态问题的求解.

所谓显式和隐式，是指求解方法的不同，即数学上的出发点不一样。并不是说显式只能求动力学问题，隐式只能求静力学问题，只是求解策略不通。
显式求解是对时间进行差分，不存在迭代和收敛问题，最小时间步取决于最小单元的尺寸。过多和过小的时间步往往导致求解时间非常漫长，但总能给出一个计算结果。解题费用非常昂贵。因此在建模划分网格时要非常注意。
隐式求解和时间无关，采用的是牛顿迭代法（线性问题就直接求解线性代数方程组），因此存在一个迭代收敛问题，不收敛就的不到结果.

Explicit method -显式算法别 use direct iterative method, which has small cost in each time increment but require relatively small increment. Abaqus pre-determine the time increment based on wave propagation speed and minimum mesh size. This method could be efficient for highly nonlinear and contact problem. For quasi-static problem, properly adjust model parameter as density and total time is important to achieve good computation time.
Standard-隐式算法 Implicit method use newton method for iteration, which means high cost for each time increment but could mean large time increment. Convergence could be a problem in this case. It could be efficient for linear and some nonlinear problem. More materials, elements and procedures are available in standard.

两者求解问题所耗时间的长短理论上无法比较。实际应用中一般感觉来说显式耗时多些。
由于两者解题的出发点，所以一般来说显式用于求解和时间相关的动力学问题。隐式用来求解和时间无关的静力学问题。但也不是绝对的。比如，用隐式求解时，为了克服迭代不收敛，改用显式算，但是要多给点时间，这样虽然克服了不收敛的问题，但是求解的时间费用也是相当客观的。另外，隐式也可以求解动力学问题。abaqus就有一个用隐式积分求解动力学的选项。

n+1个时间步的量可以由第n个时间步的量直接求得，称为显式
例如：
an+1=bn+cn
bn+1=an+cn
cn+1=an+bn
优点是计算量比较小
缺点是有累积误差

n+1个时间步的量不可以由第n个时间步的量直接求得，称为隐式
例如：
an+1+bn+1=cn
bn+1+cn+1=an
an+1+cn+1=bn
优点是计算量比较大，需要通过方程组求解
缺点是没有累计误差

显示算法不进行刚度矩阵的重新计算，只在开始形成以后不变，是时间的显示积分。而隐式算法没进行一次计算都要重新计算刚度矩阵，然后进行迭代，是无条件收敛的

Q: What is the difference between implicit and explicit dynamics? (Difference between regular ANSYS and ANSYS/LS-DYNA?)
A:For computers, matrix multiplication isn't difficult. Matrix inversion is the more computationally expensive operation. The equations we solve in nonlinear, dynamic analyses in ANSYS and in LS-DYNA are:
[M]{a} + [C]{v} + [K]{x} = {F}

Hence, in ANSYS, we need to invert the [K] matrix when using direct solvers (frontal, sparse). Iterative solvers use a different technique from direct solvers which I won't get into here, but, basically, the inversion of [K] is the CPU-intensive operation for any 'regular' ANSYS solver, direct or iterative. We then can solve for displacements {x}. Of course, with nonlinearities, [K(x)] is also a function of {x}, so we need to use Newton-Raphson method to solve for [K] as well. (material nonlinearities and contact get thrown into [K(x)])

In LS-DYNA, on the other hand, we solve for accelerations {a} first. Now, in LS-DYNA, we assume that the mass matrix is lumped. This basically forces us to use lower-order elements -- that is why, for all explicit dynamics codes (ANSYS/LS-DYNA, MSC.Dytran, ABAQUS/Explicit), we can only use lower-order elements. Also, the benefit of doing lumped mass is that, if we solve for {a}, then [M], if lumped, is a diagonal mass matrix. This means that inversion of [M] is trivial (diagonal terms only) -- another way to view it is that we now have N set of *uncoupled* equations. Hence, we just have to do matrix multiplication, which isn't nearly as CPU-intensive. It's also worthwhile to note that [K] does not need to be inverted, and accounting for material nonlinearties and contact is easier.

Now, as for time integration, the terms 'implicit' and 'explicit' refer to time integration -- for example, if you might recall something like backward Euler method, that is an example of an implicit time integration scheme, whereas central difference or forward Euler are examples of explicit time integration schemes. It relates to when you calculate the quantities -- either based on current or previous time step. In any case, this is a very simplified explanation, and the main point is that implicit time integration is unconditionally stable, whereas explicit time integration is not (there is a critical time step your delta(t) needs to be smaller than). As a result, 'regular' ANSYS allows for much larger time steps, but LS-DYNA requires much tinier time steps. Also, LS-DYNA requires very tiny steps, so that is why it is usually good for impact/short-duration events, not usually things like maybe creep where the model's time scale may be on the order of hours or more.

In summary:
'Regular' ANSYS uses implicit time integration. This means that {x} is solved for, but we need to invert [K], which means that each iteration is computationally expensive. However, because we solve for {x}, it is implicit, and we don't need very tiny timesteps (i.e., each iteration is expensive, but we usually don't need too many iterations total). The overall timescale doesn't affect us much (although there are considerations of small enough timesteps for proper momentum transfer, capturing dynamic response, etc., but I'm getting ahead of myself).
ANSYS/LS-DYNA uses explicit time integration. This means that {a} is solved for, and inverting [M] is trivial -- each iteration is very efficient. However, because we solve for {a}, then determine {x}, it is explicit, and we need very small timesteps (many, many iterations) to ensure stability of solution since we get {x} by calculating {a} first. (i.e., each iteration is cheap, but we usually need many, many iterations total)

Anyways, this is a very simplified (maybe over-simplified) explanation, but I hope it may help clear the distinction between these two methods. For very high-impact, nonlinear events of *short* duration, ANSYS/LS-DYNA is usually the better choice. For events which are of long duration, 'regular' ANSYS is usually the preferred method. For quasi-static events, there are ways in which you can use either solution method (e.g., mass-scaling for explicit). However, you can solve most problems with either method -- I'm just referring to which ones are more *efficient*. [Note that I haven't talked about mode-superposition transient analyses, which is an efficient subset of 'regular' ANSYS for mostly linear behavior, but it is efficient because we uncouple the equations in the frequency domain rather than time domain, but I've probably digressed enough already...]

隐式与显示最重要的区别在于是否对于整体刚度矩阵求逆，而这一过程也就决定了两者对于模型的要求，由于隐式算法要求逆，所以计算时要求整体刚度阵不能奇异，而显示就没有这一问题啦。而对于动力学问题来将，从数学上看它属于微分方程中初边值问题，如果采用显示求解，很容易发生总纲奇异的问题，所以很多时候求解动力学问题都采用explicit来做。但是explicit也有自身的问题，由于要对于时间积分，如果时间积分步长取得太长，计算结果很有可能是不精确的，但是太短了，还会使得计算时间大幅度增加，并且动力学问题中还存在应力波效应影响，所以使得显示问题更为复杂，但是abaqus中提供了最小单元尺寸限制时间步长的方法，还是可以很好地解决这问题。

显式和隐式的区别很多人都讲了，说一下计算效率的问题，隐式需要解线性方程组，而对于显式，当我们使用集中质量矩阵时，不需要求解线性方程组，所以对于大规模问题，虽然显式的时间步长较小，但显式会比隐式更有效率。