Week - 2 - Explicit and Implicit Analysis

AIM:

To solve the equation `F(u) = u^3+9u^2+4u` using both explicit and implicit methods with a residual tolerance of 0.01. In the equation, F-Force in the bar and u-displacement in the bar. The problem is solved by both explicit and implicit analysis methods. In both cases an incremental load control scheme is used.

Clearly, it is possible to plot a graph of force, f, versus displacement, u, by using the force equation. However, if the nonlinear force versus displacement relationship is not known, but the stiffness is known, it is possible to construct the graph of force versus displacement numerically. One method is to use an incremental explicit load control scheme wherein, equal load increments (or steps) of dF = 1 unit each are used to load the tension bar. Similarly, an implicit method can also be used to solve the problem by using Newton-Raphson iterations to establish convergence after each step. Solve the problem using both methods and plot the Force v/s displacement graph for both methods                                                                                                                                                                                                                          

THE EXPLICIT AND IMPLICIT SCHEMES                                                                                                                                                                                                                      

The explicit and implicit methods are simply two different approaches used to solve ODEs and PDEs used to depict physical processes as computer simulations. While the Explicit scheme uses the value from the present time step to calculate the value in the next timestep, the implicit scheme calculates the value in the next time step by using the present values and expressing the source term as a function of the next time step. This creates a need for Matrix inversion in the case of the implicit method. Having said all this, we must note that these schemes are just two different ways of solving the same problem. A fundamental difference between the two schemes is that the Explicit scheme assumes convergence for all time steps and thus doesn't check for convergence after each timestep. On the other hand, the implicit scheme checks for convergence after every timestep before proceeding to the next. This makes the implicit scheme stable but demanding in terms of computations as most of the time, convergence is reached only after several iterations. As a result, the time taken for computing for a single time step is bigger.  The explicit scheme can be considered as more direct as there are no convergence checks done in between but this generates stability problems. To avoid this, the timesteps have to be kept extremely small and in most cases, the user doesn't have much control over the selection of this extremely small timestep. This is not the case for the implicit method. Since the convergence check is performed after every time step, the user has control over how big each timestep should be, in the implicit method.                                                                                                                                                              

 Overview on Explicit and Implicit analysis: We will use Implicit and Explicit solvers to solve dynamic problems. Implicit and Explicit analysis differ in the approach to time increments.. In Implicit analysis each time increment has to converge, but we 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. In general, when we want to solve a dynamic problem, we are asking the solver 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 we 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 increment in static analysis. Also, since we 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 our model one increment of time after another. Explicit analysis: Explicit analysis works in a way, that we 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.It calculates all of the local finite element variables for given increment, and moves to the next one. 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. Implicit analysis: Implicit analysis works in a way,that 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). Since global equilibrium is verified at each time increments, those increments can be large.Each time increment computes slowly, since iterations are needed to get to the global equilibrium. Explicit scheme: If the nonlinear force versus displacement relationship is not known, but the stiffness is known, it is possible to construct the graph of force versus displacement numerically. It can be done using an incremental explicit load control scheme. The following equation is solved using explicit method as follows, `F(u) = u^3+9u^2+4u` Differentiating force with respect to displacement gives the stiffness(k) of the bar (since F = kx). `k(u) = (dF)/ (du) = 3u^2+18u+4` Here,three equal load increments (or steps) of `DeltaF = 1` unit each are used to load the tension bar. The variables used are u for displacement, f for internal force in the bar, F for external force applied to the bar and k for stiffness. Incremental displacements or incremental externally applied forces are represented as `Deltau` or `DeltaF`, respectively. `DeltaF =k .Deltau` This relation is used to find the incremental displacement.

USING THE EXPLICIT SCHEME

Force function, `F(u) =(u)^3 + 9(u)^2 + 4u`

Stiffness, `k(u) =d/(du)F(u)=3u^2 + 18u + 4`

Displacement = Force/Stiffness`=F/k`

Force increment`= dF = 1` Displacement increment, `du=(dF)/(k)`

Displacement, `u_(i+1) = u_i+du_i`

Step 1: `dF=1`

`k(u_0)= 3(u_0)^2 + 18u_0 + 4 = 3*0^2+18*0+4=4`

`du_1= (dF)/(k(u_0))= 1/4=0.25`

`u_1 = u_0 + du_1=0+0.25=0.25`

`F(u_1) =(u_1)^3 + 9(u_1)^2 + 4u_1=0.25^3+9*0.25^2+4*0.25=1.578`

