# 3.6.3: Analyze Nonlinear WIP

Last updated

Last updated

Linear structural behaviour means that if one changes the external loads by a factor$f$ also the physical response quantities (displacements, cross section forces, stresses, …) change by that factor. This has the pleasant effect, that the impact of different loads can be superimposed. Thus it is not necessary to recalculate the model for each possible combination of external loads. For real structures the assumption of linear behaviour is an approximation – a good one in many cases. There are two mayor sources of non-linearity:

Physical non-linearity: Comes into play when materials leave the linear elastic range (e.g. concrete that cracks, steel that yields, …)

Geometric non-linearity: Takes effect when

lateral displacements get so large, that their effect on the axial (in case of e.g. beams) or in-plane (think of shells) deformation can not be neglected any more,

a nodal rotation$\alpha$reaches such a value, that the difference between $\alpha$ and $\tan(\alpha)$ gains importance.

The **“Analyze Nonlinear WIP”**-component lets one deal with geometric non-linearity. It is work-in-progress. This means that especially for shells the algorithms may not converge within acceptable time for some structures. If however a result is returned, then it is sound.

With the **“Analyze Nonlinear WIP”**-component one can chose from three variants of iterative solution algorithms. Each of these has different benefits and liabilities which will be explained below. The algorithms are based on the assumption of small strains, but allow arbitrarily large displacements.

The target of all three algorithms is to find a displacement state, where the external loads and the internal forces are in equilibrium. Starting from a known initial displacement state, one has to guess how the structure deforms under the given loads. This guess leads to a second displacement state where the internal and external forces usually do not match. The remaining imbalance forms the basis of a next prediction regarding the change of displacements and so on. Equilibrium is reached when the residual-force or change of displacements falls below a given threshold. The three algorithms offered by the **“Analyze Nonlinear WIP”**-component differ in how they predict the displacement increments.

Fig**. **3.5.3.1 shows a cantilever beam with a bending moment load about the local y-axis at its tip. It consists of 20 beam elements. For calculating its response the **“DynamicRelaxation”**-option is used. This algorithm predicts the next move of a structure based on the direction of the residual forces acting on each node. It is a robust procedure which converges to equilibrium quite reliably but sometimes needs a large number of iterations to do so. This component offers the following input-plugs:

During a non-linear calculation lots of things can happen. In order to get an idea about why and where something went wrong, the DR variant of the **“DynamicRelaxation”**-option produces the following output:

In practice, dynamic relaxation(DR) procedures are used for highly non-linear problems like numerical crash-tests of cars, bolts being shot into a wall, …. The reason is, that implementing non-linear effects as DR code is relatively easy. This ease of implementation comes at the cost of high computational effort: Many iterations are necessary to reach equilibrium with acceptable accuracy. The way out of this is to invest more effort in a better prediction of the displacement increments. In DR-methods the residual forces at the nodes form the basis of predicting the next position of a node. Methods like the Newton-Raphson- or Arc-Length-method use a stiffness matrix for producing displacement predictions. There the computational cost per iteration is higher, but the number of iterations can be made much smaller as compared to DR-methods. With a consistent stiffness matrix quadratic convergence can be achieved under optimal conditions. This means that for the iterative displacement- and force-errors the number of zeros after the decimal separator doubles in each iteration. For the **“Analyze Nonlinear WIP”**-component this is not yet the case and one reason for the “work in progress”-label. Details on the Newton-Raphson- or Arc-Length methods can be found in [6] on page 102 ff. and 214 ff.**.**

Fig. 3.5.3.2 shows the same cantilever beam as before, this time analyzed with the **“NewtonRaphson”**-option. The Newton-Raphson variant of the **“Analyze Nonlinear WIP”**-component comes with nearly the same input- and output-plugs as the DR-version. The only difference is the missing **“StepSizeFac”**-input. Since Newton-Raphson procedures have the same limitation with respect to unstable structures as DR-methods, an interval halving strategy for closing in on limit-points is applied as before.

For many structures reaching a first point of instability is not yet the end of the story. Especially thin plate and shell structures show large load bearing reserves when considering their post-buckling behavior. The Arc-Length-method can be used for these kinds of situations. Fig. 3.5.3.3 shows the calculation of a truss structure which snaps through from an unstable state to a stable post-buckling configuration.

