Flexible multibody dynamics — Exercises
A Finite Element Approach
R.G.K.M. Aarts
Edition 2021/2022
© 2020–2022. Copyright R.G.K.M. Aarts, Universiteit Twente, Enschede.
All rights reserved. No part of this work may be reproduced, in any form or by any means,
without the explicit and prior permission from the author. Permission to print a hardcopy of this
document is granted to students participating in courses of the University of Twente.
The cover image shows a model of a 2-DOF manipulator with compliant joints and is © S.E. Boer.
1
General remarks about “template” files
For the following exercises MATLAB scripts can be downloaded in which a considerable part
of the code has already been typed, such that you can focus on implementing the final parts
after studying and understanding the relevant theory. These files are called “template” files and
-TEMPLATE is included in the filename.
It is strongly advised to make a copy of the file or at least rename it. In fact, you have to remove
the -TEMPLATE part from the filename as it can’t be run in MATLAB otherwise. This procedure
is imposed to avoid that you may overwrite your own files if you download these “template”
files once more in the future.
Note that it is also advised to remove the first comment, lines 2–10, as the line numbers mentioned in the exercises are incorrect with this comment included.
1
Sliding rigid bar
Consider Example 3.2.1 in the reader, see also Fig. 1. In this example the motion of a rigid
bar is analysed of which one end p moves horizontally and the other end q vertically. In that
example the horizontal velocity of point p is prescribed. The angle of the bar doesn’t play a role
and hence a (rigid) planar truss is well suited for the analysis. In this exercise we consider two
cases: First the motion is described as above, Fig. 1(a). Next the motion will be prescribed by
defining the angle β(t) as a function of time instead, Fig. 1(b).
y
y
q
β
p
q
β
1
1
p
v
x
√
x
√
3
(a) Prescribed position xp (t)
3
(b) Prescribed rotation β = βp = ϕp (t)
Figure 1: Example of a sliding bar in an arbitrary configuration.
Prescribed position xp (t)
First we would like to reformulate the analysis in the reader somewhat. Consider the system
shown in Fig. 1(a), so with a horizontal velocity v prescribed in node p. More precisely, the
position xp is prescribed as
xp (t) = −l0 + v t,
(1)
2
with length l0 = 2 m and velocity v = 4 m/s in numerical simulations. The time t is limited to
the range t ∈< 0, 2l0 /v >.
This system is modelled with a sliding truss, so the list of coordinates x is given in Eq. (3.2.1)
and there is a single deformation being the elongation ε1 of Eq. (3.2.2). Its deformation function
can be written as
q
ε1 = D1 (x) = (xq − xp )2 + (yq − yp )2 − l0 ,
(2)
where the actual length of the element according to Eq. (3.2.3) has been substituted. The superscript (k) has been omitted for readability. An expression for the first derivative D1,x , the
Jacobian, of this function is given in Eq. (3.2.4)
To align with the notation that is used in reader from Sect. 3.3 onwards, we reorder the nodal
coordinates. The fixed coordinate(s) are collected in x(o) , the dependent coordinate(s) in x(c)
and the independent coordinate(s) in x(m) . The vector with all coordinates is then

x(o)