`F_(ext)=dF=1` `u_(exact) =0.177` { by solving the equation,  `F_(ext) =(u_(exact))^3 + 9(u_(exact))^2 + 4u_(exact)`}

Step 2: `dF=1`

`k(u_1)= 3(u_1)^2 + 18u_1 + 4 = 3*0.25^2+18*0.25+4=8.688`

`du_2= (dF)/(k(u_1))= 1/8.688=0.115`

`u_2 = u_1 + du_2=0.25+0.115=0.365`

`F(u_2) =(u_2)^3 + 9(u_2)^2 + 4u_2=0.365^3+9*0.365^2+4*0.365=2.709`

`F_(ext)=dF+dF=1+1=2`

`u_(exact) =0.296` { by solving the equation,  `F_(ext) =(u_(exact))^3 + 9(u_(exact))^2 + 4u_(exact)`}

Step 3: `dF=1`

`k(u_2)= 3(u_2)^2 + 18u_2 + 4 = 3*0.365^2+18*0.365+4=10.972`

`du_3= (dF)/(k(u_2))= 1/10.972=0.091`

`u_3 = u_2 + du_3=0.365+0.091=0.456`

`F(u_3) =(u_3)^3 + 9(u_3)^2 + 4u_3=0.456^3+9*0.456^2+4*0.456=3.793`

`F_(ext)=dF+dF+dF=1+1+1=3`

`u_(exact) =0.391` { by solving the equation,  `F_(ext) =(u_(exact))^3 + 9(u_(exact))^2 + 4u_(exact)`}  

It is evident from the results that external and internal forces are NOT in equilibrium because `F_(external)!=F_(Internal)`. The following table summarizes the results for explicit analysis method.

Implicit scheme: An implicit analysis is the same as the explicit analysis, except that at the end of each step Newton-Raphson iterations are used to enforce equilibrium before moving to the next step. Basically, an incremental force is applied to advance the solution forward at the beginning of a step. However, internal forces and external forces will not be in equilibrium unless the stiffness is linear for the given step. Hence, in order to achieve equilibrium, corrections must be made to the displacement. This is accomplished by using Newton-Raphson iterations to minimize the residual, `R=F_(Internal)-F_(external)`

Expanding the residual as a Taylor series about the current displacement `u^j` gives

`R^(j+1) = R^j(u^j) + (dR(u^j))/ (du )deltau^(j+1) + ... = R^j + k(u^j)deltau^(j+1 )+ ...`

By neglecting higher order terms in the series, setting `R^(j+1) =0`  and solving for `deltau^(j+1)` the following correction is obtained

`deltau^(j+1 )= −[k(u^j)]^(−1)*R^j` Here, the iteration variable is j and it may take several iterations for the norm of the residual, R, to be reduced below the chosen tolerance criteria of 0.01.

The implicit analysis proceeds as follows 

(Step- 1)

`u_0 = 0.0, ⇒ k(u_0) =4 , DeltaF = 1, Deltau_1 = (DeltaF)/(k(u_0)) = 0.25, u_1 = u_0 + Deltau_1 = 0.25`

Checking the residual, `F_(external)=DeltaF = 1`

`F_(Internal)=u_1^3+9u_1^2+4u_1=1.578`

`R^((0))=F_(Internal)-F_(external)=0.578`

`R^((0)) > 10^(−2) ⇒`Newton-Raphson iterations are necessary.

Calculate the correction to `u_1 = u_1^((0))`

`deltau^((1 ))= −[k(u_1^((0)))]^(−1)*R^((0))=-(8.6875)^(-1)*0.578=-0.0665` `⇒`The updated value of `u_1^((1)) = u_1^((0)) + deltau^((1))=0.25-0.0665=0.1835`

Checking the residual again,

`F_(external)=DeltaF = 1`

`F_(Internal)=(u_1^((1)))^3+9(u_1^((1)))^2+4u_1^((1))=1.0432`

`R^((1))=F_(Internal)-F_(external)=0.0432`

`R^((1)) > 10^(−2) ⇒`Newton-Raphson iterations are necessary

Calculate the new total correction to `u_1 = u_1^((0))`

`deltau^((2))=deltau^((1)) −[k(u_1^((1)))]^(−1)*R^((1))=-0.0665-(7.404)^(-1)*0.0432=-0.0723`

The updated value of  `u_1^((2)) = u_1^((0)) + deltau^((2))=0.25-0.0723=0.1777`

Checking the residual again,

`F_(external)=DeltaF = 1`

`F_(Internal)=(u_1^((2)))^3+9(u_1^((2)))^2+4u_1^((2))=1.0006`

