PROJECT 2 Antonio Rinaldi 388982

TASK 1
PART A

In this case we have ‘id=2*i’ because we have to refer to the vertical degree of freedom on the node in
which the force/ displacement boundary condition is applied.

PART B >> Please, see ‘felm11.m’

PART C

I’ve found two different initial guesses that allow us to use larger load steps:

The first one is a linear initial guess and the second one is parabolic.
The results obtained using the two different initial guesses are the same, but with the linear initial guess
the computation time is smaller.

PART D

- DISPLACEMENT DRIVEN
- FORCE DRIVEN
COMPARISON BETWEEN RESULTS OBTAINED WITH FORCE AND DISPLACEMENT DRIVEN CODE

The two curves almost completely overlap. Decreasing the step size and/or decreasing the mesh size, the
overlapping could be total.

Fora deeper description of the parameters R and u put on the axes, please see TASK 2, part A.

PART E

- displacement driven convergence

ZOOMING IN

For a better understanding , the error on the R with respect to the ultrafine mesh results( in results_u.dat) ,
is plotted for different mesh sizes and for each displacement u. (to clarify : ERROR= abs(R(jmesh=i)-
R(ultrafine mesh)))

So it can be noticed that decreasing the mesh size the results converge to the ideally exact result
(continuum case). It can be seen that the convergence is not linear, as shown in the ERROR plot.
 - FORCE DRIVEN CONVERGENCE

Zooming in
In this case the error has to be computed on the displacement u. It can be shown that with increasing value
of the R, the error on the displacement u decreases for each mesh size. In the displacement driven case the
error on R increases with increasing value of u. Also here, the errors have been computed with respct to
the results obtained with the ultrafine mesh (in results_f.dat).
TASK 2

PART A

I’ve implemented 3 different types of initial guesses and each one leads to the same solution in terms
of the force-displacement curves and of the stress representation plot.
 In the plot above are shown the three different initial guesses. The maximum displacement is set in
the middle where the load is applied and the initial dispacement gradually goes to zero following
the shape of the approximation function, and it reaches the value of exact zero at the supports.
The initial guesses are all symmetric as the loading and the geometry in this case.

The value of central ‘ds’ in the figure has only an illustrative meaning, not a physical one(like in task
1).

The parabolic initial guess is set so that the displacement is maximum in the centre point and zero
at the supports. The function is tangent to the x- axis at the supports’ points.

Identical results are obtained using the three different initial guesses.

Considering the following load stepping

The following results are obtained:
In the ‘reported stress figure’, thanks to the colormap, we can see that in the final configuration the
fibers of the lower part of the beam are stretched (yellow color) and the fibers of the upper part of
the beam are in compression (blu color).

Before describing the meaning of the force- displacement curve, I want to clarify the parameters
reported on the axes. I’ll do it following the matlab code (not in a sequential way but in a logical
one, tracing back what’s the origin of the parameters):
So the parameter R on the y -axis of the plot is the vertical global internal (reaction )force acting on
the node in which the load is applied (number of the node: nno= id/2). It is taken with a negative
sign as shown by the ‘ – Uh(:,2) ’ in the ‘plot’ code.

On the x- axis the parameter u represents the vertical dispacement of the node in which the load is
applied . This parameter is computed for each of the load step l . Moreover, it is taken with a
negative sign : in fact the displacement of this node should be negative since it is going downward,
but for an easily readable plot it is taken with a negative sign so that it becomes positive.

What we get from the FEM code are only the points shown in the plot: the line that links the points
can become more precise if the number of the load steps increases.

The plot shows that the value of R increases with u until a value of u of about 3, where R reaches its
maximum, then R starts decreasing and becomes zero for u of about 7.5. So R becomes negative
and reaches its minimum for u of about 9.5, then it restarts to increase and becomes again positive.
At the last load step the value of R is closer to its maximum.

This strange behaviour can be reconduced to material instabilities or to the fact that geometrical
non linearities can lead to the buckling problem or to the snap-through behaviour: the fact is
that real structures respond to external loading often in a nonlinear way and some nonlinearities
are associated with sudden changes of the system behaviour.