x =  x(c)  ,
(3)
x(m)
see e.g. Eq. (3.3.4).
Similarly also the deformations are ordered, but that is simple in this example as only a rigid
deformation is considered which is denoted as ε(o) . The associated deformation function is then
also written as D (o) . Obviously rigid deformations are always zero, so D (o) = 0 by definition.
Next also the derivative of the deformation function is split into parts similar to the coordinate
vector, so
h
i
(o)
(o)
(o)
D,x(o) = D,x(o) D,x(c) D,x(m) .
(4)
Position analysis
In the kinetic analysis the fixed coordinate(s) x(o) and independent coordinate(s) x(m) are
known. Hence the goal of the position analysis is to compute the dependent coordinate(s) x(c) ,
so yq of the truss in this exercise. For this we need to solve the non-linear constraint equation
for the rigid deformations D (o) (x) = 0.
A numerical solution can be found with the iterative Newton–Raphson procedure. We start with
an initial guess x0 for the coordinates. In general, the constraint equation is not satisfied for this
solution, so D (o) (x0 ) ̸= 0. Next we use a Taylor series to estimate the change of the constraint
equation for a (small) change ∆x of the coordinates:
D (o) (x0 + ∆x) = D (o) (x0 ) + D,x(o) ∆x + t.o.h.
(5)
Ignoring the terms of higher order (t.o.h.) and using the partitioning of Eq. (4) we write
(o)
(o)
(o)
D (o) (x0 + ∆x) ≈ D (o) (x0 ) + D,x(o) ∆x(o) + D,x(c) ∆x(c) + D,x(m) ∆x(m) .
3
(6)
As only the dependent coordinates x(c) are unknown, the other parts don’t need to be updated
and hence ∆x(o) = 0. Furthermore, the goal is to make D (o) (x0 + ∆x) = 0 and hence we
obtain
(o)
D (o) (x0 ) + D,x(c) ∆x(c) ≈ 0.
(7)
Then the best linear approximation for the update of the dependent coordinates is
h
i−1
(o)
∆x(c) ≈ − D,x(c)
D (o) (x0 ).
(8)
This correction to the dependent coordinates x(c) can be applied iteratively until some tolerance
||D (o) (x)|| < ϵtol is met.
This position analysis will be done with the help of a MATLAB script sliding_truss.m. An
incomplete version of this script is provided that you can complete as outlined in the following
exercises. Don’t forget the remarks about these “template” files on page 2.
a. Check that you understand the description above about the position analysis with Newton–
Raphson iterations. Also download the template of the script sliding_truss.m and
try to understand the first parts. You should recognize that the coordinate vector x1
is defined for the truss element (line 34), but that the coordinates are also ordered into
a “system level” coordinate vector x (line 45). The term “system level” is somewhat
exaggerated for this simple system consisting of a single truss element, but is used in
agreement with the notation for more complex systems.
In lines 49 and 61 the deformation function, i.e. the truss elongation, and its Jacobian are
computed respectively. For these calculations two functions truss_D and truss_Dx
are defined near the end of the script file. You should recognize the expressions from the
reader.
In lines 73–75 the Jacobian is split into the three partitions of Eq. (4).
In lines 85–92 MATLAB functions are defined for the deformation function and the three
partitions of the Jacobian. In this way it is rather simple to use these functions in the
calculations to follow. Note that the functions can be called with symbolic as well as
numerical parameters.
In line 110 a loop starts where the time evolves in the interval specified before. The
prescribed coordinate xp is computed with Eq. (1).
Next you need to add a few steps to the script:
Line 116: Specify how to compute the estimated update ∆x(c) with Eq. (8). Consider
using one or more of the functions Do_fun, Doxo_fun, Doxc_fun and Doxm_fun
defined a few lines above.
Line 119: Update yq in variable yq_num.
If everything is correct, two figures will open when running the script. One shows the
moving truss. The second plot from line 131 should show only two curves as the Newton–
Raphson approximation should match the exact value of yq very well.
4
Velocity analysis
(k)
Using the expression for the derivative D1,x of Eq. (3.2.4) directly results in the velocity equation (3.2.7a) from which the unknown velocity ẏp follows easily in Eq. (3.2.7c). As already
used in the position analysis, the rigid deformations are always zero by definition, so D (o) = 0
and hence also for its time derivative applies that D,x(o) ẋ = 0, which is actually applied in
Eq. (3.2.7a). Combining this constraint equation for the derivative with the partitioning of
Eq. (4) gives
(o)
(o)
(o)
D,x(o) ẋ = D,x(o) ẋ(o) + D,x(c) ẋ(c) + D,x(m) ẋ(m) = 0.
(9)
The fixed coordinates don’t change, so ẋ(o) = 0. Then
(o)
(o)
D,x(c) ẋ(c) + D,x(m) ẋ(m) = 0,
(10)
so finally the velocities of the dependent coordinates ẋ(c) can be related to the independent
velocities ẋ(m) as
h
i−1
(o)
(o)
(c)
D,x(m) ẋ(m) ,
(11)
ẋ = − D,x(c)
h
i−1
(o)
assuming the inverse D,x(c)
exists. That should be true as the inverse is already used in
Eq. (8) of the Newton–Raphson procedure for the position analysis.
This velocity analysis will be done by checking the equations “manually” and with the help of
the MATLAB script sliding_truss.m already used for the position analysis.
b. Show that the same result for velocity ẏq is obtained as in Eq. (3.2.7c) when the equations
are rewritten as outlined above.
You can use the MATLAB script sliding_truss.m for this with a bit of editing:
Line 145: Complete the expression to compute ẋ(c) in xcdot from ẋ(m) in xmdot.
Consider using one or more parts of the Jacobian D,x(o) , see Doxo, Doxc and Doxm in the
position analysis section (lines 73–75).
Check the output from lines 162–163.
Acceleration analysis
Finally, the MATLAB script sliding_truss.m also offers a section for the acceleration analysis and a numerical simulations of the results so far.
c. Argue that with this reformulation the accelerations of the dependent coordinates ẍ(c) can
be related to the independent velocities ẍ(m) and previously computed velocities ẋ as
h
i−1 (o)
(o)
ẍ(c) = − D,x(c)
D,x(m) ẍ(m) + (D,xx ẋ) ẋ ,
(12)
from which the same analysis and results for ÿq as in Eqs. (3.2.8a) to (3.2.8e) follow.
You can again use the MATLAB script sliding_truss.m for this. As programming
with the Hessian can be quite confusing, you get this “for free” in this exercise.
Check the output from lines 201-202.
5
d. Running the MATLAB script sliding_truss.m completely will open a plot showing
a simulation of the bar with constant velocity ẋp = v. If the variable createmovie
is true the plot of the simulation is stored in a movie file that can be opened with your
favourite media player. You can change some of the parameters if you like. One set of
arrows indicate the velocities at the ends of the bar; the other arrows are the accelerations.
Do you have an idea why the simulation doesn’t begin and end with a horizontal bar?
Do you agree with the direction of ẏq and ÿq ?
To reuse the functions truss_D, truss_Dx and truss_Dxx in future scripts, consider
storing these in a private subfolder of the folder in which you write your scripts.
Prescribed rotation β = βp = ϕp (t) (β0 = 0)
Next we consider the system in which the motion is prescribed by defining the angle β(t) as a
function of time instead.
e. Argue that in this case a model with a planar truss element is less suited for the analysis,
but that a rigid or flexible beam element would be a better choice. Which of these options
is then preferable?
In the remaining of this exercise the sliding bar will be modelled with a rigid beam element.
For a rigid beam element the coordinates are defined in Eq. (3.2.11) of the reader as