`R^((2))=F_(Internal)-F_(external)=0.0006` `R^((2)) < 10^(−2) ⇒`Newton-Raphson iterations are not necessary Therefore, the final value is `u_1 = u_1^((2)) =0.1777`

`ul(Step -2)`

`u_1 = 0.1777,⇒ k(u_1) =7.2933 , DeltaF = 1, Deltau_2 = (DeltaF)/(k(u_1)) = 0.1371, u_2 = u_1 + Deltau_2 = 0.3148`

Checking the residual, `F_(external)=DeltaF+DeltaF = 2`

`F_(Internal)=u_2^3+9u_2^2+4u_2=2.1822`

`R^((0))=F_(Internal)-F_(external)=0.1822`

`R^((0)) > 10^(−2) ⇒`Newton-Raphson iterations are necessary.

Calculate the correction to `u_1 = u_1^((0))`

`deltau^((1 ))= −[k(u_2^((0)))]^(−1)*R^((0))=-(9.9637)^(-1)*0.1822=-0.0182` `⇒`The updated value of `u_2^((1)) = u_2^((0)) + deltau^((1))=0.3148-0.0182=0.2966`

Checking the residual again, `F_(external)=DeltaF+DeltaF = 2` `F_(Internal)=(u_2^((1)))^3+9(u_2^((1)))^2+4u_2^((1))=2.0042` `R^((1))=F_(Internal)-F_(external)=0.0042` `R^((1)) < 10^(−2) ⇒`Newton-Raphson iterations are not necessary  

Therefore, the final value is `u_2 = u_2^((1)) =0.2966`

`ul(Step -3)`  

`u_2 = 0.2966, ⇒ k(u_2) =9.6027 , DeltaF = 1, Deltau_3 = (DeltaF)/(k(u_2)) = 0.1041, u_3 = u_2 + Deltau_3 =0.4007` Checking the residual, `F_(external)=DeltaF+DeltaF+DeltaF = 3`

`F_(Internal)=u_3^3+9u_3^2+4u_3=3.1121` `R^((0))=F_(Internal)-F_(external)=0.1121` `R^((0)) > 10^(−2) ⇒`Newton-Raphson iterations are necessary.

Calculate the correction to `u_2 = u_2^((0))`

`deltau^((2 ))= −[k(u_3^((0)))]^(−1)*R^((0))=-(11.6942)^(-1)*0.1121=-0.00958`

`⇒`The updated value of `u_3^((1)) = u_3^((0)) + deltau^((2))=0.4007-0.00958=0.3911`

Checking the residual again, `F_(external)=DeltaF+DeltaF+DeltaF = 3`

`F_(Internal)=(u_3^((1)))^3+9(u_3^((1)))^2+4u_3^((1))=3.0008`

`R^((1))=F_(Internal)-F_(external)=0.0008` `R^((1)) < 10^(−2) ⇒`Newton-Raphson iterations are not necessary   Therefore, the final value is `u_3 = u_3^((2)) =0.3911`

The results of the implicit analysis are summarized in the following table.  

It is evident from the table that the external forces and internal forces are coming into equilibrium. 

It is evident from the plot that the explicit analysis drifts from the exact solution. The drift from the exact solution illustrates the lack of equilibrium between the internal and external forces. To correct for this problem an implicit analysis is required. The Newton-Raphson iterations correct the incremental steps so that they land on the exact solution according to the specified tolerance. Excellent agreement is achieved with just 3 increments and in each step only two Newton-Raphson iterations are required.

CONCLUSION:

As experimented we can use both implicit and explicit solvers to solve the same type of problems. The only difference is in approach to time increment. 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 we can make it reasonably big for our analysis. Explicit time increments calculate really fast because they do not iterate for global equilibrium, but the time increment there is not the user’s choice. Solver simply assumes an acceptable time increment and goes with it.  The speed of computing is exactly the difference between implicit and explicit. Of course, the size of explicit step depends on our model and computing times depend on the system hardware. The debate on what type of solver is better depends upon the type of problem and accuracy we need.

Thus, a nonlinear analysis is illustrated using an incremental explicit and implicit procedure. The results are plotted for comparison. It is evident from the results that the explicit analysis drifts from the true solution. To overcome this problem an implicit analysis is used, which includes Newton-Raphson iterations to enforce equilibrium between internal and external forces. The techniques demonstrated are for a load control scheme.Once satisfactory equilibrium is achieved, a new load increment is applied to advance the solution and the process is repeated.