So we see that R increases until point A and decreases afterwards for increasing displacements u.
This situation can be seen thanks to the fact that our loading process is ‘dynamic’ because of the
load stepping method, but if the load was applied in a static way we could not see this behaviour.
The system cannot be in static equilibrium until point B. So point A can be seen as thepoint in which
the system changes his stability behaviour: before A the system is stable, between A and B is
unstable and after B is stable again.

PART B
As shown from the above force-displacement plot, the force driven code gives the same results of the
displacement driven code. The force driven code has the following force steps:
with

Now we can think to make a try and follow the force -displacement curve obtained with the displacement
driven code, using the force driven code through increasing the load (e.g. es> 11): the results is that the
code will stop (not because of negative Jacobian) at the force step in which u is about 3 and the force value
is the maximum one of the load history compared to the displacement driven code.

Here the matlab results: the figure below wants to show where the force driven code stops and why (no
convergence in the newton raphson iterations)
 While the displacement driven code has no problem in fact:

The fact that the force driven code doesn’t find a solution is because it fails when there are instability
problems like the buckling phenomena. If the displacement driven code is flexible because you give a set of
displacements and it will give you the solution (if the load steps are sufficiently small and there is a reasonable
initial guess), the force driven code doesn’t give the solution if something ‘ phisically’ strange is happening
like the snap-through phenomena: I increase the load but I don’t find any suitable displacement that fits the
energy constrain( en< TOL with en= energy residual). This happens because for the force step F slightly higher
F_max=R(u=3) the force driven code will find the displacement in point B (reported in the plot of Part A).
during the Newton iterations . This displacement is too high: in fact the right displacement should be the one
of point A). For this reason the Newton iterations won’t find a solution.

Another thing to consider is that with the displacement driven version you control more directly the
volume changes of the elements thanks to the displacements steps and the initial guess while with the
force driven version is more difficult to do something like that, and so in case of non linear situation
(geometry or material related) it can be easier to get negative Jacobians with force driven code.

The advatage of the force driven code is that it is more physical in the design problems: it can be suggested
a combined displacement -force driven code in order to have more accurate results.

PART C

In order to break the symmetry I have put the load in the position shown in the figure below:

Since the load in not symmetric with the geometry, also the initial guess for the displacement driven
code should not be symmetric. I have found two initial guesses that allow the code to come up with a
solution.
These are shown in the pictures below:

the left initial guess (I.G.) (from the left support to the loading point) is parabolic and the rigth I.G. is linear
(from the loading point to the rigth support).
in the picture below the left initial guess and the rigth initial guess are both parabolic

In order to implement this asymmetric initial guesses I have divided the nodes in two sets: in one set there
are the nodes at the left of the load and the other ones are those at the right of the load.

The function ‘find’ tells the ‘index of row’ (= number of the node) in which the condition inside the ‘find’
function is satisfied. I multiply this function by 2 because we need the vertical degree of freedom of the
nodes found in this way.

I have used ‘setdiff’ because I need only the unconstrained and unloaded degree of freedom.
Using both sets of initial guesses I have obtained the same following results : (MATLAB SETTINGS jsym=1,
jmesh=2, jload=0)

The load step used is the SAME of the symmetric case

In this case there is not the buckling phenomena such us in the symmetric case, the force has the same sign
all along the displacement steps. We can notice that after u=8 there is a considerable increase of the R and
this can be explained considering that until the u=9 the geomery is ‘adapting’ itself to the load and only
after a certain displacement it becomes to ‘react’. More over in this case the fibers that are to the left of
the load are stretched while the fibers that are to the rigth of the load are compressed.

One difference that I’ve noticed with the symmetric case is the difference in the averaged number of
Newton steps for convergence(en<TOL): considering the case of displacement driven code and jmesh=2,
the average number of Newton steps in the asymmetric case is higher than the symmetric case and for this
reason also the computational time is the asymmetric case is higher.

I try to do a comparison with the asymmetric case with jmesh=4 and FORCE DRIVEN obtaining the following
results:
It seems that the rate of convergence to the ‘exact’ solution is quite low, when decreasing the mesh size
from jmesh=2 to jmesh=4;

Finally comparing the symmetric and asymmetric problems, we can conclude that the results obtained are
strictly connected to

1) Geometry of the structure

2) Loaded point (symmetric or not with respect to the geometry)
3) Orientation of the load with respect to mesh (penetration problems>> negative Jacobian)
4) Mesh size