rp
T
(k)
.
(13)
xrigid beam =  ϕp  = xp , yp | ϕp | xq , yq
rq
There are two deformations that are written in Eq. (3.2.14) as
q
(k)
(k)
(k)
(k)
ε1 = D1 (x ) = (xq − xp )2 + (yq − yp )2 − l0 = 0 ,
(k)
(k)
ε2 = D2 (x(k) ) = −(xq − xp ) sin βp + (yq − yp ) cos βp = 0 ,
(14a)
(14b)
with βp = βo + ϕp as defined in Eq. (3.2.15). The initial configuration of the bar is β0 =
0 rad. The rotation is defined with a constant angular velocity ω by prescribing the rotational
coordinate as
ϕp (t) = ωt .
(15)
Expressions for first and second derivatives of the deformation functions are given in Eqs. (3.2.16).
A MATLAB script sliding_rbeam.m is provided to get started. In the exercise it is outlined
what you have to add or modify in this script. Don’t forget the remarks about these “template”
files on page 2.
The script basically proceeds similar to the previous case with the truss, with one main difference: The position analysis is now integrated in the simulation and visualisation loop. Then all
equations for the position, velocity and acceleration analysis are defined first after which these
are all used in the right order in the loop.
6
f. Again set up a model of the sliding bar with a rigid beam element and split the coordinates
again in the three parts x(o) , x(c) and x(m) .
In MATLAB script sliding_rbeam.m:
Lines 41 and 43: Specify the respective nodal coordinates. See also the example in line
39.
g. Argue that both deformations are rigid such that D (o) is now a vector function that gives
(k)
(k)
two results, i.e. ε1 and ε2 .
In MATLAB script sliding_rbeam.m:
Lines 50–59 and function rbeam_D towards the end of the script: Verify that this has
already been implemented correctly.
h. Continue the velocity analysis to compute all velocities and verify that you can redo the
analysis in the first part for the configuration and motion specified in Example 3.2.1 in
the reader.
In MATLAB script sliding_rbeam.m:
Lines 76–78: Specify the respective indices. Instead of using numerical values, consider
using the variables ind_xo, ind_xc ad ind_xm introduced a few lines before.
Lines 96–98: Check that the velocities are computed correctly.
Line 117: Specify the correct value for omega expressed in v. For this purpose you have
to figure out for which ẋ(m) = ϕ̇p = ω node p moves with a horizontal velocity v as in
the reader. Then you can check the output from lines 119–120.
i. Continue with the acceleration analysis to compute all accelerations and verify once more
that you can redo the analysis in the first part for the configuration and motion specified
in Example 3.2.1 in the reader.
In MATLAB script sliding_rbeam.m:
Line 137: Check that the indices in index_x are in the correct order.
Lines 139–140 and function rbeam_Dxx: You get the code with the Hessian “for free”.
Lines 143–149: Check that the accelerations are computed correctly.
Lines 160 and 162: Specify the correct value for omega (see above) and omega_dot.
For this purpose you have to figure out for which ẍ(m) = ϕ̈p = omega
˙ node p moves with
a constant horizontal velocity v as in the reader. Then you can check the output from
lines 164–165.
j. The final part of the MATLAB script sliding_rbeam.m will open a plot showing a
simulation of the bar with constant angular velocity ϕ̇p = β̇. Before it runs, you should
complete the position analysis.
In MATLAB script sliding_rbeam.m:
Lines 223 and 224: Update the coordinates xp_num and yq_num making use of previously computed results.
If the variable createmovie is true the plot of the simulation is stored in a movie
file that can be opened with your favourite media player. You can change some of the
parameters if you like. As before, one set of arrows indicate the velocities at the ends of
the bar; the other arrows are the accelerations.
7
To reuse the functions rbeam_D, rbeam_Dx and rbeam_Dxx in future scripts, consider
storing these in a private subfolder of the folder in which you write your scripts.
2
Slider crank – Kinematic analysis on system level
Reconsider Example 3.4.2 in the reader, see also Fig. 2. In the reader we didn’t care about
the angle of the connecting rod, β34 in the reader, that was just used to simplify some of the
equations. In this exercise this angle is explicitly included in the list with coordinates.
y
↶
⃗3 4
1
Ω
↶
⃗1 2
2
ϕ2 = 60◦
ϕ4 = −30◦
⃗5
x
Figure 2: Finite element model of the slider-crank mechanism.
a. Argue that the model in the reader with one rigid beam for the crank and one truss for the
connecting rod is not suited for the analysis as proposed above. Reason that a model with
two ridig beams instead is well-suited for this purpose.
In the remainder of this exercise this model with two rigid beams will be set up. Hence the
numbering of the coordinates in Fig. 2 is also somewhat different compared to the reader. More
specifically, the translational node of the slider is now number 5. That is caused by the introduction of a rotational node, number 4, that describes the angle of the connecting rod. This was
β34 in the reader, but is denoted with coordinate ϕ4 in this exercise.
For getting started it is advised to study and understand the model of Example 3.4.2 in the reader
first. Note that you can also download a MATLAB script to check that kinematic analysis. It is
not needed for this exercise. Instead an incomplete MATLAB script slider_crank_kin.m
is provided that you can complete as outlined in the following exercises. Don’t forget the
remarks about these “template” files on page 2.
In addition,the functions rbeam_D, rbeam_Dx and rbeam_Dxx for the rigid beam element
defined in the previous exercise are assumed to be available from the Matlab path or a private
subfolder.
b. The slider-crank mechanism is driven by prescribing the angle ϕ2 (t) of the crank as a
function of time. More specifically, the initial angle ϕ2 (0) = 0 and its initial velocity
8
ϕ̇2 (0) and (constant) acceleration ϕ̈2 are known. Use this information to classify the
coordinates in fixed x(o) , dependent x(c) , and independent coordinates x(m) .
In the MATLAB script slider_crank_kin.m edit:
Lines 52, 54 and 56: Specify the respective nodal coordinates.
Lines 67–79: Check the deformation functions. Are there indeed 4 deformations?
c. Complete the system level Jacobian D,x , split it into parts and use these to compute all
velocities ẋ.
In the MATLAB script slider_crank_kin.m edit:
Lines 104–106: Check that you get meaningful results for the three parts of D,x .
Line 126: Edit to compute ẋ(c) .
Do you get the correct output in lines 136–139?
d. Alternatively we can use the first-order geometric transfer functions F,q (and E,q ) to compute ẋ (and ε̇) directly from q̇ as
ẋ = F,q q̇ ,
(16)
ε̇ = E,q q̇ ,
(17)
and
where the independent coordinates and deformations have been collected in vector q.
In the MATLAB script slider_crank_kin.m edit:
Line 148: Edit to compute the matrix D(c) as defined in the reader.
Line 149: Edit to compute F,q(c) .
Do you get the correct output in lines 160–162?
Argue that E,q is trivial for this system.
e. A similar procedure is followed for the accelerations ẍ. First these are computed directly,
using the known velocities.
In the MATLAB script slider_crank_kin.m:
Lines 170–184: Once more you get the equations with the Hessians “for free”. Check
that you understand what is going on here.
Line 189: Edit to compute ẍ(c) .
Do you get the correct output in lines 199–203?
f. Next the second-order geometric transfer functions F,qq (and E,qq ) are used to compute ẍ
(and ε̈) directly
ẍ = F,q q̈ + (F,qq q̇) q̇ ,
(18)
ε̈ = E,q q̈ + (E,qq q̇) q̇ .
(19)
and
In the MATLAB script slider_crank_kin.m edit:
(c)
Line 214: Edit to compute F,qq
.
Do you get the correct output in lines 225–227?
Argue that E,qq is trivial for this system.
9
g. Running the MATLAB script slider_crank_kin.m completely will open a plot showing a simulation of the mechanism driven with a constant angular velocity of the crank
ϕ̇2 . If the variable createmovie is true the plot of the simulation is stored in a movie
file that can be opened with your favourite media player. You can change some of the
parameters if you like. As before, one set of arrows indicate the velocities at the ends of
the bar; the other arrows are the accelerations. Do you agree with the direction of these
velocities and accelerations?
Some concluding remarks about the script. In this exercise all equations are set up symbolically
which includes the computations of some matrix inverses. It is not recommended to do that for
more complicated systems, so in future exercises this will be arranged differently. One may
also note that the interface to various functions is somewhat “unhandy” as all coordinates need
to be specified (in the correct order), whereas interfacing with e.g. the global coordinate vector
x would be more logical. Also this will be taken care of in future exercises.
Furthermore, note that in this and the previous exercises 1-DOF systems have been investigated.
For such systems, the second order geometric transfer functions F,qq and E,qq are relatively easy
to handle as two of the three dimensions are just 1, such that these expressions effectively look
like a vector. For a thorough understanding it is essential to practice with a more complicated
system as well. The 2-DOF systems presented in the reader can be a good starting point for
this. One can try to understand the analysis presented there first and next consider extensions or
variations of those systems, such as using different elements (if possible). In these exercises a
multi-DOF will appear when flexibility is introduced for the connecting rod in the slider-crank
mechanism.
The following exercises are from course year 2020/2021
and have not been updated yet.
3
Slider crank – Dynamic analysis on system level
Reconsider Example 4.7.2 in the reader, see also Fig. 3. In the reader we didn’t care about
the angle of the connecting rod, β34 in the reader, that was just used to simplify some of the
equations. In exercise 2 this angle was explicitly included in the list with coordinates.
In the reader a dynamic analysis is presented to compute the driving torque τ2 and constraint
forces for a prescribed rotation of the crank. In that model a rigid beam and a truss are used.
Mass m5 is assumed to be concentrated in node 5 (according to the numbering in this exerise)
and mass m2 is distributed homogeneously along the connecting rod 2 . In this exercise we
continue the analysis using the model from exercise 2, so with two rigid beams.
For getting started it is once more advised to study and understand the model of Example 4.7.2 in
the reader first. Note that you can also download a MATLAB script to check that dynamic analysis. It is not needed for this exercise. Instead an incomplete MATLAB script slider_crank_dyn.m
is provided that you can complete as outlined in the following exercises. Don’t forget the remarks about these “template” files on page 2.
For the final part of this exercise two additional files are supplied: A SIMULINK model slider_crank_simul.
10
y
↶
⃗3 4
1
Ω, τ2
↶
⃗1 2
2
m2
β2 = 60◦
⃗5
β4 = −30◦
x
m5
Figure 3: Finite element model of the slider-crank mechanism with masses m2 of the connecting
rod and m5 of the slider.
Scope phi2
PD(s)
phi2 reference
PD Controller
Interpreted
MATLAB Fcn
slider_crank_phi2ddot
Figure 4:
SIMULINK
Interpreted
MATLAB Fcn
phi2dot
phi2
slider_crank_plot
model to simulate the rigid slider-crank system.
(suited for SIMULINK versions R2018a and newer), which calls a MATLAB function slider_crank_plo
for visualisation, see also Fig. 4.
a. It is assumed that you completed the kinematic analysis of exercise 2 before starting the
following dynamic analysis.
In the MATLAB script slider_crank_dyn.m:
In lines 10–17 it is checked that the results from the kinematic analysis are still available
in the current MATLAB session. If needed the kinematic analysis is redone. It is not
advisable to clear all variables in your workspace after each test.
b. Indicate which forces (or torques) contribute to the force vector f , or more specifically
its parts f (o) , f (c) and f (m) . Outline how e.g. gravity could be added to the force vector.
In the MATLAB script slider_crank_dyn.m:
In lines 35 only f (c) is initialised to zero which can be changed if desired, but then the
outcome will differ from the analysis in the reader.
c. In in the reader mass m2 is modelled with the consistent mass formalism. Argue that a
lumped description is indeed not possible in Example 4.7.2.
Argue that for the model is this exercise both mass modelling approaches can be used and
derive the resulting mass matrices for both approaches. Also show how the total system
mass matrix M is obtained then.
11
In the MATLAB script slider_crank_dyn.m:
In lines 46 and 52 add expressions to compute the element mass matrix M (2) for the connecting rod. Use m2l for the lumped approach and m2c for the consistent formulation,
respectively.
In lines 62 and 63 show how the mass m5 can be added to the system mass matrix. Note
that Mc and Ml refer to the system mass matrices that are obtained with the consistent or
lumped approach, respectively, but refers to mass m2 , see lines 67 and 68. For mass m5
only one approach is used, so both additions to lines 62 and 63 are identical.
In lines 71 and 72 show how Mcbar and Mlbar can be computed which refer to the
reduced mass matrix M̄ which is obtained either from the system mass matrix with the
consistent or lumped approach, respectively. Consider using a simplify in your MATLAB expression.
In line 77 the difference between the reducers mass matrices according to both methods
is evaluated. Should this be zero (or not) and do you get the expected result?
Finally, in lines 90–92 the result is compared to the reduced mass given in the reader for
the specific configuration shown in Fig. 3 as well.
d. The equation of motion for this example is shown in Eq. (4.7.25) of the reader:
h
i
(c)
(c)
M̄ q̈ = F,q(c)T f (c) − M (c,c) (F,qq
q̇) q̇ + f (m) − M (m,c) (F,qq
q̇) q̇ ,
(20)
Use it to compute the driving torque τ2 . Check your results with those in the reader.
In the MATLAB script slider_crank_dyn.m:
In line 108 add an expression to compute f (m) .
Do you get the correct output in lines 122–124?
e. The constraint forces in the supports are calculated in the reader by first determining the
stress resultant vector σ (o) in Eq. (4.7.34):
i−1 h
(o)T
(o)
σ = D,x(c)
f (c) − M (c,c) ẍ(c) − M (c,m) ẍ(m) ,
(21)
and with this result the vector of reaction forces f (o) is obtained in Eq. (4.7.37):
(o)T
f (o) = D,x(o) σ (o) + M (o,c) ẍ(c) + M (o,m) ẍ(m) ,
(22)
Use these expressions to compute the support forces f (o) . Check your results with those
in the reader.
In the MATLAB script slider_crank_dyn.m:
In lines 147 and 159 add an expressions to compute σ (o) and f (o) .
Do you get the correct output in lines 155–157 and 167–169?
f. Finally, the equation of motion can be reconsidered to simulate the system with a prescribed force/moment instead of prescribed motion. In this example Eq. (20) can be
rewritten as
h
h
i
i
(c)T
(c)
(c)
−1
(c)
(c,c)
(m)
(m,c)
q̈ = M̄
F,q
f −M
(F,qq q̇) q̇ + f
−M
(F,qq q̇) q̇ , (23)
from which the acceleration q̈ can be computed for a prescribed driving force/moment
f (m) and know configuration q and velocity q̇.
12
In the MATLAB script slider_crank_dyn.m:
In line 184 add an expressions to compute q̈.
To simulate the motion of the slider-crank, we have to solve the ordinary differential equation (ODE) (23) by integrating q̈ twice as a function of time. Instead of writing our own
ODE solver, we can also use one of MATLABś options, e.g. the general purpose ode45.
The ODE can be solved in MATLAB or alternatively with a SIMULINK model. The
latter is offered in the file slider_crank_simul.slx available for download and
suited for SIMULINK versions R2018a and newer. This model calls a MATLAB function
slider_crank_phi2ddot.m to compute q̈ = ϕ̈2 . This function is generated in lines
193–197 of slider_crank_dyn.m. For visualisation slider_crank_plot.m
which can be downloaded. It assumes the dimensions as defned before in this exercise,
but these can be modified in the script if needed.
In the simulation the motion of the crank is controlled with a PD-controller that should
have correct settings for dimensions of the links and masses as defined before in this
exercise. The “Scope” window shows the desired and realised angle ϕ2 and the driving
torque τ2 as generated by the PD-controller.
As for the kinematic analysis, it is strongly recommended to consider at least one 2-DOF example as well.
4
Flexible slider crank
Reconsider Example 4.10.1 in the reader, see also Fig. 5. To simulate the bending of the connecting rod, this part of the system will now be modelled with one or more flexible planar beam
elements.
y
(a)
A
v
Ω
B
O
x
y
lc
(b)
O
lr
B
A
x
Figure 5: (a) Slider–crank mechanism with a flexible connecting rod. (b) Initial configuration.
13
Interpreted
MATLAB Fcn
phi2(0)
slider_crank_plot
Scope bending
phi2
Interpreted
MATLAB Fcn
phi2dot(0)
phi2dot
slider_crank_flex_qd_ddot
qd_dot
qd
phi2(d(d)ot)
phi2ddot
Figure 6:
SIMULINK
model to simulate the flexible slider-crank system (one flexible beam).
Length crank
l1
Length connecting rod
l2
Constant angular speed crank ϕ̇2
Total mass connecting rod m2
Total mass slider m5
Bending stiffness parameter connecting rod EI
0.15
0.30
150
0.06676
m2 /2
12.72
m
m
rad/s
kg
kg
N m2
Table 1: Dimensions, mass and stiffness properties of the flexible slider-crank mechanisms.
Part 1: One flexible beam
The simple deformations as introduced initially in the reader will be used, i.e. Eqs. (3.2.28).
Only flexibility due to bending in one flexible (planar) beam element is considered, so deformations ϵ2 and ϵ3 . In other words, the elongation ϵ1 is considered to be rigid. Mass and stiffness
properties are also taken from the reader. Note that these are different from the previous exercises and summarised in Table 1.
For getting started it is advised to look at Example 4.10.1 in the reader first. Note that you can
also download a MATLAB MATLABscript to redo that dynamic analysis. It is not needed for this
exercise. Instead an incomplete MATLAB script slider_crank_flex.m is provided that
you can complete as outlined in the following exercises. Don’t forget the remarks about these
“template” files on page 2.
In addition a SIMULINK model slider_crank_flex_simul.slx is provided (suited for
SIMULINK versions R2018a and newer), which calls the MATLAB function for visualisation
slider_crank_plot.m from the previous exercise.
If you have installed the SPACAR software already, you can compare your simulation results
with an analysis using the SPACAR input file slider_crank_flex.dat, but this is optionally.
a. At first the kinematic analysis is set up. Argue that there are 3 DOFs in case the crank
rotation is prescribed and flexibility is described by the bending modes of the connecting
rod modelled with one flexible planar beam element. In the remaining of this exercise the
(2)
(2)
angle ϕ2 of the crank and the bending deformations ε2 and ε3 of the connecting rod are
defined as the degrees of freedom.
In the MATLAB script slider_crank_flex.m:
14
Complete and check the kinematic analysis up to line 242.
In particular add the computation of F,q(c) in line 149 and ẍ(c) in line 239.
b. Continue with the dynamic analysis. First the force vector and mass matrix are defined.
In this case the consistent formulation for a flexible beam has to used. Next to the mass
matrix, also the velocity dependent inertia vector h has to be taken into account. The vector q with the degrees of freedom has to be split in the dynamic and rheonomic parts, i.e.
q d and q r . The latter is the prescribed motion and then the dynamic degrees of freedom
can be simulated from the ordinary differential equation (4.5.12) in the reader:
M̄dd q̈ d = fd − M̄dr q̈ r ,
(24)
where
M̄dd = F,qTd M F,qd ,
fd =
h
(c)T
F,qd
(m)T
F,qd
M̄dr = F,qTd M F,qr ,
(25a)
""
# " (c,c) #
#
"
#
i f (c) − h(c)
h
i σ (m)
M
(m)T
(c)T
(c)
−
(F,qq
q̇) q̇ − E,qd E,qd
.
(m)
(m)
(m,c)
f
−h
M
σ (c)
(25b)
In the MATLAB script slider_crank_flex.m:
Complete and check the dynamic analysis.
In particular generate the mass matrix in lines 282 and 286.
Compute fd in line 352 and q̈ d in line 355.
Note that the result is written to a file as a MATLAB function slider_crank_flex_qd_ddot.m
for use in the next part.
c. The ordinary differential equation of the flexible slider-crank is simulated in SIMULINK
model slider_crank_flex_simul.slx, see Fig. 6. A function slider_crank_flex_qd_
(2)
needs to be supplied which is called to compute ϕ̈4 and ϕ̈6 as functions of ϕ2 , ϕ̇2 , ϕ̈2 , ε2 ,
(2) (2) (2)
ε̇2 , ε3 , ε̇3 .
(2)
(2)
This simulation computes the deformations ε2 and ε3 from which the deflection v as
shown in Fig. 4.10.3 in the reader can be derived. For this purpose, the deformation along
the flexible beam can be computed with Eqs. (4.3.21a), (4.3.22a) and (4.3.22b) from the
reader. In Fig. 4.10.3 the relative deflection is computed in the middle of the beam which
equals
v̄( 12 ) = ε2 Nv̄p ( 12 ) + ε3 Nv̄q ( 12 ) = 81 (ε2 + ε3 ) ,
(26)
where shear deformation is neglected, i.e. Φ = 0. To obtain the same plot, the deformation
has to be scaled with the length l2 of the connecting rod.
In the MATLAB script slider_crank_flex.m:
The SIMULINK model is open and run. Afterwards the scaled deflection v/l2 is shown in
a graph as a function of angle ϕ2 using Eq. (26).
15
d. [Optional] If you have already installed the SPACAR software, you can check your simulation results by comparing it to the results from a SPACAR simulation with the input file
slider_crank_flex.dat.
In the MATLAB script slider_crank_flex.m:
SPACAR is called if installed correctly. Afterwards the scaled deflection v/l2 is shown in
a graph as a function of angle ϕ2 for both the previously obtained result and the SPACAR
output.
Part 2: One or more flexible beams, elongation rigid or flexible
Next, the model of the previous part is extended such that is can handle more than one flexible
beam element for the connecting rod. Also flexibility due to elongation ϵ1 may be taken into
account. Still the simple deformations as introduced initially in the reader will be used, i.e.
Eqs. (3.2.28). Mass and stiffness properties are not changed, see Table 1.
An important difference with the previous model is that for this more complicated model the
“cheat” solution for the non-linear constraint equations of the position problem is not readily available. Hence a numerical solution has to be implemented for this part, e.g. using the
Newton–Raphson scheme of Sect. 3.5 in the reader. The time integration is once more taken
care of by one of MATLAB’s standard ODE solvers, e.g. by using ode45 in SIMULINK.
qr
phi2(0)
phi2
qr_dot
qr_ddot
phi2dot
Scope bending
Flexible slider-crank
2 flexible beams
Only major timestep
slider_crank_num_plot
xplot
elongation rigid
qd
phi2dot(0)
Interpreted
MATLAB Fcn
vl
qd_ddot
qd_dot
qd_dot
Flexible slider-crank
qd
phi2ddot
Figure 7:
beamx).
SIMULINK
model to simulate the flexible slider-crank system (one or more flexible
A combination of MATLAB and
(partly) available for download:
SIMULINK
files are used to set up this simulation, which are
slider_crank_num_simul.slx is the main SIMULINK model (suited for SIMULINK
versions R2018a and newer), see Fig. 7. It can be used as provided, but it calls the next
two MATLAB functions which must be available.
slider_crank_num_plot.m takes care of a visualisation of the (flexible) slider crank.
The crank rotates about the origin O. Input of the function are the coordinates of the
connecting rod. For each node three coordinates must be specified, i.e. x, y and angle ϕ.
Note that in the SIMULINK model a RateTransition block is put in from of the block
that calls this function. In this way the visualisation is only called at so-called major time
steps during the simulation. Higher order ODE solvers with a variable time step like the
16
default ode45 employ intermediate time steps and may also step back in time before
obtaining a solution for one time step with specified accuracy. If all these intermediate
time steps are visualised, a very irregular motion may appear.
slider_crank_num_gw.m is a gateway function that takes care of most of the “bookkeeping” needed for SIMULINK. This is needed as in this model it has been chosen to
use a so-called S-function to program the model of the flexible beam. This S-function has
the advantage of more features in its interface, like multiple inputs and outputs as well
as passing additional parameters, however at the expense of being more complicated. To
separate the required “bookkeeping” from the “real” model, this gateway function takes
care of the first part. There should be no need to modify the provided script. It calls the
next function which does the actual computations. Just note that two parameters can be
modified in the SIMULINK block:
nbeams specifies the number of flexible beams in the connecting rod. It is a variable
of type double, but only integer values in the range from 1 to 10 (including these
limits) are accepted.
eps1flex is a logical variable that can be false or true to indicate whether the
elongation ϵ1 should be considered flexible or not.
slider_crank_num.m does the “real” job. The interface is defined as
function [ vl, xplot, qd_ddot ] = slider_crank_num( ...
qr,qr_dot,qr_ddot,qd,qd_dot,nbeams,eps1flex)
It should compute the outputs:
vl is the midpoint deflection v of the flexible connecting rod, scaled with its length l2 .
xplot is the vector with the coordinates that are required as inputs for the visualisation
function slider_crank_num_plot described above.
qd_ddot is the computed acceleration of the dynamic degrees of freedom q̈d , so the
outcome of the equations of motion. SIMULINK’s ODE solver integrates it twice to
compute q̇d and qd , see below.
The inputs are:
qr, qr_dot and qr_ddot specify the prescribed motion expressed in the rheonomic
degrees of freedom qr and its time derivatives q̇r , q̈r .
qd and qd_dot are the dynamic degrees of freedom qd and its time derivative q̇d that
(completely) describe the current configuration of the system.
nbeams and eps1flex are the two additional parameters introduced above.
For this file an incomplete “template” file is provided for which the remarks on page 2
apply. During this exercise the file will be completed to compute the outputs from the
inputs.
17
While programming the function slider_crank_num you may appreciate debugging the
provided and your own code. For this you can call the function directly from the MATLAB
command prompt or from another script, but then you have to assure all parameters are provided
with meaningful input. Alternatively, you can also use all debug options like breakpoints and
inspecting variables when you run the SIMULINK simulation. Just add a breakpoint in the script,
start the simulation and SIMULINK and see what happens.
e. Re-examine the kinematic analysis. Make an overview of the fixed, dependent and independent coordinates as well as the rigid, independent and dependent deformations. Assume that the crank angle ϕO is prescribed as a function of time. Note that the number
of DOFs depends on the parameters nbeams and eps1flex. Show that the correct
number of DOF is obtained when all flexible deformations are defined as dynamic DOF.
In the MATLAB script slider_crank_num.m:
In lines 23–42 check that the physical properties are defined correctly. In particular note
that m2 represents the total mass m2 of the connecting rod, but also m2pl is defined as in
some expressions the mass per unit length shows up. Note also the computation of scalar
S1 and 2 × 2 matrix S2 that represent the contributions to the element stiffness matrix S
as in Eqs.(4.3.19) in the reader when shear effects are neglected.
Lines 45+46 specify the criteria to stop the Newton–Raphson scheme for the position
problem.
In lines 48–139 the coordinates and deformations are set up. Check whether these agree
with your ideas about this. Note that for easy access in the rest of the code four index
arrays are defined that store the indices of coordinates and deformations in the global
vectors x and e for all elements:
indx_rbeam(1:5) coordinates rigid crank in x;
indx_flbeams(k,1:6) coordinates flexible beam k in x;
inde_rbeam(1:2) deformations rigid crank in e;
inde_flbeams(k,1:3) deformations flexible beam k in e.
In lines 142+143 the number of the degrees of freedom ndof is calculated and all DOF
are collected in vector q.
f. Next the non-linear constraints for the position analysis have to be solved. More specifically, Eqs. (3.3.5) and (3.3.6) from the reader have to be satisfied:
( (o)
D (x) = ε(o) = 0,
(27)
D (m) (x) = ε(m) (t).
In other words, the coordinates x have be determined such that the residuals
"
# " (o)
#
∆ε(o)
D (x)
=
,
∆ε(m)
D (m) (x) − ε(m) (t)
(28)
are zero or at least sufficiently small, see also Eqs. (3.5.6) and (3.5.7). As outlined
in Sect. 3.5 in the reader this can be accomplished with an iterative Newton–Raphson
(c)
scheme. In iteration n for estimate x(n) of the coordinates the residuals are computed by
substituting this estimate in Eq. (28). As long as the residuals are too large, the dependent
coordinates are updated in the next iteration n+1 as
(c)
(c)
(c)
x(n+1) = x(n) + ∆x(n) ,
(29)
18
with correction
"
(c)
(c)
∆x(n) = −(D(n) )−1
(o)
∆ε(n)
(m)
∆ε(n)
#
.
(30)
(c)
(c)
Matrix D(n) is the matrix D(c) well-known from the kinematic analysis, evaluated for x(n) .
Apply this procedure to the flexible slider-crank mechanism.
In the MATLAB script slider_crank_num.m:
Lines 145–187 implement the Newton–Raphson scheme. Note that now functions are defined at the end of the script to compute the deformations and their derivatives at element
level:
function D = rbeam_D(x,l0)
function D = flbeam_D(x,l0)
function Dx = rbeam_Dx(x)
function Dx = flbeam_Dx(x)
These functions all expect the coordinates x = x(k) for a specific rigid or flexible element
ordered as in the reader. Output are the deformations D = D (k) (x(k) ) or their derivatives
(k)
Dx = D,x(k) also in the order of the reader. Some functions also need the element’s reference length l0. The index arrays introduced before now make it easy to link element
coordinates and deformations to the global vectors and matrices.
In line 186 add the correction for the next iteration.
Towards the end of the file, check the functions for the deformations and the derivatives.
Can you check how many iterations are typically needed to obtain convergence?
g. Once the position problem has been solved, the first outputs of the function can already
be computed as these only depend on the coordinates. Can you identify these outputs and
indicate how these can be computed? Does it make a difference if there is an even or odd
number of flexible beam elements in the connecting rod?
In the MATLAB script slider_crank_num.m:
In lines 192–218 the deflection in the middle of the connecting rod is computed. For this
the coordinates of the mid point M are calculated. Then the deflection v is the length of
the vector connecting points M and A onto a normal vector perpendicular to the straight
connection of points A and B. Finally, v is scaled with l2 as this is the convention of plotting the deflection in Fig. 4.10.3 in the reader.
Lines 220–226 extract the right coordinates from vector x that are needed by the visualisation function.
h. The kinematic analysis continues with the velocity analysis. The system level derivative
D,x has already been computed in the Newton–Raphson scheme, so it can be reused.
In the MATLAB script slider_crank_num.m:
In lines 249 compute the first order geometric transfer function F,q(c) .
i. The kinematic analysis is completed with the acceleration analysis. The computation of
the (system level) second order geometric transfer function F,qq can be avoided as shown
in Eq. (3.3.45a) in the reader. Instead the quadratic velocity contributions (D,xx ẋ)ẋ are
then computed at element level.
19
In the MATLAB script slider_crank_num.m:
In lines 263 Dxx_xdot_xdot is initialised to zero. This variable will be used to collect
(k)
the (D i,xx ẋ)ẋ for each deformation. The second derivatives D i,xx are computed per
element with two additional functions towards the end of the script:
function [ D1xx, D2xx ] = rbeam_Dxx(x)
function [ D1xx, D2xx, D3xx ] = flbeam_Dxx(x)
These functions all expect the coordinates x = x(k) for a specific rigid or flexible element
ordered as in the reader. The second derivatives are separate output variables D1xx,
D2xx and for the flexible beam also D3xx. Each of these can be multiplied (twice) with
the correct subset ẋ(k) of the velocity vector x_dot. By implementing it in this way, the
use of three-dimensional arrays is avoided.
In lines 273–275 compute the relevant parts of Dxx_xdot_xdot for the flexible beams.
j. Continue with the dynamic analysis. This is basically similar to the analysis in the first
part of this exercise. In the end the accelerations of the dynamic degrees of freedom q̈ d
are obtained from Eq. (24).
In the MATLAB script slider_crank_num.m:
Complete and check the dynamic analysis.
In line 281 no additional forces are applied. This can be changed e.g. to include gravity,
but that is optional as it is also not included in the simulations in the reader.
Lines 293+294 take care of the rather straightforward implementation of the lumped formulation for the mass m5 of the slider.
More elaborate is the consistent mass of the flexible beams. For the computation of the
consistent mass matrix Mkc = M (k) and velocity dependent inertia vector hkc = h(k)
at element level, one final function is added at the end of the script:
function [ Mkc, hkc ] = flbeam_Mass(m, l, phip, phiq, ...
phip_dot, phiq_dot)
It is called in lines 301+302.
In lines 303+304 add how the element Mkc and hkc should be included in the system
mass matrix M and vector h.
In lines 339 and 342 add how to compute vectors fd and finally qd_ddot, respectively.
k. If there are no remaining errors you can run the simulation with the SIMULINK model
slider_crank_num_simul.slx. For the default setting that agree with the example in the reader, the deflection is only sightly visible in the visualisation, but the plot with
the scaled deflection should closely resemble Fig.4.10.3 in the reader even though in the
reader a somewhat more complicated model has been used, i.e. including elongation and
shear effects.
Elongation can be enabled quite easily in our SIMULINK model: Double click on the
block referring to our script and enable “Elongation flexible”. If the implementation is
indeed error-free, the increase in computational effort should be most notably and the
differences in the deflection are small.
More “spectacular” results can be obtained with higher rotational speeds of the crank.
The (initial) speed can be increased or the acceleration can be set to a non-zero value.
Then it is not difficult the “break” the connecting rod. If the deformations become too
large, the Newton–Raphson scheme will not converge anymore and the simulation will
end with an error for too many iterations.
20