The first two inputs of the **“Arclength”**-component have the same meaning as before. Here a description of how the rest of the input-plugs controls the solution process:

**"Model"**

Structure to be analyzed.

**"nLoadSteps"**

Number of load-cases which shall act as load-steps. The default is 1. When setting it to e.g. 2 it means that the algorithm starts with finding equilibrium for load-case 0. After that, the loads of load-case 0 remain in place and the loads of load-case 1 are added in order to arrive at the final stage. This allows to model a loading history. The remaining load-cases get added to the final stage separately and under the assumption of small displacements. In the case of an active bending structure the first load-cases serve as those which cause the deformed structure, whereas the rest of the load-cases constitute additional actions on the deformed configuration like wind- or live-load. The scaling factor for displacements in the **“Display Scales”** submenu of the **“ModelView”**-component acts only on the loading-steps for which small displacements are assumed. The large deformation share of the total displacements does not get scaled and is displayed in real size.

**"nLoadIncs"**

Number of increments per load-case (the default is 5). External loads get applied in several steps. In case of structures with nearly linear behaviour, the number of increments can be set to a small number. For highly non-linear problems a larger value can be advantageous. The smaller the load-increments, the easier it is for the algorithm to find equilibrium. The number of iterations usually decreases with increasing number of load-steps (and thus decreasing step size). The overall performance can however suffer if the number of load-steps is set to a number which is too high for the given type of structural behaviour.

**"maxEquiIter"**

Sets the maximum number of equilibrium iterations per load-increment and thus sets a limit on computation time. It defaults to 200.

**"EquiTol"**

Tolerance for the iterative change of residual forces and displacements relative to their incremental change in the current load-step. The default value is $1E-7$.

**"maxLimitIter"**

The range of problems which can be tackled using the dynamic relaxation (DR) algorithm as implemented in Karamba3D is limited to stable structures. In case of phenomena like buckling or snap-through, equilibrium states may exist beyond the point of initial instability. They are however hard to reach due to their often large distance from the last known stable configuration. In such a case the DR-algorithm does not converge to an equilibrium state within the maximum number of equilibrium iterations. It then tries to close in on the point of assumed instability by halving the load-increment which led to divergence. By proceeding in this manner, the so called limit load can be determined with arbitrary precision. **“maxLimitIter”** sets an upper limit on the number of limit-load-iterations which is equal to 200 by default. Sadly, divergence can also be caused by numerical problems in the algorithm. Thus the limit-load-factor as determined by the **“Analyze Nonlinear WIP”**-component constitutes only a lower limit estimation.

**"LimitTol"**

Sets the minimum load-increment threshold for calculating the limit-load.

**"StepSizeFac"**

A factor for scaling the predicted displacement increments of the DR-algorithm.

**"Model"**

Structure with calculated displacements, stresses and internal forces.

**"Disp"**

Maximum displacement reached in centimeter.

**"Energy"**

Deformation energy stored in the structure in $kN m$ .

**"Info"**

Details regarding the solution process. It outputs five columns of text:

**“Factor”**: The factor of the loads of the current load-step.**“Step”**: The current load-step**“Iter”**: Counts the number of iterations for the current load-increment.**“Disp.Err”**: Outputs the ratio of the sum of iterative changes of the nodal displacements with respect to the change of displacements of the first iteration in the current load-increment**“Force.Err”**: Outputs the ratio of the sum of iterative changes of the residual forces with respect to the current load-increment.

**"Lambdas"**

Informs about the load-factors for which equilibrium could be reached.

**"IniLoadFac"**

The displacement of the structure under the external load multiplied by **“IniLoadFac”** serves as a first estimate for the target deformation increments.

**"MaxEquiIter"**

The maximum number of iterations per load increment.

**"TargetEquiIter"**

Sets the number of increments to be used in each increment. Is used to scale the load-increments accordingly.

**"EquiTol"**

The tolerance for out of balance forces and displacement changes from one iteration to the next.

**"MaxLoadInc"**

Maximum number of load iterations.